DevOps & CI/CD MCP Servers

Tools to read, search, and manipulate Git repositories. Full Git operations support.

authenticated access to the whole GitHub platform — repositories, files, branches, issues, pull requests, Actions runs, security alerts, discussions and notifications — from Claude, Cursor, VS Code, Copilot CLI and any other MCP host. There is no npm package for this server, and that trips up most people who try to install it: `@github/mcp-server` is not published to the npm registry, so any `npx` line you find for it will fail. GitHub ships it three other ways. The easiest is the hosted remote server at https://api.githubcopilot.com/mcp/, which needs no install at all — point an HTTP-transport MCP client at that URL and log in with OAuth (VS Code 1.101+, Claude Desktop, Claude Code, Cursor and Windsurf all support this). The second is the official Docker image ghcr.io/github/github-mcp-server, which is what the copy-paste command on this page runs; on github.com it now performs a browser-based OAuth login on first use and keeps the token in memory only, which is why the published Docker configs map a fixed loopback callback port (-p 127.0.0.1:8085:8085 with GITHUB_OAUTH_CALLBACK_PORT=8085) so the container can receive the callback. Prefer a token? Set GITHUB_PERSONAL_ACCESS_TOKEN instead — it takes precedence over OAuth, and the minimum useful scopes are repo, read:org and read:packages. The third is the native Go binary from the repository's releases, which needs no fixed port for the OAuth flow. GitHub Enterprise Server has no hosted option: use the local server with --gh-host or GITHUB_HOST set to your instance (include the https:// scheme — it defaults to http://, which GHES rejects). Toolsets can be narrowed with GITHUB_TOOLSETS, and an insiders channel is available at /mcp/insiders or via the X-MCP-Insiders header.

a first-party MCP endpoint built into the GitLab instance itself — there is no package to install, because the server ships inside GitLab and answers at https://<your-gitlab>/api/v4/mcp (gitlab.com exposes the same path, so https://gitlab.com/api/v4/mcp works for SaaS projects). It landed as an experiment in GitLab 18.3 and moved to beta in 18.6. Authentication is the part that makes it different from every community GitLab server: it uses OAuth 2.0 Dynamic Client Registration, so the first time a client connects it registers itself as an OAuth application on your instance and is issued an access token — no personal access token pasted into a config file. Administrators who do not want one OAuth application per tool can pre-create a shared application instead. Three prerequisites are what actually block most first connections: GitLab Duo must be set to Always on or On by default, beta and experimental features must be enabled, and MCP access must be switched on at the group or instance level. The tool surface covers issues and merge requests (create_issue, get_issue, create_merge_request, get_merge_request, list_merge_requests, get_merge_request_commits, get_merge_request_diffs, get_merge_request_pipelines, create_merge_request_note, get_merge_request_notes), CI/CD (manage_pipeline for list/create/delete/retry/cancel, get_pipeline_jobs, get_job_log), work items (create_workitem_note, get_workitem_notes, link_work_items, get_saved_view_work_items), search (search across the instance, search_labels, semantic_code_search), list_wiki_pages, and attach_scan_profile. HTTP is the recommended transport — claude mcp add --transport http GitLab https://gitlab.com/api/v4/mcp — and clients that only speak stdio can wrap it with npx mcp-remote <url> on Node 20+. Send the X-Gitlab-Mcp-Server-Tool-Name-Prefix header if generic names like search collide with another connected server. If your instance predates 18.3 or Duo is not available to you, the community alternative most teams land on is zereight/gitlab-mcp (1,889 stars as of 2026-08-16, npm @zereight/mcp-gitlab), which authenticates with a plain personal access token and ships 217 tools — including merge_merge_request, approve_merge_request, execute_graphql and full CI/CD variable management, none of which the built-in server exposes — behind GITLAB_PERMISSION_MODE=readonly/modify and GITLAB_TOOLSETS/GITLAB_TOOLS filtering. One further change worth noting: MCP server access moved from GitLab Premium to GitLab Free in 19.2 and became a setting of its own.

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.

Cloudflare ships two different things under this name. The mcp-server-cloudflare repo provides 16 remote, domain-specific MCP servers rather than one monolith — Documentation, Workers Bindings (storage/AI/compute primitives), Workers Builds, Observability (logs/analytics), Container sandboxes, Browser Rendering (fetch pages, convert to markdown, screenshots), Logpush health, AI Gateway (prompt/response search), AI Search, Audit Logs, DNS Analytics, Digital Experience Monitoring, Cloudflare One CASB, Radar, GraphQL analytics and the Agents SDK docs server, each on its own `*.mcp.cloudflare.com/mcp` hostname. Separately, the Cloudflare API MCP server at mcp.cloudflare.com/mcp (repo: cloudflare/mcp) exposes the whole 2,500+ endpoint Cloudflare API through just two tools, `search` and `execute`, using the Code Mode pattern — model-written JavaScript runs in an isolated Dynamic Worker, costing ~1,000 tokens of context against the ~1.17M an equivalent native-tool server would need. Pick a domain server when you want a readable, curated tool list for one product area; pick the API server for breadth or for endpoints nobody wrote a tool for. All endpoints are Streamable HTTP on `/mcp` and support the MCP 2026-07-28 spec; the historical `/sse` URLs remain as aliases for the same Streamable HTTP handler but no longer serve the deprecated HTTP+SSE transport, so clients pinned to SSE must switch. Auth is OAuth on connect, or a scoped Cloudflare API token as a bearer header for CI. Clients without native remote-MCP support bridge via `npx mcp-remote https://<subdomain>.mcp.cloudflare.com/mcp`.

The Vercel MCP server is a powerful Model Context Protocol integration that allows AI assistants like Claude, Cursor, and Cline to interact directly with your Vercel infrastructure. It exposes essential platform capabilities as AI-callable tools, meaning you can manage projects, trigger deployments, inspect build logs, and configure custom domains via natural language prompts. For frontend developers and DevOps teams working within the Vercel ecosystem, this eliminates the need to constantly context-switch between an IDE, terminal, and the Vercel dashboard. You can simply ask your AI agent to "check the status of the latest production deployment", "fetch the build logs for the staging environment and identify the Next.js hydration error", or "list all environment variables for the current project". By bridging the gap between your codebase and your hosting platform, the Vercel MCP server turns your AI assistant into an embedded DevOps engineer capable of diagnosing build failures and managing serverless deployments in real time. Vercel ships this as an official hosted (remote) MCP server at https://mcp.vercel.com — there is no package to install locally. Connect an MCP client to that URL and authenticate through the browser-based OAuth flow, which scopes access to the Vercel teams and projects your account can already reach rather than a long-lived Personal Access Token. For example, add it to Claude Code with `claude mcp add --transport http vercel https://mcp.vercel.com`, then complete the OAuth consent screen; the repo vercel/vercel-mcp-overview is the official public overview of this server, with full docs at vercel.com/docs/mcp/vercel-mcp.

The Docker MCP server (ckreiling/mcp-server-docker) gives an AI assistant direct control of a Docker daemon over the Model Context Protocol: containers, images, networks and volumes, as tools rather than shell commands. It is the community server most people mean by "Docker MCP" — distinct from Docker’s own Docker MCP Gateway, which does not manage your containers at all but runs *other* MCP servers inside containers. If you want to ask Claude why the postgres container keeps restarting, you want this one; if you want a single secure endpoint in front of twenty catalog servers, you want the gateway. The tool surface is explicit and small enough to reason about: list_containers, create_container, run_container, recreate_container, start_container, fetch_container_logs, stop_container and remove_container for containers; list_images, pull_image, push_image, build_image and remove_image for images; list_networks / create_network / remove_network and list_volumes / create_volume / remove_volume for the rest. Two resource templates, docker://containers/{id}/logs and docker://containers/{id}/stats, let a client read logs and live stats by container ID or name without a tool call. It also ships a docker_compose prompt that puts the model into a plan-then-apply loop — you describe the containers you want under a project name, the model proposes a concise plan, and nothing runs until you approve it; reopening the prompt with the same project name re-reads the state of everything created under it, which is how you clean up after a lost chat. It runs on the Python Docker SDK’s from_env, so DOCKER_HOST applies: set ssh://user@host and the same server administers a remote engine. Two limits are deliberate and stated by the project — privileged options like --privileged and --cap-add/--cap-drop are not supported, and container configuration passes through the model, so no secrets belong in it.

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.

LiteLLM is not a single MCP server so much as an MCP Gateway: the MCP layer inside the LiteLLM AI Gateway (proxy), which puts one fixed `/mcp` endpoint in front of every MCP server your organisation uses and controls access to them by key, team and organisation. Start with the install trap, because it is the reason most people land here. There is no separate `litellm-mcp-server` package — that name is not published on PyPI, so any guide telling you to `pip install litellm-mcp-server` is wrong and the command will fail. The gateway ships inside LiteLLM itself, so the correct install is `pip install 'litellm[proxy]'` (litellm 1.95.0 on PyPI), from the BerriAI/litellm repository. Backing servers are registered either in `config.yaml` under `mcp_servers:` or from the LiteLLM UI under MCP Servers → Add New MCP Server; persisting them to the database needs `STORE_MODEL_IN_DB=True` (or `general_settings.store_model_in_db: true`, optionally narrowed with `supported_db_objects: ["mcp"]` so only MCP objects are stored). All three transports are supported for the servers behind it — streamable HTTP, SSE and stdio — so a stdio entry with `command`, `args` and `env` (say `npx -y @circleci/mcp-server-circleci`) sits behind the same gateway endpoint as a hosted URL. Auth per backing server is declarative: `auth_type` accepts `none`, `api_key` (sends `X-API-Key`), `bearer_token`, `basic`, `authorization` (verbatim, no prefix), `token` (GitHub style), `oauth2` — which must declare an `oauth2_flow` of `authorization_code` for interactive PKCE sign-in or `client_credentials` for machine-to-machine — `oauth2_token_exchange` for RFC 8693 on-behalf-of, and `aws_sigv4` for MCP servers hosted on Bedrock AgentCore. `static_headers` covers servers that just want fixed headers on every request, `extra_headers` names headers to forward from the client, and `${VAR_NAME}` server variables can be scoped Instance (shared) or Per-user. On the client side you connect to `http://<your-proxy>:4000/mcp/` with an `x-litellm-api-key` header, choose a server group with `x-mcp-servers`, and pass per-server credentials as `x-mcp-{server_alias}-{header_name}` — `x-mcp-github-authorization: Bearer gho_…` alongside `x-mcp-zapier-x-api-key: sk-…` — so a single connection carries different auth for each backing server instead of sharing one token across all of them. Tool names are namespaced by server, and `litellm_settings.mcp_aliases` maps a short alias onto a server name so tools read `github_create_issue` rather than `github_mcp_server_create_issue`. A direct REST path, `/mcp-rest/tools/list` and `/mcp-rest/tools/call`, lets you list and call tools with curl and no LLM in the loop. One version note: from LiteLLM v1.80.18 the gateway speaks MCP protocol 2025-11-25 and rejects new server names that do not comply with SEP-986; existing non-compliant names only warn for now.

Access and manage secrets stored in 1Password vaults. Retrieve credentials, SSH keys, API tokens, and secure notes directly in AI coding environments.

The Netlify MCP Server is Netlify's official Model Context Protocol integration (netlify/netlify-mcp), acting as a bridge between AI coding agents and the Netlify API/CLI so they can create, build, deploy, and manage Netlify projects using natural-language prompts instead of manual dashboard clicks or hand-written API calls. Installed via `npx -y @netlify/mcp` (requires Node.js 22+, and the Netlify CLI installed globally for the best experience), it connects to Windsurf, Cursor, Claude Desktop/Code, VS Code Copilot, Cline, Warp, LM Studio, and any other MCP-compatible client, with one-click install links published for several of them. Core capabilities include creating and managing sites, triggering and monitoring deploys, modifying access controls and team permissions, installing or uninstalling Netlify extensions, fetching user/team/site metadata, and creating or updating environment variables and secrets. Authentication runs through the Netlify CLI's existing login session, so agents inherit whatever account/team access the developer already has rather than requiring a separately scoped token. Typical use: ask Claude to "deploy the current branch as a preview and give me the URL" or "add a STRIPE_SECRET_KEY environment variable to the production site" and the agent executes the equivalent Netlify CLI/API calls directly, which is useful for developers who want deploy and config management folded into an AI pair-programming workflow instead of context-switching to the Netlify dashboard.

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.

The Datadog MCP Server is Datadog's official, vendor-hosted Model Context Protocol endpoint — not a package. Each Datadog site has its own URL of the form https://mcp.<your-site>/api/unstable/mcp-server/mcp (US1: mcp.datadoghq.com, EU1: mcp.datadoghq.eu), and OAuth 2.0 is the recommended way in; a Personal or Service Access Token as an Authorization bearer header is the documented fallback for CI, with DD_API_KEY plus DD_APPLICATION_KEY headers as a third option. Datadog ships first-party client integrations rather than expecting hand-written config: a Claude Code plugin (/plugin install datadog@claude-plugins-official, then /ddsetup and /ddtoolsets), a Claude connector from the Connectors Directory, plugins for Cursor, VS Code/Copilot, JetBrains and OpenCode, and a ChatGPT app in Preview for US1. Tools are grouped into toolsets selected with a ?toolsets= query parameter, and only `core` — logs, metrics, traces, dashboards, monitors, incidents, hosts, services, events, notebooks — loads by default; two dozen more cover alerting, DBM, DDSQL, RUM, profiling, security, Kubernetes, error tracking, feature flags, cost management and data observability, with apm, cases, code-exec and remote-actions in Preview and excluded from toolsets=all. Access requires the mcp_read or mcp_write role permission in addition to the normal resource permission, which is why a working connection can still return no data. Limits at time of writing are 50 requests per 10 seconds of tool-call burst and 50,000 tool calls per month, and the server is not GovCloud compatible.

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. Authentication is a Grafana service account token (Editor role, or granular RBAC scopes) passed as GRAFANA_SERVICE_ACCOUNT_TOKEN alongside GRAFANA_URL, and every tool category can be individually disabled to control context-window usage. On install, the recommended route is uvx: `uvx mcp-grafana` pulls the PyPI package mcp-grafana, which is published by Grafana Labs from this same repository — so despite the server being written in Go, the copy-paste command most Claude Desktop and Cursor configs use is a Python-tooling one, not a binary download. The alternatives are `go install github.com/grafana/mcp-grafana/cmd/mcp-grafana@latest` for a real binary, or the grafana/mcp-grafana container — `-t stdio` for local clients, or the default HTTP mode on :8000 (add `-t streamable-http`) with MCP_GRAFANA_SERVER_TOKEN set to authenticate callers when you expose it.

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

