Guides9 min read

Best MCP Servers for Platform Engineers in 2026

Platform engineers build and maintain internal developer platforms — the infrastructure, tooling, and self-service systems that keep engineering teams moving. These MCP servers give your AI access to cluster state, infrastructure as code, secret management, CI/CD pipelines, and observability data.

By MyMCPTools Team·

Platform engineering is infrastructure work at the speed of product development. Your job is to abstract the complexity of distributed systems into reliable, self-service primitives that product engineers can consume without needing a PhD in Kubernetes. The challenge: the state of those systems is always changing, and understanding it requires pulling context from a dozen different tools.

MCP servers collapse that context into a single conversation. Instead of switching between kubectl, Terraform, Vault, Grafana, and GitHub Actions to diagnose a problem or plan a change, your AI can query all of them at once. Here are the best MCP servers for platform engineers in 2026.

1. Kubernetes MCP Server — Live Cluster State as Context

The cluster is the platform. The Kubernetes MCP server gives your AI direct access to cluster state — pods, deployments, services, namespaces, config maps, events, and resource quotas — making it possible to reason about operational issues and configuration changes with real data rather than stale documentation.

Key capabilities:

  • Query pod status, logs, and events across namespaces
  • Inspect deployment rollout history and current replica counts
  • Check resource quota consumption by namespace or team
  • Read config maps and secrets metadata for configuration auditing

Best for: Diagnosing why a team's deployment is failing without opening a terminal. Ask "what's happening in the payments namespace right now?" and get pod status, recent events, and resource pressure in one response. Excellent for capacity planning discussions where current utilization needs to be grounded in real numbers.

2. Terraform MCP Server — Infrastructure as Code at Scale

Platform infrastructure is code. The Terraform MCP server gives your AI access to your infrastructure declarations — module trees, resource dependencies, state, and planned changes — so infrastructure design conversations can reference the actual configuration rather than diagrams that drift from reality.

Key capabilities:

  • Read module structures and resource dependency graphs
  • Query Terraform state for current infrastructure inventory
  • Review planned changes before apply to catch unintended side effects
  • Search for resource patterns or anti-patterns across environments

Best for: Architecture reviews where you need to understand what's actually deployed. Ask "what AWS resources does the data platform module create?" and get a precise answer from the actual Terraform configuration — not from someone's memory of what they think they shipped six months ago.

3. Vault MCP Server — Secret Management and Access Auditing

Secret sprawl is the silent killer of platform security. The Vault MCP server gives your AI visibility into your secret management posture — engines, policies, lease TTLs, and access patterns — making it easier to audit access, enforce rotation policies, and diagnose authentication issues without manually navigating the Vault UI.

Key capabilities:

  • Audit secret engine configurations and mount paths
  • Review policy definitions for over-permissioned access
  • Check token lease TTLs and renewal patterns
  • Diagnose authentication failures by reviewing auth method configurations

Best for: Quarterly security reviews where you need to audit who has access to what, and whether rotation policies are being enforced. Ask "which services have leases expiring this week?" before a high-traffic event to avoid authentication failures from stale credentials.

4. GitHub Actions MCP Server — CI/CD Pipeline Intelligence

The CI/CD pipeline is your platform's delivery nervous system. The GitHub Actions MCP server gives your AI access to workflow runs, job logs, failure patterns, and pipeline configuration — so you can diagnose build failures, identify flaky tests, and optimize pipeline performance without manually trawling through run logs.

Key capabilities:

  • Read recent workflow run results across repositories
  • Access job logs to diagnose build failures
  • Identify recurring failure patterns across runs
  • Review workflow configuration for optimization opportunities

Best for: Platform teams responsible for build reliability who want AI to identify why a specific workflow has been failing intermittently, or to audit whether teams are following established pipeline patterns before approving new workflow additions.

5. Prometheus MCP Server — Metrics as Operational Context

Platform health is measured in metrics. The Prometheus MCP server gives your AI access to your metrics data — cluster resource utilization, service SLIs, custom business metrics, and alerting rules — so reliability discussions can be grounded in real performance data rather than intuition.

Key capabilities:

  • Query time-series metrics for infrastructure resources
  • Read alerting rules to understand current monitoring coverage
  • Check metric cardinality for scalability assessment
  • Evaluate recording rule efficiency for high-cardinality queries

Best for: Capacity planning conversations where you need to project resource growth from current utilization trends. Ask "based on current memory growth, when do we need to add nodes to the production cluster?" and get an answer grounded in actual metric data rather than guesswork.

6. Helm MCP Server — Release Management and Chart Intelligence

Helm charts are how platform teams package and distribute standardized workloads. The Helm MCP server gives your AI access to chart definitions, release histories, and value configurations — so you can audit what's deployed, diagnose release failures, and maintain chart hygiene across environments.

