AppSignal MCP Server: Get Started in your IDE

Cursor, Claude, and their fellow tools are great when they are speaking code, but once that code hits production, they are not exactly native. However, if your code is monitored by AppSignal, an MCP server can bridge that gap and allow agents to poke around the production.

TL;DR Adding your AI agent into the monitoring loop gives it direct access to the context from monitoring data. That means you can transition from knowing that there is a bug to having that bug-fix deployed, all in your editor. In this guide, I will quickly introduce you to AppSignal’s MCP server and show you how to set it up in your favorite IDE in under five minutes. Stroopwafels on us! 🧇

What Is MCP?

Model Context Protocol (MCP) is an open standard that lets AI agents interact with external tools and data sources. It may feel like an API, but really, it gives AI systems a common way to connect with external tools and data sources. Kind of like a USB-C!

AppSignal’s MCP server implements several tools across seven areas:

• App discovery
• Error incidents
• Performance
• Anomaly detection
• Logging
• Metrics
• Dashboards

What You Can Do With AppSignal’s MCP

Once you are connected to the MCP server, your AI agent can:

• Investigate and triage errors: The agent can list open incidents, pull stack traces, bulk-update states, assign team members, and more.
• Review anomaly alerts: You can browse open anomaly incidents, check which triggers are configured for a specific metric, and see alert history.
• Query metrics: The agent lets you discover available metrics and pull timeseries data.
• Manage dashboards: You can create new dashboards and charts from a prompt.
• Document investigations: Your team can add notes to incidents so that everyone has the full context.

Prerequisites

Before your agent starts communicating with AppSignal, you need:

• AppSignal account with an app
• AppSignal MCP token (you can generate one from Account Settings > MCP Tokens)
• Preferred IDE of your choice (Cursor, Claude Code, VS Code with GitHub Copilot, or Zed)

💡 Tokens have configurable permissions per toolset. By default, you get write access to exceptions and dashboards + read access to app discovery. You can adjust as necessary. ✨

Setup Options

Previously, if you wanted to connect an AI agent to AppSignal, you had to have a Docker container running. And while this worked, it just added unnecessary overhead.

AppSignal’s MCP public endpoint sits at https://appsignal.com/api/mcp. This approach cuts out all the extra steps: just point your agent, authenticate with a token, and you’re good to go.

The Docker image is still available if you need a local MCP server, but for most cases, the public endpoint will do just fine.

Agent Setup with a Public Endpoint (Recommended)

💡 OAuth support is now available across all our supported editors. If the OAuth tab doesn’t work for your editor, just switch to the Bearer token tab and let us know in our Discord community. We can use your feedback to tighten these instructions. ✨

Claude Code

Tabbed code from https://docs.appsignal.com/mcp.html

Cursor

Add this to your Cursor MCP configuration (~/.cursor/mcp.json):

Tabbed code from https://docs.appsignal.com/mcp.html

See Cursor's MCP docs for more on managing MCP servers.

VS Code with GitHub Copilot

Add the code below to .vscode/mcp.json in your project or your user-level settings (VS Code MCP docs):

Tabbed code from https://docs.appsignal.com/mcp.html

🚧 Note for GitHub Copilot organization accounts: Make sure MCP servers are enabled at Organization Settings > Copilot > Policies > MCP servers in Copilot. 🚧

Zed

Open your Zed settings file and add the context_servers section (Zed MCP docs):

Tabbed code from https://docs.appsignal.com/mcp.html

Agent Setup with Docker (Local Server)

The Docker image is available on GitHub for setups that require a local MCP server. Use your AppSignal API key (not your MCP token) for Docker-based setups.

Claude Desktop

Edit ~/Library/Application Support/Claude/claude_desktop_config.json:

{
  "mcpServers": {
    "appsignal": {
      "command": "docker",
      "args": ["run", "-i", "--rm", "-e", "APPSIGNAL_API_KEY", "appsignal/mcp"],
      "env": {
        "APPSIGNAL_API_KEY": "your-api-key"
      }
    }
  }
}

You can find this by navigating to your Profile > Settings > Developer and then pressing Edit Config.

Claude Code

claude mcp add appsignal \\
  -e APPSIGNAL_API_KEY=your-api-key \\
  -- docker run -i --rm -e APPSIGNAL_API_KEY appsignal/mcp

Cursor / Windsurf

For Cursor use ~/.cursor/mcp.json

For Windsurf use ~/.codeium/windsurf/mcp_config.json

