Cloud MCP Servers

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

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`.

Supabase MCP Server connects Cursor, Claude Code, Claude Desktop, Windsurf and other MCP clients to a Supabase project, and the first thing to know is that the personal access token setup most guides still describe is gone. Supabase now runs a hosted server at https://mcp.supabase.com/mcp using OAuth 2.1 with dynamic client registration — you add the URL, your client opens a browser, you pick the organization, and there is no PAT to mint or rotate. For Claude Code that is `claude mcp add --scope project --transport http supabase "https://mcp.supabase.com/mcp"` followed by `/mcp` in a plain terminal (not the IDE extension) to run the auth flow. Three URL query parameters do the real configuration work: `read_only=true` runs every statement as a read-only Postgres role, `project_ref=<id>` scopes the server to one project and drops the account-management tools entirely, and `features=` selects the tool groups. Those groups are database (list_tables, list_extensions, list_migrations, apply_migration, execute_sql), debugging (get_logs across API/Postgres/Edge Functions/Auth/Storage/Realtime, plus get_advisors for security and performance findings), development (get_project_url, get_publishable_keys, generate_typescript_types), Edge Functions (list, get, deploy), account management, docs search, experimental branching on paid plans, and storage — storage is the one group disabled by default. Running Supabase locally with the CLI exposes a reduced server at http://localhost:54321/mcp with no OAuth; self-hosted installs are similar. The npm package `@supabase/mcp-server-supabase` still exists for stdio clients and also exports `createToolSchemas()` so Vercel AI SDK users get typed tool inputs and outputs. Read Supabase's security best-practices page before pointing this at anything with production data — the mutating tools are real.

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 E2B MCP Server connects Claude Desktop and other MCP clients to E2B's cloud-hosted code sandboxes, giving an AI assistant a safe, isolated place to actually execute code instead of only reasoning about it. Each sandbox is a full Firecracker microVM with a real filesystem, package manager, and network access, so an agent can install dependencies, run scripts in Python, JavaScript, or other languages, read back stdout/stderr/exceptions, and iterate on failures the same way a human developer would in a REPL — a strong fit for data-analysis agents, coding assistants that need to verify generated code actually runs, and any workflow where letting the LLM execute arbitrary shell commands directly on the host would be unsafe. The server ships in two editions in the same repo: a JavaScript/Node package and a Python package, both wrapping the underlying E2B SDK and code-interpreter API. Install via `npx -y @e2b/mcp-server` (Node 18+) or the equivalent Python entry point, then set an E2B_API_KEY environment variable from the E2B dashboard; a Smithery one-click installer (`npx @smithery/cli install e2b --client claude`) is also documented. IMPORTANT: this repository is explicitly marked deprecated/no-longer-actively-maintained by E2B (last meaningful update several months ago) — it still installs and runs, and remains the highest-starred E2B-authored MCP entry point, but teams building new integrations should check E2B's current docs for whether a newer first-party server or their Code Interpreter SDK directly is now the recommended path before committing to long-term production use.

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.

Unofficial Home Assistant MCP server with 2,000+ stars — control lights, switches, climate, locks, media players, and automations via natural language. Runs as HA add-on or standalone. Full entity state read/write, service calls, and history queries.

Google's open-source MCP Toolbox for Databases — multi-database MCP server supporting AlloyDB, Cloud SQL, Spanner, BigQuery, PostgreSQL, MySQL, and more. Enterprise-grade connection pooling, auth, and query tools for production AI database access.

Token-efficient MCP server for the entire Cloudflare API — 2,500+ endpoints in ~1K tokens via dynamic OpenAPI-driven tool generation. Covers DNS, Workers, R2, Zero Trust, Firewall, Images, Stream, Vectorize, Access, and every other Cloudflare product through two unified tools: search() and execute().

The Neon MCP Server (neondatabase/mcp-server-neon) is Neon's official, open-source bridge between natural language and the Neon serverless Postgres platform. It translates conversational requests into Neon API and SQL calls, letting Claude, Cursor, VS Code, and other MCP clients create projects and branches, run queries, inspect schemas, and perform database migrations without hand-writing SQL or hitting the API directly. A standout capability is migration support built on Neon's branching: the server can spin up a branch, apply and test a schema change there, and only then merge it — so an assistant can safely run "add a created_at column to the users table" against an isolated copy first. The easiest setup is the remote hosted server at https://mcp.neon.tech/mcp, which supports both OAuth (no API key to manage) and API-key auth via the Authorization header; run `npx neon@latest init` for one-command configuration of Cursor, VS Code (Copilot), and Claude Code, or `npx add-mcp https://mcp.neon.tech/mcp` to register it across all detected editors. Requires Node.js 18+ and a free Neon account; if IP Allow is enabled, whitelist the mcp.neon.tech static IPs. Neon explicitly scopes this server to local development and IDE workflows — its README warns against production use since natural-language commands can execute powerful, irreversible database operations, so always review actions before authorizing them.

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.

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.

