Click on "Install Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@GlitchTip MCP Server Show me the most recent unresolved issues and their stacktraces"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
MCP server enabling LLMs to query issues, stacktraces, and resolve errors in GlitchTip.
GlitchTip is an open-source, self-hosted error tracking platform that's API-compatible with Sentry. This MCP server lets AI assistants like Claude directly access your error data to help debug and fix issues faster.
List Issues - Query all unresolved, resolved, or ignored issues
Get Issue Details - Retrieve full stacktraces and error context
Resolve Issues - Mark issues as resolved after fixing them
Related MCP server: Bugsink MCP Server
pip install mcp-server-glitchtipgit clone https://github.com/hffmnnj/mcp-server-glitchtip.git
cd mcp-server-glitchtip
pip install -e .Go to your GlitchTip instance: https://your-glitchtip.com/settings/api-tokens
Click Create New Token
Copy the token
Your organization slug is in the URL when viewing your organization:
https://your-glitchtip.com/organizations/{org-slug}/issuesYour project slug is visible in your project settings or URL:
https://your-glitchtip.com/organizations/{org-slug}/projects/{project-slug}claude mcp add mcp-server-glitchtip \
-s user \
-e GLITCHTIP_AUTH_TOKEN=your_token_here \
-e GLITCHTIP_API_URL=https://your-glitchtip.com/api/0/ \
-e GLITCHTIP_ORGANIZATION=your-org-slug \
-e GLITCHTIP_PROJECT=your-project-slug \
-- mcp-server-glitchtipAdd to your claude_desktop_config.json:
{
"mcpServers": {
"glitchtip": {
"command": "mcp-server-glitchtip",
"env": {
"GLITCHTIP_AUTH_TOKEN": "your_token_here",
"GLITCHTIP_API_URL": "https://your-glitchtip.com/api/0/",
"GLITCHTIP_ORGANIZATION": "your-org-slug",
"GLITCHTIP_PROJECT": "your-project-slug"
}
}
}
}Variable | Required | Description | Example |
| Yes | API token from GlitchTip |
|
| Yes | Base API URL (include trailing slash) |
|
| Yes | Organization slug |
|
| Yes | Project slug |
|
get_glitchtip_issuesList all issues from your GlitchTip project.
Parameters:
status (optional): Filter by status - unresolved, resolved, or ignored. Default: unresolved
Example response:
GlitchTip Issues (unresolved):
---
ID: 123 (PROJ-1)
Title: TypeError: Cannot read property 'foo' of undefined
Level: error | Count: 42
Culprit: app.js in handleClick
First: 2024-01-15T10:30:00Z | Last: 2024-01-15T14:22:00Zget_glitchtip_issueGet detailed information about a specific issue including the full stacktrace.
Parameters:
issue_id (required): The numeric issue ID
resolve_glitchtip_issueMark an issue as resolved after fixing the underlying bug.
Parameters:
issue_id (required): The numeric issue ID to resolve
Once configured, you can ask Claude:
"Show me all unresolved errors in GlitchTip"
"What's the stacktrace for issue 123?"
"What errors are happening most frequently?"
"I fixed that null pointer bug, mark issue 456 as resolved"
This server works with any GlitchTip instance. GlitchTip uses a Sentry-compatible API, so the endpoints follow Sentry's API structure.
Tested with:
GlitchTip 3.x+
Python 3.10+
# Clone the repo
git clone https://github.com/hffmnnj/mcp-server-glitchtip.git
cd mcp-server-glitchtip
# Create virtual environment
python -m venv venv
source venv/bin/activate # or `venv\Scripts\activate` on Windows
# Install in development mode
pip install -e .
# Run the server locally
GLITCHTIP_AUTH_TOKEN=xxx \
GLITCHTIP_API_URL=https://your-glitchtip.com/api/0/ \
GLITCHTIP_ORGANIZATION=your-org \
GLITCHTIP_PROJECT=your-project \
mcp-server-glitchtipGlitchTip - Open source error tracking
MCP - Model Context Protocol
mcp-sentry - Similar MCP server for Sentry.io
MIT License - see LICENSE for details.
Get detailed information about a specific GlitchTip issue including full stacktrace. Use this when you need to investigate a specific error in detail. Provides the complete stacktrace, error counts, and timing information.
| Name | Required | Description | Default |
|---|---|---|---|
| issue_id | Yes | The GlitchTip issue ID (numeric) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It describes what information is returned ('complete stacktrace, error counts, and timing information'), which adds useful context beyond the basic read operation implied by 'Get'. However, it doesn't cover aspects like authentication needs, rate limits, or error handling.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately sized and front-loaded, with three concise sentences that each add value: stating the purpose, providing usage guidance, and listing returned information. There is no wasted text or redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's low complexity (one parameter, no output schema, no annotations), the description is reasonably complete. It covers purpose, usage, and return details, though it could be enhanced with more behavioral context (e.g., error cases) or explicit sibling differentiation to achieve a perfect score.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema description coverage is 100%, so the schema already documents the single parameter 'issue_id' as a numeric string. The description doesn't add any parameter-specific details beyond what the schema provides, such as format examples or constraints, meeting the baseline for high schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose with specific verbs ('Get detailed information') and resources ('GlitchTip issue'), including key details like 'full stacktrace'. It distinguishes from the sibling 'get_glitchtip_issues' by focusing on a single issue, though it doesn't explicitly name that sibling.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context for when to use this tool ('when you need to investigate a specific error in detail'), which implicitly distinguishes it from the sibling 'get_glitchtip_issues' (for listing issues). However, it doesn't explicitly mention when not to use it or name alternatives like 'resolve_glitchtip_issue'.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List all issues from GlitchTip for the configured project. Use this to see all current errors and exceptions in production. Returns issue titles, counts, status, and when they were first/last seen.
| Name | Required | Description | Default |
|---|---|---|---|
| status | No | Filter by status: 'unresolved', 'resolved', 'ignored' | unresolved |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden. It discloses that this is a read operation (listing) and describes the return format (issue titles, counts, status, first/last seen timestamps). However, it doesn't mention pagination behavior, rate limits, authentication requirements, or error conditions that would be important for a production monitoring tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is perfectly concise with three focused sentences: one stating the purpose, one providing usage context, and one describing the return format. Every sentence adds value without redundancy, and the information is front-loaded appropriately.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a single-parameter read tool with no output schema, the description provides adequate context about what the tool does and what it returns. However, it lacks details about behavioral aspects like pagination, error handling, or authentication that would be valuable given this is a production monitoring tool with sibling mutation tools available.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already fully documents the single optional parameter. The description doesn't add any parameter-specific information beyond what's in the schema, maintaining the baseline score of 3 for adequate but not enhanced parameter documentation.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('List') and resource ('all issues from GlitchTip'), specifies the scope ('for the configured project'), and distinguishes from sibling tools by focusing on listing all issues rather than getting a specific issue (get_glitchtip_issue) or resolving one (resolve_glitchtip_issue).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context about when to use it ('to see all current errors and exceptions in production'), but doesn't explicitly state when not to use it or name alternatives. It implies this is for monitoring production issues but doesn't contrast with the sibling tools beyond their different functions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Mark a GlitchTip issue as resolved after fixing it. Use this after you've fixed the bug causing the error.
| Name | Required | Description | Default |
|---|---|---|---|
| issue_id | Yes | The GlitchTip issue ID to resolve |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It correctly identifies this as a mutation operation ('Mark as resolved'), but doesn't address important behavioral aspects like whether this requires specific permissions, whether the resolution is reversible, what happens to the issue after resolution, or potential rate limits. The description adds some context about timing but lacks comprehensive behavioral details.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is perfectly concise with just two sentences that each serve a clear purpose: the first states the action, and the second provides usage context. There's no wasted language or redundancy, and the information is front-loaded appropriately.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a mutation tool with no annotations and no output schema, the description provides adequate basic information about what the tool does and when to use it. However, it lacks important context about what 'resolved' means in the system, what the response looks like, or any error conditions. The description is complete enough for basic understanding but has clear gaps for a mutation operation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% description coverage, with the single parameter 'issue_id' clearly documented in the schema. The description doesn't add any additional parameter information beyond what the schema already provides, such as format examples or constraints. With complete schema coverage, the baseline score of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Mark as resolved') and target resource ('GlitchTip issue'), making the purpose immediately understandable. However, it doesn't explicitly differentiate this from sibling tools like 'get_glitchtip_issue' or 'get_glitchtip_issues' beyond the obvious action difference, so it doesn't reach the highest tier of sibling differentiation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear contextual guidance about when to use this tool ('after you've fixed the bug causing the error'), which helps the agent understand the appropriate timing. However, it doesn't explicitly mention when NOT to use it or name specific alternatives among the sibling tools, preventing a perfect score.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
get_glitchtip_issueget_glitchtip_issuesresolve_glitchtip_issueEach tool has a clearly distinct purpose: get_glitchtip_issue retrieves detailed information about a single issue, get_glitchtip_issues lists all issues, and resolve_glitchtip_issue marks an issue as resolved. There is no overlap in functionality, making it easy for an agent to select the correct tool.
All tool names follow a consistent verb_noun pattern with 'glitchtip_issue' as the common noun component. The verbs 'get', 'get' (for list), and 'resolve' are clear and uniformly applied in snake_case, providing a predictable naming convention throughout.
With only 3 tools, the set feels thin for a GlitchTip server, which might be expected to handle more operations like creating issues, updating them, or managing projects. While the tools cover basic viewing and resolving, the count is borderline for comprehensive error management.
The tool set has significant gaps for a GlitchTip server. It lacks create, update, or delete operations for issues, and there are no tools for managing projects, users, or other GlitchTip entities. This incomplete surface will likely cause agent failures when trying to perform common error management tasks beyond viewing and resolving.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
Direct access to Cypress tests results and accessibility reports in your AI workflow.
Query your team's drift, vulnerability, and upgrade data from any AI assistant. OAuth 2.1, 51 tools.
Investigate errors, track deployments, analyze performance, and manage application monitoring
Provides access to Civic Plus - See Click Fix, allowing you to interact with your data via an LLM.…
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/hffmnnj/mcp-server-glitchtip'
If you have feedback or need assistance with the MCP directory API, please join our Discord server
