Guides8 min read

Best MCP Servers for Site Reliability Engineers in 2026

SREs need to investigate incidents, correlate metrics and logs, query infrastructure state, and reduce time to recovery. These MCP servers connect your AI to your observability stack, infrastructure, runbooks, and deployment history — so the next incident doesn't start from a blank page.

By MyMCPTools Team·

When something is on fire, the last thing an SRE needs is friction. The fastest path to resolution runs through your observability stack, your infrastructure state, your runbooks, and your deployment history — and right now, most of that context has to be assembled manually, tab by tab, under pressure.

MCP servers change the investigation flow. With the right setup, your AI can query metrics, search logs, inspect infrastructure state, and pull relevant runbook sections in a single conversation. Here are the best MCP servers for site reliability engineers in 2026.

1. Datadog MCP Server — Metrics, APM, and Service Intelligence

Datadog is where most SRE investigations start. The Datadog MCP server gives your AI direct access to metrics, APM traces, service maps, and dashboards — so you can ask natural language questions about system behavior and get answers grounded in live telemetry data.

Key capabilities:

  • Query time-series metrics for any service or infrastructure component
  • Read APM trace data to identify latency spikes and error hotspots
  • Access service dependency maps and upstream/downstream health
  • Search monitors and alert history to understand recent state changes

Best for: Incident investigation — ask "what changed in the payments service latency in the 30 minutes before the alert fired?" and get a data-grounded answer rather than manually building a dashboard under pressure.

2. Grafana MCP Server — Unified Observability Query

Grafana aggregates metrics from Prometheus, Loki, Tempo, and other sources into a single pane. The Grafana MCP server gives your AI access to your dashboards, panels, and data sources — so investigation queries can cross observability pillars in one conversation.

Key capabilities:

  • Query Prometheus metrics via Grafana data sources
  • Read Loki log streams with label filters and time ranges
  • Access Tempo distributed traces for end-to-end request tracking
  • Read dashboard configurations to understand what's being monitored

Best for: Teams running open-source observability stacks who want AI to correlate metrics and logs without switching between the Grafana UI, Prometheus, and Loki query interfaces separately.

3. Sentry MCP Server — Error Tracking and Issue Context

Production errors have fingerprints: stack traces, affected versions, user impact counts, and issue history. The Sentry MCP server gives your AI access to that structured error data — so diagnosis can start from the actual exception rather than reconstructed from logs.

Key capabilities:

  • Read current error issues by project, severity, and recency
  • Access full stack traces and breadcrumb event sequences
  • Query error occurrence counts and affected user metrics
  • Check release health and regression status per deployment

Best for: SREs triaging application-layer incidents who want to understand the error pattern — "is this a new regression or a recurring flake?" — before spending time in logs.

4. AWS MCP Server — Infrastructure State and Configuration

Infrastructure incidents often trace to configuration drift, resource exhaustion, or unexpected state. The AWS MCP server gives your AI access to your actual AWS resource inventory and configuration — EC2, ECS, RDS, Lambda, VPCs, security groups — via the AWS CLI.

Key capabilities:

  • Describe EC2 instances, ECS services, and their current health status
  • Check RDS instance state, replication lag, and connection limits
  • Query CloudWatch metrics directly for any AWS resource
  • Inspect security group rules and network ACLs during a network incident

Best for: Infrastructure incidents where the problem is in the cloud layer — ask "what's the current CPU credit balance on our t3 RDS instance and when did it start dropping?" instead of navigating to the CloudWatch console under stress.

5. Kubernetes MCP Server — Container Orchestration State

Most modern services run on Kubernetes, and Kubernetes incidents require reading pod state, events, logs, and resource configurations. The Kubernetes MCP server gives your AI kubectl-level access to your clusters without requiring you to type the queries yourself.

Key capabilities:

  • List pods by namespace and check their status, restarts, and readiness
  • Read pod events and describe failing deployments
  • Check resource requests and limits versus actual consumption
  • Query node conditions and capacity constraints

Best for: SREs investigating OOMKills, CrashLoopBackoffs, or deployment rollout failures who want AI to diagnose the cluster state rather than running individual kubectl commands one by one.

6. GitHub MCP Server — Deployment and Change History

The leading cause of production incidents is a recent change. The GitHub MCP server gives your AI access to your deployment history through recent commits, pull requests, and releases — so incident timelines can be correlated with code changes immediately.

Key capabilities:

  • List recent commits and PRs merged around the incident timeframe
  • Read the diff of a specific release to understand what changed
  • Check deployment workflow runs and their status
  • Review recent changes to configuration files and infrastructure code

