Top MCP Servers for Site Reliability Engineers (SRE) and How to Set Them Up in Cursor

Introduction

#

Site Reliability Engineers spend a lot of time context-switching: between logs, dashboards, runbooks, incident tools, and code. The more you can bring these together, the faster you can respond to incidents and improve reliability.

Model Context Protocol (MCP) lets AI assistants in Cursor connect directly to your tools and data sources. Instead of copying logs into a chat or describing your infrastructure from memory, the model can fetch live data, run queries, and take actions on your behalf.

Why MCP Matters for SRE

#

• Faster incident response: Ask “What are the open PagerDuty incidents?” or “Show me the last 100 errors from Sentry” and get real answers without leaving the editor.
• Reduced context-switching: Correlate deployments, logs, and incidents in one conversation.
• AI-assisted runbooks: The model can read your runbooks, query systems, and guide you through steps.
• Documentation at your fingertips: Search Confluence, Notion, or internal docs from chat.

How AI + Tools Improve Reliability Work

#

Without MCP, the model only has what you paste into the chat. It can’t access your PagerDuty, query your logs, or check GitHub deploy status. With MCP, it gains tools — functions that call real APIs. The model decides when to use them and interprets the results. That turns a generic chat into an SRE copilot that can actually see your systems.

What is MCP (Model Context Protocol)?

#

Simple Explanation

#

MCP is an open protocol that lets AI assistants connect to external tools and data sources — APIs, databases, CLIs, and more — through a standardized interface. Think of it as a plugin system: each MCP server exposes capabilities, and clients like Cursor can discover and invoke them.

How MCP Servers Work

#

MCP servers expose three kinds of capabilities:

Cursor communicates with MCP servers via:

• stdio: A local process (e.g., npx mcp-server) that Cursor spawns and talks to over stdin/stdout
• SSE or Streamable HTTP: Remote servers that Cursor connects to over the network

Flow: You ask a question → Cursor invokes an MCP tool → The server runs the operation → The response goes back to the model → The model answers you.

MCP vs Normal LLM Usage

#

Example: “Why did our API latency spike at 2pm?” — Without MCP, the model guesses. With MCP + Honeycomb or Axiom, it can run a query and reason over real traces and logs.

Recommended MCP Servers for SRE

#

Below are MCP servers that fit SRE workflows. All are available in the Cursor MCP Directory or MCP Registry. For each, we list what it does, why it’s useful for SRE, and example use cases.

GitHub MCP Server

#

PagerDuty MCP Server

#

incident.io MCP Server

#

Honeycomb MCP Server

#

Axiom MCP Server

#

Sentry MCP Server

#

AWS MCP Server

#

Elasticsearch MCP Server

#

Notion / Atlassian MCP Servers

#

Bringing IaC and Kubernetes into Context

#

Terraform / IaC: There’s no dedicated Terraform MCP in Cursor’s directory yet. In the meantime, use the Filesystem or Git MCP from the official modelcontextprotocol/servers repo to read Terraform files from your workspace. Terraform-specific MCP servers may appear in the MCP Registry — check there for updates.

Kubernetes: For EKS, the AWS MCP covers many cluster operations. For GKE, see Google’s MCP servers. For community Kubernetes MCP servers, browse the MCP Registry.

How to Set Up MCP Servers in Cursor

#

Prerequisites

#

• Node.js (for npx-based servers)
• Docker (for some servers, e.g., GitHub)
• Cursor IDE (with MCP support)
• API keys / tokens for your services (GitHub, PagerDuty, Axiom, etc.)

Configuration Locations

#

Example mcp.json

#

Create or edit ~/.cursor/mcp.json with your desired servers:

{
  "mcpServers": {
    "github": {
      "command": "docker",
      "args": ["run", "-i", "--rm", "-e", "GITHUB_PERSONAL_ACCESS_TOKEN", "ghcr.io/github/github-mcp-server"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "${env:GITHUB_TOKEN}"
      }
    },
    "pagerduty": {
      "command": "uvx",
      "args": ["pagerduty-mcp", "--enable-write-tools"],
      "env": {
        "PAGERDUTY_USER_API_KEY": "${env:PAGERDUTY_API_KEY}",
        "PAGERDUTY_API_HOST": "https://api.pagerduty.com"
      }
    },
    "axiom": {
      "url": "https://mcp.axiom.co/mcp",
      "headers": {
        "Authorization": "Bearer ${env:AXIOM_TOKEN}"
      }
    }
  }
}

For STDIO servers (local processes), use command and args. For remote servers, use url and headers. Use ${env:VAR_NAME} to pass secrets from your environment instead of hardcoding them.

Step-by-Step Setup

#

1. Create the config file Create ~/.cursor/mcp.json (or .cursor/mcp.json in your project).

2. Add server entries Copy the example above and add or remove servers for your stack. Ensure each server has the correct command/args or url/headers.

3. Set environment variables Export the required tokens before launching Cursor, for example:

   export GITHUB_TOKEN="ghp_..."
   export PAGERDUTY_API_KEY="..."
   export AXIOM_TOKEN="..."

4. Restart Cursor Reload the window (Cmd+Shift+P → “Developer: Reload Window”) or restart Cursor so it picks up the new config.

5. Verify Go to Settings → Tools & MCP and confirm your servers appear. In chat, enable the tools you want the model to use.

Minimal Config Example

#

A simple starter configuration using npx:

{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "${env:GITHUB_TOKEN}"
      }
    },
    "kubernetes": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-kubernetes"]
    }
  }
}

Package names may vary. For Kubernetes, you may need the AWS MCP (for EKS) or community servers from the MCP Registry. Always check the Cursor MCP Directory for the exact install commands per server.

Best Practices and Security

#

MCP servers can access external services and execute operations on your behalf. Treat them with care.

For more details, see Cursor’s security considerations.

Conclusion and Future Outlook

#

MCP gives SREs a way to combine AI assistance with live tooling (GitHub, PagerDuty, logs, cloud APIs) directly in Cursor. Instead of juggling between tools, you can ask questions and get answers backed by real data.

Expect more SRE-focused servers over time — Datadog, Grafana, Terraform, and dedicated Kubernetes MCP servers may appear. The MCP Registry and Cursor MCP Directory are the best places to discover new integrations.

If you have feedback or runbook ideas, share them. The MCP ecosystem is evolving quickly, and SRE use cases are a natural fit.