Retrieval from AWS Knowledge Base using Bedrock Agent Runtime.

Access to key Azure services and tools like Azure Storage, Cosmos DB, the Azure CLI, and more.

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 Firebase MCP Server ships as part of the official firebase-tools CLI and gives AI coding tools direct access to your Firebase projects and app codebase. It works with any MCP client, including Firebase Studio, Gemini CLI, Claude Code, Cursor, VS Code Copilot, Windsurf, and Cline. Tool coverage spans project and app management (create, list, and configure Firebase projects and apps); Firebase Authentication user administration; Cloud Firestore and Firebase Data Connect querying, reading, and writing; security-rules retrieval and validation for Firestore, Cloud Storage, and Realtime Database; Firebase Cloud Messaging push notifications; Crashlytics crash-report and issue debugging; App Hosting backend monitoring and log retrieval; Realtime Database read/write; Cloud Functions log queries; and Remote Config template management. No separate install is required — it runs through the existing firebase-tools binary via npx -y firebase-tools@latest mcp, and can be added to Claude Code either as a plugin (claude plugin marketplace add firebase/firebase-tools) or manually with claude mcp add firebase npx -- -y firebase-tools@latest mcp. Because it operates against live Firebase projects, treat it like any tool with write access to production data — review generated security-rules and Firestore write operations before approving them. Labeled "experimental" by the Firebase team as the tool surface continues to expand.

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.

DigitalOcean MCP Server gives Claude, Cursor, and other MCP clients direct access to your DigitalOcean cloud infrastructure. The actively maintained community server lives at digitalocean-labs/mcp-digitalocean, built on the official godo Go SDK and the mark3labs/mcp-go framework — the earlier @digitalocean/mcp npm package under the digitalocean org has been archived in favor of this project. It exposes tools for managing Droplets, Kubernetes clusters, App Platform deployments, Spaces object storage, databases, VPCs, load balancers, and DNS records, letting an AI assistant provision, inspect, and tear down cloud resources through natural-language prompts instead of the doctl CLI or web console. Authentication uses a DigitalOcean Personal Access Token supplied via the DIGITALOCEAN_API_TOKEN environment variable — the README explicitly warns against hardcoding it into client config files, since committing a token to GitHub triggers automatic revocation. Typical workflows include deploying an app from a GitHub repo, redeploying with the latest changes, tailing logs, restarting components, and auditing which regions and droplet sizes are available before provisioning. Because it operates directly against billable cloud infrastructure, DigitalOcean recommends scoping tokens narrowly and reviewing any destructive action (deleting droplets, dropping databases) before confirming it in your MCP client.

Introspect and query your apps deployed to Convex.

Fast and secure execution of your AI generated code with Daytona sandboxes.

Replit ships an official, vendor-hosted MCP server that lets an external client create, update, and manage full-stack applications on Replit through natural language. It is hosted at https://replit-mcp.com/server/mcp over Streamable HTTP with OAuth 2.1 plus PKCE, handled automatically by MCP clients and SDKs, so there is no package to install and no API key to paste; that also means there is no public source repository, which is why this listing carries no GitHub link. Under the hood the server is a front door to Replit Agent, so a single tool call turns a prompt into a real, running, published app rather than a code snippet. The public tool surface is deliberately small. create_app_from_prompt takes an appDescription plus an app_stack enum (react_website, mobile_app, design, slides, animation, data_visualization, 3d_game, document, or spreadsheet) and optional userSpecifiedAppName, userQuotes, and attachmentSummary; it returns a replId, a replUrl, and a turnId while Agent keeps building asynchronously in the background. update_app_using_prompt takes that replId plus a changeDescription to add features, fix bugs, or iterate on an existing app. ask_question runs Agent in discussion mode against a replId so you can check build status, ask about the tech stack, or relay a question without modifying any files. Add it to Claude Code with claude mcp add --transport http replit https://replit-mcp.com/server/mcp. Builders need a Replit account on any tier including Free. The server is documented as beta, so tools and behavior may change.

Cloud development environments.

Gitpod does not publish a Model Context Protocol server — a `gitpod-io/mcp-server` repo does not exist, and a GitHub search for "gitpod mcp" turns up nothing beyond an unrelated Minecraft joke repo. Gitpod's own product direction has moved toward Gitpod Flex and CDE-as-infrastructure rather than shipping an MCP tool surface, and unlike GitHub Codespaces (which has an official codespaces-mcp) no community project has stepped in to fill the gap either. If you want an AI agent to provision or control a Gitpod workspace over MCP, no first-party or notable community server currently exists for that — this entry is kept for search/reference purposes and will be updated if Gitpod or the community ships one. In the meantime, the closest cloud-dev-environment MCP options are the CodeSandbox and StackBlitz servers listed in this directory, or GitHub Codespaces MCP for a GitHub-native workflow.