Best for: Root cause analysis — "what was deployed between 14:00 and 15:00 UTC before the error rate spiked?" — answered from Git history rather than Slack archaeology.

7. Confluence MCP Server — Runbooks and Post-Mortem History

The fastest incident resolution reuses solutions that have already worked. The Confluence MCP server gives your AI access to your runbook library, past incident post-mortems, and architecture documentation — institutional knowledge that's otherwise buried in pages nobody opens under pressure.

Key capabilities:

  • Search runbooks by service name or symptom description
  • Read past post-mortems to find similar incidents and their resolutions
  • Access architecture documentation to understand service dependencies
  • Draft post-mortem documents from incident timeline notes

Best for: SREs who want AI to find the relevant runbook section during active incidents, or to draft the post-mortem afterward by pulling from the incident's Slack timeline and GitHub history.

8. Axiom MCP Server — High-Volume Log Search

Log volumes at scale make manual search impractical. The Axiom MCP server provides efficient querying over high-volume log streams — so your AI can search millions of log events with structured filters without timing out or requiring you to write APL queries by hand.

Key capabilities:

  • Execute structured log queries with field filters and time ranges
  • Search for specific error strings, trace IDs, or user identifiers
  • Aggregate log counts to identify the highest-frequency error patterns
  • Correlate logs with metrics by timestamp during incident investigation

Best for: SREs correlating log-level evidence with metric-level signals during complex incidents — finding the specific request that caused the spike, not just that the spike happened.

Recommended SRE Stacks

  • Incident triage: Datadog + Sentry + GitHub (metrics → error context → recent changes)
  • Infrastructure investigation: AWS + Kubernetes + Grafana (cloud state → container state → metrics)
  • Root cause analysis: GitHub + Confluence + Axiom (change history → runbooks → log evidence)
  • Post-mortem workflow: GitHub + Slack + Confluence (deployment history → incident timeline → draft post-mortem)
  • Full SRE on-call stack: Datadog + Grafana + Sentry + AWS + Kubernetes + GitHub + Confluence — complete context for any production incident, from alert to resolution to written post-mortem

Browse all DevOps MCP servers on MyMCPTools. For related guides, see Best MCP Servers for DevOps and Best MCP Servers for Cloud Engineers.

Recommended Tools

Better Stack

Free Plan

Get alerted when your APIs, browser tests, payment pipelines, or MCP server dependencies go down. Used by 100K+ developers.

Start monitoring free →

1Password

14-day Free Trial

Store and inject API keys, payment credentials, tokens, and file access secrets into your MCP server configs. Trusted by 150K+ developers.

Try 1Password free →

🔧 MCP Servers Mentioned in This Article

📊

Datadog MCP Server

The Datadog MCP Server is Datadog's official Model Context Protocol integration that connects AI assistants directly to your Datadog observability platform — metrics, logs, APM traces, infrastructure, and monitors. Built and maintained by Datadog, the server uses your API and application keys to expose tools for querying live time-series metrics with full DQL expressions, searching log events with Datadog Log Management query syntax, retrieving distributed APM traces and service performance summaries, listing infrastructure hosts and their tags, and checking the status of Datadog monitors and downtime windows. This gives Claude real-time visibility into your production systems: ask "What's the p99 latency for the payments service over the last hour?" or "Find all ERROR-level logs from the auth service since the last deploy," and receive answers backed by live Datadog data rather than stale dashboards. Authentication requires a Datadog API key (DD_API_KEY) and an Application key (DD_APP_KEY) with appropriate scope — both available from Organization Settings > API Keys and Application Keys in the Datadog UI. Set DD_SITE to your Datadog region (e.g., datadoghq.com, datadoghq.eu, or us3.datadoghq.com). Works with Claude Desktop, Cursor, Windsurf, and any MCP-compatible client. Especially powerful for SRE, DevOps, and on-call workflows where engineers need AI to correlate metrics, logs, and traces during incident response without context-switching away from their conversation.

Local
📊

Grafana MCP Server

