Automated Error Analysis with Sentry MCP
Build an AI-powered error monitoring workflow that analyzes Sentry issues, identifies patterns, and creates actionable GitHub issues automatically.
🚀 New: Sentry Mission Control Integration with Continuous AI
The new Sentry Mission Control Integration enables Continuous AI for error monitoring - where AI agents autonomously detect, analyze, and fix production errors. When Sentry detects an issue, your agent automatically analyzes it, generates a fix, creates a PR, and validates the solution without manual intervention.
Mission Control Benefits:
- Webhook-based triggers - Automatically respond when new errors occur in production
- Centralized error workflows - Manage all error monitoring Tasks from one dashboard
- Dedicated inbox view - Monitor all Sentry-related agent activity at continue.dev/inbox?view=sentry
- Metrics & intervention rates - Track how often agents successfully fix errors without human help
This represents Level 2 Continuous AI: AI handles routine error analysis and fixes autonomously while developers focus on complex problems. As outlined in our Continuous AI guide, this reduces mean time to resolution (MTTR) and improves application reliability.
Get Started: Use this cookbook to understand error monitoring fundamentals, then enable Mission Control to deploy autonomous error-fixing agents across your organization.
What You'll Build
An automated error monitoring system that uses Continue CLI with Sentry MCP to analyze production errors, identify root causes with AI, and create detailed GitHub issues with suggested fixes.
What You'll Learn
This cookbook teaches you to:
-
Use Sentry MCP to access issues
-
Analyze error patterns and stack traces with AI
-
Automatically create GitHub issues with root cause analysis
-
Set up continuous error monitoring with GitHub Actions
Prerequisites
Before starting, ensure you have:
- GitHub repository where you want to create issues
- Sentry account with an active project collecting errors
- Node.js 18+ installed locally
- Continue CLI with active credits (required for API usage)
- GitHub CLI installed (
ghcommand)
1
Install Continue CLI
curl -fsSL https://raw.githubusercontent.com/continuedev/continue/main/extensions/cli/scripts/install.sh | bash
2
Set up Continue CLI Account & API Key
- Visit Continue Organizations
- Sign up or log in to your Continue account
- Navigate to your organization settings
- Click "API Keys" and then "+ New API Key"
- Copy the API key immediately (you won't see it again!)
- Login to the CLI:
cn login
Continue CLI handles complex error analysis and API interactions - you just need to provide the right prompts!
Step 1: Set Up Your Credentials
First, you'll need to gather your Sentry and GitHub API credentials.
See Sentry MCP Documentation for detailed configuration options
The Sentry MCP supports multiple configuration methods. For Continue CLI, OAuth is recommended:
Option 1: OAuth Configuration (Recommended)
The Sentry MCP will prompt for OAuth authentication when first used. Simply follow the authorization flow.
Option 2: STDIO Mode with Auth Token
For local development or self-hosted Sentry installations, you can use STDIO mode:
npx @sentry/mcp-server@latest --access-token=YOUR_SENTRY_TOKEN --host=sentry.io
Or use environment variables:
SENTRY_ACCESS_TOKEN=your-token SENTRY_HOST=sentry.io
The
--host parameter is required and should point to your Sentry instance (e.g., sentry.io or sentry.example.com for self-hosted).Sentry Error Monitoring Workflow Options
Fastest Path to Success
Skip the manual setup and use our pre-built Sentry Continuous AI agent that includes
optimized prompts, rules, and the Sentry MCP for more consistent results.
How Sentry MCP Works:
- Connects to your Sentry organization via OAuth
- Provides tools for accessing issues, projects, teams, and DSNs
- Supports both hosted (
https://mcp.sentry.dev) and self-hosted Sentry instances - Automatically handles authentication and API interactions
Perfect for: Immediate error analysis with AI-powered root cause detection and built-in debugging
1
Add the Pre-Built Agent
Visit the Sentry Continuous AI Agent on Continue Mission Control and click "Install Agent" or run:
cn --agent continuedev/sentry-continuous-ai-agent
This agent includes:
- Optimized prompts for Sentry error analysis and GitHub issue creation
- Built-in rules for consistent formatting and error handling
- Sentry MCP for more reliable API interactions
- Automatic authentication via OAuth flow
2
Run Error Analysis
Navigate to your project directory and enter this prompt in the Continue CLI TUI:
Analyze recent Sentry errors and create GitHub issues for critical bugs with suggested fixes
That's it! The agent handles everything automatically.
Why Use the Agent? Results are more consistent and debugging is easier thanks to the Sentry MCP integration and pre-tested prompts.
Why GitHub CLI over GitHub MCP: While GitHub MCP is available, it can be
token-expensive to run. The
gh CLI is more efficient, requires no API tokens
(authenticated via gh auth login), and provides a cleaner command-line
experience. GitHub MCP remains an option if you prefer full MCP integration.Repository Labels Required: Make sure your GitHub repository has these labels:
bug,sentry,productioncritical,high-priority,medium-priority,low-priorityneeds-investigation,has-fix
Create missing labels in your repo at: Settings → Labels → New label
Step 2: Analyze Sentry Errors with AI
Use Continue CLI to perform intelligent error analysis. Enter these prompts in the Continue CLI TUI:
To run any of the example prompts below in headless mode, use
cn -p "prompt"Prompt:
Show me Sentry errors from the past 7 days, grouped by error type, with frequency counts
Available Sentry MCP Tools:
- Organizations: Access org-level data and settings
- Projects: Query projects and their configurations
- Issues: Search and analyze error issues
- Teams: Manage team assignments
- DSNs: Retrieve project DSN configurations
Step 3: Automate GitHub Issue Creation
Create actionable GitHub issues from Sentry errors. Enter this prompt in the Continue CLI TUI:
Prompt:
For each unresolved Sentry error with 'critical' or 'high' severity:
1. Analyze the error using Sentry MCP
2. Create a GitHub issue with gh CLI:
- Title: '🐛 [Sentry] [Error Type]: Brief description'
- Body with:
* Error summary and impact (affected users, frequency)
* Full stack trace
* Environment details (browser, OS, release version)
* Link to Sentry issue
* Root cause analysis from AI
* Suggested fix with code snippets
* Related Sentry issues
- Labels: 'bug', 'sentry', 'production', and severity label
- Assignees: Team member based on code ownership
3. Update Sentry issue with GitHub issue link
4. Confirm creation with GitHub issue URL
Best Practice: Link GitHub issues back to Sentry for full traceability. This creates a bidirectional connection between your error monitoring and issue tracking.
Step 4: Set Up Continuous Monitoring with GitHub Actions
Automate error monitoring with the Sentry Release GitHub Action and Continue CLI to create comprehensive, AI-powered issue descriptions:
Why Combine Sentry Releases with Continue CLI?
- Release Tracking: Associate errors with specific deployments
- AI-Powered Analysis: Continue CLI generates detailed issue descriptions with root cause analysis
- Better Context: Link errors to commits and pull requests
- Automated Workflows: Create issues with full stack traces and suggested fixes
name: Sentry Error Monitoring
on:
push:
branches:
- main
schedule:
# Run every 6 hours
- cron: "0 */6 * * *"
workflow_dispatch: # Allow manual triggers
jobs:
monitor-errors:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
with:
fetch-depth: 0
- uses: actions/setup-node@v4
with:
node-version: "22"
# Create Sentry release for better error tracking
- name: Create Sentry release
uses: getsentry/action-release@v1
env:
SENTRY_AUTH_TOKEN: ${{ secrets.SENTRY_AUTH_TOKEN }}
SENTRY_ORG: ${{ secrets.SENTRY_ORG }}
SENTRY_PROJECT: ${{ secrets.SENTRY_PROJECT }}
with:
environment: production
- name: Install Continue CLI
run: |
npm install -g @continuedev/cli
echo "✅ Continue CLI installed"
- name: Authenticate GitHub CLI
run: |
echo "${{ secrets.GITHUB_TOKEN }}" | gh auth login --with-token
echo "✅ GitHub CLI authenticated"
- name: Analyze Sentry Errors and Create Issues
env:
CONTINUE_API_KEY: ${{ secrets.CONTINUE_API_KEY }}
SENTRY_AUTH_TOKEN: ${{ secrets.SENTRY_AUTH_TOKEN }}
SENTRY_ORG: ${{ secrets.SENTRY_ORG }}
SENTRY_PROJECT: ${{ secrets.SENTRY_PROJECT }}
run: |
echo "🔍 Analyzing Sentry errors..."
# Use Continue CLI to analyze errors and generate comprehensive issue descriptions
cn -p "Using Sentry MCP, analyze errors from the past 6 hours for project $SENTRY_PROJECT:
1. Filter for unresolved errors with high or critical severity
2. Group similar errors to avoid duplicates
3. For each unique critical error:
- Generate a comprehensive issue description including:
* Error summary with frequency and user impact metrics
* Full stack trace with highlighted problem areas
* Environment details (browser, OS, release version)
* Link to Sentry issue dashboard
* Root cause analysis using AI
* Step-by-step reproduction if available
* Suggested fix with code examples
* Related errors or patterns
- Check if a GitHub issue already exists for this error
- If not, create a new issue with the generated description
- Use gh CLI: gh issue create --title '[Sentry] [Error Type]: Brief description' --body 'AI-generated comprehensive analysis' --label 'bug,sentry,critical,needs-investigation'
- Link the GitHub issue back to Sentry
4. Generate a summary report with:
- Total errors analyzed
- New issues created with URLs
- Errors skipped (already tracked)
- Release correlation if available
Sentry Organization: $SENTRY_ORG
Project: $SENTRY_PROJECT
Only process errors not already tracked in GitHub."
- name: Post workflow summary
if: always()
run: |
echo "## 📊 Sentry Error Monitoring Summary" >> $GITHUB_STEP_SUMMARY
echo "✅ Workflow completed at $(date)" >> $GITHUB_STEP_SUMMARY
echo "" >> $GITHUB_STEP_SUMMARY
echo "Check the 'Analyze Sentry Errors' step above for:" >> $GITHUB_STEP_SUMMARY
echo "- Number of errors analyzed" >> $GITHUB_STEP_SUMMARY
echo "- GitHub issues created" >> $GITHUB_STEP_SUMMARY
echo "- Errors already tracked" >> $GITHUB_STEP_SUMMARY
Required GitHub Secrets:
CONTINUE_API_KEY: Your Continue API key from continue.dev/settings/api-keysSENTRY_AUTH_TOKEN: Your Sentry User Auth Token (needs scopes:org:read,project:read,project:releases,event:read)SENTRY_ORG: Your Sentry organization slugSENTRY_PROJECT: Your Sentry project slugGITHUB_TOKEN: Automatically provided by GitHub Actions
Add these at: Repository Settings → Secrets and variables → Actions
Workflow Best Practices:
- Run every 6 hours to catch critical errors quickly
- Create Sentry releases on push to track error-to-deployment correlation
- Use Continue CLI to generate comprehensive, AI-powered issue descriptions
- Use duplicate detection to avoid creating multiple issues for the same error
- Filter by severity to focus on high-impact issues
- Include full error context and suggested fixes in issues
- Tag issues with appropriate labels for team routing
- Link GitHub issues back to Sentry for bidirectional tracking
What You've Built
After completing this guide, you have a complete Sentry-powered error monitoring system that:
-
Monitors production errors - Automatically fetches and analyzes Sentry issues every 6 hours
-
Identifies critical bugs - Uses AI to spot high-impact errors
-
Creates actionable tasks - Generates GitHub issues with root cause analysis and suggested fixes
-
Runs autonomously - Operates continuously without manual intervention using GitHub Actions
-
Scales with your app - Handles growing error volumes and complexity automatically
Continuous AI Error Monitoring
Your system now operates at Level 2 Continuous AI - AI handles routine error analysis with human oversight through GitHub issue review and resolution.
Advanced Error Analysis Prompts
Enhance your workflow with these advanced Continue CLI prompts:
Release Impact Analysis
Compare error rates before and after the latest Sentry release to identify regressions introduced in the deployment
Error Trend Detection
Analyze Sentry error trends over the past 30 days and identify emerging issues before they become critical
User Impact Assessment
Identify which errors are affecting the most unique users and prioritize fixes based on user impact
Performance Correlation
Cross-reference Sentry performance issues with error spikes to identify root causes
Security Best Practices
Protect Your API Keys:
- Store all credentials as GitHub Secrets, never in code
- Use Continue CLI's secure secret storage
- Limit Sentry token scopes to minimum required permissions
- Rotate API keys regularly (every 90 days recommended)
- Monitor token usage for unusual activity
- Use OAuth when possible for better security
Troubleshooting
Sentry MCP Connection Issues
If you encounter connection issues:
- Verify OAuth authentication is complete
- Check your Sentry organization access
- Ensure the MCP server URL is correct (
https://mcp.sentry.dev/mcp) - For self-hosted Sentry, verify your host URL is configured correctly
See the Sentry MCP GitHub Issues for known issues and solutions.
Common Error Analysis Issues
| Issue | Solution |
|---|---|
| No errors returned | Verify your Sentry project has collected errors recently |
| OAuth prompt not appearing | Check that Continue CLI has proper MCP configuration |
| Duplicate GitHub issues | Implement duplicate detection in your prompts |
| Missing error context | Ensure your Sentry token has event:read scope |
Next Steps
- Set up Sentry performance monitoring
- Configure Sentry release tracking for deployment correlation
- Integrate Slack MCP for error alerts
- Join the GitHub Discussions for support