An MCP server for reading files and project structure from StackBlitz projects, built by sxzz. Note this is a community project, not an official StackBlitz release — the previously-listed `stackblitz/mcp-server` repo does not exist. It exposes four tools: `resolve_project` looks up a StackBlitz project by ID or full stackblitz.com/edit/ URL and returns metadata (title, description, preset, visibility, file count); `list_files` renders the project's files as an ASCII tree, optionally filtered by a path prefix; `read_file` pulls the raw contents of a single file by path; and `search_files` runs a text or regex search across the project with case-sensitivity and result-limit options. It also exposes two MCP resource URI patterns — `stackblitz://{projectId}/tree` for the file tree and `stackblitz://{projectId}/files/{path}` for individual file contents — so an agent can browse a StackBlitz reproduction repo the same way it would a local directory. The server is read-only (no file writing or sandbox execution) and requires no API key, since it works against StackBlitz's public project data. It's aimed at the common "someone shared a StackBlitz repro link, now debug it" workflow: paste the project ID into Claude/Cursor and let the agent inspect the code directly instead of you copy-pasting files by hand. Install via npm as a global CLI (`stackblitz-mcp`) and wire it into any MCP-compatible client's config.

A Model Context Protocol server that exposes the official CodeSandbox SDK as MCP tools for AI agents, built by techlibs. This is a community project (not an official CodeSandbox release) — the previously-listed `codesandbox/mcp-server` repo does not exist. Unlike simpler read-only sandbox browsers, this server is fully stateless and covers the entire sandbox lifecycle: `createSandbox` (optionally forking a template, with privacy/title/tags/VM-tier/hibernation settings), `resumeSandbox` and `hibernateSandbox` for VM power state, `getSandboxInfo` for metadata without starting the VM, and `updateSandbox` for changing VM tier (Pico through XLarge) or hibernation timeout. File and shell access go through per-call sessions — `createSession`/`resumeSession` (with read/write permission, environment variables, and optional Git identity for commits) back `readFile`, `readdir`, and `writeFile`, all of which connect per call using a sandboxId + sessionId rather than holding open server-side state. A `--read-only` CLI flag disables all mutating tools and defaults new sessions to read permission, which is the recommended mode for agents you don't fully trust with a live VM. Requires a `CODESANDBOX_API_TOKEN` (or `CSB_API_KEY`) from your CodeSandbox account and Node.js 18+. Run via `npx @techlibs/codesandbox-mcp` in any MCP client config; the CLI binary is `mcp-server-codesandbox`.

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

Navigate your Aiven projects and interact with PostgreSQL, Kafka, ClickHouse, OpenSearch.

Query and manage AWS DynamoDB tables using natural language. Supports single-table design patterns, GSIs, and batch operations.

Distributed SQL database MCP server. Execute transactions, manage schemas, and query CockroachDB with full PostgreSQL-compatible SQL.

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.

Interact with Amazon S3 buckets and objects. Upload, download, list, and manage files, configure bucket policies, and analyze storage costs. Repository corrected 3 August 2026: this listing pointed at aws/mcp-proxy-for-aws, which is AWS's SigV4 authentication proxy and not an S3 server at all, and carried that repo's star count. The closest real S3 server is aws-samples/sample-mcp-server-s3 (78 stars, MIT-0, Python), which exposes ListBuckets, ListObjectsV2 and GetObject as tools and additionally surfaces PDF documents as MCP resources, capped at 1,000 objects. It is sample code rather than a supported product and is not published to PyPI, so it has to be cloned and run with uv rather than installed with a one-liner; the command below is the documented local path. For production AWS access, AWS's maintained servers live in the awslabs/mcp monorepo.

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 Azure Blob Storage containers and blobs. Upload and download files, configure access tiers, manage lifecycle policies, and inspect metadata.

Access and manage Google Cloud Storage buckets and objects. Transfer files, configure IAM permissions, set retention policies, and analyze storage usage.

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.

Affordable cloud storage MCP for Backblaze B2. Manage buckets, upload/download files, configure lifecycle rules, and generate presigned URLs.

Manage BunnyCDN zones, storage, and video streaming. Purge cache, upload to bunny storage zones, manage pull zones, and analyze bandwidth usage.

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

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.

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

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

Access Google's Gemini and other AI models via Vertex AI. Fine-tune models, run batch predictions, and manage ML pipelines with enterprise-grade security.

Deploy and manage ML models on AWS SageMaker. Run inference on endpoints, manage training jobs, track experiments, and use SageMaker Studio capabilities.

Run Python functions in the cloud with Modal. Deploy serverless GPU workloads, schedule jobs, build ML pipelines, and access data lakes without infrastructure setup.