The official Grafana MCP server connects Claude and other AI assistants directly to your Grafana instance and its surrounding observability ecosystem, turning natural-language questions into dashboard lookups, incident investigations, and datasource queries. Dashboard tools cover search, retrieval, JSONPath-scoped property extraction, patch-based editing, and per-panel query/datasource introspection, with context-window-aware helpers like get_dashboard_summary so an agent never has to pull a full multi-megabyte dashboard JSON just to answer a simple question. Query tools speak PromQL against Prometheus (including histogram-percentile helpers), LogQL against Loki, and native query languages for InfluxDB, ClickHouse, CloudWatch, Graphite, Athena, Snowflake, Elasticsearch/OpenSearch, and Quickwit datasources — most gated behind opt-in --enabled-tools flags to keep the default tool surface lean. It also wraps Grafana Incident for creating and updating incidents, Sift for automated error-pattern and slow-request investigations, full alerting CRUD (rules, contact points, notification policies) across Grafana-managed and external Alertmanager sources, Grafana OnCall schedule/shift/alert-group management, RBAC-gated admin tools for teams/users/roles, deeplink generation so the LLM never has to guess a dashboard URL, annotations, snapshots, PNG rendering via the Grafana Image Renderer, and provisioning-repo validation for git-sync workflows. Ships as a Go binary or via uvx, authenticates with a Grafana service account token (Editor role or granular RBAC scopes), and every tool category can be individually disabled to control context-window usage.

Local
🔧

Sentry MCP Server

The Sentry MCP Server is Sentry's official Model Context Protocol integration, purpose-built for human-in-the-loop coding agents like Claude Code, Cursor, and Windsurf. Rather than exposing every Sentry API endpoint, it focuses tightly on developer debugging workflows: searching and triaging issues, pulling stack traces and event details, inspecting performance traces, and querying project/team/org metadata in natural language. The primary deployment is a hosted remote MCP server at mcp.sentry.dev, built on Cloudflare's remote-MCP infrastructure, so most users connect with zero local setup — just add the remote URL to their client. For self-hosted Sentry instances or local development, a stdio transport is also available via npx @sentry/mcp-server, authenticated with a Sentry User Auth Token scoped to org:read, project:read, project:write, team:read, team:write, and event:write. AI-powered search tools (search_events, search_issues) translate natural-language queries into Sentry's query syntax, but require a configured LLM provider (OpenAI, Azure OpenAI, Anthropic, or OpenRouter) — all other tools work without one. Claude Code users can also install it as a plugin (claude plugin install sentry-mcp@sentry-mcp) for automatic subagent delegation whenever a conversation touches Sentry errors, issues, or traces. This turns "why did this deploy break in production" into a direct conversational debugging session instead of tab-switching into the Sentry dashboard.

Auth required
☁️

AWS MCP Servers

AWS Labs maintains a monorepo of specialized, open-source MCP servers that bring AWS best practices directly into AI-assisted development workflows, spanning infrastructure, data, AI/ML, cost management, and healthcare/life-sciences domains. Rather than one monolithic server, the project ships dozens of focused servers you install individually depending on the task: the AWS Documentation MCP Server for real-time official docs and API references, dedicated servers for Terraform/CDK/CloudFormation infrastructure-as-code, container and serverless platforms (ECS, EKS, Lambda), SQL/NoSQL databases (DynamoDB, RDS, Aurora), search and analytics (OpenSearch), messaging (SQS/SNS), and cost/billing analysis. Most servers install via uvx with a package name like awslabs.aws-documentation-mcp-server, run locally over stdio, and use standard AWS credential chains (IAM roles, profiles, or access keys) rather than exposing raw account credentials to the model. AWS also now offers a managed, remote "AWS MCP Server" (in preview) that combines full API coverage with pre-built agent SOPs, syntactically validated API calls, and complete CloudTrail audit logging for teams that want centralized governance instead of running servers locally. The Getting Started with Kiro/Cursor/VS Code/Claude Code sections in the repo provide one-click install configs for each server, making it straightforward to wire up only the AWS services a given project actually touches.

Local
🔧

Kubernetes MCP Server

The Kubernetes MCP server (mcp-server-kubernetes, built by Flux159) brings cluster management capabilities into AI assistant workflows, letting developers and platform engineers query and manage Kubernetes resources through natural-language interactions with Claude, Cursor, and other MCP-compatible clients. It loads your existing kubeconfig automatically, so it works with any cluster — local minikube and kind setups, Amazon EKS, Google GKE, Azure AKS, or on-premises deployments — with no separate credential setup required. Core tools exposed by the server include: listing pods, deployments, services, and namespaces; describing individual resources and their status; fetching pod logs for debugging; applying and updating manifests; scaling deployments; checking rollout status and history; and querying resource utilization and cluster events. A built-in non-destructive mode can disable delete/scale-down operations entirely, making it safe to point at production clusters for read-only diagnostics. DevOps engineers use it to debug failing deployments by asking Claude to inspect pod logs and recent events, identify resource constraints causing OOMKilled pods, or summarize the current state of a namespace before a production release. For SREs responding to incidents, it enables rapid triage through conversational commands — no memorizing kubectl flags or switching terminal windows mid-incident — and optional OpenTelemetry integration adds observability into what the AI agent actually did against the cluster. Install with: `npx mcp-server-kubernetes`. Pairs well with the GitHub MCP server for full GitOps review workflows.