CircleCI's official MCP server exists to close one specific loop: a build fails, and the person who has to fix it is already in an editor with an AI assistant open, not in the CircleCI web UI reading logs. get_build_failure_logs pulls the actual failure output for a branch or pipeline into the conversation, which is enough for an assistant to propose a patch against the real error rather than a guessed one. get_latest_pipeline_status answers whether the branch is currently green, and get_job_test_results returns test metadata so a model can distinguish a genuine regression from an environment problem. Beyond triage, the server covers the workflows around a build. find_flaky_tests analyses execution history to name the tests that pass and fail without a code change — the single most valuable tool here, because flakiness is exactly the kind of pattern that is obvious across hundreds of runs and invisible in any one of them. find_underused_resource_classes reports jobs provisioned larger than their actual compute use, which is a direct cost lever on a CI bill, and download_usage_api_data pulls raw Usage API data for the same analysis. config_helper validates a .circleci/config.yml and explains what is wrong with it, so an assistant can iterate on config without pushing commits to find out. Control tools cover run_pipeline, rerun_workflow (from the start or just from the failed job), run_rollback_pipeline, list_artifacts, list_followed_projects and list_component_versions. Installation is npx -y @circleci/mcp-server-circleci@latest with CIRCLECI_TOKEN in the environment, and there is an official Docker image (circleci/mcp-server-circleci) plus a self-managed remote-server mode documented for teams that would rather run one shared instance than a process per developer. CIRCLECI_BASE_URL is optional and only needed by on-prem customers. Note that rerun_workflow, run_pipeline and run_rollback_pipeline are write operations against real infrastructure — a rollback pipeline in particular ships to production — so a token scoped to the projects you want an agent touching is worth setting up before you connect it.

Exposing Buildkite data (pipelines, builds, jobs, tests) to AI tooling.

MCP support for Jenkins delivered as a Jenkins plugin rather than a standalone server — you install it from the update centre (plugin id mcp-server, currently 0.188, requires Jenkins 2.533 or newer) and the controller itself starts answering MCP over HTTP with no further configuration. Three transports are exposed and all are on by default: Streamable HTTP at <jenkins-url>/mcp-server/mcp (recommended), SSE at /mcp-server/sse with /mcp-server/message, and a session-free /mcp-server/stateless endpoint for clients that make independent one-shot requests. Authentication reuses Jenkins credentials: generate an API token under your user Security page and pass username:token as HTTP Basic auth. The default tool set is genuinely operational rather than read-only — getJob, getJobs, triggerBuild and getQueueItem for job management; getBuild, updateBuild, getBuildLog, searchBuildLog, rebuildBuild, getReplayScripts, replayBuild and getTestResults for builds; getJobScm, getBuildScm, getBuildChangeSets and findJobsWithScmUrl for SCM; whoAmI and getStatus for instance health. getBuildLog is the one worth reading about before you wire this into an agent: it paginates with a cursor tied to a specific (job, buildNumber), supports end-relative reads with negative skip/limit, and reads a non-blocking snapshot so it returns promptly against a build that is still running. Two deployment gotchas the README calls out: Jenkins runs Winstone with a 30-second httpKeepAliveTimeout that races the plugin's 30-second MCP keep-alive, so start Jenkins with --httpKeepAliveTimeout=600000, and behind Nginx you need proxy_buffering off with 600s read/send timeouts on the /mcp-server/ paths. Origin header validation is off by default so agents that omit the header still work; enable it with the requireOriginMatch system property. The plugin is extensible — implement McpServerExtension and annotate methods with @Tool to add your own, or set override = true to replace a built-in.

live Terraform Registry data — provider schemas, module inputs and outputs, policy libraries — plus full HCP Terraform and Terraform Enterprise workspace management, so an AI assistant writes HCL against the real resource arguments instead of inventing attribute names from memory. HashiCorp distributes it as a Go binary and a Docker image, not as an npm package: `@hashicorp/terraform-mcp-server` returns 404 on the npm registry, so npx configurations copied from older write-ups cannot work. The supported install is the hashicorp/terraform-mcp-server image on Docker Hub (v1.1.0, released 2026-07-14), run with `docker run -i --rm hashicorp/terraform-mcp-server:1.1.0`, or the release binary invoked as `terraform-mcp-server stdio`. Both transports are supported: stdio for local clients, and streamable-http via `terraform-mcp-server streamable-http --transport-port 8080 --mcp-endpoint /mcp` for shared deployments. Registry lookups need no credentials at all — only the HCP Terraform and Terraform Enterprise tools do, via TFE_TOKEN plus TFE_ADDRESS (which must include the protocol, e.g. https://app.terraform.io, and in streamable-http mode can only be set as an environment variable, never supplied by a client header). Two flags matter before you expose it to a team: ENABLE_TF_OPERATIONS is false by default and gates the tools that mutate infrastructure, and the HTTP server defaults to strict CORS with 10:20 global and 5:10 per-session rate limits, an MCP_ORGANIZATION_ALLOWLIST for restricting which HCP organisations can connect, and required MCP_TLS_CERT_FILE / MCP_TLS_KEY_FILE for any non-localhost bind. Server instructions live in cmd/terraform-mcp-server/instructions.md and are meant to be replaced with your own conventions if the default answers do not match how your organisation writes Terraform.

Google Cloud's official MCP server enables AI agents (like Claude Desktop, Cursor, Gemini CLI, and Windsurf) to securely interact with GCP services and deploy applications directly to Cloud Run. It exposes essential deployment and observability tools: `deploy-file-contents` (deploys files directly), `list-services`, `get-service`, and `get-service-log`. When running locally, it additionally provides `deploy-local-folder`, `list-projects`, and `create-project` (which creates a new GCP project and attaches it to the first available billing account). The server supports natural language prompts like 'deploy' and 'logs' for faster workflows. It respects standard Google Cloud SDK authentication (`gcloud auth login`) and can be configured via environment variables like `GOOGLE_CLOUD_PROJECT`, `GOOGLE_CLOUD_REGION`, and `DEFAULT_SERVICE_NAME`. It also includes an anti-DNS-rebinding security feature (`ENABLE_HOST_VALIDATION`).

The Heroku MCP Server is the official Model Context Protocol implementation from Heroku, giving Claude, Cursor, Zed, Windsurf, Cline, and VS Code direct LLM-driven control over Heroku Platform resources without leaving the chat. Application-management tools cover list_apps/get_app_info/create_app/rename_app/transfer_app plus deploy_to_heroku (deploys straight from an app.json manifest, including team and private-space targets) and deploy_one_off_dyno for running sandboxed one-off scripts or tests. Process tools (ps_list/ps_scale/ps_restart) handle dyno scaling and restarts, while add-on tools list, inspect, and provision add-ons per app. A dedicated Postgres toolset — pg_psql, pg_info, pg_ps, pg_locks, pg_outliers, pg_credentials, pg_kill, pg_maintenance, pg_backups, pg_upgrade — lets the model run SQL directly against Heroku Postgres and diagnose slow queries or blocking locks. Pipeline tools (pipelines_create/promote/list/info) and team/space tools (list_teams, list_private_spaces) round out CI/CD and org-management coverage, alongside maintenance-mode toggles and app log retrieval. The recommended install is `heroku mcp:start` via the Heroku CLI (v10.8.1+), which reuses your existing CLI login so no HEROKU_API_KEY needs to be set; an `npx -y @heroku/mcp-server` path is available for clients that need a directly configured API-key auth flow instead. The project is explicitly labeled early-development by Heroku, so tool coverage is still evolving.

n8n-MCP gives an AI assistant deep knowledge of n8n rather than a remote control for it: 2,412 nodes (829 core plus 1,583 community, 1,340 of them verified) with 99% property coverage and 66.5% operation coverage, 86% documentation coverage, a library of 2,352 workflow templates, and validators that check a node config or a whole workflow before anything is deployed. Seven documentation tools always load — search_templates, get_template, search_nodes, get_node, validate_node, validate_workflow and tools_documentation — and get_node is deliberately tiered because full node detail costs 3,000-8,000 tokens. Supplying N8N_API_URL and N8N_API_KEY unlocks a further sixteen management tools that create, partially update, validate, autofix, deploy and inspect workflows on your own instance, plus executions, credentials, folders, data tables and health checks; without credentials the server cannot execute anything at all. MCP_MODE=stdio is required for stdio clients, or log output corrupts the JSON-RPC stream; WEBHOOK_SECURITY_MODE=moderate is required when N8N_API_URL points at localhost or host.docker.internal, because the default SSRF gate rejects loopback. Install with npx n8n-mcp, the ghcr.io/czlonkowski/n8n-mcp Docker image, or the maintainer's hosted instance at dashboard.n8n-mcp.com (100 tool calls/day free). This is a community project by Romuald Czlonkowski under MIT, not published by n8n, and it is distinct from n8n's own MCP Server Trigger node, which does the reverse — exposing an n8n workflow as an MCP server over SSE or Streamable HTTP. The project's own headline warning is never to let an AI edit production workflows directly.

PagerDuty MCP Server is PagerDuty's official, actively maintained local MCP server (github.com/PagerDuty/pagerduty-mcp-server) for managing incident response directly from an MCP-enabled client like Claude, Cursor, or VS Code. Beyond the standard tool surface for incidents, services, on-call schedules, and event orchestrations, it ships embedded React 'MCP Apps' that render interactive UIs inside supporting IDEs: an Incident Command Center with a real-time incident feed, timeline/notes/alert inspection, one-click acknowledge/escalate/resolve, and AI-powered similar-incident detection; an On-Call Manager for schedule overrides and escalation-policy edits; an On-Call Compensation Report tracking hours worked, interruption rates, and EU Working Time Directive compliance with CSV export; a Service Dependency Graph visualizing upstream/downstream impact; and an Onboarding Wizard for first-time account setup. The server runs as a single Python process via `uv run pagerduty-mcp`, avoiding a separate HTTP server to manage. Authentication uses a PagerDuty User API Token generated from My Profile → User Settings → API Access (Freemium accounts have role-based limits on who can generate one), used subject to PagerDuty's Developer Agreement. This combination of deep incident-lifecycle tooling and embedded operational dashboards makes it one of the more feature-complete official vendor MCP servers for on-call/DevOps teams.

The OpsGenie MCP Server bridges MCP-capable clients like Claude Desktop and Cursor to OpsGenie's alerting and on-call platform, so an on-call engineer can triage incidents from an AI assistant instead of switching to the OpsGenie web console. Alert tools cover list_alerts (with OpsGenie's powerful filter-query syntax for scoping by status, priority, tag, or team), get_alert for full detail, and acknowledge_alert/unacknowledge_alert for actually working an incident from chat. Team tools (list_teams, get_team) let an agent resolve who owns a given alert, and heartbeat tools (list_heartbeats, get_heartbeat) expose the health of OpsGenie's dead-man's-switch monitors — useful for an agent answering "is our nightly batch heartbeat still healthy?" without a dashboard. The server is written in Go, ships as a single binary installable via `go install`, and supports stdio, SSE, and streamable-HTTP transports plus a built-in self-update command. Authentication uses an OpsGenie API token set via the OPSGENIE_TOKEN environment variable (or a custom var name via --token-env-var). Important context: this is a community project, not an Atlassian first-party release — no official Atlassian OpsGenie MCP server exists, and Atlassian has been folding OpsGenie's alerting/on-call features into Jira Service Management's roadmap, so teams already on JSM should also check the Jira MCP Server entry on this site. The repo itself is now archived (last updated 2026-05) but the built binary remains functional for existing OpsGenie accounts.

Observability and monitoring with New Relic.

Dynatrace MCP Server connects AI assistants to the Dynatrace observability platform so an agent can pull live problems, Davis AI root-cause findings, logs, metrics, traces, entity relationships and security findings into a coding session instead of making you leave the editor for the Dynatrace UI. Read the deprecation notice before you install: dynatrace-oss/dynatrace-mcp is now deprecated and 2.1.2 was its final release, with no further updates planned. Dynatrace splits the replacement in two. For local development in VS Code, IntelliJ, Claude Code or Cursor, the maintained path is the Dynatrace-for-AI toolkit together with the dtctl CLI. For agent-to-agent and remote use — Atlassian Rovo, the GitHub Coding Agent, and other hosted clients — Dynatrace now runs a Remote MCP Server listed on the Dynatrace Hub that needs no local setup at all. The deprecated local server still runs if you need it: Node.js 24 or newer, `npx -y @dynatrace-oss/dynatrace-mcp-server` over stdio, and a DT_ENVIRONMENT pointing at a Dynatrace Platform URL such as https://abc12345.apps.dynatrace.com (classic abc12345.live.dynatrace.com URLs are not accepted). Authentication runs an Authorization Code Flow in the browser on first start rather than requiring a Platform Token or OAuth client up front, and the resulting token is stored in the OS keychain — macOS Keychain, Windows Credential Manager or Linux Secret Service — and reused, so the browser opens once per token lifetime. In headless or container environments where no keychain is available, set DT_MCP_TOKEN_STORAGE=file to persist tokens under ~/.config/dynatrace-mcp/ instead. One correction worth making explicitly: although the repository lives under the dynatrace-oss organisation, its README states the project is not officially supported by Dynatrace, so it is listed here as community rather than official.

Query and analyze data, alerts, dashboards, and cross-reference production behavior with codebase.

