Rootly MCP Server for AI assistants and IDEs

Introduction

The Rootly MCP Server implements the Model Context Protocol to expose Rootly incident data and actions as tools that any MCP-compatible client can use. This means you can query incidents, check on-call schedules, find similar past incidents, and take action — all from within Cursor, Windsurf, Claude Code, Gemini CLI, or any other MCP-compatible environment. The server dynamically generates tools from Rootly’s OpenAPI specification, so it always reflects the current API surface. It also includes a set of intelligent tools built on top of that foundation:

Two Rootly MCP surfaces. This page covers the Product MCP Server at https://mcp.rootly.com — the one that exposes Rootly’s API as tools your AI client can call. Rootly also publishes a Docs MCP Server at https://docs.rootly.com/mcp that exposes the documentation content for search and retrieval. The two are complementary: connect both and your AI client can answer “how do I configure X?” (docs MCP) and “now configure X for me” (product MCP) in the same session. Setup for the Docs MCP is at the bottom of this page — see Rootly Docs MCP Server.

find_related_incidents — uses TF-IDF similarity analysis to surface historically similar incidents
suggest_solutions — mines past incident resolutions to recommend actionable next steps
get_oncall_shift_metrics — shift counts, hours, and days on-call grouped by user, team, or schedule
get_oncall_handoff_summary — current and next on-call plus incidents during shifts, with optional regional filtering
get_shift_incidents — incidents during a time window, filterable by severity, status, and tags

Authentication

The hosted MCP server supports two authentication methods:

OAuth2 (Recommended)

MCP clients that support OAuth2 (Claude Desktop, Claude Code, Cursor) authenticate automatically — a browser window opens for you to log in to Rootly and grant access. No API token needed. Permissions are scoped through Rootly’s granular OAuth2 consent screen. OAuth2 is supported on all hosted transport endpoints: Streamable HTTP (/mcp), SSE (/sse), and Code Mode (/mcp-codemode).

API Token

For clients that don’t support OAuth2, or for local/self-hosted installations, use a Rootly API token. Generate one in Account > Manage API keys > Generate New API Key.

Token Type	Access Level
Global API Key (recommended)	Full access across all teams, schedules, and incidents
Team API Key	Full read/write access scoped to a single team
Personal API Key	Inherits the permissions of the user who created it

Tools like get_oncall_handoff_summary and get_oncall_shift_metrics require organization-wide visibility. A Global API Key is recommended for full functionality.

For local installation, you also need:

Python 3.12 or higher
The uv package manager

Installation

Choose the deployment option that fits your team. The hosted option is the fastest way to get started and requires no local setup.

Hosted (recommended)

Connect to Rootly’s managed MCP server — always up to date, zero maintenance. The standard hosted URL exposes the full tool surface by default. If you want a smaller remote profile, add ?tool_profile=slim to the URL or send X-Rootly-Tool-Profile: slim. Transport Options:

Code Mode (recommended): https://mcp.rootly.com/mcp-codemode
Streamable HTTP: https://mcp.rootly.com/mcp
SSE: https://mcp.rootly.com/sse

Use Code Mode. Instead of registering ~200 individual tools — whose schemas are re-sent on every model turn — Code Mode exposes a compact set of meta-tools (list_tools, tool_search, get_schema, tags, execute). The model discovers the tools it needs and writes a short async Python block in execute that chains multiple call_tool(...) calls server-side, returning only the final result. This means dramatically lower token usage and fewer round-trips for multi-step work. It supports OAuth2 and API tokens identically to the other endpoints.Connect Code Mode instead of the classic endpoints, not alongside them. If both surfaces are available to the same client, the model tends to call the classic tools directly and skip execute — so the full tool surface still loads and you lose the savings.

With OAuth2 (recommended):

{
  "mcpServers": {
    "rootly": {
      "url": "https://mcp.rootly.com/mcp-codemode"
    }
  }
}

Your MCP client handles OAuth2 login automatically. No token configuration needed. With API Token:

{
  "mcpServers": {
    "rootly": {
      "url": "https://mcp.rootly.com/mcp-codemode",
      "headers": {
        "Authorization": "Bearer <YOUR_ROOTLY_API_TOKEN>"
      }
    }
  }
}

Slim Profile (Hosted):