Cloud security platform MCP for Wiz. Query misconfigurations, vulnerabilities, and security risks across multi-cloud environments with natural language.

Cloud security analytics MCP for Lacework. Investigate threats, query behavioral anomalies, and analyze cloud activity across AWS, Azure, and GCP.

Real-time image processing and CDN MCP for Imgix. Transform images on-the-fly with URL-based parameters, generate responsive srcsets, and manage rendering pipelines.

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.

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

Serverless PostgreSQL with branching MCP for Neon. Create database branches for dev/test, auto-scale compute, and manage connection pooling for modern apps.

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.

Full-stack backend platform MCP server. Manage Appwrite databases, authentication, storage, and functions from your AI assistant. Create documents, manage users, and trigger serverless functions.

Edge SQLite database MCP server. Access Turso databases at the edge with sub-millisecond latency. Query, insert, and manage your Turso database instances — including multi-tenant group databases — from your AI assistant.

Particle platform MCP server for managing IoT devices and fleets. Flash firmware, read device variables, call functions, subscribe to events, and monitor Particle Photon/Argon/Boron devices via Particle Cloud API.

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 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.

High-throughput LLM inference via vLLM. Run PagedAttention-optimized serving for open-source models at production scale with continuous batching and streaming support.

Ethereum, IPFS, and Web3 infrastructure via Infura. Query mainnet and testnets, deploy contracts, store files on IPFS, and access 10+ blockchain networks through a single endpoint.

S3-compatible cloud object storage via Wasabi. Upload, download, list, and manage files across buckets at 80% less cost than AWS S3 — uses standard S3 API so fully compatible with S3 tools.

Distributed SQL database via TiDB Cloud. Run MySQL-compatible queries at scale, manage multi-region clusters, inspect execution plans, export data to S3, and access TiDB Serverless through the MCP integration.

Distributed messaging and streaming via Apache Pulsar. Produce and consume messages from topics, manage namespaces and tenants, inspect subscription backlogs, and configure retention and replication policies.

Query and manage Turso edge SQLite databases. Execute SQL queries, manage database replicas, handle schema migrations, and work with embedded SQLite at the edge.

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.

Connect to ThingsBoard IoT platform. Manage devices, read telemetry data, create dashboards, configure alarms, and automate IoT workflows. Supports both cloud and self-hosted deployments.

Interface with EMQX MQTT broker for IoT messaging. Publish and subscribe to topics, manage client connections, monitor broker stats, and configure access control lists for secure device communication.

Query Orca Security cloud security posture management. Retrieve risks, vulnerabilities, and misconfigurations across AWS, Azure, and GCP. Investigate attack paths, compliance status, and asset inventories.

Interface with Wiz cloud security platform. Query vulnerabilities, misconfigurations, and security issues across cloud infrastructure. Investigate risk graphs, compliance frameworks, and remediation priorities.

Manage HiveMQ enterprise MQTT broker. Monitor connected clients, subscriptions, and message throughput. Query retained messages, manage access control, and analyze broker performance metrics.

Interact with AWS IoT Core for device management and messaging. Manage thing registries, certificates, and policies. Publish and subscribe via MQTT, query device shadows, and monitor IoT rules and jobs.

Manage Azure IoT Hub device fleet. Query device twins, send cloud-to-device messages, invoke direct methods, monitor telemetry routing, and manage IoT Hub endpoints and consumer groups.

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 Autodesk Build/PlanGrid construction document management via MCP. Access project blueprints, submittals, RFIs, punch list items, and daily reports. Track field issues, sync sheet revisions, manage attachments, and collaborate on construction documents across web and mobile.

Rockwell Automation FactoryTalk platform API — connect to industrial controllers, monitor production line data, analyze OEE metrics, and manage factory automation workflows.

Honeywell Forge industrial IoT platform API — access building and industrial asset data, energy consumption analytics, predictive maintenance insights, and connected worker data.

GE Digital Predix industrial IoT and analytics platform — connect industrial assets, analyze operational data, run predictive maintenance models, and monitor equipment health.

PTC Windchill product lifecycle management API — manage CAD files, BOMs, change orders, and ECOs. Access part revision history, manage document vaults, query product structure, and integrate engineering change workflows with ERP and manufacturing systems.

Dassault Systèmes 3DEXPERIENCE platform API — access CATIA models, manage ENOVIA PLM data, query SOLIDWORKS Manage PDM, retrieve simulation results from SIMULIA, and orchestrate collaborative engineering workflows on the 3DEXPERIENCE platform.

Airbyte open-source data integration platform API — manage 300+ connectors, trigger ELT sync jobs, monitor connection health, view sync logs, and orchestrate data pipeline runs between sources (SaaS, databases, APIs) and destinations (warehouses, lakes).