Lightstep was a distributed-tracing and observability platform built on OpenTelemetry, acquired by ServiceNow in 2021 and folded into the ServiceNow Cloud Observability product line; its GitHub org still hosts the legacy OpenTelemetry Launcher and tracer SDKs for Go, Java, Python, Node.js, and C++, but none of those repos are MCP servers. Neither ServiceNow nor the community has shipped an MCP server exposing Lightstep/Cloud Observability trace and metric data to AI assistants — repeated GitHub and web searches across review cycles turn up zero results for "lightstep mcp" or "servicenow observability mcp" with any real implementation. If you need AI-agent access to distributed tracing data today, check this directory's Honeycomb or Grafana entries, which do have real, actively maintained MCP servers covering similar observability workflows. This entry is kept as a placeholder so the "lightstep mcp" search term stays discoverable and will be updated the moment ServiceNow or a community project ships a real server.

Feature flags as a service for continuous delivery.

Split.io was acquired by Harness and rebranded to Harness FME (Feature Management & Experimentation) — a `splitio/mcp-server` repo does not exist, and Harness has not published a first-party MCP server for it. The best available option is kud/mcp-harness-fme, a community-built, MIT-licensed TypeScript server exposing 30 tools across workspaces, environments, feature flags, flag definitions, segments, rule-based segments, and change requests. It supports a zero-config startup that reads the `MCP_HARNESS_FME_API_KEY` environment variable and exits immediately if it is missing, plus a "kill & restore" flow that instantly forces all traffic to a flag's default treatment (or restores it) with a single tool call. Every destructive operation — delete, kill, archive, disable — requires an explicit `confirm: true` argument, preventing accidental changes from an agent acting on ambiguous instructions. It also supports the full change-request flow for rule-based segments, letting teams submit segment-definition changes with optional approvers for orgs that require approval gates. Install with `npx --yes @kud/mcp-harness-fme@latest`, or add it directly via `claude mcp add --transport stdio --scope user harness-fme --env MCP_HARNESS_FME_API_KEY=your_api_key -- npx --yes @kud/mcp-harness-fme@latest` in Claude Code. An optional `get_flag_url` deep-link tool activates when `MCP_HARNESS_FME_ACCOUNT_ID` and `MCP_HARNESS_FME_ORG_GUID` are also set. Works with any stdio MCP client — Claude Desktop, Claude Code, Cursor, Windsurf, Cline, Zed.

The Flagsmith MCP Server is Flagsmith's official, Speakeasy-generated Model Context Protocol server for its Core and SDK APIs, letting AI assistants read and manage feature flags, remote config values, and environment/identity segmentation directly from a conversation. It ships as an installable Desktop Extension (`mcp-server.mcpb`) for Claude Desktop — drag-and-drop install with no additional setup — and as an npm package (`flagsmith`) for CLI-based clients, started with `npx flagsmith start --token-auth <your-api-token>` and wired into Claude Code, Cursor, Gemini, and Windsurf via each client's standard MCP config or one-line `mcp add` command. Progressive discovery keeps the tool surface manageable across the full Flagsmith API rather than dumping every endpoint into context at once. Typical use: ask Claude to "list all feature flags enabled for the beta segment in production" or "toggle the new-checkout-flow flag off for the EU environment," with the assistant calling the live Flagsmith API instead of requiring a dashboard visit. NOTE: as of this writing the repo carries an explicit "not yet ready for production use" notice from its Speakeasy-generated setup flow — expect rough edges and check the repo before depending on it for anything mission-critical.

Provides access to OpenTelemetry traces and metrics through Logfire.

Deploy your project to the cloud seamlessly with the Defang platform.

Official Gremlin MCP server for chaos engineering and reliability management, exposing Gremlin's Reliability Management (RM) APIs as agent-callable tools. On the service side, `list_services` enumerates every RM service with its reliability score and targeting info, while `get_service_dependencies`, `get_service_status_checks`, and `list_service_risks` drill into a single service to show what it depends on, how it is monitored, and which risks Gremlin has flagged. Reporting tools cover `get_reliability_report` (per-service report for a given date) and `get_reliability_experiments`, which returns recent chaos experiments filtered by dependency or test. Test-suite visibility comes from `get_recent_reliability_tests` and `get_current_test_suite`, so an agent can answer questions like whether a weekly test schedule is actually firing across a six-week policy-expiry window. There is also a billing and fleet-health tier — `get_pricing_report` breaks usage down by tracking period (Daily/Weekly/Monthly) with active agents and unique targets by type, and `get_client_summary` and `get_attack_summary` report agent activity and attack outcomes per team over a date range. Requires Node 18 or higher and a `GREMLIN_API_KEY` from your Gremlin account settings; `GREMLIN_SERVICE_URL` optionally repoints the server at a staging or self-hosted API. Install with `npx -y @gremlin/mcp-server`, with documented setup for Claude Desktop, Cursor, and VS Code 1.99+.

Chat with your builds, CI, and more.

Enable AI access to your CloudBees CI cluster, the Enterprise-grade Jenkins-based solution.

MCP server for DeployHQ API integration, enabling AI to manage deployments.

MCP Server for the JFrog Platform API, enabling repository management and build tracking.

Discovery, exploration, reporting and root cause analysis using all observability data.

Bring real-time production context—logs, metrics, and traces—into your local environment.

Query and interact with kubernetes environments monitored by Metoro.

Access network of thousands of probes to run ping, traceroute, mtr, http and DNS resolve.

Allows Homebrew users to run Homebrew commands locally.

CLI for interacting with GitKraken APIs, includes MCP server for Jira, GitHub, GitLab.

Official MCP server for Cortex.

Experimental MCP server for real-time compliance intelligence into your AI workflows.

Access Datadog metrics, logs, and traces from AI tools. Query infrastructure data, investigate incidents, and analyze performance using natural language.

Manage PagerDuty incidents, on-call schedules, and escalation policies from AI tools. Acknowledge, resolve, and query incidents through natural language.

Time-series database MCP for InfluxDB. Write and query metrics using Flux or InfluxQL. Ideal for monitoring, IoT, and observability data.

High-performance build system for JavaScript monorepos. Query task graphs, run builds, manage caching, and optimize pipelines with AI.

Smart build system for monorepos. Run tasks, understand project graph, generate code, and optimize CI pipelines across frameworks with AI assistance.

Build automation MCP for Java/Kotlin/Android projects. Run tasks, manage dependencies, analyze build scripts, and inspect Gradle project structure.

Java build and dependency management MCP server. Manage POM files, run lifecycle phases, resolve dependencies, and analyze Maven project structure.

Google's build system MCP server. Navigate Bazel build graphs, run targets, manage deps, and analyze large monorepo builds across languages.

FlyMCP is an official Model Context Protocol server developed by Fly.io that wraps the `flyctl` CLI, giving AI assistants like Claude Desktop, Cursor, and Windsurf direct control over your global Fly.io deployments. By bridging agents to the Fly.io environment, it enables LLMs to perform platform capabilities directly from your chat—managing applications, scaling machines, inspecting logs, and orchestrating deployments without requiring developers to manually run terminal commands. Written in Go, it requires Go 1.21+ and a locally installed `flyctl` CLI authenticated via `flyctl auth login`. Because it acts as a wrapper over the CLI, it inherits your existing authentication state and permissions seamlessly. Currently, it is distributed as a source repository rather than a precompiled binary, requiring a quick `go build -o flymcp` setup before configuring your MCP client to point at the generated executable.

Railway's official MCP server puts your Railway projects — services, databases, environment variables, deployments, networking, volumes, and templates — inside natural-language reach of Claude Code, Cursor, GitHub Copilot, OpenAI Codex, Factory Droid, and OpenCode. As of the current release, the standalone `@railway/mcp-server` npm package is deprecated in favor of shipping MCP support directly inside the Railway CLI: running `railway mcp` starts a local stdio server, while `railway mcp install` auto-detects installed AI tools and writes the correct client config for you (add `--agent <tool>` to target one of claude-code, cursor, factory-droid, copilot, codex or opencode; add `--remote` to route through `railway mcp proxy` to Railway's hosted server at mcp.railway.com using your CLI login, or `--remote --oauth` to write the HTTPS endpoint directly and let the client run OAuth). `railway setup agent` does the same thing and also installs Railway's `use-railway` agent skill. The installer merges Railway's entry into existing MCP configs without clobbering other servers you've already set up. Local and Remote are not the same tool set: Local exposes roughly fifty tools including domains, volumes, TCP proxies, buckets, logs and metrics, while Remote exposes eleven — and only Remote has `railway-agent`, which hands multi-step debugging to Railway's own agent. Remote also refuses project tokens; it requires a user identity for billing and audit. Once connected, you can ask your AI agent to spin up a new environment from a GitHub repo, roll environment variables across services, inspect deploy logs when a build fails, provision a Postgres or Redis instance, or manage networking and volume mounts — all without leaving your editor or touching the Railway dashboard. Because the CLI is the source of truth, keeping `railway` up to date is enough to pick up new MCP tools; there's no separate npm package to track anymore. The legacy `@railway/mcp-server` package is a deprecated compatibility shim, last published as 0.1.12 on 2026-05-23, and the repository it came from (railwayapp/railway-mcp-server, 192★) was archived the same day — both still install cleanly, which is why people are still running the old path.

Render's official MCP server connects AI coding tools directly to your Render cloud infrastructure — create and manage web services, static sites, background workers, cron jobs, and PostgreSQL/Redis databases without leaving your editor. The primary integration path is Render's hosted server at mcp.render.com/mcp, authenticated with a scoped Render API key generated from your Account Settings page; configure it in Cursor, Codex, Claude Code (via `claude mcp add --transport http`), Claude Desktop (via the `mcp-remote` bridge), or Jules with a few lines of JSON. Render also publishes the underlying implementation as an open-source Go project (render-oss/render-mcp-server) for teams that want to inspect or self-host the tool-calling logic. Core tools span workspace selection (list_workspaces, select_workspace), service management (list_services, get_service, create_web_service, create_static_site, create_cron_job with full runtime/plan/region options), deploy triggers, log and metrics inspection for debugging failed builds, and direct Postgres database queries from inside the LLM. Render explicitly flags that the server currently supports one potentially destructive action — modifying an existing service's environment variables — so it scopes API keys broadly but keeps write operations narrow. Typical prompts include "deploy this repo as a new Node web service in Oregon" or "show me the last 100 log lines for my API service and tell me why it's crashing." Because it's a hosted remote server, there's no local runtime to keep updated, and Render ships new tools directly through mcp.render.com without requiring a client-side package upgrade.

Invoke and manage AWS Lambda functions. Test functions locally, deploy code, view execution logs, and manage layers and event source mappings.

Manage EC2 instances, security groups, AMIs, and VPCs. Start/stop instances, query metadata, analyze costs, and automate infrastructure tasks.

Manage Linode/Akamai Cloud instances, object storage, and Kubernetes clusters. Deploy, resize, and monitor cloud resources via natural language.

Manage Hetzner Cloud servers, load balancers, and volumes. Deploy European cloud infrastructure, manage firewalls, and monitor resource usage via AI.

Manage Fastly CDN services, VCL configurations, and edge logic. Purge cache, deploy edge functions, and monitor real-time performance metrics.

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

the Argo CD MCP server, an Argo Project Labs implementation (argoproj-labs/mcp-for-argocd) that lets an assistant drive a live Argo CD instance in natural language over stdio or HTTP stream transport. Install it with npx argocd-mcp@latest stdio on Node 18+ and give it two things: ARGOCD_BASE_URL and ARGOCD_API_TOKEN. The tool surface is genuinely operational rather than read-only — list_applications, get_application, create_application, update_application, delete_application and sync_application for the application lifecycle; get_application_resource_tree, get_application_managed_resources, get_application_workload_logs, get_resource_events, get_resource_actions and run_resource_action for the Kubernetes objects underneath; plus list_clusters and get_appproject. get_application_workload_logs is the one that changes day-to-day work: it pulls Pod and Deployment logs for a failing app without a kubectl context, so an agent can go from 'this app is degraded' to the actual stack trace in one hop. Two configuration details cause most first-run failures. Self-signed or private-CA certificates on the Argo CD endpoint need NODE_TLS_REJECT_UNAUTHORIZED=0 in the client config, which is a development-only workaround. And the API token is deliberately never accepted as a tool-call argument — it is read only from the x-argocd-api-token header or the ARGOCD_API_TOKEN environment variable, so it never enters a prompt, model context, or tool-call log. For fleets, ARGOCD_TOKEN_REGISTRY_PATH points at a JSON file mapping each base URL to its own token; a call then targets an instance with the non-secret argocdBaseUrl argument and the server pairs it with the registered credential. The default token is bound to the default base URL and is never sent to another host, which is what stops a prompt-injected argocdBaseUrl from exfiltrating it. If the registry file is set but missing or malformed the server fails closed at startup rather than falling back. One more thing worth knowing before you expose it: the http and sse transports open a listener that reaches delete_application and run_resource_action, and ARGOCD_API_TOKEN does not protect it — that token authenticates the server to Argo CD, not the caller to the server. It binds 127.0.0.1 by default; set MCP_AUTH_TOKEN to require Authorization: Bearer on every inbound request before changing MCP_BIND_ADDRESS.

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

