> ## Documentation Index > Fetch the complete documentation index at: https://docs.rootly.com/llms.txt > Use this file to discover all available pages before exploring further. # Rootly MCP Server for AI assistants and IDEs > Connect AI assistants and IDEs to Rootly using the Model Context Protocol, with Code Mode, OAuth2, hosted, and self-hosted deployment options. ## Introduction The Rootly MCP Server implements the [Model Context Protocol](https://modelcontextprotocol.io) 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](#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):** ```json theme={null} { "mcpServers": { "rootly": { "url": "https://mcp.rootly.com/mcp-codemode" } } } ``` Your MCP client handles OAuth2 login automatically. No token configuration needed. **With API Token:** ```json theme={null} { "mcpServers": { "rootly": { "url": "https://mcp.rootly.com/mcp-codemode", "headers": { "Authorization": "Bearer " } } } } ``` **Slim Profile (Hosted):** ```json theme={null} { "mcpServers": { "rootly": { "url": "https://mcp.rootly.com/mcp?tool_profile=slim", "headers": { "Authorization": "Bearer " } } } } ``` **Header Alternative:** ```json theme={null} { "mcpServers": { "rootly": { "url": "https://mcp.rootly.com/mcp", "headers": { "Authorization": "Bearer ", "X-Rootly-Tool-Profile": "slim" } } } } ``` **SSE Alternative:** ```json theme={null} { "mcpServers": { "rootly": { "url": "https://mcp.rootly.com/sse", "headers": { "Authorization": "Bearer " } } } } ``` ### Client-Specific Setup #### Claude Code **With OAuth2 (recommended):** ```bash theme={null} claude mcp add --transport http rootly https://mcp.rootly.com/mcp-codemode ``` **With API Token:** ```bash theme={null} 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: ```json theme={null} { "mcpServers": { "rootly": { "type": "http", "url": "https://mcp.rootly.com/mcp" } } } ``` #### Cursor Add to `.cursor/mcp.json` or `~/.cursor/mcp.json`: **With OAuth2 (recommended):** ```json theme={null} { "mcpServers": { "rootly": { "url": "https://mcp.rootly.com/mcp" } } } ``` **With API Token:** ```json theme={null} { "mcpServers": { "rootly": { "url": "https://mcp.rootly.com/mcp", "headers": { "Authorization": "Bearer " } } } } ``` #### Windsurf Add to `~/.codeium/windsurf/mcp_config.json`: ```json theme={null} { "mcpServers": { "rootly": { "serverUrl": "https://mcp.rootly.com/mcp", "headers": { "Authorization": "Bearer " } } } } ``` #### Codex Add to `~/.codex/config.toml`: ```toml theme={null} [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):** ```json theme={null} { "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):** ```json theme={null} { "mcpServers": { "rootly": { "command": "npx", "args": [ "-y", "mcp-remote", "https://mcp.rootly.com/mcp", "--transport", "http", "--header", "Authorization: Bearer " ] } } } ``` #### Gemini CLI Install as an extension: ```bash theme={null} gemini extensions install https://github.com/Rootly-AI-Labs/Rootly-MCP-server ``` Or configure manually in `~/.gemini/settings.json`: ```json theme={null} { "mcpServers": { "rootly": { "command": "uvx", "args": ["--from", "rootly-mcp-server", "rootly-mcp-server"], "env": { "ROOTLY_API_TOKEN": "" } } } } ``` ### 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`:** ```json theme={null} { "mcpServers": { "rootly": { "command": "uv", "args": ["tool", "run", "--from", "rootly-mcp-server", "rootly-mcp-server"], "env": { "ROOTLY_API_TOKEN": "", "ROOTLY_MCP_ENABLE_WRITE_TOOLS": "true" } } } } ``` **With `uvx`:** ```json theme={null} { "mcpServers": { "rootly": { "command": "uvx", "args": ["--from", "rootly-mcp-server", "rootly-mcp-server"], "env": { "ROOTLY_API_TOKEN": "" } } } } ``` #### Security Controls (Local Only) Local installations support granular permission controls through environment variables: **Default Mode (All Tools):** ```json theme={null} { "env": { "ROOTLY_API_TOKEN": "" // All tools available by default, matching hosted behavior } } ``` **Read-Only Mode (Restricted):** ```json theme={null} { "env": { "ROOTLY_API_TOKEN": "", "ROOTLY_MCP_ENABLE_WRITE_TOOLS": "false" } } ``` **Restrict to Specific Tools:** ```json theme={null} { "env": { "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:** ```json theme={null} { "env": { "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: ```bash theme={null} ROOTLY_API_TOKEN= \ uvx --from rootly-mcp-server rootly-mcp-server --list-tools ``` With write tools enabled: ```bash theme={null} ROOTLY_API_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: ```bash theme={null} 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:** ```bash theme={null} ROOTLY_API_TOKEN= \ uv run python -m rootly_mcp_server --list-tools ``` **Smoke-test a self-hosted allowlist:** ```bash theme={null} ROOTLY_API_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):** ```bash theme={null} docker run -p 8000:8000 \ -e ROOTLY_TRANSPORT=streamable-http \ -e ROOTLY_API_TOKEN= \ -e ROOTLY_MCP_ENABLE_WRITE_TOOLS=true \ rootly-mcp-server ``` **Run with Docker (SSE):** ```bash theme={null} docker run -p 8000:8000 \ -e ROOTLY_TRANSPORT=sse \ -e ROOTLY_API_TOKEN= \ rootly-mcp-server ``` **Run with Docker (Dual Transport + Code Mode):** ```bash theme={null} docker run -p 8000:8000 \ -e ROOTLY_TRANSPORT=both \ -e 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](/integrations/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: ```bash theme={null} ROOTLY_API_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](https://github.com/Rootly-AI-Labs/Rootly-MCP-server#supported-tools). ## 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](https://github.com/Rootly-AI-Labs/Rootly-MCP-server#workflow-focused-tool-subsets). You can also run multiple MCP instances with different tool subsets for different teams: ```json theme={null} { "mcpServers": { "rootly-incident-response": { "command": "uvx", "args": ["--from", "rootly-mcp-server", "rootly-mcp-server"], "env": { "ROOTLY_API_TOKEN": "", "ROOTLY_MCP_ENABLED_TOOLS": "" } } } } ``` ## 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](https://github.com/Rootly-AI-Labs/rootly-mcp-server/blob/main/examples/skills/rootly-incident-responder.md) 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:** ```bash theme={null} # 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: ```python theme={null} 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: ```python theme={null} 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](https://oncallhealth.ai) to detect workload health risk in scheduled responders. Set the `ONCALLHEALTH_API_KEY` environment variable to enable it: ```json theme={null} { "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 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. 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 `, and for local/self-hosted it goes in the `ROOTLY_API_TOKEN` environment variable. 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. 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. 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](https://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 ```bash theme={null} claude mcp add --transport http rootly-docs https://docs.rootly.com/mcp ``` #### Cursor Add to `.cursor/mcp.json` or `~/.cursor/mcp.json`: ```json theme={null} { "mcpServers": { "rootly-docs": { "url": "https://docs.rootly.com/mcp" } } } ``` #### Claude Desktop Add to `claude_desktop_config.json`: ```json theme={null} { "mcpServers": { "rootly-docs": { "url": "https://docs.rootly.com/mcp" } } } ``` #### Windsurf Add to `~/.codeium/windsurf/mcp_config.json`: ```json theme={null} { "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: ```json theme={null} { "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`](/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). *** ## Related Pages Browse the full Rootly API — all endpoints exposed by the MCP server come from here. Learn about Rootly's built-in AI features for incident management. Source code, issues, and release notes for the Rootly MCP Server.