{
  "servers": {
    "appsignal": {
      "command": "docker",
      "args": ["run", "-i", "--rm", "-e", "APPSIGNAL_API_KEY", "appsignal/mcp"],
      "env": {
        "APPSIGNAL_API_KEY": "your-api-key"
      }
    }
  }
}

Zed

Open your Zed settings file and add the context_servers section:

{
  "context_servers": {
    "appsignal": {
      "source": "custom",
      "command": "docker",
      "args": ["run", "-i", "--rm", "-e", "APPSIGNAL_API_KEY", "appsignal/mcp"],
      "env": {
        "APPSIGNAL_API_KEY": "your-mcp-token"
      }
    }
  }
}

VS Code with GitHub Copilot

Add this config to your .vscode/mcp.json settings:

{
  "inputs": [
    {
      "type": "promptString",
      "id": "appsignal_mcp_token",
      "description": "AppSignal MCP Token",
      "password": true
    }
  ],
  "servers": {
    "appsignal": {
      "command": "docker",
      "args": ["run", "-i", "--rm", "-e", "APPSIGNAL_API_KEY", "appsignal/mcp"],
      "env": {
        "APPSIGNAL_API_KEY": "${input:appsignal_mcp_token}"
      }
    }
  }
}

Verify That Everything Works

Open a conversation with your AI agent and ask:

What apps do I have in AppSignal?

If connected correctly, the agent will return your app list. However, if it responds with generic advice instead of actual data or states that it cannot find necessary tools, revisit your configuration. The most common cause is a malformed token header or a missing Bearer prefix.

Your First Investigation

With the AppSignal MCP server connected, you can now try a real end-to-end workflow:

Step 1: Check current status

Are there any open incidents in my production app?

The agent queries all open incidents scoped to your production environment and returns a summary list.

Step 2: Dig into an error

Show me the stack trace for the most recent Payment Failed error.

The agent pulls the full incident detail for the most recent matching error. If the same error has multiple samples, it can surface the most recent one. That way, you’ll be looking at the freshest occurrence, not a stale one from last week.

Step 3: Correlate with deploys

When was the last deploy? Did error rates change after it?

The agent checks your deploy markers and cross-references them against error rate data around the same time window.

Step 4: Document what you find

Add a note to that incident that we're investigating a timeout in the payment gateway.

The agent writes a timestamped note and attaches it directly to the incident in AppSignal. Anyone on the team who opens the incident gets the context immediately.

Step 5: Update the incident state

Mark that incident as acknowledged and assign it to me.

The agent updates the incident state to acknowledged and assigns it to your AppSignal user. It will chain the underlying tools on its own. You don’t even need to know which tools exist. 😉

See the full reference in the AppSignal MCP Tool Reference.

Tips for Productivity and Effective Use

To have your MCP be as effective as possible, consider these few productivity tips:

• Be specific about time ranges: “Errors in the last hour” will give better results than “recent errors.”
• Name your apps clearly: The agent uses app names to scope queries. Ambiguous names produce ambiguous results, it’s just simple math.
• Iteration over one-shots: Start broad (”what is happening in prod?”), and then narrow it down (”tell me more about why we have an outage in the USA”)
• Use investigation notes: Let the agent add notes directly to incidents so that your team has context without a separate Slack thread.
• Combine with code context: I like this one! In Cursor, Claude or your IDE of choice, ask the agent to look at your source code and monitoring data together.

Wrap Up and Next Steps

Getting your agent to talk to AppSignal takes less than five minutes. Once connected, your agent can query everything AppSignal’s dashboard would conventionally offer, but at a speed of communication (in plain English as well!).

Generate your MCP token in the Account Settings, and connect it to your favorite editor.

If you don’t have an AppSignal account yet, start a free 30-day trial (no credit card required).

Frequently Asked Questions (FAQ)

Do I need Docker to use AppSignal MCP?

No, the public endpoint works for all supported editors without Docker. Docker is only necessary if your environment restricts outbound traffic to the public endpoint.

What is the difference between an MCP token and an API key?

MCP tokens are generated separately in Account Settings and have per-toolset read/write permissions. API keys are used for the Docker setup and grant broader access. Use MCP tokens for the public endpoint.

Can I limit what my AI agent can access?

Yes. When generating an MCP token, configure each toolset (exceptions, anomalies, metrics, dashboards, app_discovery) as read, write, or disabled. You can also scope a token to specific apps.

Does this work with Windsurf?

It absolutely does.

The agent returns generic advice instead of my AppSignal data? What happened?

It’s almost always a token header issue. Double-check that the header is Authorization: Bearer your-mcp-token with the Bearer prefix and that you're using an MCP token (not your API key) for the public endpoint setup.