Key capabilities:

  • Inspect chart templates and default value schemas
  • Read release histories and rollback availability
  • Compare values between environments to identify configuration drift
  • Review chart dependencies for version compatibility

Best for: Diagnosing environment-specific issues caused by value overrides. Ask "how do the production values for the API gateway chart differ from staging?" to quickly identify why a service behaves differently across environments without manually diffing YAML files.

7. Grafana MCP Server — Dashboards and Alert Context

Grafana is the observation layer of most platform stacks. The Grafana MCP server gives your AI access to dashboard definitions, panel queries, and alert configurations — making it possible to audit monitoring coverage, update dashboards, and understand what's being measured without navigating the Grafana UI manually.

Key capabilities:

  • Read dashboard definitions and panel configurations
  • Audit alert rules for correctness and coverage gaps
  • Search for dashboards related to a specific service or metric
  • Review data source configurations for connection issues

Best for: Onboarding new services onto the platform's observability stack. Ask "do we have dashboards covering the key SLIs for the payment service?" and get an assessment of current monitoring coverage before the service goes to production.

8. Argo CD MCP Server — GitOps Delivery State

GitOps means the cluster state should match the Git state. The Argo CD MCP server gives your AI visibility into your application synchronization status — which apps are out of sync, which are degraded, and what the git diff looks like between desired and actual state — making GitOps drift easy to detect and diagnose.

Key capabilities:

  • List applications and their current sync status
  • Read sync errors and health assessment for degraded apps
  • Review application manifests and target revisions
  • Check sync policy configurations for auto-sync enforcement

Best for: Platform teams operating GitOps workflows who need to quickly assess the delivery state of the entire fleet. Ask "which production applications are out of sync right now and why?" to get a prioritized list of drift incidents before your daily platform review.

Recommended Stacks for Platform Engineers

  • Incident diagnosis: Kubernetes + Prometheus + Grafana (cluster state → metrics → dashboards)
  • Infrastructure review: Terraform + Vault + GitHub Actions (IaC state → secrets posture → CI/CD health)
  • Release management: Argo CD + Helm + GitHub Actions (GitOps state → chart config → pipeline logs)
  • Capacity planning: Kubernetes + Prometheus + Terraform (current utilization → trends → IaC for scaling)
  • Full platform stack: Kubernetes + Terraform + Vault + Prometheus + Grafana + Argo CD — complete coverage across runtime, infrastructure, security, and observability

Browse all DevOps MCP servers on MyMCPTools. For related guides, see Best MCP Servers for DevOps and Best MCP Servers for Site Reliability 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

🔧

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
🔧

Terraform MCP Server

The Terraform MCP Server is HashiCorp's official integration that brings Terraform's infrastructure-as-code capabilities into AI assistants via the Model Context Protocol. It connects Claude Desktop, Cursor, VS Code, and other MCP clients to the Terraform ecosystem — letting you explore providers, look up module schemas, validate configurations, and work with HCP Terraform (Terraform Cloud) all through natural-language conversation. Core tools include: search the Terraform Registry for modules and providers by keyword, retrieve full provider schema documentation including resource arguments and attribute types, look up specific module input/output variables and their defaults, resolve provider version constraints and compatibility matrices, and run Terraform operations against HCP Terraform workspaces including plan, apply, and state inspection. A key use case is AI-assisted IaC authoring: ask Claude to "generate a Terraform module for an AWS VPC with public and private subnets using the latest aws provider schema" and the server fetches the live provider schema to ensure accurate attribute names and types rather than hallucinating outdated syntax. For HCP Terraform users, workspace integration supports listing workspaces, triggering runs, and checking plan output. HashiCorp maintains the server at hashicorp/terraform-mcp-server and distributes it as a pre-built binary for Linux, macOS (arm64 + amd64), and Windows. Install via: `npx @hashicorp/terraform-mcp-server`. Pairs well with GitHub MCP for full IaC PR review workflows.

Local
🔧

HashiCorp Vault

Manage secrets and sensitive data stored in HashiCorp Vault. Read and write secrets, manage dynamic credentials, and handle PKI operations via AI.

Local
🔧

GitHub Actions

Manage GitHub Actions workflows, runs, and secrets. Trigger workflows, inspect run logs, manage environment variables, and debug CI failures via AI.

Local
🔧

Prometheus

Query Prometheus metrics using PromQL from AI assistants. Analyze time-series data, set up alerting rules, and monitor infrastructure performance.

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
🔧

Helm

Kubernetes package manager MCP server. Install, upgrade, and roll back Helm charts. Inspect release history, manage repositories, and debug chart templates.

Local
🔧

Argo CD

Declarative GitOps continuous delivery for Kubernetes. Manage applications, sync deployments, inspect health status, and rollback releases via AI.

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
📊

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

📚 More from the Blog