{
  "mcpServers": {
    "rootly": {
      "url": "https://mcp.rootly.com/mcp?tool_profile=slim",
      "headers": {
        "Authorization": "Bearer <YOUR_ROOTLY_API_TOKEN>"
      }
    }
  }
}

Header Alternative:

{
  "mcpServers": {
    "rootly": {
      "url": "https://mcp.rootly.com/mcp",
      "headers": {
        "Authorization": "Bearer <YOUR_ROOTLY_API_TOKEN>",
        "X-Rootly-Tool-Profile": "slim"
      }
    }
  }
}

SSE Alternative:

{
  "mcpServers": {
    "rootly": {
      "url": "https://mcp.rootly.com/sse",
      "headers": {
        "Authorization": "Bearer <YOUR_ROOTLY_API_TOKEN>"
      }
    }
  }
}

Client-Specific Setup

Claude Code

With OAuth2 (recommended):

claude mcp add --transport http rootly https://mcp.rootly.com/mcp-codemode

With API Token:

claude mcp add --transport http rootly https://mcp.rootly.com/mcp-codemode \
  --header "Authorization: Bearer YOUR_ROOTLY_API_TOKEN"

Manual Configuration - Create .mcp.json in your project root:

{
  "mcpServers": {
    "rootly": {
      "type": "http",
      "url": "https://mcp.rootly.com/mcp"
    }
  }
}

Cursor

Add to .cursor/mcp.json or ~/.cursor/mcp.json: With OAuth2 (recommended):

{
  "mcpServers": {
    "rootly": {
      "url": "https://mcp.rootly.com/mcp"
    }
  }
}

With API Token:

{
  "mcpServers": {
    "rootly": {
      "url": "https://mcp.rootly.com/mcp",
      "headers": {
        "Authorization": "Bearer <YOUR_ROOTLY_API_TOKEN>"
      }
    }
  }
}

Windsurf

Add to ~/.codeium/windsurf/mcp_config.json:

{
  "mcpServers": {
    "rootly": {
      "serverUrl": "https://mcp.rootly.com/mcp",
      "headers": {
        "Authorization": "Bearer <YOUR_ROOTLY_API_TOKEN>"
      }
    }
  }
}

Codex

Add to ~/.codex/config.toml:

[mcp_servers.rootly]
url = "https://mcp.rootly.com/mcp"
bearer_token_env_var = "ROOTLY_API_TOKEN"

Claude Desktop

Add to claude_desktop_config.json: With OAuth2 (recommended):

{
  "mcpServers": {
    "rootly": {
      "url": "https://mcp.rootly.com/mcp"
    }
  }
}

Claude Desktop handles OAuth2 login automatically — a browser window opens for you to authenticate with Rootly. With API Token (via mcp-remote):

{
  "mcpServers": {
    "rootly": {
      "command": "npx",
      "args": [
        "-y",
        "mcp-remote",
        "https://mcp.rootly.com/mcp",
        "--transport",
        "http",
        "--header",
        "Authorization: Bearer <YOUR_ROOTLY_API_TOKEN>"
      ]
    }
  }
}

Gemini CLI

Install as an extension:

gemini extensions install https://github.com/Rootly-AI-Labs/Rootly-MCP-server

Or configure manually in ~/.gemini/settings.json:

{
  "mcpServers": {
    "rootly": {
      "command": "uvx",
      "args": ["--from", "rootly-mcp-server", "rootly-mcp-server"],
      "env": {
        "ROOTLY_API_TOKEN": "<YOUR_ROOTLY_API_TOKEN>"
      }
    }
  }
}

Slack (Slackbot)

Connect the Rootly MCP server to Slack’s Slackbot MCP client so your team can query Rootly from a Slackbot DM. No changes to the MCP server are required — you point Slackbot at the hosted endpoint and authenticate with a Rootly OAuth application.

Prerequisite: Slack AI features must be enabled for your workspace and app. The MCP Servers configuration and the Slackbot Apps connection flow only appear when Slack’s AI / agent features are turned on.