The Prometheus MCP Server lets an AI assistant drive a live Prometheus instance through the HTTP API instead of you hand-writing PromQL in the expression browser — ask it why queries got slow, what is currently firing, or which recording rules would make an SLO cheap to evaluate, and it composes and runs the queries itself. One point of provenance worth knowing before you install: this began life as tjhop/prometheus-mcp-server and was adopted into the Prometheus organisation, so that path now 301-redirects to prometheus/prometheus-mcp, while release binaries and container images are still published under the tjhop namespace. The tool surface goes far past a single query endpoint. Instant and range queries (query, range_query, exemplar_query) sit alongside discovery tools — label_names, label_values, metric_metadata, list_targets, alertmanagers — and operational ones: list_alerts, list_rules, config, flags, build_info, healthy, ready, plus TSDB admin endpoints such as clean_tombstones, delete_series, snapshot, reload, wal_replay_status and quit. It also embeds the official prometheus/docs corpus as both tools (docs_list, docs_read, docs_search) and MCP resources under prometheus://docs, so the model can cite metric-naming best practice rather than invent it. Two features exist specifically to keep long investigations inside a context window: optional TOON (Token-Oriented Object Notation) encoding of API responses in place of JSON, and a configurable response-truncation limit that capable models can override per tool call. Prometheus-compatible backends are handled explicitly rather than assumed — a --prometheus.backend flag selects an implementation, and the Thanos profile removes the tools Thanos returns 404 for (config, alertmanagers, quit, reload, the TSDB admin set) while adding list_stores. Install as a Go binary from the releases page, as a Debian/RPM system package with a bundled systemd unit, via the OCI Helm chart at oci://ghcr.io/tjhop/charts/prometheus-mcp-server, or as a container: `docker run --rm -i ghcr.io/tjhop/prometheus-mcp-server:latest --prometheus.url "https://your-prometheus:9090"` for stdio, or add `--mcp.transport http --web.listen-address ":8080"` for streamable HTTP. Every flag has a PROMETHEUS_MCP_SERVER_* environment-variable equivalent. Secured Prometheus instances are reached with a standard Prometheus http_config file via --http.config, and the MCP endpoint itself can be put behind TLS and basic auth with a Prometheus web-configuration file via --web.config.file. Read the credential-forwarding note before exposing it: over HTTP transport the server forwards each request's Authorization header to Prometheus verbatim without validating it, requests without one fall back to the default client's credentials, and basic_auth_users in the web config conflicts with that forwarding — so anyone who can reach the endpoint can query Prometheus as at least the default client.

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

Service mesh and configuration management MCP. Query service discovery, manage KV store, inspect health checks, and configure intentions.

IT automation MCP server for Ansible. Run playbooks, manage inventories, inspect task results, and troubleshoot automation failures via AI.

Kubernetes-native CI/CD pipeline MCP. Manage Tekton tasks, pipelines, and runs. Inspect logs, trigger pipelines, and debug task failures with AI.

Comprehensive vulnerability scanner MCP. Scan container images, filesystems, and git repos for CVEs, misconfigurations, and secrets with Aqua's Trivy.

Runtime security detection MCP for Falco. Monitor container and host activity, detect anomalous behavior, query security events, and investigate incidents.

The dbt MCP Server is dbt Labs’ own first-party server, and it is unusually large: 61 tools across nine toolsets, covering dbt Core, dbt Fusion and the dbt platform from one process. The Discovery toolset reads your project’s metadata graph — get_all_models, get_lineage, get_node_details, get_model_health and get_model_performance answer “what does this model depend on and did it pass last night” without opening the warehouse. The Semantic Layer toolset (list_metrics, query_metrics, get_dimensions, get_metrics_compiled_sql) is the one that makes governed numbers possible: the agent queries your defined metrics rather than inventing SQL against raw tables. The dbt CLI toolset runs build, run, test, compile, parse, show and list against a local project, and the Admin API toolset triggers, retries, cancels and inspects platform job runs. Codegen (generate_source, generate_staging_model, generate_model_yaml), Fusion column-level lineage, and product-docs search round it out. It ships in two flavours. Self-hosted runs beside your client via `uvx dbt-mcp` and is the only flavour that can execute dbt CLI commands or Codegen; the remote server at /api/ai/v1/mcp/ on your dbt platform host needs no install but is consumption-only. Auth is either DBT_TOKEN or an interactive OAuth login that caches its context in ~/.dbt/mcp.yml — and the fallback between them is silent, which is the single most common way a first run appears to hang. Python 3.12 or 3.13 only; 3.14 is blocked on pyarrow wheels.

Collect and query distributed traces, metrics, and logs using OpenTelemetry standards. Analyze application performance and correlate signals across services.

Open-source distributed tracing MCP for Jaeger. Query traces, inspect service dependencies, analyze latency distributions, and investigate production incidents.

High-performance time-series database MCP for VictoriaMetrics. Query metrics with MetricsQL, manage clusters, and analyze long-term storage efficiently.

Application performance monitoring MCP for Elastic APM. Query transaction traces, error rates, and service maps. Integrate with Kibana dashboards.

Load testing and performance engineering MCP for k6. Run performance tests, analyze results, configure VUs and scenarios, and integrate with Grafana Cloud.

Log aggregation MCP for Grafana Loki. Query log streams with LogQL, inspect labels, analyze error patterns, and correlate logs with metrics and traces.

Durable execution platform MCP for Temporal. Start and query workflows, signal and cancel executions, inspect workflow history, and manage worker processes.

Distributed task queue MCP for Celery. Monitor task execution, inspect queues, revoke and retry tasks, and analyze worker performance and failure patterns.

Modern workflow orchestration MCP for Prefect. Trigger and monitor flows, manage deployments, inspect run logs, and orchestrate data pipelines at scale.

Network discovery and security scanning MCP using Nmap. Scan ports, detect services, identify OS fingerprints, and analyze network topology for security research.

Parse, validate, and generate cron expressions via MCP. Get human-readable descriptions, next execution times, and validate scheduling syntax.

Execute commands on remote servers via SSH through MCP. Run shell commands, transfer files with SCP, manage SSH keys, and automate remote operations.

Manage multi-container Docker applications with Compose MCP. Start, stop, and scale services, inspect container logs, and manage service dependencies.

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

Execute AWS CLI commands via MCP. Query any AWS service, manage resources across regions, configure profiles, and automate complex multi-service workflows.

Execute gcloud commands via MCP. Manage GCP resources across all services, configure projects and IAM, and automate Google Cloud workflows.

Execute az commands via MCP. Manage Azure resources, subscriptions, and services. Automate infrastructure deployments and resource group management.

Manage Proxmox Virtual Environment hypervisor via MCP. Create and control VMs and LXC containers, manage storage, configure networking, and monitor cluster nodes.

Manage your Tailscale mesh VPN network via MCP. List devices, manage ACLs, view network status, and control peer connections across your tailnet.

Deploy and manage Cloudflare Pages projects via MCP. Trigger deployments, manage environment variables, configure custom domains, and inspect build logs.

Control AVM FRITZ!Box routers from your AI assistant. Manage connected devices, WiFi settings, network configurations, parental controls, and schedule timed actions.

Manage Render deployments from your AI assistant. Trigger deploys, check service status, manage environment variables, inspect build and deploy logs, and configure scaling settings.

Self-hosted Heroku/Netlify alternative control via MCP. Manage applications, databases, and services on your own infrastructure. Deploy from Git, manage environment variables, and monitor logs.

Apache Kafka MCP server for streaming data integration. Produce and consume messages, manage topics, inspect consumer groups, and build event-driven AI workflows with Kafka as your data backbone.

RabbitMQ MCP server for message queue management. Publish messages, consume from queues, inspect bindings, and monitor queue health. Perfect for integrating AI reasoning into event-driven microservice architectures.

Gradle build system MCP server for JVM and Android projects. Run tasks, inspect dependencies, check build variants, manage Android SDK configurations, and debug build failures through your AI assistant.

Atlassian Statuspage API server for querying component status, incident history, and maintenance windows. Monitor service status pages and create incident updates programmatically.

Balena fleet management MCP server for Linux IoT devices. Deploy containerized applications, manage device fleets, monitor resource usage, update configurations, and access device logs via balenaCloud API.

HashiCorp Vault secrets management MCP server. Read and write dynamic secrets, manage policies and tokens, rotate database credentials, retrieve PKI certificates, and query audit logs via Vault HTTP API.

HashiCorp Nomad workload orchestrator MCP server. Deploy and manage containerized and non-containerized applications, inspect job allocations, scale task groups, query node health, and manage namespaces via Nomad API.

Website and API uptime monitoring via UptimeRobot. Check monitor statuses, query downtime history, create new monitors, manage maintenance windows, and receive alert contact configurations.

API and browser monitoring as code via Checkly. Run API checks and browser tests, inspect check results and error logs, manage alert channels, trigger manual check runs, and view SLA metrics.

Incident management and log aggregation via Better Stack. Query structured logs, manage on-call schedules, view incident timelines, check monitor uptime, and manage status page incidents in real time.

Full-stack observability via Coralogix. Search logs with DataPrime query language, create alerts, inspect traces, analyze metrics, and investigate incidents across distributed applications and infrastructure.

Log management and security analytics via Sumo Logic. Run log queries with Sumo Logic Query Language, view dashboards, manage scheduled searches, and detect anomalies across cloud-native infrastructure.

Enterprise integration and API management via MuleSoft Anypoint Platform. Query APIs, manage integration flows, monitor runtime performance, and trigger Mule application deployments via CloudHub.

Dell Boomi iPaaS integration via MCP. Execute integration processes, query audit logs, manage connection settings, monitor real-time process results, and inspect deployed components on Boomi AtomSphere.

Interact with n8n workflow automation. Execute workflows, create new automations, manage webhook triggers, and inspect execution logs — all through natural language.

Trigger and manage Pipedream event-driven workflows. Run serverless functions, inspect workflow logs, manage HTTP triggers, and connect 900+ APIs with AI assistance.

Manage Benthos (Redpanda Connect) stream processing pipelines. Create, modify, and monitor data pipelines that process, transform, and route messages between systems.

Manage Vector data pipelines for log and metrics processing. Configure sources, transforms, and sinks; monitor pipeline health; and route observability data at scale.

Configure and monitor Telegraf metrics agent. Manage input/output plugins, inspect collected metrics, and orchestrate data collection from servers, containers, and IoT devices.

Manage Logstash data ingestion pipelines. Configure input/filter/output stages, monitor pipeline health, inspect queued events, and troubleshoot log processing issues.

Manage Kestra data orchestration workflows. Trigger flows, monitor executions, manage namespaces, and inspect task outputs in this open-source workflow automation platform.

Integrate with Tenable's vulnerability management platform (Nessus, Tenable.io). Query scan results, asset vulnerabilities, risk scores, and remediation guidance across your infrastructure.

Manage Oracle Cloud Infrastructure (OCI) resources including compute instances, storage, networking, databases, and Kubernetes clusters via the OCI SDK.

Manage Vultr cloud infrastructure including compute instances, bare metal servers, Kubernetes, block storage, and managed databases via the Vultr API.

Automate infrastructure configuration and management via SaltStack (Salt). Execute remote commands, manage state files, orchestrate deployments, and query minion data.

Manage infrastructure as code with Puppet. Query node reports, apply manifests, inspect resource states, manage Hiera data, and orchestrate Puppet agent runs across your infrastructure.

Control Node-RED flow-based programming for IoT and automation. Create and deploy flows, trigger injections, read node outputs, manage credentials, and integrate with hundreds of Node-RED nodes via MCP.

Monitor website uptime with Freshping. Query check statuses, retrieve incident history, manage alert contacts, and get performance metrics across your monitored URLs and APIs.

Query Sematext Cloud for log management and infrastructure monitoring. Search log data, inspect metrics, manage alert rules, and correlate logs with APM traces across your monitored services.

Query Graylog log management and SIEM platform via MCP. Search log streams using GELF queries, fetch alert conditions, access dashboards, correlate security events, and investigate incidents across distributed infrastructure.

Integrate with Chef infrastructure automation via MCP. Query node inventories, cookbooks, recipes, roles, environments, and data bags. Trigger Chef runs, audit compliance with InSpec, and manage infrastructure as code across cloud and on-premises environments.

Connect to Pulumi infrastructure as code via MCP. Query stacks, resources, updates, and drift detection. Preview and deploy cloud infrastructure changes across AWS, Azure, GCP, and 100+ cloud providers using your preferred programming language through Pulumi AI.

Connect to Cisco AppDynamics application performance management platform via MCP. Query business transaction health dashboards, tier dependency maps, error snapshot call chains, JVM heap diagnostic reports, and database query plan analyses. Access Cognition Engine anomaly detection events, policy violation alerts, agent installation health checks, and cloud-native Kubernetes cluster correlation data.

Integrate with IBM Instana automated application observability platform via MCP. Access service dependency graphs, infrastructure maps, website real-user monitoring traces, and SLI/SLO compliance summaries. Query unbounded analytics incident event correlations, pipeline acceleration CI/CD integration metrics, and Instana Sensor autodiscovery inventory updates for cloud-native and mainframe environments.

ClearML MLOps platform MCP — manage experiment tracking, model deployment, data versioning, and ML pipelines. Query task history, compare runs, clone experiments, and orchestrate distributed training jobs.

A community Go MCP server (sinadarbouy/mcp-nats) for the NATS messaging system. Note before you plan around it: this is NOT a NATS-maintained project — there is no `nats-io` MCP server, so the `nats-io/...` module path you may find quoted elsewhere does not exist. The design is deliberately read-mostly. Server and stream operations are read-only by construction: list and inspect servers, ping for health, retrieve server info, measure round-trip time, view stream state, inspect subjects and retrieve messages. The mutating surface is scoped to the two NATS data stores and to publishing — object store buckets can be created, listed, put/get, watched, sealed against further updates and deleted; KV buckets support create, put, get, watch-for-updates and delete; and messages can be published to subjects asynchronously in several formats. Account operations cover account info and metrics, connection/statistics reports, backup and restore, and TLS chain inspection for connected servers, with multi-account credential handling so one server instance can span several NATS accounts. Requires Go 1.25+, a reachable NATS URL and credentials. A prebuilt image is also published at ghcr.io/sinadarbouy/mcp-nats if you would rather not build from source.

Vitess MySQL-compatible distributed database clustering MCP — run queries on Vitess clusters, inspect shard topology, manage keyspaces, query VTAdmin API, and operate MySQL at scale with horizontal sharding and connection pooling.

ManageEngine IT management suite MCP — query incidents and service requests, manage assets in IT inventory, run reports, access network monitoring data, and interact with ServiceDesk Plus, OpManager, and ADManager modules.

Nx monorepo build system MCP — query project graph, run targeted builds and tests, manage dependencies between apps and libs, inspect affected projects, and leverage Nx caching and distributed task execution.

Turborepo monorepo task runner MCP — query pipeline configurations, run tasks with caching, inspect workspace dependencies, manage remote cache settings, and speed up builds across your JavaScript and TypeScript monorepo.