BentoML model serving and deployment MCP — build and deploy ML services, manage Bentos and runners, scale inference endpoints, monitor serving performance, and package models for production with any framework.

YugabyteDB distributed SQL database MCP — run queries on PostgreSQL-compatible distributed clusters, manage universes, inspect node health, scale clusters, and leverage YSQL and YCQL APIs for multi-region deployments.

Sigma Computing cloud BI MCP — query live data from your cloud warehouse via Sigma workbooks, retrieve element values and filters, access shared datasets, explore pivot tables and charts, and embed governed analytics into AI workflows.

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.

Cloudflare Stream video delivery MCP — upload and manage videos, query playback analytics and viewer counts, generate signed URLs, manage live streams, configure watermarks and encoding settings, and retrieve video processing status at scale.

Cumulocity IoT platform MCP — query connected device inventory, retrieve sensor measurements and events, manage device groups and configurations, access real-time telemetry streams, trigger remote operations on devices, and monitor alarm states across your IoT network.

AWS HealthLake FHIR MCP server — access and manage HIPAA-eligible FHIR R4 datastores on Amazon HealthLake. Query patients, conditions, medications, observations, and clinical documents. Auto-discovers datastores, 11 FHIR tools built-in.

Espressif's official ESP RainMaker IoT platform MCP server — control and monitor ESP32/ESP8266 devices via the RainMaker cloud. Query device parameters, send commands, manage device groups, access time-series sensor data, and trigger automations.

Official Redis Cloud MCP server — create, configure, and manage Redis Cloud databases via natural language. Manage subscriptions, databases, security rules, and access control. Built by Redis to bring AI-native control to the Redis Cloud platform. It is a control-plane server, not a data server: it manages subscriptions, databases, payment methods, modules, regions and long-running tasks through the Redis Cloud API, and cannot read or write keys inside a database — that is the separate redis/mcp-redis server. There is no published npm package; the documented setup is to clone the repository, run npm run build, and point your client at node dist/index.js with API_KEY and SECRET_KEY set to Redis Cloud API credentials.

Extended Home Assistant MCP server with advanced automation support — control entities, create automations, manage scripts, query energy usage, access history, and interface with the HA event bus. Supports HA Long-Lived Access Tokens and REST API.

Official Microsoft Sentinel SIEM MCP server. Query security incidents, hunt threats using KQL, explore data tables, retrieve alerts, and automate security operations workflows directly from AI agents. Connects to Microsoft Sentinel's data lake via natural language.

Local-first MCP server for Microsoft Fabric analytics platform. Access lakehouses, warehouses, pipelines, Power BI reports, and Spark notebooks via AI agents. Query item definitions, manage workspaces, and leverage Fabric REST APIs for unified analytics.

Official MCP server for Microsoft Dev Box. Enable natural language interactions for developer-focused operations — manage Dev Boxes, configure environments, handle pools, start/stop/create/delete dev environments, and access development portal APIs.

Official MCP server for Azure AI Foundry (formerly Azure ML Studio). Access models, knowledge bases, evaluations, deployments, and experiments. Manage AI model lifecycle, fine-tuning jobs, and endpoint deployments across Azure AI services.

MCP server to query Azure Resource Graph for AI-powered infrastructure analysis. Retrieve and filter information about Azure resources across subscriptions using KQL, manage ARM deployments, and explore resource relationships with natural language queries.

Cloudflare Workers AI inference platform via MCP. Run 50+ AI models at the edge including LLaMA, Mistral, Stable Diffusion, and Whisper. Access text generation, embeddings, image classification, translation, and speech-to-text — all serverless with no GPU setup required.

DJI drone telemetry and control via MCP. Access real-time flight telemetry, GPS coordinates, altitude, battery level, and camera gimbal state. Retrieve flight logs, manage media files, check geofencing zones, and control camera settings for DJI drones via the DJI Cloud API.

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.

IBM FileNet Content Manager integration via MCP. Access and manage enterprise content repositories, extract document properties, run AI document insight analysis, classify content, and interact with IBM's enterprise content management platform.

IBM watsonx.data lakehouse integration via MCP. Query document libraries, run natural language analytics against IBM's data lakehouse platform, retrieve structured data using the watsonx.data AI-powered retrieval service, and interact with enterprise data stored in watsonx.

IBM Business Automation Workflow (BAW) integration via MCP. Connect AI agents to IBM BAW process management, automate business workflows, query process instances and task lists, manage case management, and integrate AI into enterprise BPM workflows.

IBM Cloud Object Storage integration via MCP with 37 comprehensive tools. Supports stdio and HTTP transport modes. Upload, download, list, and manage objects and buckets in IBM COS. Seamlessly integrates with WatsonX Orchestrate and agent frameworks for enterprise cloud storage workflows.

IBM MDM (Master Data Management) integration via MCP. Search and retrieve master data records, manage customer/product/supplier MDM entities, query cross-reference data, and perform entity resolution operations via Claude and other AI assistants.