Local
💻

GitHub MCP Server

The GitHub MCP server is GitHub's official Model Context Protocol integration, giving AI assistants like Claude and Cursor direct, authenticated access to the GitHub platform and its full developer surface. With this MCP server, you can ask your AI to read and write repository files, create and merge branches, open and review pull requests, comment on and close issues, trigger GitHub Actions workflows, search across code repositories with GitHub's code search, and inspect commit history — all through natural-language prompts in your AI interface. Developers use it to supercharge code review workflows, automate issue triage, generate PR descriptions from diffs, bulk-update repository settings, and wire AI agents into CI/CD pipelines. The GitHub MCP server connects via a GITHUB_PERSONAL_ACCESS_TOKEN environment variable with scopes for the operations you need, keeping authentication clean and auditable. Install with Docker: `docker run -e GITHUB_PERSONAL_ACCESS_TOKEN=<token> ghcr.io/github/github-mcp-server` — or configure it as a remote MCP server in Claude Desktop, Cursor, VS Code, Windsurf, and Cline. With over 8,000 GitHub stars, it is the most widely deployed official code-platform MCP server and the reference implementation for AI-native GitHub automation.

Auth required
📋

Confluence MCP Server

The Atlassian Remote MCP Server brings Confluence and Jira into any MCP-compatible AI assistant, IDE, or agent platform through a centrally hosted, enterprise-grade connection backed by Atlassian's Teamwork Graph. Launched in May 2025 with Anthropic as the first official partner and hosted on Cloudflare infrastructure, authentication is handled via OAuth 2.1 — no local server process to deploy or maintain. For Confluence specifically, available operations include summarizing pages and spaces, creating new pages from AI-generated content, searching across your wiki with natural language, and performing multi-step knowledge retrieval across Confluence spaces. Jira operations include creating, updating, and triaging work items, summarizing sprint state, and linking knowledge to in-flight issues. Atlassian's Teamwork Graph underpins every response — connecting people, services, knowledge, and work items into a unified context for richer AI answers. Enterprise customers at AT&T, NVIDIA, Pfizer, Booking.com, and Visa use the integration in production. Connect from Claude Desktop via Settings > Connectors, or from Claude Code with: `claude mcp add --transport http atlassian https://mcp.atlassian.com/v1/mcp`. Cursor and Windsurf users can add the remote URL directly to their MCP config.

Auth required
💬

Slack MCP Server

The Slack MCP server (built by Ivan Korotovsky) connects AI assistants like Claude, Cursor, and Windsurf directly to Slack workspaces, enabling conversational access to your team communication channels without requiring workspace admin approval for a bot install. Its standout feature is a "no permission" stealth mode — it authenticates using your own personal Slack session tokens (xoxc/xoxd, or a stored browser session) rather than requiring a Slack App with OAuth scopes, so it works even in locked-down workspaces where you cannot create bots. It also supports full OAuth Bot Token auth and Enterprise/GovSlack deployments for teams that prefer a conventional app install. Tools exposed include reading channel and DM/group-DM history with smart pagination, searching messages across the workspace, posting messages and thread replies, listing channels and users, and adding reactions. Common use cases include automating standups by posting summaries directly to team channels, searching past Slack conversations to surface decisions or context, monitoring specific channels for keywords or alerts, and drafting replies to thread discussions — all from natural-language prompts. Supports both Stdio and SSE transports plus proxy configuration for corporate networks. Install with: `npx slack-mcp-server@latest --transport stdio`. A separate official-style integration exists from Zencoder (@zencoderai/slack-mcp-server) for teams that prefer standard Bot Token OAuth over session-token auth. Compatible with Claude Desktop, Cursor, VS Code, Windsurf, and Cline.

Local
📊

Axiom

Query and analyze your Axiom logs, traces, and all other event data in natural language.

Local
🔧

Kubernetes Dashboard

Advanced Kubernetes cluster management MCP. Manage namespaces, deployments, services, ingresses, and custom resources beyond what the basic kubectl server offers.

Local

📚 More from the Blog