Log inSubmit server
Runframe MCP Server logo

Runframe MCP Server

Connects AI agents and IDEs to Runframe for incident response, on-call lookup, service discovery, paging, and postmortems.

InstallRepositoryWebsite
Full README Compare alternatives Embed widget Claim this listing

Install Runframe MCP Server

Pick your client, then add it in one click or paste the config.

STDIONode.js
~/Library/Application Support/Claude/claude_desktop_config.json
claude_desktop_config.json
{
  "mcpServers": {
    "runframe-mcp-server": {
      "command": "npx",
      "args": [
        "-y",
        "@runframe/mcp-server"
      ],
      "env": {
        "RUNFRAME_API_KEY": "YOUR_VALUE_HERE",
        "RUNFRAME_API_URL": "YOUR_VALUE_HERE",
        "MCP_ACCESS_TOKEN": "YOUR_VALUE_HERE"
      }
    }
  }
}

Settings → Developer → Edit Config, merge this into mcpServers, then fully quit and reopen Claude Desktop.

Values are written into the snippet above so you can paste it as is. They never leave your browser.

We couldn’t confirm it starts correctly

The install command installed and started the server, which then stopped for configuration (such as an API key) that our sandbox does not have — expected for servers that connect to your account.

npx -y @runframe/mcp-server

No response to initialize.

This is an experimental automated check and can have false negatives — missing environment variables, a slow cold install, etc. It doesn’t necessarily mean something’s wrong. Last checked 5d ago.

Overview

runframe-mcp-server MCP server connects MCP clients to the Runframe API for incident response, on-call, services, teams, users, and postmortems. It translates tool calls into HTTPS API requests and uses a scoped Runframe API key without storing data locally. Use it when an agent needs to inspect or update incidents, contact responders, identify ownership, or document an outage from an IDE or remote deployment. It supports stdio by default and streamable HTTP for containerized or remote setups.

Use cases

  • Acknowledge and triage active incidents from an IDE
  • Page responders through Slack or email
  • Check current on-call ownership and escalation policies
  • Create postmortems after service outages
  • Find services, teams, and users for incident workflows

Key features

  • Incident creation, updates, status changes, and escalation
  • On-call and escalation-policy lookup
  • Responder paging through Slack or email
  • Service, team, and user discovery
  • Postmortem creation and retrieval
  • stdio and streamable HTTP transports

Tools17

What Runframe MCP Server lets your agent do. Expand a tool for its parameters.

Self-reported~250 tokens of context

Security & health

What it can reach and how reliably it runs — from our own checks, not the maintainer’s claims.

ActiveLast checked 3d ago

Recent health check succeeded.

8/8 checks healthy over the last 51d

Supply-chain signal

No high-severity advisories surfaced by our automated scan.

Critical 0High 0Medium 0Low 0

Scanned 15d ago via OSV.dev · @runframe/mcp-server (npm)

Adoption & maintenance

Factual signals from GitHub, npm, and our automated checks — not a rating.

GitHub stars4Stargazers on the source repository.
npm downloads180Package downloads in the last 30 days.
Last commit6mo agoMost recent push to the default branch.
Install checkRunsOur sandbox started it; it then asked for an API key or config.
Tools exposed17Callable tools this server registers over MCP.
Directory activity3 viewsConfig copies, upvotes, and views on AllMCPs.

How Runframe MCP Server works

What runframe-mcp-server MCP server does

runframe-mcp-server MCP server exposes Runframe’s incident-management workflows to MCP-compatible clients. It covers incident investigation and updates, on-call lookup, service records, team and escalation-policy discovery, user searches, and postmortems. The available operations can support both read-only investigation and authorized changes to operational records.

Incident tools can list records with filters and pagination, retrieve an incident by ID or number, create and update incidents, move them through statuses, acknowledge them, add timeline events, escalate them, and page a responder through Slack or email. Other tools identify the current on-call person, list or inspect services, find teams and escalation policies, and create or retrieve postmortems.

How it works

The server acts as a stateless translation layer. An MCP client sends a tool call over stdio or streamable HTTP, and the process makes an HTTPS request to the Runframe API using the configured API key. No application data is stored locally.

Authorization comes from the scopes attached to the Runframe API key. Read and write operations require different Runframe permissions, including incident, on-call, service, postmortem, team, and user scopes. In HTTP mode, a separate bearer token protects access to the MCP endpoint.