Use the Code Mode endpoint (https://mcp.rootly.com/mcp-codemode) for Slack — it exposes a compact tool surface and keeps token usage low.

1. Register a Rootly OAuth application In Rootly, open your OAuth Applications settings and create a new application:

Grant Type: Authorization Code (user login via browser redirect — not Client Credentials)
Redirect URI: https://oauth2.slack.com/external/auth/callback
Scopes: the minimum your use case needs, for example openid and ir.incidents:read. Keep this list small.
Use PKCE: enabled
Use HTTP Basic Authentication: enabled

Save the application and note its Client ID and Client Secret. 2. Configure the Slack app In your Slack app (api.slack.com/apps → Features → MCP Servers), add the Rootly server using manual OAuth:

mcp_servers:
  - name: rootly
    url: https://mcp.rootly.com/mcp-codemode
    auth_type: manual_auth
    external_auth_providers:
      - client_id: <YOUR_ROOTLY_CLIENT_ID>
        client_secret: <YOUR_ROOTLY_CLIENT_SECRET>   # store as a Slack secret / env var
        authorization_url: https://rootly.com/oauth/authorize
        token_url: https://rootly.com/oauth/token
        scope: openid ir.incidents:read              # must match the Rootly app's scopes
        use_pkce: true
        token_url_config:
          use_basic_auth_scheme: true                # must match "Use HTTP Basic Authentication" on the Rootly app
        identity_config:
          url: https://api.rootly.com/v1/users/me
          account_identifier: $.data.id

Add the mcp:connect bot scope under OAuth & Permissions, then install (or reinstall) the app to your workspace. 3. Connect and use Open a direct message with Slackbot, click Apps, and connect the Rootly server. You’ll be redirected to log in to Rootly and grant access. Once connected, ask Slackbot in natural language, for example “list recent Rootly incidents.”

The Slack scope and the Rootly application’s granted scopes must match, and PKCE and HTTP Basic Authentication must be enabled on both sides. Start with a minimal scope set — requesting a large number of scopes at once can cause the authorization step to fail.

Local Installation

The package is downloaded automatically when you first open your editor. Local installation provides additional security controls not available in the hosted version. With uv:

{
  "mcpServers": {
    "rootly": {
      "command": "uv",
      "args": ["tool", "run", "--from", "rootly-mcp-server", "rootly-mcp-server"],
      "env": {
        "ROOTLY_API_TOKEN": "<YOUR_ROOTLY_API_TOKEN>",
        "ROOTLY_MCP_ENABLE_WRITE_TOOLS": "true"
      }
    }
  }
}

With uvx:

{
  "mcpServers": {
    "rootly": {
      "command": "uvx",
      "args": ["--from", "rootly-mcp-server", "rootly-mcp-server"],
      "env": {
        "ROOTLY_API_TOKEN": "<YOUR_ROOTLY_API_TOKEN>"
      }
    }
  }
}

Security Controls (Local Only)

Local installations support granular permission controls through environment variables: Default Mode (All Tools):

{
  "env": {
    "ROOTLY_API_TOKEN": "<YOUR_ROOTLY_API_TOKEN>"
    // All tools available by default, matching hosted behavior
  }
}

Read-Only Mode (Restricted):

{
  "env": {
    "ROOTLY_API_TOKEN": "<YOUR_ROOTLY_API_TOKEN>",
    "ROOTLY_MCP_ENABLE_WRITE_TOOLS": "false"
  }
}

Restrict to Specific Tools:

{
  "env": {
    "ROOTLY_API_TOKEN": "<YOUR_ROOTLY_API_TOKEN>",
    "ROOTLY_MCP_ENABLE_WRITE_TOOLS": "true",
    "ROOTLY_MCP_ENABLED_TOOLS": "createIncident,getIncident,listTeams,getCurrentUser"
  }
}

Full Access by Default — Local installations match hosted behavior with all tools available. Use ROOTLY_MCP_ENABLE_WRITE_TOOLS=false to restrict to read-only mode.

Environment Variables:

Variable	Description	Default
`ROOTLY_API_TOKEN`	Your Rootly API authentication token	Required
`ROOTLY_MCP_ENABLE_WRITE_TOOLS`	Enable write operations (create, update)	`true`
`ROOTLY_MCP_ENABLED_TOOLS`	Comma-separated allowlist of specific tools	All available tools

Example: Minimal Write Access for Automation:

{
  "env": {
    "ROOTLY_API_TOKEN": "<YOUR_ROOTLY_API_TOKEN>",
    "ROOTLY_MCP_ENABLE_WRITE_TOOLS": "true",
    "ROOTLY_MCP_ENABLED_TOOLS": "createIncidentActionItem,updateIncidentFormFieldSelection,listIncidents,getIncident"
  }
}

This configuration allows only creating action items and updating form fields — perfect for automation that needs to add findings without modifying incident status or severity. Discovering Available Tools: To see all available tool names for your configuration:

ROOTLY_API_TOKEN=<YOUR_TOKEN> \
uvx --from rootly-mcp-server rootly-mcp-server --list-tools

With write tools enabled:

ROOTLY_API_TOKEN=<YOUR_TOKEN> \
ROOTLY_MCP_ENABLE_WRITE_TOOLS=true \
uvx --from rootly-mcp-server rootly-mcp-server --list-tools

Self-Hosted

For organizations that need full control over infrastructure or data flow:

git clone https://github.com/Rootly-AI-Labs/Rootly-MCP-server
cd Rootly-MCP-server
uv pip install .

Both hosted and self-hosted deployments expose the same curated tool surface by default, including write-enabled tools. To restrict to read-only tools, start the server with --no-enable-write-tools or set ROOTLY_MCP_ENABLE_WRITE_TOOLS=false. To expose only a specific subset of MCP tools, set ROOTLY_MCP_ENABLED_TOOLS (or pass --enabled-tools) with a comma-separated allowlist of exact tool names. Discover available tool names:

ROOTLY_API_TOKEN=<YOUR_TOKEN> \
uv run python -m rootly_mcp_server --list-tools

Smoke-test a self-hosted allowlist:

ROOTLY_API_TOKEN=<YOUR_TOKEN> \
ROOTLY_MCP_ENABLED_TOOLS=list_incidents,getIncident,get_server_version \
uv run python -m rootly_mcp_server --transport streamable-http --log-level ERROR

Then connect an MCP client to http://127.0.0.1:8000/mcp and verify tools/list returns only the specified tools. Run with Docker (Streamable HTTP):

docker run -p 8000:8000 \
  -e ROOTLY_TRANSPORT=streamable-http \
  -e ROOTLY_API_TOKEN=<YOUR_ROOTLY_API_TOKEN> \
  -e ROOTLY_MCP_ENABLE_WRITE_TOOLS=true \
  rootly-mcp-server

Run with Docker (SSE):

docker run -p 8000:8000 \
  -e ROOTLY_TRANSPORT=sse \
  -e ROOTLY_API_TOKEN=<YOUR_ROOTLY_API_TOKEN> \
  rootly-mcp-server

Run with Docker (Dual Transport + Code Mode):

docker run -p 8000:8000 \
  -e ROOTLY_TRANSPORT=both \
  -e ROOTLY_API_TOKEN=<YOUR_ROOTLY_API_TOKEN> \
  rootly-mcp-server

The MCP server is now connected. Your MCP client can call Rootly tools to list incidents, check on-call schedules, find related incidents, and more.

Alternative: Rootly CLI — For terminal-based workflows, check out the Rootly CLI which provides direct command-line access to incidents, alerts, and on-call operations.

Available Tools

The MCP server exposes 200+ tools dynamically generated from Rootly’s OpenAPI specification, plus custom agentic tools for intelligent incident analysis.

Hosted default: full tool surface
Hosted slim profile: about 70 high-usage tools via ?tool_profile=slim
Local and self-hosted default: full tool surface
Exact custom subset: use ROOTLY_MCP_ENABLED_TOOLS to expose only a specific allowlist

Custom Agentic Tools

check_oncall_health_risk — detects workload health risk in scheduled responders
check_responder_availability — checks responder availability
collect_incidents — collects incident data with filtering
createIncident — create incidents with scoped fields for agent workflows
create_override_recommendation — suggests on-call override recommendations
find_related_incidents — uses TF-IDF similarity to find historically similar incidents
getIncident — retrieve single incidents with PIR-related fields
get_alert_by_short_id — get alerts using short IDs
get_oncall_handoff_summary — complete handoff information
get_oncall_schedule_summary — schedule overview
get_oncall_shift_metrics — comprehensive shift analytics
get_server_version — server version information
get_shift_incidents — incidents during specific time periods
list_endpoints — available API endpoints
list_incidents — incident listing with filters
list_shifts — on-call shift information
search_incidents — advanced incident search
suggest_solutions — mines past resolutions for actionable recommendations
updateIncident — scoped incident updates for summary and retrospective progress

OpenAPI-Generated Tools

The server also includes all standard Rootly API operations — covering alerts, escalation policies, schedules, services, teams, workflows, dashboards, playbooks, post-incident reviews, and more. Security-sensitive operations (API key management, user creation/deletion, role management, webhook configuration) and delete operations are excluded from the default tool surface. To see the exact tools available under your configuration:

ROOTLY_API_TOKEN=<YOUR_TOKEN> \
uvx --from rootly-mcp-server rootly-mcp-server --list-tools

For the complete tool inventory and pre-built workflow subsets (Incident Response, On-Call Management, Monitoring & Alerting, Post-Incident Analysis, Analytics & Reporting), see the README on GitHub.

Workflow-Focused Tool Subsets

With 200+ tools available by default, you can either use the hosted slim profile or configure focused subsets for optimal AI agent performance using ROOTLY_MCP_ENABLED_TOOLS. For hosted clients that want the smaller remote profile without maintaining a custom allowlist, use https://mcp.rootly.com/mcp?tool_profile=slim or send X-Rootly-Tool-Profile: slim. Pre-built subsets are available for:

Subset	Tools	Use Case
Incident Response	25	Emergency responders and incident commanders
On-Call Management	35	Schedule coordinators and on-call managers
Monitoring & Alerting	41	Platform teams setting up observability
Post-Incident Analysis	30	SREs doing retrospectives and process improvement
Analytics & Reporting	15	Leadership and metrics teams (read-only)

Copy-paste ready tool lists for each subset are maintained in the GitHub README. You can also run multiple MCP instances with different tool subsets for different teams:

{
  "mcpServers": {
    "rootly-incident-response": {
      "command": "uvx",
      "args": ["--from", "rootly-mcp-server", "rootly-mcp-server"],
      "env": {
        "ROOTLY_API_TOKEN": "<YOUR_ROOTLY_API_TOKEN>",
        "ROOTLY_MCP_ENABLED_TOOLS": "<paste subset from GitHub README>"
      }
    }
  }
}

MCP Resources

AI agents can access these resources for situational awareness:

Resource	Description
`incident://{incident_id}`	Detailed incident information for specific incidents
`team://{team_id}`	Team details including name, color, and metadata
`rootly://incidents`	List of recent incidents for quick reference
`rootly://oncall-status`	Current on-call status across all schedules
`rootly://workflow-guide`	Step-by-step workflow guidance for common operations

Example usage: “Check the current on-call status” → AI reads rootly://oncall-status resource.

Example Skills

Rootly Incident Responder

The MCP server includes a pre-built Rootly Incident Responder skill for Claude Code that demonstrates a complete incident response workflow:

Analyzes production incidents with full context
Finds similar historical incidents using ML-based similarity matching
Suggests solutions based on past successful resolutions
Coordinates with on-call teams across timezones
Correlates incidents with recent code changes and deployments
Creates action items and remediation plans
Provides confidence scores and time estimates

Quick Start:

# Copy the skill to your project
mkdir -p .claude/skills
curl -o .claude/skills/rootly-incident-responder.md \
  https://raw.githubusercontent.com/Rootly-AI-Labs/rootly-mcp-server/main/examples/skills/rootly-incident-responder.md

# Then in Claude Code, invoke it:
# @rootly-incident-responder analyze incident #12345

Example Tools

On-Call Shift Metrics

Get shift counts, hours, and days on-call for any time period, grouped by user, team, or schedule:

get_oncall_shift_metrics(
    start_date="2025-10-01",
    end_date="2025-10-31",
    group_by="user"
)

On-Call Handoff Summary

Get current and next on-call responders plus incidents that occurred during their shifts. Supports optional regional filtering to show only responders on-call during business hours in a given timezone:

get_oncall_handoff_summary(
    team_ids="team-1,team-2",
    timezone="America/Los_Angeles"
)

# Show only APAC on-call during APAC business hours
get_oncall_handoff_summary(
    timezone="Asia/Tokyo",
    filter_by_region=True
)

Shift Incidents

Incidents during a time window, filterable by severity, status, and tags. Returns an incident list plus a summary with counts and average resolution time:

get_shift_incidents(
    start_time="2025-10-20T09:00:00Z",
    end_time="2025-10-20T17:00:00Z",
    severity="critical",
    status="resolved",
    tags="database,api"
)

On-Call Health Integration

The MCP server integrates with On-Call Health to detect workload health risk in scheduled responders. Set the ONCALLHEALTH_API_KEY environment variable to enable it:

{
  "mcpServers": {
    "rootly": {
      "command": "uvx",
      "args": ["--from", "rootly-mcp-server", "rootly-mcp-server"],
      "env": {
        "ROOTLY_API_TOKEN": "your_rootly_token",
        "ONCALLHEALTH_API_KEY": "och_live_your_key"
      }
    }
  }
}

Then call:

check_oncall_health_risk(
    start_date="2026-02-09",
    end_date="2026-02-15"
)

Returns at-risk users who are scheduled on-call, recommended safe replacements, and action summaries.

Troubleshooting

The server connects but tools are not appearing

Some MCP clients require a restart after adding a new server configuration. Fully restart your editor or AI assistant after saving the configuration. Also confirm that the JSON configuration is valid — a missing comma or bracket will silently prevent the server from loading.

Authentication errors when calling tools

Confirm that the API token is active and has not been revoked. Go to Account > Manage API keys in Rootly and verify the key exists. Also check that the token is passed correctly — for hosted configurations it goes in the Authorization header as Bearer <token>, and for local/self-hosted it goes in the ROOTLY_API_TOKEN environment variable.

Organization-wide tools return incomplete data

Tools like get_oncall_handoff_summary and get_oncall_shift_metrics require visibility across all teams. If results are incomplete, your API token may be scoped to a single team. Switch to a Global API Key for full access.

The local server fails to start

Confirm that Python 3.12 or higher is installed (python --version) and that uv is available (uv --version). If using uvx, the package is downloaded on first run — ensure you have network access. For proxy environments, you may need to configure uv proxy settings.

On-Call Health tools are not available

The check_oncall_health_risk tool only appears when ONCALLHEALTH_API_KEY is set. Confirm the environment variable is present in your MCP server configuration and that the key is valid at oncallhealth.ai.

Rootly Docs MCP Server

In addition to the Product MCP server documented above, Rootly publishes a Docs MCP Server that exposes the content of docs.rootly.com for AI-driven search and retrieval. Connect it to your AI client and the model can ground its answers in current Rootly documentation — no copy-pasting docs into prompts, no stale training data.

What It’s For

Question your AI client is being asked	Which MCP answers it
”How do I configure Datadog alert routing in Rootly?”	Docs MCP — searches the relevant pages and returns the answer
”What’s the difference between Alert Deduplication and Alert Grouping?”	Docs MCP — surfaces the comparison page
”What does the Slack Channel Created workflow trigger fire on?”	Docs MCP
”Page the on-call for the payments team.”	Product MCP — calls the Rootly API
”Create a SEV1 incident with these details.”	Product MCP
”Show me incidents from last week with Datadog as a source.”	Product MCP

Connecting both gives the same AI session the ability to answer how-to questions from the docs and take action against your Rootly account.

What The Docs MCP Exposes

Two tools and one auto-generated skill resource:

Capability	Type	What it does
`search_rootly`	Tool	Semantic search across the Rootly knowledge base. Returns titles, links, and excerpts of the most relevant pages for a natural-language query. Best for “how do I…” and conceptual questions.
`query_docs_filesystem_rootly`	Tool	Read-only shell-like access to a virtualized filesystem of every Rootly docs page. Supports `rg` (ripgrep), `grep`, `find`, `tree`, `ls`, `cat`, `head`, `tail`, `stat`, `wc`, `sort`, `uniq`, `cut`, `sed`, `awk`, `jq`. Best when your AI needs exact keyword matching, structural exploration of the docs tree, or the full content of a specific page.
`mintlify://skills/rootly`	Resource	Auto-generated Rootly Skill Reference — a Markdown document that tells your AI client when to reach for Rootly (incident management, on-call paging, alert routing, etc.), where the API and CLI live, and the canonical entry points for each task type. Your AI client reads this once at session start for grounding.

Installation

The Docs MCP is hosted by Mintlify at https://docs.rootly.com/mcp and uses Streamable HTTP transport with the standard MCP protocol (version 2024-11-05). It’s read-only and unauthenticated — no API key, no Rootly account required.

Claude Code

claude mcp add --transport http rootly-docs https://docs.rootly.com/mcp

Cursor

Add to .cursor/mcp.json or ~/.cursor/mcp.json:

{
  "mcpServers": {
    "rootly-docs": {
      "url": "https://docs.rootly.com/mcp"
    }
  }
}

Claude Desktop

Add to claude_desktop_config.json:

{
  "mcpServers": {
    "rootly-docs": {
      "url": "https://docs.rootly.com/mcp"
    }
  }
}

Windsurf

Add to ~/.codeium/windsurf/mcp_config.json:

{
  "mcpServers": {
    "rootly-docs": {
      "serverUrl": "https://docs.rootly.com/mcp"
    }
  }
}

Running Both MCPs Together

If you already have the Product MCP configured, add the Docs MCP as a second entry under mcpServers — don’t replace the existing rootly block. The two servers don’t conflict, and your AI client routes queries to whichever surface is relevant.

Preserve your existing Product MCP configuration. If your current rootly entry uses Authorization headers, ?tool_profile=slim, or any other query params, keep them exactly as they are. Only add the new rootly-docs stanza. Copy-pasting a stripped-down rootly block from any example — including the one below — will silently drop your auth and tool-profile settings.

Add this stanza alongside your existing rootly block:

{
  "mcpServers": {
    "rootly-docs": {
      "url": "https://docs.rootly.com/mcp"
    }
  }
}

Verifying the Connection

The most reliable check is tool discovery in your client. After connecting, confirm the Docs MCP is registered by looking for these tools in your client’s MCP or tools list:

search_rootly
query_docs_filesystem_rootly

If both tools appear, the connection is working. If they don’t, restart your client — most MCP clients only re-scan configuration at startup.

As a functional test, ask your AI client a question whose answer requires current Rootly docs — for example: “Using the Rootly docs, what triggers are available on an incident workflow?” A working Docs MCP surfaces the trigger list from /workflows/incident-workflows. Note that some clients don’t cite sources by default, so use tool discovery above as the primary check.

The client-specific commands above target current stable versions of Claude Code, Cursor, Claude Desktop, and Windsurf as of publication. If your client uses a different pattern for adding a Streamable HTTP MCP server, follow its documentation and set the URL to https://docs.rootly.com/mcp (transport: Streamable HTTP; auth: none).

API Reference

Browse the full Rootly API — all endpoints exposed by the MCP server come from here.

Rootly AI

Learn about Rootly’s built-in AI features for incident management.

MCP Server on GitHub

Source code, issues, and release notes for the Rootly MCP Server.

​Introduction

​Authentication

​OAuth2 (Recommended)

​API Token

​Installation

​Hosted (recommended)

​Client-Specific Setup

​Claude Code

​Cursor

​Windsurf

​Codex

​Claude Desktop

​Gemini CLI

​Slack (Slackbot)

​Local Installation

​Security Controls (Local Only)

​Self-Hosted

​Available Tools

​Custom Agentic Tools

​OpenAPI-Generated Tools

​Workflow-Focused Tool Subsets

​MCP Resources

​Example Skills

​Rootly Incident Responder

​Example Tools

​On-Call Shift Metrics

​On-Call Handoff Summary

​Shift Incidents

​On-Call Health Integration

​Troubleshooting

​Rootly Docs MCP Server

​What It’s For

​What The Docs MCP Exposes

​Installation

​Claude Code

​Cursor

​Claude Desktop

​Windsurf

​Running Both MCPs Together

​Verifying the Connection

​Related Pages

API Reference

Rootly AI

MCP Server on GitHub

Introduction

Authentication

OAuth2 (Recommended)

API Token

Installation

Hosted (recommended)

Client-Specific Setup

Claude Code

Cursor

Windsurf

Codex

Claude Desktop

Gemini CLI

Slack (Slackbot)

Local Installation

Security Controls (Local Only)

Self-Hosted

Available Tools

Custom Agentic Tools

OpenAPI-Generated Tools

Workflow-Focused Tool Subsets

MCP Resources

Example Skills

Rootly Incident Responder

Example Tools

On-Call Shift Metrics

On-Call Handoff Summary

Shift Incidents

On-Call Health Integration

Troubleshooting

Rootly Docs MCP Server

What It’s For

What The Docs MCP Exposes

Installation

Claude Code

Cursor

Claude Desktop

Windsurf

Running Both MCPs Together

Verifying the Connection

Related Pages