# BugSnag MCP for AI Agents MCP

> BugSnag connects your error monitoring into your AI agent, letting you track application stability without opening a dashboard. Your agent can list organizations or projects, inspect specific error groups, and retrieve deep details about individual error events using natural conversation. It lets engineers quickly diagnose issues by pulling real-time metrics and historical trends directly into their workflow.

## Overview
- **Category:** fort-knox
- **Price:** Free
- **Tags:** error-monitoring, stability-tracking, incident-response, full-stack-monitoring, debugging, application-performance

## Description

Debugging complex software doesn't require manually hopping between dashboards and API calls. This MCP gives your AI client direct access to BugSnag, letting you manage application errors right where you work. Instead of searching through project settings or digging up specific error IDs, you just ask your agent a question about system health. It pulls everything—from listing all organizations to getting detailed statistics on an error group—and presents it instantly.

This capability means incident response gets faster and less painful. You can use natural language to get historical error trends, check collaboration status across projects, or even find out how many times a specific event has popped up in the last 24 hours. If you're already using Vinkius for other services, connecting BugSnag here makes your entire stack visible and actionable through one interface. It’s about getting immediate answers to operational questions that used to take five minutes of clicks.

## Tools

### get_error
Pulls specific details about a defined group of errors (an error class).

### get_event
Retrieves full, unique details for one single instance of an error event.

### get_project
Gets key information about a specific software project within the system.

### get_project_stats
Calculates and provides error trends and overall statistics for an entire project over time.

### list_collaborators
Displays a directory of team members who work in the same organization.

### list_errors
Generates a comprehensive list of all error groups found for a given project.

### list_events
Creates a navigable list of individual, historical error events tied to a specific project.

### list_organizations
Provides an inventory of all BugSnag organizations you have access to monitor.

### list_projects
Lists every software project configured within a specific organization.

### list_release_stages
Shows the various release stages that are currently set up and monitored for a project.

## Prompt Examples

**Prompt:** 
```
List all my projects in BugSnag for organization vinkius corp.
```

**Response:** 
```
**Vinkius Corp Projects**

The following 4 projects are currently monitored:

*   🌐 **Web Dashboard**: ID: proj_1 (Last Error: ReferenceError)
*   📱 **iOS App**: ID: proj_2 (Last Error: NetworkError)
*   🤖 **API Gateway**: ID: proj_3 (Last Error: TypeError)
*   ⚙️ **Auth Service**: ID: proj_4 (Last Error: NullPointer)
```

**Prompt:** 
```
What are the details for error group 'err_99283'?
```

**Response:** 
```
**Error Group Details: err_99283**

*   **Name**: ReferenceError
*   **Severity**: Error (High)
*   **Occurrences (Last 24h)**: 150 times
*   **Affected Users**: ~45 users in production.
*   **Description**: This error happens when an object expected to be defined isn't found. It usually relates to outdated API endpoints.
```

**Prompt:** 
```
Show the top 5 error events for 'iOS App'.
```

**Response:** 
```
**Top 5 Recent Failures (iOS App)**

| Event ID | Type | Severity | Time Ago |
| :---: | :---: | :---: | :---: |
| ev_102 | NetworkError | Warning | 1h ago |
| ev_987 | TypeError | Error | 4h ago |
| ev_551 | ReferenceError | Critical | 6h ago |
| ... | ... | ... | ... |
      *Note: The most frequent event is `TypeError` (32 occurrences in the last week).*
```

## Capabilities

### Check organizational visibility
List all the organizations you have access to, giving you a high-level view of your entire tech portfolio.

### Identify project errors and groups
List and inspect error groups for any specific project, showing details like severity levels and how often those errors occur.

### Diagnose individual incidents
Retrieve full records of single error events to pinpoint exactly when and where a failure happened.

### Review system health over time
Get detailed statistics on error trends for a project, helping you monitor application stability across releases.

### Manage team context
Access directory information about collaborators and the current release stages to keep all teams aligned.

## Use Cases

### Investigating a spike in production errors
A developer notices error reports spiking after deployment. They ask their agent to 'Show me all active error groups for the web dashboard.' The MCP uses `list_errors` and `get_error`, immediately identifying the high-severity group, allowing them to pull the specific project details using `get_project` and start debugging.

### Onboarding a new team member
A PM needs an overview of all system health. They ask their agent to 'List every organization and project we monitor.' The MCP runs `list_organizations` followed by `list_projects`, generating a clean inventory that shows the full scope of monitoring coverage.

### Debugging flaky API calls
An SRE suspects a specific, intermittent bug. They ask their agent to 'Get details for event ID XYZ.' The MCP uses `get_event`, providing metadata and occurrence counts instantly, letting the SRE confirm if it was a one-off failure or a systemic issue.

### Assessing post-release impact
A manager wants to know if the latest feature release impacted stability. They ask their agent for 'Error trends and statistics on the mobile app.' The MCP runs `get_project_stats`, delivering a clear, actionable graph showing performance changes over time.

## Benefits

- Pinpoint root causes faster. Instead of just knowing an error happened, you can retrieve the full event details using `get_event` to debug exactly why it failed.
- Get a complete picture of your infrastructure. You don't have to guess where to look; simply use `list_organizations` and `list_projects` to map out your entire tech stack's visibility.
- Keep stakeholders informed easily. Use `list_collaborators` to quickly check who is on the team and what release stages they are working with, keeping everyone aligned during an incident.
- Understand performance shifts. By calling `get_project_stats`, you track error trends over time, helping you prove whether a recent code change actually improved or worsened stability.
- Consolidate your knowledge. You can use natural language to compile data from multiple calls—like combining results from `list_errors` and `list_events`—without leaving the chat window.

## How It Works

The bottom line is, you talk to your AI client about bugs instead of navigating complex dashboards.

1. First, subscribe to this MCP on Vinkius and enter your BugSnag Personal Auth Token.
2. Next, tell your AI client what you need—for example, 'What are the top three error groups for my production web app?'
3. Your agent sends that query through the connection, retrieves the data from BugSnag, and presents a clean summary of the error details or statistics back to you.

## Frequently Asked Questions

**How can BugSnag MCP help me debug production errors?**
Your agent lets you query real-time and historical error data directly. You can ask for specific event details or list all current error groups, speeding up diagnosis without needing to open the main dashboard.

**Does BugSnag MCP help with release version tracking?**
Yes. It lets you check which software projects are configured across different release stages (like staging or production). This is crucial for understanding if an error started appearing after a specific deployment.

**What kind of reports can I get from the BugSnag MCP?**
You can pull various reports, including comprehensive statistics on error trends over time and deep dives into individual error groups. This gives you both high-level metrics and low-level diagnostic data.

**Is this only for small errors or major outages?**
It handles both. You can get a general overview of all your organizations, or drill down to retrieve the metadata for a single, highly critical error event that requires immediate attention.

**Can BugSnag MCP tell me if two projects are related?**
It helps you map out relationships by listing all available projects within an organization and checking which collaborators work across multiple services. This ensures your team is aligned on the scope of monitoring.