IBM OpenPages Governance, Risk, and Compliance (GRC) platform integration via MCP. Query risk assessments, manage controls and issues, access compliance frameworks, interact with GRC workflows, and integrate AI-assisted risk analysis into enterprise governance processes.

IBM Data Intelligence unified MCP gateway for the watsonx ecosystem. Exposes and manages MCP tools across microservices in IBM's Data Intelligence platform, enabling AI agents to access data catalogs, lineage information, quality metrics, and enterprise data governance tools from a single endpoint.

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.

An MCP server for SAP ABAP Development Tools (ADT) that gives an assistant controlled access to a real ABAP repository — where-used lists, object metadata, structure and dependency navigation, plus full CRUD on classes, interfaces, function groups and modules, programs, DDIC objects and CDS/view/service artifacts, all validated through ADT flows rather than raw table writes. **There are two unrelated projects called `mcp-abap-adt`, and the npm name belongs to the other one.** The plain `mcp-abap-adt` package on npm is mario-andreschak's server (165 stars, beginner-focused, read-oriented, published to the official MCP registry as `io.github.mario-andreschak/mcp-abap-adt`) — a fine project, but not the one documented here. The server on this page is fr0ster/mcp-abap-adt, published under its own scope as **`@mcp-abap-adt/core`** (8.x, actively pushed), with a companion client configurator at `@mcp-abap-adt/configurator` (`mcp-conf --client cline --name abap --mcp TRIAL`) that writes the JSON/TOML config for you. Running `npx mcp-abap-adt` therefore installs a different codebase with a different auth model, which is the single most common way this listing gets used wrong. What distinguishes fr0ster's build is coverage of enterprise auth and topology: **JWT/XSUAA**, RFC, and destination-based **service keys**, where a "destination" is simply the filename of a service key you drop into `~/.config/mcp-abap-adt/service-keys/<name>.json` and select with `--mcp=<destination>` — so one install can address several systems. It supports On-Premise ECC/S/4HANA, ABAP Cloud on BTP, and legacy systems below BASIS 7.50, over stdio, HTTP, or SSE transports. The maintainer frames it as AI-assisted pair programming, not autopilot: it can create and delete real repository objects, so give it a development system and a developer key you would be comfortable handing to a new hire.

Salesforce Data 360 MCP server (Developer Preview, May 2026). Access unified customer data across Salesforce clouds, query Data Cloud segments and profiles, run identity resolution lookups, retrieve calculated insights, and connect AI agents to Salesforce's real-time customer data platform.

Salesforce's managed remote MCP servers that connect AI assistants (Claude, ChatGPT, Copilot) securely to your Salesforce logic and assets. Access Apex classes, Flows, metadata, SOSL search, and business logic without deploying local infrastructure. OAuth-authenticated and runs on Salesforce's own infrastructure.

EPLAN Electric P8 and EEC PRO 2026 automation via MCP. Drive EPLAN P8 directly from a local MCP server using AI-assisted script generation. Includes a documentation scraper and local RAG indexer for EEC Pro, plus remote MCP servers on Cloudflare Workers exposing indexed electrical engineering documentation via semantic search.

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.

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.

Nhost open-source Firebase alternative MCP server. Interact with Hasura GraphQL APIs, authentication, storage, and serverless functions on your Nhost backend.

Back4App managed Parse Server platform MCP integration. Query and mutate Parse objects, manage users, and trigger cloud functions on your Back4App backend.

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

A dedicated Cloudflare D1 MCP server could not be confirmed to exist. Cloudflare publishes a suite of official MCP servers at cloudflare/mcp-server-cloudflare, but as of the 2026-08-18 check that repository contains no D1 application and the d1.mcp.cloudflare.com endpoint does not resolve. The npm package this entry previously advertised has never been published, and the repository it linked was cloudflare/workers-mcp, a different product. The closest working options are the official Workers Bindings server, which reaches D1 through a Worker binding, or a small community project such as semanticintent/semantic-d1-mcp — neither is a Cloudflare-published D1 server. This entry is kept unresolved rather than deleted so the claim is on the record and can be corrected the moment Cloudflare ships one.

Manage GoDaddy domains, DNS records, and SSL certificates via the GoDaddy REST API.

Query and manage Namecheap domains, DNS zones, and WHOIS information through the Namecheap API.

Manage Porkbun domains, DNS records, and SSL certificates using the Porkbun API.

Manage AWS Route 53 hosted zones, DNS records, health checks, and routing policies.

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 AWS Cognito user pools, identity pools, users, groups, and app client configurations.

Query and manage Google Firestore collections, documents, subcollections, and real-time listeners.

Connect to Google AlloyDB for PostgreSQL-compatible queries, connection pooling, and cluster management.

