Scout Monitoring MCP
OfficialThis server exposes Scout Monitoring's application performance and error data to AI assistants, enabling setup guidance and deep performance investigation.
Setup Scout APM: Get official step-by-step instrumentation instructions for frameworks like Rails, Django, Flask, FastAPI, Celery, and SQLAlchemy.
Discover applications: List Scout APM apps, filtered by activity date.
Analyze app metrics: Retrieve timeseries data (response time, throughput, etc.) for an app, endpoint, or background job.
Inspect endpoints & jobs: List all endpoints and background jobs with aggregated performance metrics to spot slow or high-throughput areas.
Examine traces: Fetch recent traces per endpoint or job, and pull detailed individual traces with all spans for line-of-code analysis.
Diagnose errors: Get recent error groups, optionally filtered by endpoint or group.
Detect anomalies: List and inspect anomaly events (response time spikes, throughput drops) with smart-monitor and deploy context.
Surface performance insights: Retrieve N+1 queries, memory bloat, and slow query insights.
Check usage: View billing period usage, transaction/node/error counts, and log bytes.
Access config resources: Read framework-specific setup templates and the list of available metrics.
Provides access to Scout APM performance monitoring data for Django applications, including traces, errors, endpoint metrics, and performance insights
Provides access to Scout APM performance monitoring data for FastAPI applications, including traces, errors, endpoint metrics, and performance insights
Can be combined with AI assistants to create GitHub issues based on Scout APM error and performance data
Can be combined with AI assistants to create GitLab issues based on Scout APM error and performance data
Can be combined with AI assistants to create Jira tickets with detailed error and performance information from Scout APM
Provides access to Scout APM performance monitoring data for Laravel applications, including traces, errors, endpoint metrics, and performance insights
Provides access to Scout APM performance monitoring data for PHP applications, including traces, errors, endpoint metrics, and performance insights
Provides access to Scout APM performance monitoring data for Python applications, including traces, errors, endpoint metrics, and performance insights
Provides access to Scout APM performance monitoring data for Ruby applications, including traces, errors, endpoint metrics, and performance insights
Click on "Deploy 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., "@Scout Monitoring MCP show me the slowest endpoints in my Rails app from the last 24 hours"
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.
Scout Monitoring MCP
This puts Scout Monitoring's performance and error data directly in the hands of your AI Assistant. For Rails, Django, FastAPI, Laravel and more. Use it to get traces and errors with line-of-code information that the AI can use to target fixes right in your editor and codebase. N+1 queries, slow endpoints, slow queries, memory bloat, throughput issues - all your favorite performance problems surfaced and explained right where you are working.
If this makes your life a tiny bit better, why not :star: it?!
Setup Wizard
The simplest way to configure and start using the Scout MCP is with our interactive setup wizard. It handles all the prereqs and installation steps for you.
Run via npx:
npx @scout_apm/wizardBuild and run from source:
cd ./wizard
npm install
npm run build
node dist/wizard.jsThe wizard will guide you through:
Selecting your AI coding platform (Cursor, Claude Code, Claude Desktop)
Entering your Scout API key
Automatically configuring the MCP server settings
Supported Platforms
The wizard currently supports setup for:
Cursor - Automatically configures MCP settings
Claude Code (CLI) - Provides the correct command to run
Claude Desktop - Updates the configuration file for Windows/Mac
For all others, it will output JSON that you can copy/paste into your AI Assistant's MCP configuration.
Related MCP server: AppSignal MCP
Prerequisites
The Wizard is a great way to get started, but you can also set things up manually. You will need to have or create a Scout Monitoring account and obtain an API key.
Install the Scout Agent in your application and send Scout data!
Visit settings to get or create an API key
This is not your "Agent Key"; it's the "API Key" that can be created on the Settings page
This is a read-only key that can only access data in your account
Install Docker. Instructions below assume you can start a Docker container
The MCP server will not currently start without an API key set, either in the environment or by a command-line argument on startup.
Installation
We recommend using the provided Docker image to run the MCP server. It is intended to be started by your AI Assistant and configured with your Scout API key. Many local clients allow specifying a command to run the MCP server in some location. A few examples are provided below.
The Docker image is available on Docker Hub.
Of course, you can always clone this repo and run the MCP server directly; uv or other
environment management tools are recommended.
Configure a local Client (e.g. Claude/Cursor/VS Code Copilot)
If you would like to configure the MCP manually, this usually just means supplying a command to run the MCP server with your API key in the environment to your AI Assistant's config. Here is the shape of the JSON (the top-level key varies):
{
"mcpServers": {
"scout-apm": {
"command": "docker",
"args": ["run", "--rm", "-i", "--env", "SCOUT_API_KEY", "scoutapp/scout-mcp-local"],
"env": { "SCOUT_API_KEY": "your_scout_api_key_here"}
}
}
}claude mcp add scoutmcp -e SCOUT_API_KEY=your_scout_api_key_here -- docker run --rm -i -e SCOUT_API_KEY scoutapp/scout-mcp-localMAKE SURE to update the SCOUT_API_KEY value to your actual api key in
Arguments in the Cursor Settings > MCP
We recommend the "Add an MCP server to your workspace" option
Add the following to your claude config file:
macOS:
~/Library/Application Support/Claude/claude_desktop_config.jsonWindows:
%APPDATA%/Claude/claude_desktop_config.json
{
"mcpServers": {
"scout-apm": {
"command": "docker",
"args": ["run", "--rm", "-i", "--env", "SCOUT_API_KEY", "scoutapp/scout-mcp-local"],
"env": { "SCOUT_API_KEY": "your_scout_api_key_here"}
}
}
}Using the Scout Monitoring MCP
Scout's MCP is intended to put error and performance data directly in the... hands? of your AI Assistant. Use it to get traces and errors with line-of-code information that the AI can use to target fixes right in your editor.
Most assistants will show you both raw tool calls and perform analysis. Desktop assistants can readily create custom JS applications to explore whatever data you desire. Assistants integrated into code editors can use trace data and error backtraces to make fixes right in your codebase.
Combine Scout's MCP with your AI Assistant's other tools to:
Create rich GitHub/GitLab issues based on errors and performance data
Make JIRA fun - have your AI Assistant create tickets with all the details
Generate PRs that fix specific errors and performance problems
Tools
The Scout MCP provides the following tools for accessing Scout APM data:
list_apps- List available Scout APM applications, with optional filtering by last active dateget_app_metrics- Get individual metric data (response_time, throughput, etc.) for a specific applicationget_app_endpoints- Get all endpoints for an application with aggregated performance metricsget_endpoint_metrics- Get timeseries metrics for a specific endpoint in an applicationget_app_endpoint_traces- Get recent traces for an app filtered to a specific endpointget_app_trace- Get an individual trace with all spans and detailed execution informationget_app_error_groups- Get recent error groups for an app, optionally filtered by endpointget_app_insights- Get performance insights including N+1 queries, memory bloat, and slow queries
Resources
The Scout MCP provides configuration templates as resources that your AI assistant can read and apply:
scoutapm://config-resources/{framework}- Setup instructions for supported framework or library (rails, django, flask, fastapi)scoutapm://config-resources/list- List all available configuration templatesscoutapm://metrics- List of all available metrics for Scout APM
Useful Prompts
Setup & Configuration
"Help me set up Scout monitoring for my Rails application"
"Create a Scout APM config file for my Django project with key ABC123"
Performance & Monitoring
"Summarize the available tools in the Scout Monitoring MCP."
"Find the slowest endpoints for app
my-app-namein the last 7 days. Generate a table with the results including the average response time, throughput, and P95 response time.""Show me the highest-frequency errors for app
Fooin the last 24 hours. Get the latest error detail, examine the backtrace and suggest a fix.""Get any recent n+1 insights for app
Bar. Pull the specific trace by id and help me optimize it based on the backtrace data."
Token Usage
We are currently more interested in expanding available information than strictly
controlling response size from our MCP tools. If your AI Assistant has a configurable
token limit (e.g. Claude Code export MAX_MCP_OUTPUT_TOKENS=50000), we recommend
setting it generously high, e.g. 50,000 tokens.
Local Development
We use uv and taskipy to manage environments and run tasks for this project.
Run with Inspector
uv run task devConnect within inspector to add API key, set to STDIO transport
Build the Docker image
docker build -t scout-mcp-local .Release
Branch and bump versions with
uv run python bump_versions.pyGet that merged
Create a GitHub release with the new version (
gh release create v2025.11.3 --generate-notes --draft)
Publishing the release pushes the v* tag, and CI publishes the Docker image, the PyPI package, and then the
MCP Registry entries:
server.json→com.scoutapm/scout-mcp-local(this server; its version is bumped bybump_versions.py)server.remote.json→com.scoutapm/scout-monitoring(the hosted server athttps://scoutapm.com/mcp). Bump itsversionby hand when you change its metadata; unchanged versions are skipped.
MCP Registry key
The registry verifies we own the com.scoutapm/* namespace through a DNS TXT record at the scoutapm.com apex
holding an Ed25519 public key. CI signs in with the matching private key from the MCP_REGISTRY_PRIVATE_KEY
repository secret. To rotate it:
openssl genpkey -algorithm Ed25519 -out key.pem
# Public key for the TXT record: replace the existing v=MCPv1 record, don't add a second one
echo "v=MCPv1; k=ed25519; p=$(openssl pkey -in key.pem -pubout -outform DER | tail -c 32 | base64)"
# Private key (hex) for the MCP_REGISTRY_PRIVATE_KEY secret
openssl pkey -in key.pem -noout -text | grep -A3 "priv:" | tail -n +2 | tr -d ' :\n'For the bots:
mcp-name: com.scoutapm/scout-mcp-local
Available Tools
15 toolsget_app_anomaly_eventB
Get a single anomaly event by ID, with smart_monitor and deploy context.
Inputs: app_id (required), anomaly_event_id (required). Returns: object
get_app_anomaly_eventsA
List anomaly events for a Scout APM application within a timeframe.
Anomaly events flag statistically significant deviations in a metric (e.g. response time spike, throughput drop) detected against a learned baseline.
Args: app_id: The ID of the Scout APM application. from_: Start datetime in ISO 8601 format. to: End datetime in ISO 8601 format. state: Filter by state - "open", "closed", or "all". metric: Filter by metric (e.g. response_time, throughput, error_rate). endpoint: Filter by endpoint (controller path).
Inputs: to (required), from_ (required), app_id (required), state, +2 more. Returns: result
get_app_endpointsA
Get all endpoints for a specific application. Also gets aggregated performance metrics withing the window of "from_" to "to". Useful for identifying high throughput, high latency or high error rate endpoints accross the application with a single call.
These endpoints can be used in other tools to fetch endpoint-specific metrics, traces or errors.
Args: app_id (int): The ID of the Scout APM application. from_ (str): The start datetime in ISO 8601 format. to (str): The end datetime in ISO 8601 format.
Inputs: to (required), from_ (required), app_id (required). Returns: result
get_app_endpoint_tracesC
Get recent traces for an app filtered to a specific endpoint.
Args: app_id (int): The ID of the Scout APM application. endpoint_id (str): The ID of the endpoint to filter traces. from_ (str): The start datetime in ISO 8601 format. to (str): The end datetime in ISO 8601 format.
Inputs: to (required), from_ (required), app_id (required), endpoint_id (required). Returns: result
get_app_error_groupsC
Get recent error_groups for an app, optionally filtered to a specific endpoint or group.
Args: app_id (int): The ID of the Scout APM application. endpoint_id (str | None): The ID of the endpoint to filter errors. If None, fetches all errors for the app. error_group_id (str | None): The ID of the error group to filter errors.
Inputs: to (required), from_ (required), app_id (required), endpoint_id, +1 more. Returns: result
get_app_insightsA
Get or generate all insights for an application (cached for 5 minutes).
Returns performance insights including N+1 queries, memory bloat, and slow queries. Each insight type includes count, new_count, and items array with specific details. If insight_type is provided, only that type will be returned.
Args: app_id (int): The ID of the Scout APM application. insight_type: (str | None): Type of insight to filter (n_plus_one, memory_bloat, slow_query) If None (the default), all types will be returned. limit (int | None): Maximum number of items per insight type (default: 20).
Inputs: app_id (required), limit, insight_type. Returns: object
get_app_jobsA
Get all background jobs for a specific application. Also gets aggregated performance metrics within the window of "from_" to "to". Useful for identifying high throughput, high latency or high error rate jobs across the application with a single call.
Each job includes: full_name, name, queue, job_id, throughput, execution_time, time_consumed, latency.
Args: app_id (int): The ID of the Scout APM application. from_ (str): The start datetime in ISO 8601 format. to (str): The end datetime in ISO 8601 format.
Inputs: to (required), from_ (required), app_id (required). Returns: result
get_app_job_tracesB
Get recent traces for an app filtered to a specific background job.
Each trace includes: id, time, duration, name, queue, metric_name, context.
Args: app_id (int): The ID of the Scout APM application. job_id (str): The Base64-encoded job ID. from_ (str): The start datetime in ISO 8601 format. to (str): The end datetime in ISO 8601 format.
Inputs: to (required), from_ (required), app_id (required), job_id (required). Returns: result
get_app_metricsB
Get individual metric data for a specific application.
Args: app_id (int): The ID of the Scout APM application. metric (str): The metric to retrieve (e.g., "response_time", "throughput"). from_ (str): The start datetime in ISO 8601 format. to (str): The end datetime in ISO 8601 format.
Inputs: to (required), from_ (required), app_id (required), metric (required). Returns: object
get_app_traceA
Get an individual trace with all spans.
Args: app_id (int): The ID of the Scout APM application. trace_id (int): The ID of the trace to retrieve.
Inputs: app_id (required), trace_id (required). Returns: object
get_endpoint_metricsB
Get a single timeseries metric for a specific endpoint in an application.
Args: app_id (int): The ID of the Scout APM application. endpoint (str): The endpoint path (e.g., "/users", "/orders"). metric (str): The metric to retrieve (e.g., "response_time", "throughput"). from_ (str): The start datetime in ISO 8601 format. to (str): The end datetime in ISO 8601 format.
Inputs: to (required), from_ (required), app_id (required), metric (required), +1 more. Returns: object
get_job_metricsA
Get a single timeseries metric for a specific background job in an application.
Valid job metrics: throughput, execution_time, latency, errors, allocations.
Args: app_id (int): The ID of the Scout APM application. job_id (str): The Base64-encoded job ID. metric (str): The metric to retrieve (e.g., "execution_time", "throughput"). from_ (str): The start datetime in ISO 8601 format. to (str): The end datetime in ISO 8601 format.
Inputs: to (required), from_ (required), app_id (required), job_id (required), +1 more. Returns: object
get_scout_setup_instructionsA
Get step-by-step instructions to instrument Scout APM in a framework.
Always use this tool first when asked to setup/instrument/configure Scout APM in an application. This provides official, tested configuration instructions that should be followed exactly.
Supported frameworks:
Web: bottle, dash, django, falcon, fastapi, flask, hug, rails, starlette
Background Jobs: celery, dramatiq, huey, rq
Database: sqlalchemy
Args: framework: The framework or library name (e.g., "fastapi", "django", "celery")
Returns: Complete setup instructions including installation, configuration, and examples.
Inputs: framework (required). Returns: result
get_usageA
Get usage and billing data for the current billing period.
Returns billing period dates, pricing style, APM transaction counts (with limit if applicable), node counts (for per-node pricing), error counts (if error monitoring is enabled), and log bytes used (if logs integration is enabled).
Inputs: no named parameters. Returns: result
list_appsA
List available Scout APM applications. Provide an optional active_since ISO 8601
to filter to only apps that have reported data since that time. Defaults to the
metric retention period of thirty days.
Args: active_since (str): ISO 8601 datetime string to filter apps active since that time.
Inputs: active_since. Returns: result
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 15 tools
The tools mostly target distinct resources and actions, and descriptions clarify scope. There is some potential confusion among the metric/trace families (app, job, endpoint metrics; app trace vs job/endpoint traces), but the naming and parameter descriptions make them separable.
All tools use snake_case with a predictable verb_noun pattern, mostly get_* or list_*, and the singular/plural distinction is meaningful. The set is consistently readable and follows a clear convention throughout.
Fifteen tools is well-scoped for an APM monitoring server covering apps, metrics, traces, jobs, endpoints, errors, anomalies, insights, usage, and setup. Each tool appears to earn its place without excessive surface area.
The surface covers the major monitoring workflows: discovering apps, inspecting metrics and traces across apps/jobs/endpoints, error groups, anomalies, insights, usage, and setup instructions. Minor gaps remain around drilling into individual error group details or deeper error diagnostics, but most workflows are workable.
Maintenance
Related MCP Connectors
Scout Monitoring data for AI assistants: slow endpoints, traces, N+1 queries, and errors.
Lets AI agents analyze API metrics, request logs, and traces, and manage apps and alerts.
Observability for AI apps: investigate traces, logs, LLM usage, replays and crashes; manage alerts.
Application monitoring: exceptions, slow requests, jobs, queries, logs and uptime monitors.
Related MCP Servers
- AlicenseCqualityBmaintenanceEnables AI assistants to interact with New Relic monitoring and observability data through programmatic access to New Relic APIs. Supports APM management, NRQL queries, alert policies, synthetic monitoring, dashboards, infrastructure monitoring, and deployment tracking.27296 PyPI6MIT
- AlicenseNot gradedqualityDmaintenanceEnables AI assistants to query and fetch error and performance monitoring data from AppSignal through the Model Context Protocol. Supports searching and retrieving detailed information about application errors and performance samples with flexible filtering options.5MIT
- AlicenseAqualityDmaintenanceEnables AI agents to access New Relic logs and APM data through the NerdGraph API. It allows users to execute NRQL queries, retrieve application performance metrics, and analyze transaction traces using natural language.61MIT
- AlicenseNot gradedqualityBmaintenanceEnables AI assistants to interact with Monti APM for Meteor application performance monitoring.55 npm6MIT