Rootly

Rootly MCP Server exposes a rich set of tools that integrate Rootly's incident and on-call data with MCP-enabled editors. It dynamically generates MCP resources from Rootly's OpenAPI specification, provides intelligent incident analysis, and includes utilities to summarize on-call handoffs, detect health risks in responder schedules, and search or correlate past incidents. The server ships with both custom agentic tools (like find_related_incidents, get_oncall_handoff_summary, and suggest_solutions) and a broad suite of OpenAPI-generated tools (e.g., createIncident, listTeams, getEnvironment, updateSchedule, etc.). This enables editors to query, filter, and act on Rootly data directly from your IDE, chat, or editor, while preserving security through scoped API tokens and endpoint filtering.

To use it, configure your MCP client to connect via uvx (or your preferred transport) and provide your Rootly API token. You can run locally with uvx, or connect to a hosted hosted-config via an editor that supports MCP. The tools will appear as resources within your editor, and you can call them to retrieve incidents, analyze on-call data, or generate actionable recommendations based on historical resolutions. When in doubt, start with the on-call health checks and the related-incidents tooling to surface high-value insights during incident response.

Prerequisites

• Python 3.12 or higher
• uv package manager installed locally (see installation steps below)
• A Rootly API token with appropriate permissions

Local installation and setup (using uvx)

1. Install uvx on your system. On Unix-like systems you can typically run:

curl -LsSf https://astral.sh/uv/install.sh | sh

2. Ensure you have a Rootly API token and set it in your environment or MCP config as ROOTLY_API_TOKEN. Example usage in MCP config (shown below) uses a placeholder.

3. Prepare your MCP config. The example below demonstrates connecting to the Rootly MCP server locally via uvx. Save as your MCP config file (e.g., mcp.config.json).

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

4. Start editing with your editor. When the MCP client loads the configuration, it will download and run the Rootly MCP server via uvx and expose 99+ tools to your editor.

Prerequisites recap

• Python 3.12+ for server prerequisites (if you opt for any Python-based setup)
• uv or uvx installed as your MCP transport
• A valid ROOTLY_API_TOKEN with appropriate permissions
• Optional: a hosted configuration URL/token if you prefer the hosted experience

Tips and common considerations:

• Transport options: The MCP server supports multiple transports (e.g., Streamable HTTP and SSE). Choose a transport per server process as documented in the README, and set ROOTLY_TRANSPORT accordingly if you deploy via Docker or uvx.
• API tokens: For full functionality (including get_oncall_handoff_summary, get_oncall_shift_metrics, and organization-wide incident search), a Global API Key is recommended. Ensure the token has the needed permissions to avoid partial data access.
• Environment variables: ROOTLY_API_TOKEN should be kept secret. Do not hard-code tokens in public repos. Use editor secrets or environment management.
• OpenAPI-generated tools: The MCP server exposes a large set of endpoints (e.g., createIncident, listTeams, getEnvironment, updateSchedule, etc.). You can automate incident response workflows by chaining these tools.
• Custom agentic tools: Tools like find_related_incidents, suggest_solutions, and get_oncall_schedule_summary enable more intelligent, historical insight for faster resolutions.
• If you run locally with Docker, ensure proper port mapping and environment variables for ROOTLY_API_TOKEN and ROOTLY_TRANSPORT.
• If you encounter tool availability issues, verify your API token permissions and that the Rootly API is reachable from your environment.