Execute SQL queries and manage schemas on Google Cloud Spanner — global distributed relational database.

Read and write Google Cloud Bigtable rows, manage column families, and run time-series queries at scale.

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

Deploy and query ML models on Anyscale — run Ray Serve endpoints, scale LLM inference, and manage fine-tuned model deployments on Anyscale's managed Ray platform.

Deploy and call ML models on Baseten — invoke Truss-packaged models, manage deployments, monitor performance, and handle autoscaling for production AI workloads.

Manage GPU cloud workloads on RunPod — spin up serverless endpoints, manage pods, query GPU availability, and run custom AI inference at scale.

Build and train ML models on Lightning AI — launch cloud studios, run training jobs, deploy models, and manage compute via the Lightning AI platform API.

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.

Modal Labs serverless GPU cloud — deploy, run, and manage ML models and Python functions with instant scale.

Inferless serverless ML inference platform — deploy and call AI models with automatic GPU scaling.

Lepton AI cloud platform for deploying open-source LLMs and AI applications with simple Python APIs.

Cerebrium ML infrastructure platform — deploy GPU workloads and custom AI models serverlessly via MCP.

Microsoft PlayFab game backend — manage players, economy, matchmaking, leaderboards, and live game data.

Val Town serverless JavaScript platform — create, run, schedule, and manage vals (functions) from your AI assistant.

Deno Deploy edge serverless platform — deploy, manage, and monitor JavaScript/TypeScript functions globally.

Tuya IoT cloud platform — control Tuya/Smart Life compatible smart home devices, manage device status, scenes, and automations via the Tuya OpenAPI.

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

Connect to AWS IoT Core for device management, MQTT messaging, rules engine, and IoT Analytics.

Manage Azure IoT Hub devices, digital twins, and telemetry streams for enterprise IoT applications.

Interface with Google Cloud IoT Core and Pub/Sub for device registry, telemetry, and IoT data pipelines.

Interact with Ray clusters for distributed ML training, hyperparameter tuning, data processing, and AI serving at scale.

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

Access AWS Bedrock foundation models — Titan, Jurassic, Stable Diffusion, and more — through AI agent workflows without API key management.

No maintained, adopted MCP server for Apache HBase exists as of August 2026. What is out there: CDataSoftware/apache-hbase-mcp-server-by-cdata, a read-only Java connector that reaches HBase through CData's JDBC driver (so it carries a commercial driver dependency, and it sits at zero stars), and j1187049781/phoenix-mcp-server, which targets Apache Phoenix — the SQL layer over HBase — rather than HBase directly, and is likewise unproven. Neither is something we can recommend as a default. If you need an assistant to query HBase now, the pragmatic path is usually Phoenix plus one of the mature generic SQL MCP servers rather than a bespoke HBase integration, since Phoenix presents HBase as JDBC-addressable tables that a general database server can already speak to. Worth knowing for context: the well-known Python client library for HBase, happybase, was marked unmaintained by its authors — it is a library, not an MCP server, and a catalog entry that links to it is describing the wrong kind of thing. This entry deliberately records no github_url until a real, maintained HBase MCP server appears.

Scale PostgreSQL horizontally with Citus — run distributed queries, shard management, and parallel analytics through AI-driven data workflows.

Query AWS HealthLake FHIR-compliant data lake for clinical analytics, population health management, ML-powered health insights, and HIPAA-eligible healthcare data storage.

Deploy and run Python functions on Modal serverless GPU infrastructure — model fine-tuning, batch inference, scheduled jobs, and web endpoints with pay-per-use GPU pricing.

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

Interact with Google Cloud Storage buckets — upload, download, list, copy, and delete objects, manage bucket policies and lifecycle rules, generate signed URLs, set CORS configurations, and monitor storage usage metrics.

Access Google Vertex AI ML platform — deploy and query models, run batch predictions, manage Vertex AI Feature Store and Model Registry, trigger AutoML training jobs, and integrate Vertex AI Search and Conversation APIs.

Administer Google Workspace organizations — manage users, groups, and organizational units, configure domain settings, monitor audit logs, handle device management, and automate onboarding and offboarding workflows via Admin SDK.

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.

Manage AWS IoT Greengrass edge deployments — list Greengrass groups and cores, deploy Lambda/component updates to edge devices, query shadow state, manage subscriptions and connectors, inspect component health via Greengrass API, and pull CloudWatch device metrics.

Access quantum hardware and simulators via Azure Quantum — submit jobs to IonQ, Quantinuum, and Pasqal backends, query workspace providers and target availability, retrieve job output data and histograms, manage Azure Quantum workspaces, access resource estimator outputs, and monitor credits and usage via Azure REST APIs.

Extract structured data from forms and documents using Azure AI Document Intelligence — analyze invoices, receipts, business cards, and custom forms; query pre-built model results; manage custom model training and labeling; retrieve layout analysis with tables and selection marks; and access key-value extraction via the Azure REST API.

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.

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.

