# Raygun MCP

> Raygun connects your AI agent to deep application monitoring data. It lets you query your app's stability, track which code deployments caused slowdowns, and inspect user-specific session recordings using plain language commands. Get visibility into crashes and real-world performance without ever leaving your chat window.

## Overview
- **Category:** developer-tools
- **Price:** Free
- **Tags:** error-tracking, crash-reporting, rum, application-monitoring, deployment-tracking

## Description

Need to know why the checkout page is slow? You don't have to jump through a dozen dashboards or wait for an engineer to pull logs. This MCP lets you talk directly to your application's health data. Your agent can automatically check which versions of your app are running and correlate those releases with performance drops. If a user reports a bug, you can search for that specific session key and get detailed metadata on exactly what happened—the browser, the steps taken, everything. Because Vinkius hosts this MCP, connecting it is simple: you authenticate once from any compatible client, and suddenly your agent has access to all these monitoring tools. You use natural conversation to manage crash reports and check application health across multiple environments.

## Tools

### create_legacy_deployment
Generates a deployment record using the legacy API endpoint.

### list_applications
Retrieves a full list of all applications available in your Raygun account.

### list_deployments
Fetches and lists all deployments associated with one specific application ID.

### rum_authenticate
Authenticates the connection to the legacy Real User Monitoring API.

### rum_get_session
Retrieves complete metadata for a single, specified RUM user session.

### rum_search_sessions
Searches through many RUM sessions using criteria like date range or geographic location.

### send_crash_report
Sends an error payload or crash report manually to Raygun for immediate tracking.

## Prompt Examples

**Prompt:** 
```
List all my Raygun applications.
```

**Response:** 
```
I've retrieved your applications. You have 'Main-Web-App' (ID: abc-123) and 'Mobile-API' (ID: def-456) active. Which one would you like to inspect?
```

**Prompt:** 
```
Show me the latest deployments for application ID abc-123.
```

**Response:** 
```
Fetching deployments for 'Main-Web-App'... I found 3 recent deployments. The latest was version 2.1.0, deployed 2 hours ago by 'CI-Runner'.
```

**Prompt:** 
```
Search for RUM sessions from the US using session key XYZ.
```

**Response:** 
```
Searching RUM sessions... I found 12 sessions from the US. Most users are on Chrome/macOS. Would you like to see the details for the most recent session?
```

## Capabilities

### List accessible applications
Retrieves a list of every environment or service you have set up within your Raygun account.

### Track deployment history
Shows the status and details for recent code deployments across specific applications.

### Search user sessions
Finds and lists performance records from real users, allowing you to target a specific group or date range.

### Inspect session details
Pulls detailed metadata for a single user session so you can pinpoint the moment an issue occurred.

### Report crashes manually
Allows you to send error payloads or crash dumps directly to Raygun for centralized tracking and analysis.

## Use Cases

### The critical bug only affects European users.
A QA engineer notices errors spiking in London. Instead of manually filtering logs by IP range and date, they ask their agent to search RUM sessions from the UK using `rum_search_sessions`. The results point directly to a missing dependency when accessing the payment page.

### Need to know if last night's release was bad.
The DevOps team just pushed version 3.2.0. Before declaring success, they check `list_deployments` for the main application. They see the deployment timeline and immediately cross-reference it with performance dashboards, catching a memory leak introduced in that specific commit.

### A customer reports an issue but gives no details.
The support team gets vague complaint: 'It broke when I did X.' They use the agent to search for sessions around the time the user claimed, using `rum_search_sessions`. The detailed metadata from a found session reveals that the client was running an outdated browser version.

### Manually submitting test errors.
During local testing, a developer hits a rare edge case error. Instead of filing a ticket and waiting for triage, they use `send_crash_report` through the agent to immediately feed the payload into Raygun's central tracking system.

## Benefits

- Pinpoint the source of slowdowns. By using `list_deployments`, you can instantly tie a drop in performance metrics to a specific code release, cutting hours off root-cause analysis.
- Debug customer bugs fast. Use `rum_search_sessions` and then `rum_get_session` to find and inspect the exact user journey that triggered an error, no guesswork required.
- Stay ahead of crashes. Instead of waiting for a full incident report, you can use `send_crash_report` directly from your agent during testing phases.
- Get a clear view of all services. The `list_applications` tool gives you an immediate inventory of every environment and service monitored by Raygun.
- Understand real user behavior. Querying session data lets Product Owners validate how new features perform in the wild, not just on internal test accounts.

## How It Works

The bottom line is you use natural language to query complex monitoring systems without needing to write any code or jump through menus.

1. Subscribe to this MCP on Vinkius.
2. Enter your Raygun Personal Access Token or API Key into the connection settings.
3. Ask your AI client a question, like 'What was the performance of the mobile app last night?' and get instant data back.

## Frequently Asked Questions

**How do I check which applications are monitored by Raygun MCP?**
You can use the `list_applications` tool to get an immediate inventory of every environment and service you have set up in your account.

**What if I need to find a specific bug from last month? Does Raygun MCP handle that?**
Yes. Use the `rum_search_sessions` tool, specifying date ranges or geographic locations. This lets you narrow down millions of sessions to just the ones you care about.

**Is manual crash reporting difficult with Raygun MCP?**
No, it's simple. You use `send_crash_report` through your agent; it takes the error data and sends it directly to Raygun's centralized tracking system.

**Can I see what code version caused a performance dip?**
You can check this using `list_deployments`. This tool lets you view deployment history, allowing you to correlate slowdowns with specific versions or commit IDs.