The incident tools follow Runframe’s public V1 API conventions. Incident creation uses public service keys, while incident paths use incident numbers such as INC-2026-001. User and team lookup tools can help resolve the email addresses and exact team names needed for filtering or assignment.

Setup and configuration

Install the package with Node.js 20 or newer and obtain an API key from Runframe settings. For a local client, the usual command is:

Terminal
npx -y @runframe/mcp-server

Set RUNFRAME_API_KEY in the client configuration. RUNFRAME_API_URL can override the default https://runframe.io endpoint. An interactive setup command is also available:

Terminal
npx @runframe/mcp-server --setup

stdio is the default transport and is suitable for clients such as Claude Code, Cursor, VS Code, and Claude Desktop. Streamable HTTP can be started with --transport http, a port, and a host. HTTP deployments require MCP_ACCESS_TOKEN; multiple comma-separated tokens support rotation. Docker runs HTTP transport on port 3100 by default.

Tools and capabilities

The 17 tools are grouped as follows:

  • Incidents: list, retrieve, create, update, change status, acknowledge, add events, escalate, and page responders.
  • On-call: retrieve the current on-call assignment.
  • Services: list services and retrieve service details.
  • Postmortems: create a postmortem or retrieve one for an incident.
  • Teams: list teams and retrieve a severity-based escalation policy.
  • Users: search by name or email, with filters for inactive and active users.

Incident creation defaults severity to SEV2 when omitted, accepts an idempotency key, and enforces title, description, and service-count limits from the V1 contract. Valid SLA configuration is required for the requested severity.

Limitations and notes

runframe-mcp-server MCP server does not provide its own authorization model for Runframe actions; the API key’s scopes determine what calls can do. HTTP mode does not provide TLS, rate limiting, or general internet-facing protection. A reverse proxy should handle TLS and rate limiting, and private networking or a VPN is preferred for remote exposure.

The server validates HTTP method and host-related requests, limits declared content length to 1 MB and headers to 8 KB, and applies a 15-second upstream timeout. Runframe API rate-limit responses are returned as 429 errors with retry guidance. Before creating incidents, discover valid public service keys with the service-list tool; use the user and team tools when exact email or team identifiers are needed.

Read the full README View source on GitHub

Reviews

No reviews yet — be the first to share how it worked for you.

Frequently Asked Questions about Runframe MCP Server

runframe-mcp-server is an MCP server that connects AI agents and IDEs to the Runframe incident management API. Its main tools list, read, create, update, acknowledge, escalate, and close incidents; page responders; inspect on-call, services, teams, and users; and create or retrieve postmortems.

Install it through `npx` with Node.js 20 or newer, then configure `RUNFRAME_API_KEY` in your MCP client. Use `npx -y @runframe/mcp-server` for the default stdio transport, or run `npx @runframe/mcp-server --setup` for the interactive setup wizard.

Yes, runframe-mcp-server works with Cursor through its stdio transport. Add the package as an MCP server in `~/.cursor/mcp.json`, use `npx` with `@runframe/mcp-server`, and provide the `RUNFRAME_API_KEY` environment variable.

Run it with `--transport http`, a port, and a host, and set both `RUNFRAME_API_KEY` and `MCP_ACCESS_TOKEN`. HTTP mode is intended for containerized or remote deployments; use a reverse proxy for TLS and rate limiting if exposing it beyond a private network.

Related MCP servers

All in Monitoring All alternatives
Add a badge to your READMEShow it’s listed — live SVG, Markdown or HTML.

AllMCPs Directory Badge

Full Badge Customizer

Showcase your server listing on GitHub or your project documentation. Embed this dynamic SVG badge to highlight official listing status and live engagement.

Badge Style:
Live Dynamic SVG PreviewRunframe MCP Server AllMCPs Directory Badge
Markdown (GitHub README)
[![AllMCPs](https://allmcps.com/api/badge/runframe-mcp-server?style=directory)](https://allmcps.com/mcp/runframe-mcp-server)
HTML Embed
<a href="https://allmcps.com/mcp/runframe-mcp-server"><img src="https://allmcps.com/api/badge/runframe-mcp-server?style=directory" alt="Runframe MCP Server on AllMCPs" /></a>