Construction project management via Autodesk Construction Cloud API — access BIM 360 and ACC project data, retrieve RFIs, submittals, and issues, manage document control and sheet sets, query cost management data and budget tracking, access model coordination and clash detection results, retrieve daily logs and progress reports, manage project members and permissions, and integrate with Procore and scheduling tools.

Manage enterprise identity governance via SailPoint IdentityNow — query user identities and access entitlements, run access certification campaigns, manage provisioning policies, detect access anomalies and risky entitlements, trigger deprovisioning workflows, pull compliance reports for SOX and SOC 2 audits, manage role mining, and automate joiner-mover-leaver processes.

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.

Orchestrate cloud data transformation via Matillion ETL — manage jobs and pipelines, trigger transformation workflows, query job execution history and logs, manage environment configurations and variables, access component libraries for data transformation, handle API and database source connections, monitor pipeline performance, and build data engineering automation for Snowflake, Redshift, and BigQuery.

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.

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 Fastly CDN and edge cloud via the Fastly API — configure VCL services and backends, manage caching rules and purge cache by URL or tag, query real-time analytics for cache hit rates and origin response times, manage TLS certificates and domains, configure WAF rules, access edge compute Compute@Edge deployments, and pull geographic traffic distribution and bandwidth reports.

Manage Akamai CDN and cloud security via the Akamai APIs — configure property rules and caching behaviors, purge cached content, manage WAF and DDoS protection configurations, access real-time traffic analytics, handle edge logic and redirect rules, manage SSL/TLS certificates, query security event logs, manage Ion and Adaptive Acceleration settings, and pull performance insights.

Manage AWS CloudFront CDN distributions via the AWS SDK — create and configure distributions with custom origins, manage cache behaviors and TTL settings, invalidate cached objects by path pattern, configure WAF and Shield integrations, access real-time and historical traffic reports, manage origin access identities, configure geo-restriction, handle Lambda@Edge function associations, and monitor error rates.

Manage Azure CDN and Front Door via the Azure SDK — configure CDN profiles and endpoints, manage custom domains and HTTPS certificates, set caching rules and query string behaviors, purge cached content, configure WAF policies on Front Door, manage origin groups and routing rules, access CDN analytics and usage reports, handle geographic traffic management, and integrate CDN management into Azure DevOps pipelines.

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.

Saviynt MCP Server is the identity-governance vendor's official Model Context Protocol server for Saviynt Identity Cloud, announced 16 July 2025 and positioned by Saviynt as the first MCP server built specifically for identity security. It lets authorized AI agents and users query and act on identity data in plain language instead of through Saviynt's query builder or REST API. Typical asks it is designed for are the "who has access to what" class of question: the server correlates users, accounts, applications, roles and both fine-grained and coarse-grained entitlements across hybrid and multi-cloud estates and returns the relationship rather than a raw log dump. Beyond retrieval it can trigger governance workflows - access requests, access reviews, certifications and revocations - subject to Saviynt's own risk-based approval and delegated-decision policies, so an approval initiated from an LLM client still runs through the same policy engine as one initiated in the Saviynt UI. Saviynt documents it against Amazon Q, Claude, ChatGPT and Microsoft Copilot as client applications. Distribution is the unusual part and worth knowing before you plan an install: Saviynt shipped as an AWS launch partner for the AI Agents and Tools category in AWS Marketplace, and the Marketplace listing (prodview-bv43ycjnfwmby) is the documented deployment path. There is no public source repository - GitHub search returns only unaffiliated community experiments such as aalmero/saviynt-mcp and oceanroveraus/saviynt-mcp-server, the Saviynt org publishes no MCP repo, and npm has no saviynt-mcp or @saviynt scoped package - so no install command is listed here rather than inventing one. Deployment requires an existing Saviynt Identity Cloud tenant; the server is an add-on to that platform, not a standalone tool. Saviynt also publishes a Model Context Protocol Server Solution Guide PDF covering the architecture, and notes integration with adjacent IAM, ITSM and analytics systems over its hardened REST APIs and webhooks.

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

Query data lakes and lakehouses via Dremio's SQL query engine — run Dremio SQL queries across S3, Azure ADLS, and GCS data sources, reflect and accelerate queries with Dremio Reflections, manage virtual datasets and spaces, access Apache Arrow Flight for fast query results, catalogue and tag data sources, and power AI-driven analytics over petabyte-scale lake storage.

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.

Extract text and structured data from documents using AWS Textract — analyze PDFs and images to detect text, tables, forms, and key-value pairs, process multi-page documents asynchronously, access signature detection and expense analysis, retrieve bounding box coordinates, query lending and identity document models, and build intelligent document processing pipelines on AWS infrastructure.

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.

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.