# Rollbar MCP

> Rollbar connects your AI client directly to a continuous code error tracking platform. Use this MCP to monitor live application health, identify active bugs, review full stack traces, check deployment history, and manage the lifecycle of critical errors—all from chat.

## Overview
- **Category:** developer-tools
- **Price:** Free
- **Tags:** error-tracking, bug-reporting, stack-trace, site-reliability, deployment-monitoring, incident-resolution

## Description

This integration turns your conversational agent into an instant site reliability engineer. You stop jumping between dashboards and start talking to your code's health status. Your AI client can now list active bugs or immediately pull up the top issues affecting users, pinpointing exactly where things broke. Want deep detail? Just give it an error ID, and the tool pulls the full stack trace logs so you know precisely which line of code failed. You can also report a new deployment using a specific Git commit tag, keeping your monitoring dashboard current automatically. Need to close out a fix? Tell your agent to change the status of the bug ticket. By connecting this MCP through Vinkius, you get complete visibility into your application's health and deployment history without leaving your chat window.

## Tools

### get_deploy
Pulls specific details for one code deployment record.

### get_item
Retrieves the main information for a single error item.

### get_occurrence
Shows all deep logs and stack traces for one specific recorded instance of an error.

### list_deploys
Provides a list of every code deployment that has been registered.

### list_invites
Lists any pending team invitations for the project.

### list_items
Gets a list of all error types and items currently tracked by Rollbar.

### list_occurrences
Lists individual instances of an error that belong to a specific item.

### report_deploy
Reports and logs a new code deployment using specified environment and Git revision details.

### top_active_items
Retrieves the list of error items that are currently happening most frequently across users.

### update_item
Changes an error item's status to active, resolved, or muted.

## Prompt Examples

**Prompt:** 
```
Check the dashboard for any listed error items recorded recently.
```

**Response:** 
```
I checked the primary error repository running `list_items`. I found 4 distinct error tickets currently listed as active issues. Let me know if you would like me to isolate the most frequent ones using `top_active_items` or examine a specific ID in depth.
```

**Prompt:** 
```
Get the stack trace and precise occurrence detail for occurrence ID '1234abcd'.
```

**Response:** 
```
I requested the deep logs calling `get_occurrence` specifically mapped to '1234abcd'. The system presented the raw stack trace revealing an uncaught `TypeError` exception breaking at `Line 42` inside `payments_module.js`. Let me print the full code output block mapped by Rollbar for you below to review.
```

**Prompt:** 
```
Report a new deployment in Rollbar for the 'production' environment using the commit revision '8a3bd41'.
```

**Response:** 
```
Action logged successfully! I triggered `report_deploy` and recorded the newest application launch for the 'production' infrastructure in Rollbar tagged dynamically with the tracking code revision '8a3bd41'. All subsequent exceptions identified via Rollbar modules will now be bound closely correlated automatically to this specific commit update marker.
```

## Capabilities

### Check for current bugs
The agent can list all currently tracked error items or quickly show the most frequent issues impacting users right now.

### View detailed failure logs
Provide a specific error ID to pull up every recorded instance and get the complete stack trace showing where the code failed.

### Track deployments
The agent lists all past code deployments or reports a brand new release tied to a Git revision.

### Change bug status
Update an error item's state, marking it as resolved or muting the alert if necessary.

## Use Cases

### The sudden production outage
A developer notices an alert about a broken endpoint. Instead of logging into Rollbar, they ask their agent to run `get_occurrence` for the latest ID. The agent immediately pulls the full stack trace showing a critical data type mismatch at Line 42 in the payments module.

### Post-deployment sanity check
An SRE just merged code and needs to verify monitoring is active. They tell their agent to run `report_deploy` for 'production' with the new commit ID, ensuring all subsequent errors are correctly linked.

### Cleaning up old bugs
An Engineering Manager knows a bug was fixed last week but the ticket is still marked active. They instruct their agent to use `update_item` on that specific error ID, changing its status to 'resolved' and clearing the board.

### Finding persistent pain points
A developer wants to know what's breaking the most often. They ask their agent for `top_active_items`, getting a ranked list of bugs, allowing them to prioritize fixes based on real user impact.

## Benefits

- You stop manually cross-referencing Git tags with error dashboards. Simply ask your agent to report a new release using the `report_deploy` tool, automatically linking future bugs to that specific commit.
- Instead of wading through hundreds of dashboard entries, use `top_active_items` to get an immediate list of the most frequent and high-impact issues affecting your user base right now.
- Debugging complex failures is faster. If you have a bad error ID, passing it to `get_occurrence` pulls the full stack trace directly into your chat, letting you see exactly where in the code the failure happened.
- Managing bug lifecycles becomes conversational. After fixing an issue, tell your agent to use `update_item` and change its status; no manual dashboard clicks are required.
- You can get a bird's-eye view of historical issues by running `list_items`, giving you a clean summary of every distinct error type the application has seen.

## How It Works

The bottom line is, after connecting the token, you talk directly to Rollbar about your code's health.

1. First, launch the Rollbar tool inside your MCP environment.
2. Next, you sign in to your Rollbar developer dashboard and generate a read/write access token.
3. Finally, paste that specific Rollbar Access Token into the connection form. You're ready to chat.

## Frequently Asked Questions

**How do I check for recent errors using Rollbar MCP?**
You can list all current issues by asking the agent to run `list_items`. For a more targeted view, use `top_active_items` to see only the most frequent bugs.

**Can I update an error status with Rollbar MCP?**
Yes, you can tell your agent to use `update_item`. This changes the bug's official state in Rollbar to active, resolved, or muted.

**What if I need to report a new release using Rollbar MCP?**
Use the `report_deploy` tool. You just need to provide the environment name (like 'production') and the specific Git commit revision number for the deployment.

**Does Rollbar MCP help with stack traces?**
Absolutely. If you have an error ID, the agent can run `get_occurrence` to retrieve the complete raw stack trace logs, showing exactly where your application failed.

**Is this tool for managing user accounts?**
No. This MCP is solely designed for code health and deployment monitoring within Rollbar; it cannot manage users or invitations (though `list_invites` can check for pending invites).