Backstage internal developer portal MCP — search the software catalog, retrieve service ownership and metadata, query TechDocs documentation, list registered APIs and components, check scaffolded templates, and explore your engineering ecosystem.

OpsLevel service catalog MCP — query service maturity scores, retrieve ownership and dependency graphs, check service level checks and rubrics, list teams and their services, and access infrastructure context for AI-powered DevOps workflows.

Incident.io incident management MCP — create and update incidents, query timeline events, list on-call schedules, retrieve postmortem drafts, manage follow-up actions, and access severity classifications for AI-assisted incident response.

Squadcast on-call and incident management MCP — query on-call schedules, create and acknowledge incidents, manage escalation policies, retrieve service health status, list past incidents, and trigger runbooks for automated incident response.

Bunny.net CDN and edge platform MCP — manage pull zones and storage buckets, purge CDN cache, query bandwidth and traffic analytics, configure edge rules, manage video stream libraries, and monitor CDN performance across global PoPs.

SigNoz open-source APM and observability MCP — query distributed traces and spans, retrieve service performance metrics, search structured logs, analyze error rates and latencies, manage alert rules, and monitor infrastructure health with OpenTelemetry data.

Icinga infrastructure monitoring MCP — query host and service check results, retrieve downtime and acknowledgement states, list monitoring objects and their health status, access performance data and trend graphs, and trigger manual checks on managed infrastructure.

Zabbix network and infrastructure monitoring MCP — query host and item data, retrieve active alerts and trigger states, search historical metrics, manage maintenance windows, access problem event timelines, and retrieve SLA reports for monitored systems.

Great Expectations data validation MCP — run expectation suites against data assets, retrieve validation results and data docs, manage checkpoints, query expectation store configurations, and surface data quality failures across your pipeline for AI-assisted debugging.

DVC (Data Version Control) ML pipeline MCP — query experiment runs and metrics, retrieve tracked dataset versions, compare model performance across commits, manage pipeline stages, access artifact storage locations, and reproduce ML experiments with version-controlled data.

Data orchestration and pipeline management via Dagster's API. Trigger asset materializations, monitor pipeline runs, query asset catalogs, manage partitions, and debug failures in your Dagster data platform.

Workflow orchestration and scheduling via Prefect's API. Trigger and monitor flow runs, inspect deployments, manage work pools, view logs, and automate data pipeline operations from your AI assistant.

Manage Apache Airflow DAGs and tasks via MCP. Trigger DAG runs, monitor task status, view logs, pause/unpause pipelines, and query execution metadata. Works with Airflow 2.x and Astro Cloud deployments.

IBM MQ queue manager integration via MCP. List local queue managers, run MQSC commands, inspect queue depths and channel status, and manage IBM MQ infrastructure. Built for enterprise messaging and event-driven architectures.

Cloudflare Workers development MCP server for on-the-fly application building with D1 databases, R2 object storage, KV stores, and other Workers bindings. Create tables, query data, upload objects, and manage Workers primitives directly from AI tools as you build Cloudflare applications.

BACnet protocol gateway for building automation and control networks. Query HVAC, lighting, and facility management devices via MCP.

CANopen industrial protocol MCP server for querying and controlling embedded field devices on CANopen networks in manufacturing and robotics.

EtherCAT real-time industrial Ethernet MCP integration. Read and write process data objects on EtherCAT slave devices for automation and motion control.

Inductive Automation Ignition SCADA/MES gateway MCP server. Browse OPC-UA tags, read historian data, and interact with Ignition projects via AI.

NetBox network source of truth MCP server. Query IP addresses, prefixes, devices, rack layouts, circuits, and DCIM data through the NetBox REST API.

Nautobot network automation platform MCP server. Interact with your network source of truth, jobs, and GraphQL API to automate network operations.

Cisco Meraki cloud-managed networking MCP server. Query network topology, clients, alerts, and device health across Meraki MX, MR, MS, and MV products.

Palo Alto Networks Panorama centralized firewall management MCP server. Query security policies, threat logs, and device status across your NGFW fleet.

Fortinet FortiGate next-generation firewall MCP server. Manage firewall policies, VPN tunnels, threat logs, and security profiles via FortiOS REST API.

Juniper Mist AI-driven networking MCP server. Query wireless clients, AP health, SLE metrics, and WAN insights through the Mist cloud API.

HPE Aruba Central network management MCP server. Monitor access points, switches, gateways, and clients across Aruba Central-managed networks.

Infoblox DDI (DNS, DHCP, IPAM) MCP server. Query and manage IP address space, DNS records, and DHCP leases through the Infoblox NIOS REST API.

Highlight.io open-source session replay and error monitoring MCP server. Query user sessions, errors, and logs to debug production frontend issues.

Baselime serverless and edge observability MCP server. Query distributed traces, logs, and metrics from AWS Lambda, Cloudflare Workers, and Vercel Edge Functions.

The Flux MCP Server ships inside the Flux Operator and connects an AI assistant directly to a Kubernetes cluster running Flux CD. It exposes the GitOps state as tools rather than as kubectl output: list and inspect Kustomizations, HelmReleases, GitRepositories, OCIRepositories and Buckets, read reconciliation status and events, trigger a reconcile, suspend or resume a resource, and compare the desired state in Git against what is actually applied in the cluster. It speaks multi-cluster — the kubeconfig context is a tool parameter, so one assistant session can debug staging and production side by side. Typical use is diagnostic: ask why a HelmRelease is not ready and the server walks the ownership chain from the release down to the failing source, returning the events and conditions that explain the stall. Distributed as the `flux-operator-mcp` binary by ControlPlane, the maintainers of the Flux Operator, for Linux, macOS and Windows on amd64 and arm64.

Provision and manage cloud infrastructure resources across providers using Crossplane compositions and XRDs.

Configure Istio traffic management, mTLS policies, service entries, and observability for Kubernetes services.

Manage KEDA ScaledObjects, ScaledJobs, and event-driven autoscaling triggers for Kubernetes workloads.

Manage Podman containers, pods, images, and volumes without requiring root privileges.

Manage Rancher multi-cluster Kubernetes environments, projects, namespaces, and workloads.

Manage Docker and Kubernetes environments through Portainer — stacks, containers, volumes, and networks.

Manage K3s lightweight Kubernetes clusters — deployments, services, ingress, and config on edge and IoT nodes.

Manage Perforce Helix Core version control — check out files, submit changelists, sync depots, manage users, and query revision history at enterprise scale.

Manage artifacts in Sonatype Nexus Repository — search Maven/npm/Docker components, check vulnerability data via OSS Index, and manage repository policies.

Stacked pull requests and code review for GitHub. Manage PR stacks, reviews, and merges programmatically.

Apache ActiveMQ integration for managing message queues, topics, and broker monitoring via MCP.

Amazon SQS server for sending, receiving, and managing messages in AWS Simple Queue Service queues.

Microsoft Azure Service Bus integration for cloud messaging, queues, and pub/sub topics via MCP.

Inngest serverless event-driven functions and background jobs — trigger, monitor, and manage workflows via MCP.

Trigger.dev background jobs and long-running tasks — create, monitor, and manage jobs from AI assistants.

Nagios monitoring server — query host/service status, acknowledge alerts, and manage downtime schedules.

LibreNMS network monitoring — discover devices, check port status, retrieve SNMP data, and manage alerts.

SNMP protocol server for querying network device metrics, interface statistics, and system information via MIBs.

The first thing to know about Kong and MCP is that the community repository most directories still link to — Kong/mcp-konnect — is deprecated. Its README now carries a maintenance warning: no further updates, bug fixes or features, issues and pull requests unmonitored, and the repo is headed for read-only archive. Kong's supported path is the Konnect remote MCP server, documented at developer.konghq.com/konnect-platform/konnect-mcp/, which is hosted by Kong rather than installed locally, so there is no npm package to run and nothing to keep patched on your side. The capability set both cover is the same: let an AI assistant query and analyze a Kong Gateway estate through Konnect. That means API request analytics with customizable filters (time windows, status codes, routes, consumers), inspection of gateway configuration objects — services, routes, consumers and plugins — and management of control planes and control plane groups. The practical use is diagnostic rather than mutating: asking which routes returned 5xx in the last hour, which consumer is driving traffic to a given service, or which plugins are attached where, without building a dashboard query for each question. Kong sits in an unusual spot in the MCP gateway conversation because it is both a subject and a peer: Kong Gateway is itself an API gateway that can front MCP traffic (Kong publishes AI-gateway guidance for exactly that, including an AWS reference architecture for GenAI MCP and A2A gateways), while this entry is the MCP server that lets an agent administer Konnect. If you arrived looking for "kong mcp gateway" you probably want the former; if you want your agent to read Konnect analytics, you want the remote server here. Node.js 20+ and a Konnect account with API access were the prerequisites for the deprecated local build.

Security monitoring MCP that tracks the supply chain provenance of local MCP servers ensuring integrity and preventing tampering.

Official Harness CI/CD MCP server with 240+ tools for pipeline management, deployment automation, feature flags, and cloud cost optimization.

Manage OpsGenie alerts, on-call schedules, escalation policies, and incident response workflows.

Manage incidents, runbooks, and retrospectives through FireHydrant for faster, AI-assisted incident response.

Manage Azure ML experiments, datasets, compute clusters, model registries, and deployments through AI-assisted MLOps workflows.

Query VictoriaMetrics for fast, cost-effective time-series data storage and analytics — compatible with Prometheus and Graphite.

Integrate Codecov code coverage platform for test coverage reporting, coverage trend analysis, pull request comments, flagging, and team coverage metrics across repositories.

Use Grype open-source container and filesystem vulnerability scanner for SBOM-based vulnerability detection, CVE lookups, policy enforcement, and CI/CD security gates.

Generate Software Bill of Materials (SBOM) with Syft for containers, filesystems, and package managers — producing CycloneDX or SPDX format SBOMs for compliance and supply chain security.

Integrate Aqua Security cloud-native security platform for container scanning, Kubernetes runtime protection, serverless security, CI/CD pipeline security, and compliance automation.

Connect to Sysdig cloud security platform for runtime threat detection, vulnerability management, cloud security posture management (CSPM), and Kubernetes security monitoring.

Integrate Losant enterprise IoT platform for device management, real-time data collection, workflow automation, edge computing, and IoT application development.

Connect to ChirpStack open-source LoRaWAN Network Server for device provisioning, gateway management, uplink/downlink data, and geolocation for LPWAN IoT deployments.

Access Helium decentralized wireless network API for IoT device connectivity, coverage maps, hotspot data, token rewards, and LoRaWAN sensor data streams.

Access Coveralls test coverage service for coverage history tracking, pull request comments, badge generation, and team coverage trend analysis across multiple languages.

Integrate Trunk code quality meta-linter for running multiple linters, formatters, and security scanners with unified configuration, caching, and CI/CD integration.

Connect to Depot remote Docker build service for 40x faster Docker builds with shared caching, native ARM support, and drop-in compatibility with existing CI/CD pipelines.

Integrate Earthly reproducible build tool for containerized builds with Makefile-like syntax, local and CI caching, monorepo support, and language-agnostic build definitions.

Connect to Tilt smart rebuilds for Kubernetes development workflows — automatic live updates, dependency graphs, health monitoring, and team dev environment standardization.

Implement OpenADR 2.0 automated demand response for energy management — VTN/VEN server integration, DR event handling, price signals, and grid flexibility programs.

Manage Apache Kafka clusters — topic management, consumer groups, message production/consumption, schema registry, Kafka Connect connectors, and cluster health monitoring.

Access HashiCorp Vault for secrets management — read/write secrets, dynamic credentials, PKI certificates, SSH key signing, encryption as a service, and audit log queries.

a Python MCP server for Jenkins (lanbaoshen/mcp-jenkins, published to PyPI as mcp-jenkins) and the alternative to the official Jenkins MCP plugin: where the plugin has to be installed into the controller from the update centre, this one runs beside Jenkins and talks to it over the ordinary REST API, so you can point it at a Jenkins you do not administer. Install it with uvx mcp-jenkins, pip install mcp-jenkins, or the ghcr.io/lanbaoshen/mcp-jenkins container. Credentials go in as --jenkins-url, --jenkins-username and --jenkins-password (an API token works in place of the password), and on the HTTP transport the same three can be supplied per-connection as the x-jenkins-url, x-jenkins-username and x-jenkins-password headers, which is what lets one running instance serve several Jenkins controllers. Three transports are available via --transport: stdio (the default), sse, and streamable-http, which listens on 0.0.0.0:9887 unless --host and --port say otherwise. The tool set is wider than most Jenkins integrations. Jobs and pipelines: get_item, get_item_config, get_item_parameters, get_all_items, query_items for pattern search, and build_item to trigger. Builds: get_build, get_build_console_output, get_build_parameters, get_build_test_report, get_build_scripts, get_running_builds and stop_build, plus get_all_build_artifacts, get_build_artifact and get_build_artifact_url for pulling artifacts out of a finished run. Queue: get_all_queue_items, get_queue_item, cancel_queue_item. Agents: get_all_nodes, get_node, get_node_config. The plugin tools are the part with no equivalent elsewhere — get_all_plugins, get_plugin, get_plugins_with_updates, get_plugins_with_backup, get_plugin_dependency_graph (Graphviz output), and get_plugins_with_problems, which reports missing dependencies and version mismatches and turns a plugin upgrade audit into one question. Two flags matter for safety. run_groovy_script executes arbitrary Groovy on the controller, which is full remote code execution against your CI; --read-only disables it along with every other mutating tool and is the right default for an agent that only needs to read build state. --jenkins-timeout defaults to 5 seconds, which is often too short for a large get_all_items on a busy controller.

Automate Octopus Deploy release management — create and promote releases, trigger deployments across environments, manage runbooks, query deployment history, and monitor tenanted multi-environment pipelines via REST API.

Interact with Atlantis pull request automation for Terraform — trigger plan and apply runs, list pending workflow locks, check workspace status, view atlantis.yaml config, and manage project-level access policies.

Work with CDK for Terraform (CDKTF) stacks — synthesize HCL from TypeScript/Python/Java constructs, plan and apply stacks against cloud providers, query state outputs, and manage CDKTF project scaffolding via CLI.

