Runframe Incident Management MCP Server

by runframe

308 downloads

Not rated

GitHub

About

Your AI agent's interface to incident management. Acknowledge, escalate, page, and resolve incidents from Claude Code, Cursor, or any MCP client. Covers the full incident lifecycle: incidents, on-call, services, postmortems, and teams.

Details

Author: runframe
Downloads: 308
Categories: Other, Developer Tools, AI, Infrastructure

Setting up with Highlight

This MCP is not yet compatible with Highlight’s one-click setup. However, you can still use it with Highlight by following these steps:

Download and install Highlight from highlightai.com/download
Navigate to the plugins tab and select "Add Custom Plugin"
Configure the plugin with the settings below

Plugin Name Runframe Incident Management MCP Server

Command (node, npx, python, etc.)

Please refer to the README for specific instructions on how to obtain API keys or other required environment variables.
Enable "Start Automatically" if you want the plugin to start when Highlight launches

Setting up with Cursor

Open Cursor's settings
Navigate to the MCP section
Click "Add new Global MCP server"
Copy and paste the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "runframe incident management mcp server": {
            "runframe": {
                "command": "npx",
                "args": [
                    "-y",
                    "@runframe/mcp-server"
                ],
                "env": {
                    "RUNFRAME_API_KEY": "rf_your_key_here"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "runframe incident management mcp server": {
            "runframe": {
                "command": "npx",
                "args": [
                    "-y",
                    "@runframe/mcp-server"
                ],
                "env": {
                    "RUNFRAME_API_KEY": "rf_your_key_here"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "runframe incident management mcp server": {
            "runframe": {
                "command": "npx",
                "args": [
                    "-y",
                    "@runframe/mcp-server"
                ],
                "env": {
                    "RUNFRAME_API_KEY": "rf_your_key_here"
                }
            }
        }
    }
}

Setting up with Claude Desktop

Open Claude Desktop's settings
Go to the Integrations tab
Click "Add MCP Server"
Use the configuration below based on your operating system

Note: Make sure Claude Desktop is running before attempting to connect.

JSON

{
    "mcpServers": {
        "runframe incident management mcp server": {
            "runframe": {
                "command": "npx",
                "args": [
                    "-y",
                    "@runframe/mcp-server"
                ],
                "env": {
                    "RUNFRAME_API_KEY": "rf_your_key_here"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "runframe incident management mcp server": {
            "runframe": {
                "command": "npx",
                "args": [
                    "-y",
                    "@runframe/mcp-server"
                ],
                "env": {
                    "RUNFRAME_API_KEY": "rf_your_key_here"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "runframe incident management mcp server": {
            "runframe": {
                "command": "npx",
                "args": [
                    "-y",
                    "@runframe/mcp-server"
                ],
                "env": {
                    "RUNFRAME_API_KEY": "rf_your_key_here"
                }
            }
        }
    }
}

Setting up with Windsurf

Open Windsurf's preferences
Go to the Integrations section
Click "Add MCP Integration"
Use the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "runframe incident management mcp server": {
            "runframe": {
                "command": "npx",
                "args": [
                    "-y",
                    "@runframe/mcp-server"
                ],
                "env": {
                    "RUNFRAME_API_KEY": "rf_your_key_here"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "runframe incident management mcp server": {
            "runframe": {
                "command": "npx",
                "args": [
                    "-y",
                    "@runframe/mcp-server"
                ],
                "env": {
                    "RUNFRAME_API_KEY": "rf_your_key_here"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "runframe incident management mcp server": {
            "runframe": {
                "command": "npx",
                "args": [
                    "-y",
                    "@runframe/mcp-server"
                ],
                "env": {
                    "RUNFRAME_API_KEY": "rf_your_key_here"
                }
            }
        }
    }
}

Setting up with Cline

Open Cline's settings
Navigate to the Integrations section
Click "Add MCP Server"
Copy and paste the configuration below based on your operating system

Note: Make sure to restart Cline after adding the configuration.

JSON

{
    "mcpServers": {
        "runframe incident management mcp server": {
            "runframe": {
                "command": "npx",
                "args": [
                    "-y",
                    "@runframe/mcp-server"
                ],
                "env": {
                    "RUNFRAME_API_KEY": "rf_your_key_here"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "runframe incident management mcp server": {
            "runframe": {
                "command": "npx",
                "args": [
                    "-y",
                    "@runframe/mcp-server"
                ],
                "env": {
                    "RUNFRAME_API_KEY": "rf_your_key_here"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "runframe incident management mcp server": {
            "runframe": {
                "command": "npx",
                "args": [
                    "-y",
                    "@runframe/mcp-server"
                ],
                "env": {
                    "RUNFRAME_API_KEY": "rf_your_key_here"
                }
            }
        }
    }
}

Setting up with Goose

Open Goose's preferences
Go to the Integrations tab
Select "MCP Servers"
Click "Add New Server"
Use the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "runframe incident management mcp server": {
            "runframe": {
                "command": "npx",
                "args": [
                    "-y",
                    "@runframe/mcp-server"
                ],
                "env": {
                    "RUNFRAME_API_KEY": "rf_your_key_here"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "runframe incident management mcp server": {
            "runframe": {
                "command": "npx",
                "args": [
                    "-y",
                    "@runframe/mcp-server"
                ],
                "env": {
                    "RUNFRAME_API_KEY": "rf_your_key_here"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "runframe incident management mcp server": {
            "runframe": {
                "command": "npx",
                "args": [
                    "-y",
                    "@runframe/mcp-server"
                ],
                "env": {
                    "RUNFRAME_API_KEY": "rf_your_key_here"
                }
            }
        }
    }
}

From the repository

Install the server via npx and provide a Runframe API key. Configuration can be done in Claude Code with the command claude mcp add runframe -e RUNFRAME_API_KEY=rf_your_key_here -- npx -y @runframe/mcp-server, or in Cursor, VS Code, or Claude Desktop by adding a JSON entry with the command and environment variable.

Claude Desktop / Cursor

Paste into your MCP client config file to install this server.

{
    "mcpServers": {
        "runframe incident management mcp server": {
            "runframe": {
                "command": "npx",
                "args": [
                    "-y",
                    "@runframe/mcp-server"
                ],
                "env": {
                    "RUNFRAME_API_KEY": "rf_your_key_here"
                }
            }
        }
    }
}

McpServers

{
    "runframe": {
        "command": "npx",
        "args": [
            "-y",
            "@runframe/mcp-server"
        ],
        "env": {
            "RUNFRAME_API_KEY": "rf_your_key_here"
        }
    }
}

Runframeis the complete incident lifecycle platform for engineering teams, covering incident response, on-call, and status pages. This MCP server lets you manage those workflows from your IDE or AI agent.

17 tools covering incidents, on-call, services, postmortems, teams, and people lookup. Requires Node.js 20+.

- Stay in your editor— acknowledge incidents, page responders, and write postmortems without switching to a browser
- Let agents handle the routine— AI agents can triage, escalate, and update incidents autonomously using scoped API keys
- Zero infrastructure— runs vianpx, no server to deploy for local use

Your IDE / Agent ↓ (stdio or HTTP) MCP Server (this package) ↓ (HTTPS, scoped API key) Runframe API

The server is stateless. It translates MCP tool calls into Runframe API requests, scoped by your API key permissions. No data is stored locally.

- "Acknowledge incident INC-2026-001"→ callsrunframe_acknowledge_incident
- "Who is on call right now?"→ callsrunframe_get_current_oncall
- "Create a postmortem for the database outage"→ callsrunframe_create_postmortem
- "Page the backend team lead about the API latency spike"→ callsrunframe_page_someone
- "List all open SEV1 incidents"→ callsrunframe_list_incidentswith severity filter
- "Find Alex so I can check their open incidents"→ callsrunframe_find_user

Get your API key from settings inside Runframe.io, then add to your agent:

claude mcp add runframe -e RUNFRAME_API_KEY=rf_your_key_here -- npx -y @runframe/mcp-server

Cursor(~/.cursor/mcp.json) ·VS Code(.vscode/mcp.json) ·Claude Desktop(claude_desktop_config.json):

{ "mcpServers": { "runframe": { "command": "npx", "args": ["-y", "@runframe/mcp-server"], "env": { "RUNFRAME_API_KEY": "rf_your_key_here" } } } }

Other MCP clients:Add the JSON config above to your client's MCP config file.

stdio(default) — used by MCP clients like Claude Code and Cursor. No network exposure. This is what the install commands above configure.

Streamable HTTP— for containerized or remote deployments. RequiresMCP_ACCESS_TOKENfor bearer auth:

RUNFRAME_API_KEY=rf_... \ MCP_ACCESS_TOKEN=your_token \ npx @runframe/mcp-server --transport http --port 3100 --host 127.0.0.1

Responsibility is split across three boundaries:

- Runframe APIhandles authorization and scopes viaRUNFRAME_API_KEY.
- This MCP serverhandles process isolation (stdio) and bearer-token validation (HTTP). It also enforces method filtering, Host/Origin checks on localhost, declared Content-Length validation (1 MB limit), 8 KB header limit, and 15s upstream timeout.
- Your reverse proxyhandles TLS, rate limiting, and streamed-body enforcement if you expose HTTP mode to a network.

The server stores nothing. It is a pass-through to the Runframe API.

This MCP server follows the public Runframe direct API contract.

- Incident create requiresservice_idscontaining public service keys likesvc_K7M4Q9TZ2H, not internal UUIDs.
- runframe_get_servicenow looks up services by publicservice_key, not UUID.
- Incident tools now follow the latest V1 contract: use incident numbers likeINC-2026-001in path parameters.
- Incident update and list filters now use the latest public identifiers where V1 does: assignee/resolver email andteam_name.
- runframe_create_incidentaccepts an optionalidempotency_key, which is forwarded as theIdempotency-Keyheader for retry-safe creates.
- runframe_create_incidentdefaultsseveritytoSEV2when omitted, matching the V1 API.
- Incident create now mirrors the V1 API limits:titlemust be 1-200 chars,descriptionmaxes at 10000 chars, andservice_idsallows at most 50 items.
- Incident creation depends on valid SLA configuration for the requested severity. If acknowledge or closure deadlines are missing, the API rejects the create.
- Userunframe_list_servicesto discover validservice_keyvalues before creating incidents.
- runframe_page_someonenow uses the latest V1 delivery contract:email,channels, and optionalmessage.
- Postmortem tools now follow the latest V1 contract: useincident_numberand snake_case nested fields likeusers_affected,owner_email, andtime_to_acknowledge.
- Userunframe_find_userto resolve a person name to an email address before filtering incidents byassigned_toorresolved_by.
- Setinclude_inactive=trueonrunframe_find_userwhen you need to resolve former employees in historical incident queries.
- Setis_active=trueoris_active=falseonrunframe_find_userwhen you need an explicit V1 active-state filter.
- Userunframe_list_teamswithsearchto resolve the exactteam_namebefore filtering incidents.

The Docker image runs HTTP transport by default on port 3100:

docker build -t runframe-mcp-server . docker run -e RUNFRAME_API_KEY=rf_... -e MCP_ACCESS_TOKEN=your_token -p 3100:3100 runframe-mcp-server

HTTP mode is meant for private networks. If you put it on the internet:

- Run behind TLS (nginx, Caddy, cloud LB). This server does not do TLS.
- Use a reverse proxy for rate limiting and request buffering.
- Prefer private subnets or VPNs over public exposure.
- RotateMCP_ACCESS_TOKENregularly. Pass old and new tokens comma-separated for zero-downtime swaps.

The Runframe API enforces rate limits server-side. If you hit a limit, tools return a 429 error with a retry hint. For HTTP transport deployments, your reverse proxy can add additional request-level throttling.

MCP_ACCESS_TOKENaccepts comma-separated tokens:
- SetMCP_ACCESS_TOKEN=new_token,old_token
- Update clients tonew_token
- Drop the old one:MCP_ACCESS_TOKEN=new_token

- Read-only for schedules — you can query on-call and escalation policies but not modify them via MCP
- Requires aRunframeaccount and API key

Issues and PRs welcome at github.com/runframe/runframe-mcp-server.

Chia Health MCP Server — Patient workflow integration for a licensed US telehealth platform. Browse GLP-1 medications (semaglutide, tirzepatide), peptide therapies (sermorelin, NAD+, glutathione), and longevity treatments. Check eligibility, complete intake, sign consents, and manage treatment plans. 30 tools, HIPAA-compliant. All prescriptions evaluated by licensed US healthcare providers and delivered from FDA-regulated pharmacies across 50 states + DC.

Broker + MCP server for last-bidder-wins games on Solana — agents register, auto-fund a Privy wallet, and bid via streamable HTTP

AI-powered no-code app builder with 17 MCP tools — create projects, generate pages from natural language, AI text/image generation (GPT, Claude, Gemini, 14+ models), page CRUD, workflow execution, publish & version control. SSE transport, API key auth.

An mcp server for your food ordering needs.

Agent-to-Agent handoff certification for multi-agent systems — validates context preservation, verifies agent capabilities before handoff, logs transfer chains, and ensures no data loss in agent orchestration.

Unified MCP & skill management gateway with progressive disclosure. Manages multiple MCP servers as Agent Apps, loading tool schemas on demand for 99% context token savings. Shared across Claude Code, Codex, OpenCode and more.

A collection of Model Context Protocol (MCP) servers for various tasks and integrations, supporting both Python and Node.js environments.

Open-souSecurely feeds real security refreshed rules into Cursor, Claude Code, and Windsurf — zero config, no API key.

Health intelligence MCP — access biomarkers, biological age, and personalized longevity action plans from your Aniva profile.

Real-time stock heatmaps and investment tools delivered as interactive React components.

No reviews yet — be the first

Use Google, GitHub, or an email account so ratings stay tied to real people.

Email sign in

No reviews posted yet.

About

Details

Jump to

Setting up with Highlight

From the repository

Claude Desktop / Cursor

McpServers

Install

More like this

Sequential Thinking

Sentry

Github

Filesystem

EverArt

Google Drive