Allows interaction with the Sentry API to fetch issue and event details, list organization projects, and query project issues with filtering and pagination support.
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., "@Sentry MCP Server show me the unresolved issues for my-api project from the last 7 days"
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.
Sentry MCP(Model Context Protocol) Server. Allows interaction with the Sentry API to fetch issue and event details.
Related MCP server: Sentry
Add the following configuration to your MCP settings file (e.g., mcp_settings.json):
{
"mcpServers": {
"sentry-server-npm": {
"command": "npx",
"args": [
"-y",
"@zereight/sentry-server"
],
"env": {
"SENTRY_AUTH_TOKEN": "YOUR_SENTRY_AUTH_TOKEN", // Required
"SENTRY_ORG_SLUG": "YOUR_ORG_SLUG", // Required: Your Sentry organization slug
"SENTRY_PROJECT_NAMES": "YOUR_PROJECT1,YOUR_PROJECT2", // Required: Comma-separated Sentry project slugs
"SENTRY_BASE_URL": "YOUR_SENTRY_BASE_URL" // Optional: Defaults to https://sentry.io
},
"disabled": false
}
}
}Replace placeholder values like "YOUR_SENTRY_AUTH_TOKEN", "YOUR_ORG_SLUG", and "YOUR_PROJECT1,YOUR_PROJECT2" with your actual Sentry details. Provide project slugs separated by commas. Project slugs are used in Sentry URLs (e.g., https://<org-slug>.sentry.io/settings/projects/<project-slug>/). Auth tokens can be generated in User Settings > Auth Tokens.
When using with Cursor or running directly, you can set up environment variables and run the server as follows:
env SENTRY_AUTH_TOKEN=YOUR_SENTRY_AUTH_TOKEN \
SENTRY_ORG_SLUG=YOUR_ORG_SLUG \
SENTRY_PROJECT_NAMES=YOUR_PROJECT1,YOUR_PROJECT2 \
SENTRY_BASE_URL=YOUR_SENTRY_BASE_URL \
npx @zereight/sentry-serverSENTRY_AUTH_TOKEN (Required): Your Sentry authentication token.
SENTRY_ORG_SLUG (Required): The slug of your Sentry organization.
SENTRY_PROJECT_NAMES (Required): Comma-separated names (slugs) of your Sentry projects.
SENTRY_BASE_URL (Optional): The base URL for your Sentry instance (e.g., for self-hosted). Defaults to https://sentry.io.
get_sentry_issue
Fetches details for a specific Sentry issue. ℹ️
Inputs:
issue_id_or_url (string, required): The Sentry issue ID or the full URL of the issue page.
Returns: Detailed information about the issue (JSON string).
list_organization_projects
Lists all projects for the configured Sentry organization. 📂
Inputs: None
Returns: A list of project objects (JSON string).
list_project_issues
Lists issues for a specific project, with optional filtering. 🐛
Inputs:
organization_slug (string, optional): The slug of the organization. Defaults to SENTRY_ORG_SLUG env var.
project_slug (string, required): The slug of the project to list issues for.
query (string, optional): Sentry search query to filter issues (e.g., "is:unresolved", "assignee:me").
statsPeriod (string, optional): Time period for statistics (e.g., "24h", "14d", "auto").
cursor (string, optional): Pagination cursor for fetching next/previous page.
Returns: A list of issue objects and pagination information (JSON string).
get_event_details
Gets details for a specific event within a project. 📄
Inputs:
organization_slug (string, optional): The slug of the organization. Defaults to SENTRY_ORG_SLUG env var.
project_slug (string, required): The slug of the project the event belongs to.
event_id (string, required): The ID of the event to retrieve.
Returns: Detailed information about the specific event (JSON string).
Before running the server, you must set the following environment variables:
SENTRY_AUTH_TOKEN=YOUR_SENTRY_AUTH_TOKEN
SENTRY_ORG_SLUG=YOUR_ORG_SLUG
SENTRY_PROJECT_NAMES=YOUR_PROJECT_NAME1,YOUR_PROJECT_NAME2Optionally, you can also set:
SENTRY_BASE_URL=YOUR_SENTRY_BASE_URL # Default: https://sentry.ioThe Inspector will provide a URL to access debugging tools in your browser.
MIT License
Get details for a specific event within a project.
| Name | Required | Description | Default |
|---|---|---|---|
| organization_slug | No | The slug of the organization the project belongs to. | |
| project_slug | Yes | The slug of the project the event belongs to. | |
| event_id | Yes | The ID of the event to retrieve. |
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 states it 'Get details' but doesn't specify if this is a read-only operation, what permissions are required, potential rate limits, or the format of returned details. This is a significant gap for a tool with no annotation coverage.
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 a single, efficient sentence that directly states the tool's purpose without unnecessary words. It's front-loaded and appropriately sized, making it easy to parse quickly.
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 complexity of retrieving event details with no annotations and no output schema, the description is incomplete. It doesn't explain what 'details' include, error conditions, or behavioral traits, leaving the agent with insufficient context for reliable invocation.
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 input schema already documents all parameters (organization_slug, project_slug, event_id) with clear descriptions. The description adds no additional meaning beyond implying a hierarchical relationship (event within project within organization), which is minimal value over the schema.
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 ('Get') and resource ('details for a specific event within a project'), making the purpose understandable. However, it doesn't explicitly differentiate from sibling tools like 'get_sentry_issue' or 'list_project_issues', which might also retrieve event-related information, so it misses full sibling distinction.
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 no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites like needing organization or project context, nor does it compare to siblings such as 'get_sentry_issue' for issue-level details or 'list_project_issues' for multiple events, leaving usage ambiguous.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get details for a specific Sentry issue using its ID or URL
| Name | Required | Description | Default |
|---|---|---|---|
| issue_id_or_url | Yes | The Sentry issue ID or the full URL of the issue page |
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 states the action ('Get details') but doesn't describe what details are returned, potential errors (e.g., invalid ID), authentication requirements, rate limits, or whether it's a read-only operation. This leaves significant gaps in understanding the tool's behavior beyond the basic purpose.
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 a single, efficient sentence with zero wasted words. It front-loads the core purpose ('Get details for a specific Sentry issue') and includes essential parameter information without redundancy. Every part of the sentence earns its place, making it highly concise and well-structured.
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 lack of annotations and output schema, the description is incomplete for a tool that retrieves detailed data. It doesn't explain what 'details' include (e.g., issue metadata, stack traces, assignee), potential response formats, or error handling. For a read operation with no structured output documentation, this leaves the agent with insufficient context to use the tool effectively.
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 parameter 'issue_id_or_url'. The description adds minimal value by restating that it accepts 'ID or URL', but doesn't provide additional context like format examples, URL structure, or how to distinguish between ID and URL inputs. Baseline 3 is appropriate as the schema does the heavy lifting.
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 ('Get details') and resource ('for a specific Sentry issue'), making the purpose immediately understandable. It distinguishes from sibling tools like 'list_project_issues' by specifying retrieval of a single issue rather than listing multiple. However, it doesn't explicitly contrast with 'get_event_details' or 'list_organization_projects', preventing a perfect score.
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 no guidance on when to use this tool versus alternatives like 'get_event_details' or 'list_project_issues'. It mentions the parameter ('issue ID or URL') but doesn't clarify scenarios where this tool is preferred over siblings, such as needing detailed issue metadata versus event-level data or bulk listings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List all projects for the configured Sentry organization
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
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 states it lists projects but doesn't describe any behavioral traits like pagination, rate limits, authentication needs, or what 'configured Sentry organization' entails. This leaves significant gaps for an agent to understand how to interact with the tool effectively.
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 a single, efficient sentence that directly states the tool's purpose without any fluff or redundancy. It's front-loaded and appropriately sized for a simple tool, making it easy for an agent to parse quickly.
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 simplicity (0 parameters, no output schema, no annotations), the description is minimally adequate but lacks completeness. It doesn't explain what 'configured Sentry organization' means or provide any context on the return format or usage scenarios, which could hinder an agent's ability to use it correctly without additional information.
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 0 parameters with 100% coverage, so no parameter information is needed. The description doesn't add any parameter details, which is appropriate here. Baseline is 4 for zero parameters, as the schema fully covers the absence of inputs.
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 ('projects for the configured Sentry organization'), making the purpose unambiguous. However, it doesn't explicitly differentiate from sibling tools like 'list_project_issues' or 'get_sentry_issue', which might also involve project-related operations, so it misses full sibling distinction.
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 no guidance on when to use this tool versus alternatives. It doesn't mention any context, prerequisites, or exclusions, such as whether it's for overview vs. detailed views or how it relates to sibling tools like 'list_project_issues' or 'get_sentry_issue'.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List issues for a specific project, with optional filtering.
| Name | Required | Description | Default |
|---|---|---|---|
| organization_slug | No | The slug of the organization the project belongs to. | |
| project_slug | Yes | The slug of the project to list issues for. | |
| query | No | Sentry search query to filter issues (e.g., "is:unresolved", "assignee:me"). Optional. | |
| statsPeriod | No | Time period for statistics (e.g., "24h", "14d", "auto"). Optional. | |
| cursor | No | Pagination cursor for fetching next/previous page. Optional. |
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 states 'list issues' but doesn't cover critical aspects like pagination behavior (implied by 'cursor' parameter but not explained), rate limits, authentication needs, or what the return format looks like (no output schema). This leaves significant gaps for an agent to understand the tool's behavior.
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 a single, efficient sentence that gets straight to the point with no wasted words. It's appropriately sized for a listing tool, though it could be slightly more informative without sacrificing brevity.
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 complexity of a 5-parameter tool with no annotations and no output schema, the description is insufficient. It doesn't explain the return values, pagination behavior, or error conditions. While the schema covers parameters well, the overall context for proper tool invocation and result interpretation is lacking.
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 description adds minimal value beyond the input schema, which has 100% coverage with clear descriptions for all 5 parameters. It mentions 'optional filtering' which aligns with the 'query' and 'statsPeriod' parameters, but doesn't provide additional context or examples beyond what's in the schema. Baseline 3 is appropriate as the schema does the heavy lifting.
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 the resource 'issues for a specific project', making the purpose understandable. However, it doesn't differentiate from sibling tools like 'get_sentry_issue' or 'list_organization_projects', which might handle similar data, so it lacks explicit sibling distinction.
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 mentions 'optional filtering' but provides no guidance on when to use this tool versus alternatives like 'get_sentry_issue' or 'list_organization_projects'. There's no context on prerequisites, exclusions, or specific scenarios for application.
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.
v1.0.0get_event_detailsget_sentry_issuelist_organization_projectslist_project_issuesThe tools have mostly distinct purposes: get_event_details and get_sentry_issue both retrieve details but target different resources (events vs. issues), while list_organization_projects and list_project_issues handle listing operations for different scopes. There is minor potential confusion between the two 'get' tools since both fetch details, but their descriptions clarify the resource distinction.
All tool names follow a consistent verb_noun pattern (e.g., get_event_details, list_organization_projects) with clear, descriptive naming. There are no deviations in style or convention across the set.
With only 4 tools, the server feels somewhat thin for a Sentry integration, which typically involves more operations like creating issues, updating statuses, or managing alerts. While the tools cover basic read and list functions, the count is borderline low for the domain's scope.
The toolset is significantly incomplete for a Sentry server, lacking essential operations such as creating or updating issues, resolving events, or managing project settings. It only supports read and list functions, leaving major gaps in CRUD coverage that will hinder agent workflows.
Investigate errors, track deployments, analyze performance, and manage application monitoring
Access the GitHub API, enabling file operations, repository management, search functionality, and…
Provides access to Civic Plus - See Click Fix, allowing you to interact with your data via an LLM.…
Search, read and create Linear issues, projects, teams and cycles.
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/zereight/sentry-mcp'
If you have feedback or need assistance with the MCP directory API, please join our Discord server