Monitor and triage Bugsnag error reports — query error trends and affected users, update error states and assignments, link errors to deploys, set stability scores, and correlate crashes with release versions.

Integrate with Rollbar error monitoring — query occurrences and stack traces, update item statuses, manage deploy tracking, set notification rules, retrieve person-level error context, and generate stability reports.

Manage LaunchDarkly feature flags programmatically — create and toggle flags, define targeting rules and percentage rollouts, query evaluation reasons, manage environments and projects, and retrieve flag change audit logs.

Centralized firewall management via Palo Alto Panorama API — query security policy rules and NAT policies, retrieve threat logs and traffic analytics, manage address objects and service groups, push configuration changes across device groups, retrieve device health and resource utilization, manage security profiles, and audit configuration diffs and compliance posture.

Firewall policy management via Check Point Management API — query and create security rules and access control policies, manage network objects and host definitions, retrieve threat prevention logs and IPS signatures, publish and install policy changes, monitor gateway health, retrieve VPN tunnel status, and audit security policy compliance.

Network security management via SonicWall NSM API — query firewall rules and access policies, retrieve VPN tunnel status and user sessions, monitor threat events and IPS signatures, manage address objects and service groups, retrieve bandwidth utilization and interface statistics, configure content filtering rules, and manage SonicWall device fleet from a centralized dashboard.

Infrastructure monitoring via PRTG API — retrieve sensor status and alert conditions, query bandwidth utilization and traffic graphs for network interfaces, manage device groups and monitoring trees, acknowledge alerts and set maintenance windows, retrieve historical performance data, manage notification triggers, and monitor uptime and response time for hosts and services.

Backup and recovery management via Veeam REST API — query backup job status and schedule, trigger on-demand backup and restore operations, retrieve restore points and recovery metadata, monitor infrastructure health and backup repository capacity, manage replication jobs and failover plans, retrieve audit logs and compliance reports, and monitor SLA adherence across protected workloads.

Data protection and cybersecurity via Acronis Cyber Cloud API — manage backup plans and policies, retrieve backup status and restore points for endpoints and workloads, initiate recovery operations, monitor antimalware scan results and threat detections, retrieve patch management status and vulnerability assessments, manage tenant hierarchies, and track storage consumption and quota usage.

Enterprise data management via Commvault Command Center API — manage backup and restore jobs, query protection status for virtual machines, databases, and cloud workloads, retrieve SLA compliance reports, initiate granular recoveries and disaster recovery tests, manage storage policies and data aging, access audit trails, and monitor infrastructure health across hybrid environments.

Disaster recovery and continuous data protection via Zerto API — monitor Virtual Protection Groups and replication health, retrieve RPO metrics and recovery point history, initiate failover and failback operations, manage recovery sites and VM protection, access journal-based recovery checkpoints, retrieve compliance and analytics reports, and monitor WAN bandwidth consumption for replication traffic.

Scalable build system integration via Bazel — query build targets and dependency graphs, run incremental builds and tests with caching, retrieve build event protocol data, analyze build performance and bottlenecks, manage remote execution and caching configuration, query workspace rules and macro definitions, and integrate with CI/CD systems for hermetic, reproducible builds.

Privileged access management via CyberArk REST API — retrieve and rotate credentials from the Digital Vault, manage safe permissions and member assignments, query privileged session recordings and audit logs, manage account onboarding and platform policies, retrieve just-in-time access requests, monitor dual control approvals, access threat analytics and risk scores, and integrate with SIEM and ticketing systems.

Privileged identity and remote access management via BeyondTrust API — manage privileged credentials and rotation schedules, retrieve session recordings and keystroke logs, manage remote support sessions and endpoints, query least privilege policy violations, access password vault contents with policy enforcement, manage role-based access and approval workflows, and integrate with ticketing systems for session authorization.

Manage secrets and encryption via HashiCorp Vault — read and write secrets from KV secret engines, generate dynamic database and cloud credentials, manage PKI certificates, access AppRole and Kubernetes auth methods, rotate static secrets, query audit logs, manage policies and tokens, and integrate secrets management into CI/CD pipelines and infrastructure automation.

Access 1Password secrets and vaults via the 1Password CLI and Connect API — retrieve secrets by reference path, query vault items, manage secrets in CI/CD environments, inject environment variables from vault, list team vaults and permissions, rotate credentials, manage service account tokens, and integrate secrets retrieval into development and deployment workflows.

Interact with Apache Pulsar distributed messaging via the Pulsar admin API — manage topics, namespaces, and tenants, publish and consume messages, configure message retention and TTL, manage subscriptions and consumer groups, query topic statistics and backlog, handle schema registry, configure geo-replication, manage authentication and authorization, and monitor broker health.

Query observability data via the New Relic NRQL API — run NRQL queries across APM metrics, distributed traces, and logs, access application performance baselines, query error rates and response times, manage alert policies and conditions, pull infrastructure metrics for hosts and containers, access synthetic monitor results, and build dashboards and SLO compliance reports.

Access Elastic APM observability via the Elasticsearch and Kibana APIs — query service performance metrics, distributed traces, and error rates, analyze transaction latency percentiles, pull infrastructure and host metrics, access ML anomaly detection results, manage APM agent configuration, query log correlation data, build service maps, and monitor real user monitoring (RUM) analytics.

Search and analyze application logs via the Loggly API — query log events with Lucene syntax, filter by source and severity, pull log volume trends, set up and manage alerts on log patterns, access parsed fields and custom tags, analyze error frequency across services, pull field distribution statistics, and integrate log search into incident investigation workflows.

Access Papertrail cloud log management via the Papertrail API — search log archives with wildcard and regex queries, tail live log streams, manage log routing to systems and groups, set up alert notifications, query events by source host and program, access historical log archives, pull usage statistics, and integrate log search into DevOps and SRE incident response workflows.

Search and manage logs via LogDNA/Mezmo — query log lines with field-based filtering, access streaming log tails, manage log views and saved queries, configure alert policies on patterns, pull log usage metrics, manage ingestion exclusion rules, access log parsing configurations, export log archives, and integrate centralized log analysis into observability and compliance workflows.

Manage infrastructure as code via Terraform CLI and the Terraform Cloud API — run plan, apply, and destroy operations, query state files and resource inventory, manage workspaces and variable sets, access run history and logs, handle module registry, manage Sentinel policies, query cost estimates, manage team permissions, and integrate IaC workflows into GitOps and CI/CD pipelines.

A local stdio MCP server for managing Cloudflare Workers from Claude Desktop or Claude Code, and the successor to the same author's cloudflare-pages-mcp — following Cloudflare's own shift from Pages to Workers with static assets. Its headline capability is deploy_static_site, which deploys a local directory as a static site in one natural-language request: manifest hashing, server-side dedupe so unchanged files are never re-uploaded, _headers and _redirects support, SPA and 404 handling, and a live workers.dev URL in the result. The author's stated reason for building it is that as of mid-2026 no other MCP server can deploy a Worker at all — Cloudflare's own remote MCP servers are read-only for Workers management, and their Code Mode server has no filesystem so it cannot upload a real asset tree. A local server can, because the static-asset direct-upload protocol is publicly documented. Beyond deploys it covers list/get/delete_worker, get_worker_code to download deployed source, deploy_worker with plain_text, secret_text, kv_namespace, r2_bucket, d1 and assets bindings, update_worker_settings, immutable version history via list/get/create_version, traffic mapping through list/create_deployment including gradual splits such as 90/10, rollback_worker, custom domains, set_workers_dev, cron triggers, and query_worker_logs. Two cautions, both from the project's own README: it was substantially AI-written and the author recommends reviewing the source or building from the repo rather than trusting the npm artifact, and the API token should be scoped to Workers Scripts: Edit and nothing more. Requires Node.js 22+.

Manage Netlify deployments and JAMstack workflows via the Netlify API — deploy sites from Git, manage build hooks and deploy previews, configure environment variables and secrets, query deploy logs and build status, manage domain DNS and SSL certificates, configure edge functions, access form submissions, manage split testing, pull bandwidth and function invocation analytics, and trigger rollbacks.

Manage Vercel deployments and frontend infrastructure via the Vercel API — deploy projects from Git, manage environment variables across environments, query deployment logs and build output, configure custom domains and SSL, manage edge configs and edge middleware, access serverless function logs, pull project analytics, manage team members and access tokens, and handle preview deployment workflows.

This entry previously pointed at a fabricated github_url (`mcp-servers/heroku-mcp`, confirmed 404 — the `mcp-servers` GitHub org exists but has zero public repos) with fabricated star and tool-scope claims. There is no separate "Heroku MCP" project distinct from Heroku's own official server: the real, actively-maintained implementation is `heroku/heroku-mcp-server`, already fully documented on the main `heroku` entry in this directory (application/process/add-on/pipeline/team/Postgres tools, install via `heroku mcp:start` or `npx -y @heroku/mcp-server`). This duplicate slug exists only to catch the "heroku mcp" search variant and now points at the same real repo rather than a fake one — see the `heroku` entry for the full tool list and setup guide. Flagged for a future dedup/redirect pass rather than deleted this fire, consistent with the huggingface-mcp precedent (2026-07-15).

Manage secrets and environment configurations via the Doppler API — fetch secrets for any project, config, and environment; inject environment variables into local dev and CI/CD pipelines; sync secrets across staging, production, and review environments; manage access controls and service tokens; audit secret access logs; rotate API keys; and build automated secret management workflows.

Access Infisical open-source secrets management via their API — read and write secrets across projects and environments; manage secret folders, tags, and overrides; pull secrets for dynamic injection into apps and CI/CD; configure service tokens and machine identities; audit secret change history; sync with AWS Secrets Manager, Azure Key Vault, and GCP Secret Manager; and manage team permissions.

Sync and manage .env files across teams via Dotenv Vault — push and pull encrypted .env files to the vault, manage environment-specific configs for development, staging, and production, share secrets with teammates securely, generate .env.vault encrypted backup files, integrate with CI/CD pipelines for automatic secret injection, and audit who accessed which environment variables.

Automate GitHub issue resolution via Sweep AI's coder bot API — create Sweep tasks from issue descriptions, retrieve PR status and code change summaries, access Sweep's codebase understanding and search results, manage sweep.yaml configuration files, pull task completion metrics, access refactoring and test generation workflows, and integrate Sweep into CI/CD pipelines for automated code maintenance and technical debt reduction.

Query and analyze log aggregation data from Grafana Loki via the LogQL API — execute LogQL log stream and metric queries, retrieve log lines with label filtering and regex matching, pull log volume metrics and rate calculations, access label discovery and value enumeration, manage log retention policies and storage tiers, build log-based alerting rules, and integrate Loki log data with Grafana dashboards and incident response workflows.

Access distributed tracing data from Grafana Tempo via TraceQL — query traces by service, operation, duration, and attribute values using TraceQL syntax, retrieve full span trees and trace timelines, analyze latency distributions and error rates across services, correlate traces with Loki logs and Prometheus metrics, access service graph data and RED metrics, pull trace exemplars, and build distributed system debugging and performance analysis workflows.

Manage and query OpenTelemetry Collector pipelines via the zPages and pprof extension APIs — retrieve pipeline status for receivers, processors, and exporters; access trace and metric sampling statistics; manage collector configuration hot-reloading; pull internal telemetry and performance metrics; manage batch processor queues; access log pipeline throughput data; and build OTel Collector administration and observability automation workflows.

Control Vector observability data pipeline via its GraphQL API and REST endpoints — retrieve pipeline topology and component status, query throughput and error rate metrics for sources, transforms, and sinks, access internal telemetry and buffer health, hot-reload pipeline configurations, manage Vector Remap Language (VRL) transform logic, pull component-level performance profiling, and build data pipeline administration and monitoring automation.

Delinea MCP (DelineaMCP) is the official open-source Model Context Protocol server for Delinea Secret Server and the Delinea Platform APIs, published under the DelineaXPM org under an MIT license. It is a Python server that authenticates against Secret Server automatically on startup, requesting a bearer token and reusing it for subsequent API calls, and it works against both self-hosted Secret Server (base URL ending in /SecretServer) and Secret Server Cloud (cloud URL, no path suffix). The tool set is broad and skews toward administration rather than raw secret retrieval: get_secret, search_secrets, get_folder, search_folders and search_users for lookup; get_secret_environment_variable, which emits a shell script for pulling secret credentials into a given environment; check_secret_template, check_secret_template_field and get_secret_template_field for template introspection; get_pending_access_requests and handle_access_request for approving or denying requests with optional start and expiration dates; get_inbox_messages and mark_inbox_messages_read for the Secret Server inbox; and a set of unified action-dispatch tools - user_management (get/create/update/delete/list_sessions/reset_2fa/reset_password/lock_out), role_management, user_role_management, group_management, user_group_management, group_role_management and folder_management - that keep the tool list short while covering full CRUD. Reporting is handled by run_report, which creates and executes a temporary report from SQL, list_example_reports for sample queries and table info, and an optional ai_generate_and_run_report that writes the SQL via Azure OpenAI; that tool self-disables when the Azure OpenAI variables are absent, and the maintainers advise leaving it off since most agents can write the report SQL themselves. Dedicated ChatGPT-compatibility search and fetch tools are included, scoped by search_objects and fetch_objects (secret by default, optionally user, folder, group and role). Configuration splits cleanly: secrets such as DELINEA_PASSWORD, PLATFORM_SERVICE_PASSWORD and AZURE_OPENAI_KEY come from environment variables, everything else from config.json. Transport is stdio or SSE, and auth_mode supports OAuth 2.0 with dynamic client registration per the MCP spec - note OAuth does not apply to stdio - with optional TLS via ssl_keyfile/ssl_certfile and a registration_psk you type in the browser to approve OAuth clients. The enabled_tools list is worth using: an empty list registers every tool, but the docs recommend enabling tools selectively per use case. A Dockerfile is provided; mount a volume for /app/data so the generated oauth.db and jwt.json persist. Documented client setups cover ChatGPT custom connector, Claude Desktop, the remote Claude connector, VS Code Copilot and openwebui.

