基础设施管理 MCP 服务器

Planton MCP Server

A stateless MCP server that connects AI-powered IDEs to Planton. It translates MCP tool calls and resource reads into gRPC requests against the Planton backend, letting Cursor, Claude Desktop, VS Code, Windsurf, and any MCP-compliant client deploy and manage infrastructure on every cloud in Planton's catalog without leaving the editor -- from discovering organizations and environments, through applying, listing and destroying Infra Components, to following every change as an Infra Job.

flowchart TD
    IDE["AI IDE\n(Cursor / Claude Desktop / VS Code / Windsurf)"]
    MCP["planton-mcp-server\n(stdio or Streamable HTTP)"]
    Backend["Planton Backend\n(gRPC · TLS on :443)"]
    IDE -->|"MCP protocol"| MCP
    MCP -->|"gRPC"| Backend

This server does not store state. It is a protocol bridge: every tool call opens a short-lived gRPC connection, performs the RPC, and returns the result. It can serve both STDIO and HTTP transports concurrently from a single process.

Key Concepts

Installation

Prerequisites

1. A Planton account
2. An API key (Console > Profile > API Keys > Create Key)
3. A compatible MCP host (Cursor, Claude Desktop, VS Code, Windsurf, or any MCP-compliant client)

Pre-built Binary

# macOS (ARM64)
curl -L https://github.com/plantonhq/planton-mcp-server/releases/latest/download/planton-mcp-server_Darwin_arm64.tar.gz | tar xz
sudo mv planton-mcp-server /usr/local/bin/

# macOS (Intel)
curl -L https://github.com/plantonhq/planton-mcp-server/releases/latest/download/planton-mcp-server_Darwin_x86_64.tar.gz | tar xz
sudo mv planton-mcp-server /usr/local/bin/

# Linux (AMD64)
curl -L https://github.com/plantonhq/planton-mcp-server/releases/latest/download/planton-mcp-server_Linux_x86_64.tar.gz | tar xz
sudo mv planton-mcp-server /usr/local/bin/

Docker

docker run -i --rm \
  -e PLANTON_API_KEY=your-api-key \
  ghcr.io/plantonhq/planton-mcp-server

Docker networking: localhost inside a container refers to the container's own loopback, not the host machine. To reach a custom endpoint running on the host, use host.docker.internal on Docker Desktop (macOS / Windows) or add --network host on Linux.

Hosted (Zero Install)

Planton hosts a shared MCP server at mcp.planton.ai. No binary or Docker required -- connect directly from any MCP client over HTTPS:

{
  "mcpServers": {
    "planton": {
      "type": "http",
      "url": "https://mcp.planton.ai/",
      "headers": {
        "Authorization": "Bearer YOUR_PLANTON_API_KEY"
      }
    }
  }
}

Each request carries its own API key, so multiple users share the same endpoint.

MCP Client Configuration

All MCP clients use the same JSON structure. The differences are the config file location and the top-level key.

Using the standalone binary

{
  "mcpServers": {
    "planton": {
      "command": "planton-mcp-server",
      "env": {
        "PLANTON_API_KEY": "YOUR_PLANTON_API_KEY"
      }
    }
  }
}

Using Docker

{
  "mcpServers": {
    "planton": {
      "command": "docker",
      "args": [
        "run", "-i", "--rm",
        "-e", "PLANTON_API_KEY",
        "ghcr.io/plantonhq/planton-mcp-server"
      ],
      "env": {
        "PLANTON_API_KEY": "YOUR_PLANTON_API_KEY"
      }
    }
  }
}

Where to put the config

VS Code uses "servers" instead of "mcpServers" as the top-level key.

Configuration Reference

TLS: Connections to endpoints on port 443 automatically use TLS with the system root CA pool. All other ports use plaintext. There is no separate TLS configuration flag.

Tools and Resources

About 250 tools span the Planton product surface:

Infra Components -- apply, get, delete, list, destroy, purge, Planton-managed state list and move

Infra Jobs -- get, latest, list, rerun, cancel, and an error recommendation for a failed job

Infra Charts -- list, get, and build reusable infrastructure charts

Infra Stacks -- search, get, apply, delete, slug check, undeploy

Infra Pipelines -- list, get, logs, latest, run, cancel, and the manual gates

Estate -- the estate answer, blast radius, and organization, environment, service and component topologies

Catalog -- catalog kinds, presets, IaC modules and provisioner mappings, and a preview of a manifest's upgrade to a newer kind version

Config Manager -- variables, secrets and their versions, secret backends, and variable groups

Audit -- the organization's activity feed, version history and unified diffs for any platform resource

Organizations and Environments -- search, get, apply, delete, slug check, and the context hierarchy

Service Hub -- services, their runs, deployments (promote, roll back), and Tekton pipelines and tasks

Connect -- cloud connections, GitHub, default providers and runners, runners, and provider auth

IAM -- identity, API keys, teams, service accounts, roles, and authorization policies

CloudOps -- live queries against AWS, GCP, Azure, and Kubernetes

Search -- ranked directory search, exact resolves, and a record by its ID

Plus 9 MCP prompts for guided workflows (debug deployments, assess change impact, explore infrastructure, provision resources, manage access, onboard teammates, diagnose services, set up environments, investigate security incidents).

And 7 MCP resources for schema discovery:

HTTP Mode

For shared or remote deployments, set the transport to http. This runs the MCP Streamable HTTP transport -- not a REST API.

PLANTON_MCP_TRANSPORT=http \
PLANTON_API_KEY=your-api-key \
  planton-mcp-server

Or with Docker:

docker run --rm \
  -e PLANTON_MCP_TRANSPORT=http \
  -e PLANTON_MCP_HTTP_AUTH_ENABLED=true \
  -p 8080:8080 \
  ghcr.io/plantonhq/planton-mcp-server

Connect your MCP client to http://host:8080 with an Authorization: Bearer <token> header, where <token> is a valid Planton API key. Each HTTP request carries its own API key, so multiple users can share a single server instance.

Auth: HTTP auth is enabled by default. Set PLANTON_MCP_HTTP_AUTH_ENABLED=false only for trusted internal networks where all callers are already authenticated at the network level.

Dual transport: Set PLANTON_MCP_TRANSPORT=both to serve STDIO and HTTP simultaneously from a single process. This is useful in development when you want local IDE access (STDIO) and remote access (HTTP) at the same time.

TLS: The HTTP transport does not terminate TLS natively. For production deployments, place a TLS-terminating reverse proxy (e.g. nginx, Envoy, or a cloud load balancer) in front of the MCP server.

Security

• STDIO mode: API key loaded once from PLANTON_API_KEY at startup
• HTTP mode: Each request carries its own key via Authorization: Bearer header -- true multi-tenant support
• Keys are held in memory only during request execution and never persisted
• All API calls are validated and logged with the caller's identity
• Fine-grained authorization is enforced by the Planton backend via OpenFGA

Supported Cloud Providers

AWS, GCP, Azure, Kubernetes, DigitalOcean, Cloudflare, Auth0, OpenFGA and Stripe -- every kind in Planton's open-source catalog.

License

Apache License 2.0. See LICENSE.