MCP Inspector is the official developer tool for inspecting Model Context Protocol servers, published by the Model Context Protocol project itself, and it is what you reach for when a server will not connect, a tool schema comes back wrong, or an OAuth handshake fails somewhere you cannot see. It ships as a single npm package, `@modelcontextprotocol/inspector`, that exposes three clients behind one `mcp-inspector` binary: a web UI (Vite + React + Mantine over a Node backend, and the default), a scriptable CLI (`--cli`) meant for automation, CI and fast agent feedback loops, and an interactive terminal UI (`--tui`) built on Ink. So `npx @modelcontextprotocol/inspector` opens the web app, and adding `--cli` or `--tui` switches client without changing anything else about the invocation. The current published line is v2 (npm `latest` is 2.0.0, with the older line still reachable on the `v1-latest` tag); worth knowing before you read the source, the repository's `main` branch is the legacy v1 implementation on bug-fixes-only, while v2 development lives on `v2/main`. Node >= 22.19.0 is required. The CLI is the part most people underuse. `--method tools/list`, `resources/list` and `prompts/list` dump a server's whole surface without opening a browser, and `--method tools/call --tool-name mytool --tool-arg key=value` invokes one directly, with `--tool-arg 'options={"format": "json"}'` for JSON-valued arguments. It connects to a local server by command (`npx @modelcontextprotocol/inspector --cli node build/index.js`) and to a remote one by URL, where `--transport http` selects streamable HTTP (a bare URL defaults to SSE) and `--header "X-API-Key: your-key"` supplies auth. Servers can also come from a file: `--catalog` points at a writable catalog (default `~/.mcp-inspector/mcp.json`, or `MCP_CATALOG_PATH`) and `--config` at a read-only session, with `--server` selecting one entry — the two flags are mutually exclusive and neither combines with an ad-hoc target. A file-configured server also carries its own headers, connection and request timeouts, OAuth settings and `roots`, and the file is the only durable way to give a run its roots, which matters for servers like `@modelcontextprotocol/server-filesystem` that call `roots/list` to learn which directories they are allowed to touch. Remote connections honour the conventional `HTTPS_PROXY` / `HTTP_PROXY` / `NO_PROXY` variables through undici's EnvHttpProxyAgent, with no Inspector-specific flag needed.

This Bitbucket MCP server wraps the Bitbucket Cloud and Bitbucket Server REST APIs so an AI assistant can work a pull request end to end instead of just reading repository metadata. Its depth is in the PR lifecycle. Beyond `listRepositories` and `getRepository`, it exposes `getPullRequests`, `createPullRequest`, `getPullRequest` and `updatePullRequest`, then the review actions that usually force a browser tab: `approvePullRequest`, `unapprovePullRequest`, `requestChanges`, `removeChangeRequest`, `declinePullRequest` and `mergePullRequest`. Draft workflow is covered too — `createDraftPullRequest`, `publishDraftPullRequest`, `convertTodraft`. Comment handling is full CRUD plus thread state: `getPullRequestComments`, `addPullRequestComment`, `getPullRequestComment`, `updatePullRequestComment`, `deletePullRequestComment`, `resolveComment` and `reopenComment`, which is what lets an agent leave inline review notes and then mark threads resolved. For reading changes there are three distinct shapes — `getPullRequestDiff`, `getPullRequestDiffStat` and `getPullRequestPatch` — alongside `getPullRequestCommits`, `getPullRequestStatuses` and `getPullRequestActivity`. PR tasks/checklists get their own five tools, and Bitbucket Pipelines are wired in with `listPipelineRuns`, `getPipelineRun`, `runPipeline`, `stopPipeline`, `getPipelineSteps`, `getPipelineStep` and `getPipelineStepLogs`, so an agent can trigger a build and read back the failing step log. Install with `npx -y bitbucket-mcp@latest`. Configuration is environment-variable driven: `BITBUCKET_URL` (defaults to `https://api.bitbucket.org/2.0`), `BITBUCKET_WORKSPACE`, and either `BITBUCKET_TOKEN` or the `BITBUCKET_USERNAME` + `BITBUCKET_PASSWORD` pair. Two auth gotchas the maintainer calls out explicitly, because both produce 401s: the username is usually your email, and an Atlassian API token goes in `BITBUCKET_PASSWORD`, not `BITBUCKET_TOKEN`. App passwords need at least Repositories: Read, Pull requests: Read+Write, and Pipelines: Read. Destructive operations are gated behind `BITBUCKET_ENABLE_DANGEROUS=true` and off by default. This is a community project, not an Atlassian one. Atlassian does ship an official alternative — the Atlassian Rovo MCP Server added Bitbucket Cloud support — but its Bitbucket tools are available only via API-token authentication, not OAuth 2.1, and it is organization-admin-enabled through Admin Hub. Choose this server when you want local control and deep pipeline/PR-task coverage, the Rovo server when you need centrally governed enterprise access across Jira, Confluence and Bitbucket together.

Manage Terraform Cloud workspaces, runs, state, and variables. Trigger plans, view logs, and approve applies via HCP Terraform API.

Interact with Apache NiFi data flow pipelines via the NiFi REST API — query and manage process groups, processors, and connections, start and stop flow components, retrieve provenance data, monitor queue depths and data lineage, manage controller services, deploy flow templates, and build AI-assisted data pipeline monitoring and orchestration workflows.

Orchestrate and monitor Apache Beam data processing pipelines via the Beam API — submit pipeline jobs to Dataflow, Spark, or Flink runners, retrieve job status and metrics, access pipeline graphs, query transformation outputs, manage job state and cancellations, and integrate Beam pipeline management into AI-driven data engineering workflows.

Monitor applications via Uptrace OpenTelemetry backend — query distributed traces and spans, retrieve service performance metrics, access log data, view error rates and P99 latencies, analyze trace attributes and custom metrics, monitor deployment health, and integrate OpenTelemetry observability into AI-assisted incident investigation and performance optimization workflows.

Monitor and manage Linkerd service mesh via the Linkerd CLI and Viz API — retrieve service topology and traffic maps, query per-route success rates and latency histograms, access TLS certificate status, retrieve pod-level proxy metrics, monitor multi-cluster links, debug traffic with Linkerd tap, and integrate service mesh observability into AI-driven platform engineering workflows.

Interact with Envoy Proxy admin interface and xDS management — retrieve cluster and endpoint health, query route configuration and listener stats, access circuit breaker and retry stats, retrieve active connections and request counters, read configuration dumps, manage dynamic xDS configurations, and integrate Envoy-based service proxy management into AI-driven traffic engineering workflows.

Manage Vagrant development environments via the Vagrant CLI — create and provision virtual machines from Vagrantfiles, start, stop, and destroy VMs, retrieve VM status and SSH connection info, run provisioning scripts, manage snapshots, list box inventories, and automate local development environment lifecycle with AI-assisted environment orchestration.

Manage GitHub Dependabot security alerts and updates via the GitHub REST API — list and triage dependency vulnerabilities, retrieve CVSS scores and affected packages, dismiss or escalate security alerts, access auto-merge pull request statuses, query version update configurations, bulk-update Dependabot PRs, and integrate automated dependency security management into AI-driven DevSecOps workflows.

access to Azure DevOps projects, repos, work items, builds, pipelines, test plans and wikis from any MCP-capable agent. This is Microsoft's own server, published under the microsoft GitHub org and shipped on npm as `@azure-devops/mcp`, and it brings Azure DevOps context — projects, repos, work items, builds, pipelines, test plans, wikis, iterations and teams — into any MCP-capable agent, so prompts like "list my work items in the current iteration for the Contoso project and Contoso Team" or "create a wiki page /Architecture/Overview with content about system design" resolve against your real organisation. The design philosophy is explicit in the README: each tool stays concise, focused and single-purpose, acting as a thin abstraction over the Azure DevOps REST APIs and leaving the complex reasoning to the model rather than bundling it into fat tools. The most important thing to know before choosing a setup path is that Microsoft now recommends the **Remote MCP Server** over this local one. The remote endpoint needs no installation, receives new features first, and is where future investment is going; the local stdio server remains supported for now, and existing users are being encouraged to migrate. Wiring the remote server is a four-line `.vscode/mcp.json` entry pointing at `https://mcp.dev.azure.com/{organization}` with `"type": "http"` (streamable HTTP transport), after which you start it from the VS Code MCP view. Use the local server only if your scenario genuinely requires stdio. For that path you need Node.js 20+ and a config that runs `npx -y @azure-devops/mcp <your-org>`, with `@azure-devops/mcp@next` available if you want nightly builds. On first tool call a browser opens for Microsoft account login, so the credentials you sign in with must match the target organisation. The local server also exposes two configuration levers worth knowing. Because Azure DevOps has a very large API surface, the full tool set can overwhelm a model or hit a client's tool-count limit, so tools are grouped into **domains** — `core`, `work`, `work-items`, `search`, `test-plans`, `repositories`, `wiki`, `pipelines`, `advanced-security` — and you pass `-d` plus the ones you want to load a narrower set (all domains load by default, and Microsoft recommends always keeping `core` so project-level lookups work). Second, `ado_mcp_project` and `ado_mcp_team` environment variables set default project and team so tools stop prompting for selection, and `--authentication azcli` switches to Azure CLI credentials. Getting-started docs cover Visual Studio 2022, Codex, Claude Code, Cursor, Opencode and Kilocode alongside VS Code with GitHub Copilot, and the maintainers strongly suggest adding a `.github/copilot-instructions.md` telling the agent to check for an Azure DevOps MCP tool first. MIT licensed; still labelled preview, so file issues rather than expecting a frozen API.

IBM ContextForge is the reference open-source MCP gateway: a registry, proxy and control plane that sits in front of any number of MCP servers, A2A agents and plain REST/gRPC APIs and exposes them to your AI client as one endpoint. The distinction that matters when you are choosing a gateway is that ContextForge is not only a router — it also virtualizes non-MCP services, wrapping an existing REST or gRPC API as a "virtual" MCP server with registered tools, prompts and resources, and it can discover gRPC methods automatically through the server reflection protocol. That means you can put a gateway in front of internal services that will never ship an MCP server of their own. Federation is the second half of the story: multiple MCP and REST backends are combined behind a single unified interface, with Redis-backed caching and multi-cluster federation for Kubernetes deployments. Transports covered are HTTP, JSON-RPC, WebSocket, SSE with configurable keepalive, stdio and streamable HTTP, and you can pin the MCP protocol version (for example 2025-11-25) rather than inheriting whatever a client negotiates. Governance is the reason most teams reach for a gateway at all, and ContextForge ships the usual controls in-band: authentication with user-scoped OAuth tokens and X-Upstream-Authorization passthrough, retries, rate limiting, and an admin UI for real-time management, configuration and log monitoring — including an airgapped deployment mode. Observability is OpenTelemetry-native, exporting to Phoenix, Jaeger, Zipkin or any OTLP backend, so tool calls are traceable the same way the rest of your services are. A plugin system (40+ plugins at time of writing) covers additional transports, protocols and integrations, and there is TOON compression plus OpenAI-compatible and Anthropic agent routing for the A2A side. It is itself a fully compliant MCP server, so anything that speaks MCP can talk to it. Install from PyPI as mcp-contextforge-gateway (1.0.6 current) or run the ghcr.io/ibm/mcp-context-forge container; Apache-2.0, Python/FastAPI/asyncio.

Agentgateway is a Rust proxy for agentic traffic that covers three planes most MCP gateways treat separately: agent-to-tool (MCP), agent-to-agent (A2A) and agent-to-LLM. If you are comparing gateways, that LLM-gateway half is the differentiator — it routes to OpenAI, Anthropic, Gemini, Bedrock and other providers behind one OpenAI-compatible API with budget and spend controls, prompt enrichment, load balancing and failover, so the same proxy that governs your MCP tool calls also governs model spend. On the MCP side it does tool federation across many servers, speaks stdio, HTTP, SSE and streamable HTTP, integrates OpenAPI services, and handles OAuth against upstream servers. The A2A side adds capability discovery, modality negotiation and task collaboration between agents. Security and policy are where a proxy earns its place in the path: JWT, API-key and OAuth authentication, fine-grained RBAC driven by a CEL policy engine, rate limiting, TLS, and OpenTelemetry metrics, logs and traces. Guardrails are multi-layered and pluggable — regex filters, OpenAI moderation, AWS Bedrock Guardrails, Google Model Armor, or your own webhook — which is the control most teams discover they need only after an agent has already been handed production tools. There is also inference routing for self-hosted models via the Kubernetes Inference Gateway extensions, making decisions on GPU utilization, KV cache state, LoRA adapters and queue depth. Two deployment shapes are documented and they are genuinely different products in practice: a standalone mode driven by flat YAML config with no Kubernetes controller, and a Kubernetes mode using the built-in controller and Gateway API — pick before you start, because the docs split at that fork. A built-in web UI lets you inspect agent-to-agent and agent-to-tool connections live. Apache-2.0, written in Rust, and under active development, so check the release notes against the feature you are relying on.

The Docker MCP Gateway is the engine underneath Docker Desktop's MCP Toolkit, shipped as the docker-mcp CLI plugin. Its premise is containment: every MCP server from the Docker MCP Catalog runs inside its own Docker container rather than as a bare npx or uvx process on your machine, and the npx/uvx servers that do run get minimal host privileges. Your AI clients then all connect to one gateway endpoint instead of each maintaining its own server list, which is what keeps VS Code, Cursor and Claude Desktop on an identical tool configuration. Servers are grouped into profiles, and a profile can pull from four different source types in the same config — catalog references (catalog://mcp/docker-mcp-catalog/github), OCI image references (docker://my-server:latest), MCP Registry URLs (registry.modelcontextprotocol.io/v0/servers/<id>) and local files (file://./server.yaml). Profiles are first-class objects: docker mcp profile create --name dev-tools --server ... --connect cursor creates one and wires it to a client in a single command, and profiles can be exported to YAML or pushed and pulled from OCI registries, so a team can version its tool set the way it versions images. Per-server configuration is set with docker mcp profile config <id> --set github.timeout=30. Secrets are the other reason to run this rather than raw stdio servers: API keys live in Docker Desktop's secrets management instead of environment variables in a JSON config file, and built-in OAuth flows handle servers that need token-based service connections. Dynamic discovery picks up tools, prompts and resources from running servers, and there is built-in logging and call tracing. Prerequisites are Docker Desktop 4.59+ with the MCP Toolkit feature enabled; the plugin can also run independently of Desktop — set DOCKER_MCP_IN_CONTAINER=1 to bypass the Desktop backend checks under WSL2, Docker CE or containerized environments, and enable profiles explicitly with docker mcp feature enable profiles, since that only auto-enables inside Desktop. MIT-licensed Go.

Obot is the governance layer an organization puts in front of its whole AI estate, and the MCP Gateway is one of two gateways inside it. The MCP Gateway gives every user a single governed entry point to every MCP server they are allowed to reach — it proxies servers whether Obot hosts them or they run somewhere else, and it can compose a new virtual MCP server out of selected tools drawn from several upstream servers, which is how you hand a team a five-tool surface instead of a two-hundred-tool one. Access is controlled per server and per tool, by user or by identity-provider group, and the gateway owns the credential problem: MCP OAuth flows, user-scoped and shared credentials, Kubernetes secret bindings, and token exchange all live in Obot rather than in a JSON file on a laptop. MCP and webhook filters can inspect, reject or modify requests and responses in flight. The second gateway is an LLM gateway presenting provider-compatible endpoints for OpenAI, Anthropic, Amazon Bedrock, Azure and generic Responses-compatible providers, with Model Access Policies deciding which models a given user can even see, plus recorded requests, token usage and estimated cost. Obot can also run servers itself: npx, uvx and containerized MCP servers execute as sandboxed Docker containers or Kubernetes workloads outside the main server process, with domain-based egress rules applied through a network-policy provider. Its MCP and Skills registries are Git-backed curated catalogs exposed through the standard MCP Registry API, so approved servers reach users and clients through a supported discovery path rather than a wiki page. A companion project, Obot Sentry, extends the audit trail onto user devices — it enrolls machines, inventories installed AI clients and servers, and installs hooks for Claude Code, Codex, Cursor and VS Code so local tool calls land in the same log as gateway traffic; device management is beta. Written in Go, MIT-licensed. The Docker quick start mounts the host Docker socket so Obot can launch hosted servers as sibling containers, which the project explicitly limits to development, evaluation or trusted single-tenant use — production installs go through the Kubernetes deployment with external PostgreSQL.

mcpo solves a different problem from the other gateways in this category: instead of merging many MCP servers into one MCP endpoint, it converts an MCP server into a plain OpenAPI HTTP service. You point it at a server command and it exposes that server's tools as REST endpoints with an auto-generated OpenAPI schema and interactive docs at /docs, which means anything that already consumes OpenAPI — agent frameworks, SDK codegen, an existing API gateway, Open WebUI itself — can call MCP tools without ever speaking the protocol. The argument the project makes for this is about the transport rather than the protocol: most MCP servers speak raw stdio, which is awkward to secure, hard to put behind standard infrastructure, and comes with no built-in docs, auth or error handling, all of which you get for free once the surface is HTTP. Usage is a single line, uvx mcpo --port 8000 --api-key "top-secret" -- your_mcp_server_command, with pip install mcpo and a ghcr.io/open-webui/mcpo:main container as alternatives. Remote servers work too — pass --server-type sse or --server-type streamable-http with the endpoint URL, and --header '{"Authorization": "Bearer token"}' for anything that needs credentials. A config file in Claude Desktop's mcpServers format serves several tools at once, each mounted on its own route with its own schema and docs page (/memory, /memory/docs, /time, /time/docs), and --hot-reload watches that file so servers can be added or changed without downtime; individual tools can be suppressed per server with disabledTools. --root-path lets it sit under a subpath behind a reverse proxy. For upstream servers requiring OAuth 2.1, mcpo defaults to dynamic client registration — usually just an oauth.server_url is needed — opening a browser on first connect, capturing the callback, and storing tokens under ~/.mcpo/tokens, with static client_metadata available for servers that do not support dynamic registration. Python 3.11+, MIT-licensed, from the Open WebUI team. Note the repository's last push was in May 2026, so it is stable rather than actively evolving.

MetaMCP aggregates any number of MCP servers into one unified MCP server, and because the aggregate is itself a compliant MCP server it plugs into any client without special support. The organising concept is the namespace: you group server configurations into a namespace, host that namespace as a single meta-server, and expose it at a public endpoint over SSE or streamable HTTP with auth in front. Switching which namespace an endpoint serves is one click, so a client config written once can be repointed at a different tool set without touching the client. Within a namespace you choose which tools to surface rather than inheriting everything upstream offers, and tool overrides and annotations let you rename or re-describe a tool so a model picks it correctly — useful when two upstream servers both ship a search. A middleware layer wraps the aggregated traffic for observability and security concerns. Server configs are ordinary Claude-Desktop-shaped JSON with STDIO, SSE and streamable-HTTP types, and secrets for stdio servers are managed as environment variables in MetaMCP rather than in client config files. A built-in inspector — effectively MCP Inspector with saved server configs — lets you test both individual upstream servers and your own MetaMCP endpoints from inside the app. Operationally it ships as a single Docker Compose stack: clone the repo, cp example.env .env, docker compose up -d. Watch two things there. It enforces a CORS policy against APP_URL, so if you change that variable the app is only reachable from that exact URL; and the Postgres volume name is global, so rename metamcp_postgres_data in docker-compose.yml if you already run another Postgres container. Authentication covers API keys and OpenID Connect against standard providers, with registration controls for enterprise deployments, plus per-endpoint MCP rate limiting. There is a cold-start cost when stdio servers are launched on demand — the docs cover baking them into a custom Dockerfile to avoid it. MIT-licensed TypeScript. The maintainer has publicly flagged review delays and now merges AI-assisted changes on the ai-dev branch, so test an image built from that branch before relying on it; a community fork exists.

This is the smallest useful thing in the gateway category: a single Go binary that aggregates several MCP servers behind one HTTP entrypoint, with no database, no web UI and no control plane to operate. Tools, prompts and resources from every configured downstream server are merged and served over SSE or streamable HTTP, and downstream clients can be stdio, sse or streamable-http, so it is also the standard way to put a stdio-only server on the network for clients that cannot spawn processes. The feature worth choosing it for is OAuth client support: you authorize once against a downstream server that requires an interactive OAuth flow — Notion is the example the project gives — and the proxy then holds and refreshes that token on behalf of every caller, which removes the per-user browser dance that otherwise blocks headless and shared deployments. Configuration is a single JSON file; an online converter at tbxark.github.io/mcp-proxy turns an existing Claude Desktop config into the proxy's format, so migrating an existing client setup takes a paste rather than a rewrite. Three install paths are documented: build from source with make build, go install github.com/tbxark/mcp-proxy@latest, or the container at ghcr.io/tbxark/mcp-proxy:latest, which is the one most people want because the image bundles npx and uvx and can therefore launch Node and Python MCP servers itself. The container accepts either a mounted config file or a remote config URL passed with --config, which makes a fleet of proxies configurable from one hosted file. Docker Compose examples are in the deployment docs, and command-line flags, endpoint paths and auth examples in the usage docs. MIT-licensed, inspired by adamwattis/mcp-proxy-server. Deliberately not what MetaMCP, ContextForge or Obot are — there is no RBAC, no audit store and no namespace model here, so if you need governance rather than plumbing, start with one of those instead.

mcp-remote is the piece of glue that appears in more MCP install instructions than almost any other package, and it exists because of one gap: most MCP clients still only speak stdio, while a growing number of vendors now ship remote servers behind OAuth. Point a client at a remote URL through mcp-remote and it runs the full authorization flow for you — opening a browser once, storing the tokens under ~/.mcp-auth, refreshing them silently afterwards — then presents the remote server to the client as an ordinary local stdio process. That is why the config snippets published by Linear, Cloudflare, Intercom, PostHog, Render, Webflow, Browserbase and Tavily all fall back to npx mcp-remote <url> for clients without native HTTP transport. Beyond auth it handles the practical details of that bridge: --header for static bearer tokens or custom headers when you want to skip OAuth entirely, --resource to keep separate OAuth sessions for two tenants of the same vendor (the documented Atlassian case), a positional port argument and --host to control where the OAuth callback lands, --allow-http for plaintext services inside a trusted network, --enable-proxy to honour HTTP_PROXY/HTTPS_PROXY/NO_PROXY, and --debug to write a verbose auth trace per server hash. Two known client bugs are worth reading the README for before you file an issue: Cursor and Claude Desktop on Windows mangle spaces inside args, so headers should be written without a space after the colon and the value moved into an env var. The author frames the project as an explicitly temporary proof of concept — the intent is that you delete it once your client supports remote authorized servers natively — and the npm package has sat at 0.1.38 since February 2026, so treat it as stable and widely relied upon rather than actively developed.

sparfenyuk/mcp-proxy is the most-starred transport bridge in the ecosystem and the one to reach for when the bridging job runs in both directions. Mode one is stdio-to-SSE/Streamable-HTTP: the client launches mcp-proxy as an ordinary local command, passes a remote endpoint URL as the first argument, and the proxy relays the session onwards — the classic way to attach Claude Desktop to a server it cannot reach natively. Add --transport=streamablehttp when the upstream uses the newer transport, --headers Authorization "Bearer ..." (or the API_ACCESS_TOKEN environment variable) for static auth, and --client-id / --client-secret / --token-url when the upstream expects an OAuth2 client-credentials exchange rather than a static token — that last one is the feature most of the alternatives do not have. Mode two runs the other way: give it --sse-port and a command after the -- separator, and it spawns a local stdio server and exposes it over the network, which is how you put an npx- or uvx-only server behind a URL that other machines, containers or hosted agents can reach. Named servers let one process front several stdio commands on distinct paths, so a single container can publish a whole toolset. It installs from PyPI as mcp-proxy (0.12.0, Python 3.10+), runs equally well via uvx, and ships a container image documented for extension — the README shows layering your own uvx/npx dependencies into it and a Docker Compose setup, which is the shape most self-hosted deployments end up using. Actively maintained, MIT licensed, last pushed July 2026.

punkpeye/mcp-proxy is the TypeScript counterpart to the Python proxy of the same name, and it solves the single direction that matters most in deployment: taking a stdio-only MCP server and publishing it over streamable HTTP and SSE. Running npx mcp-proxy --port 8080 -- tsx server.js starts the wrapped command and serves it at /mcp for streamable HTTP and /sse for SSE simultaneously; --server sse or --server stream narrows it to one, and --endpoint, --sseEndpoint and --streamEndpoint move the paths. The details that decide whether it fits your deployment are the session semantics and the timeouts: --stateless spins up a fresh server instance per request instead of holding a session, which is what you want behind a load balancer or in a serverless container, while the default stateful mode keeps a session per client. --connectionTimeout (60s default) covers the initial handshake with the wrapped server and --requestTimeout (5 minutes default) covers individual calls — both are worth raising for servers that do slow work. CORS is on by default with configurable origins, which removes the most common first-run failure when a browser-based client connects. Its real significance is that it is not just a CLI: this is the transport layer FastMCP uses to offer streamable HTTP and SSE, so a large number of TypeScript MCP servers already run this code without their authors calling it a proxy. Published on npm as mcp-proxy (6.5.7), MIT licensed, pushed the same day this listing was verified.

Supergateway converts an MCP server between every transport pair anyone actually asks for, in one command and with no config file. Running npx -y supergateway --stdio "uvx mcp-server-git" exposes a stdio server over SSE on port 8000; swapping --outputTransport streamableHttp publishes it at /mcp instead, --outputTransport ws publishes a WebSocket endpoint, and pointing --sse or --streamableHttp at a remote URL runs the bridge backwards, presenting a hosted server to a stdio-only client. Stateful mode with --sessionTimeout is available for streamable HTTP when you need session continuity, and stateless is the default. The operational flags are the reason it shows up in so many container deployments: --cors accepts a bare flag for any origin, explicit origins, or a regex; --healthEndpoint /healthz registers liveness paths for an orchestrator; --header can be repeated for arbitrary headers and --oauth2Bearer sets an Authorization header in one argument; --logLevel none keeps a noisy bridge out of your logs. WebSocket output is the genuinely distinguishing capability here — the other proxies in this category cover stdio, SSE and streamable HTTP but not WS. One caveat to weigh before you standardise on it: the repository was last pushed in October 2025 and npm has sat at 3.4.3 since, so it predates parts of the current transport guidance and will not pick up spec changes. It is stable and still widely used, but for a new deployment that needs ongoing maintenance the Python and TypeScript mcp-proxy projects are the actively developed alternatives.

MCP Proxy for AWS is Amazon's answer to an authentication mismatch rather than a transport one. The MCP specification standardises on OAuth, but MCP servers hosted on AWS — Bedrock AgentCore endpoints in particular — can be secured with AWS IAM and SigV4 request signing, which no ordinary MCP client knows how to produce. This package sits between the two: it picks up whatever credentials your environment already resolves (an AWS CLI profile, environment variables, or an attached IAM role), signs every outbound MCP request with SigV4, and presents the remote AWS-hosted server to the client as a local stdio server. The proxy path is a one-liner — uvx mcp-proxy-for-aws@1.6.4 followed by the SigV4 MCP endpoint URL — and AWS recommends pinning the version rather than tracking @latest, because minor releases have changed behaviour. A Docker image is published to the public ECR gallery at public.ecr.aws/mcp-proxy-for-aws for container deployments, and the repository can be run directly with uv run for local development. The second mode is the one worth knowing about if you are not using a desktop client at all: the same package is importable as a Python library, so LangChain, LlamaIndex and Strands Agents applications can open an authenticated session against an IAM-secured MCP server and manage its lifecycle in code, with no proxy process and no hand-written signing logic. Requires Python 3.10 or newer (below 3.15), Apache-2.0 licensed, and maintained directly by AWS — it was pushed the same day this listing was verified.