# Porter MCP MCP Server

> **Porter MCP MCP Server** is a hosted, multitenant Model Context Protocol (MCP) server run by **MewCP** (https://mewcp.com), giving AI agents managed access to Porter MCP.
>
> MewCP takes care of all MCP infrastructure for you — credential storage, OAuth flows,
> token refresh, and production-grade auto-scaling — so your AI agents can connect to
> third-party services and run freely without you managing any MCP server yourself.
>
> Server page:  https://mewcp.com/mcp/porter-mcp
> MewCP docs:   https://docs.mewcp.com
> Full catalog: https://mewcp.com/llms.txt

---

## About

Porter enables AI agents to deploy, update, and troubleshoot applications running in your own AWS, GCP, or Azure account. Inspect deployment logs and infrastructure metrics, manage services and environments, diagnose failed deployments, adjust resource allocations, and redeploy applications.

---

## Details

- Server ID: `porter-mcp`
- Version: 0.5.1
- Tools: 47
- Authentication: OAuth, managed by MewCP
- Transport: http

---

## Access

The gateway URL below serves your **entire MewCP toolset**, not this server on its
own. Pasting a config snippet is not enough — Porter MCP has to be in the toolset
first. In order:

1. Add Porter MCP to your toolset at https://mewcp.com/mcp/porter-mcp
2. Connect your Porter MCP account (OAuth); MewCP stores the credential and attaches it to each call
3. Copy your MewCP API key from the dashboard (Developer)
4. Configure your client with the snippet for it below

Once connected, an agent does **not** see this server's tools as top-level tools.
It sees four meta-tools and reaches everything through them:

- `search(query)` — find tools by keyword across the toolset
- `get_schema(tools)` — full description and arguments for the tools you picked
- `list_accounts(provider)` — only when one app has several connected accounts
- `call_tool(server_maskedId, tool_name, args)` — execute

So the list below is what `search` can return for this server, not a set of
callable tool names on their own.

---

## Tools (47)

Descriptions are truncated to 160 characters; call `get_schema`
for the full text and the argument schema. Where a tool is annotated, its type
is shown — treat `destructive` as irreversible.

- `check_aws_cluster_quota` _(read)_ — Check whether an AWS cloud account has quota (vCPUs, elastic IPs, NAT gateways, VPCs, availability zones) to provision a Porter cluster in a region. Run before…
- `connect_cloud_account` _(write)_ — Connect a cloud account to a Porter project and return the one action that advances the connection. For AWS and GCP it returns immediately without waiting, so…
- `connect_github` _(read)_ — Check whether Porter can reach a GitHub repository and return the browser action required to connect it.
- `connect_slack` _(read)_ — Report the Slack channels connected to a Porter project, or return the browser URL that connects one. The channel is chosen on Slack's own install screen, not…
- `create_app` _(write)_ — The recommended way to create a Porter application is to provide GitHub source and a build configuration. Before using that flow, call connect_github with the…
- `create_aws_quota_request` _(write)_ — File quota increase requests with AWS for every quota check_aws_cluster_quota would fail for a cloud account in a region, sized to cover current usage plus the…
- `create_cluster` _(write)_ — Provision a new Porter cluster into a connected AWS cloud account (the provider is inferred from the account; GCP and Azure accounts are not supported yet and…
- `create_github_workflow` _(write)_ — Create or re-create the GitHub Actions workflow pull request for a Porter application. Porter generates the workflow YAML, opens a PR in the application's…
- `create_project` _(write)_ — Create a Porter project owned by the caller and return its identifier. Not idempotent: every call creates a new project, so a retry leaves a duplicate behind.…
- `create_sandbox` _(write)_ — Create a sandbox, an isolated container started from an image, on a Porter cluster that has sandboxes enabled. The call may return before the sandbox is…
- `delete_addon` _(destructive)_ — Uninstall an addon from a Porter cluster and remove its configuration, including the deploy token Porter issued for it. The addon's workloads stop before the…
- `enable_sandboxes` _(write)_ — Enable sandboxes on a Porter cluster, which adds a sandbox node group and installs the sandbox runtime. Only AWS EKS clusters that have finished provisioning…
- `exec_sandbox` _(write)_ — Run a command in a running sandbox on a Porter cluster that has sandboxes enabled, and return its stdout, stderr, and exit code. A non-zero exit_code is a…
- `get_addon_status` _(read)_ — Report where an addon on a Porter cluster is in its install, changing nothing. Poll it after install_addon or update_addon, waiting between calls, until status…
- `get_addons` _(read)_ — List the addons installed on a Porter cluster with each addon's type, install status, and, for QM, its URL and sign-in state. Accepts a cluster name or ID.…
- `get_app_logs` _(read)_ — Fetch capped runtime logs for a Porter app. Filter by time window, service, revision, search, pod/container. Requires project. Returns truncated=true when…
- `get_application` _(read)_ — Return configuration for a Porter app and its services. Accepts an app name or UUID. Requires project. Never returns variables, secrets, or environment_groups.
- `get_application_metrics` _(read)_ — Query one time-series metric for one Porter application service. Returns resolved context, the effective bounded UTC query, and normalized series without…
- `get_application_revisions` _(read)_ — List revisions for a Porter app (newest first), returning up to 50 at a time with cursor pagination. Accepts an app name or UUID. Requires project.
- `get_application_status` _(read)_ — Return status for a Porter app: resolved IDs plus current revision and process health. Accepts an app name or UUID. Requires project. Does not include revision…
- `get_applications` _(read)_ — List applications in a Porter project with cursor-based pagination, optionally filtered by name or deployment target. Accepts a project ID or exact name. Each…
- `get_build_status` _(read)_ — Report which stage of its build and deploy pipeline a Porter app is in: the latest build, pre-deploy, and deploy step, each progressing, success, or failed.…
- `get_cloud_account_status` _(read)_ — Report where a cloud account sits in the Porter connect flow, changing nothing. This is the polling companion to connect_cloud_account: poll it and follow…
- `get_cluster_node_groups` _(read)_ — List node groups in a Porter cluster, including autoscaling bounds and cost-optimization (Karpenter) status. Accepts a cluster name or ID. Requires project.
- `get_cluster_nodes` _(read)_ — List nodes in a Porter cluster with resource capacity, usage, and reservation metrics. Accepts a cluster name or ID. Requires project.
- `get_cluster_pod` _(read)_ — Get full detail for one pod in a Porter cluster the caller can access: owning controller, resource usage, restart count, recent events, Kubernetes metadata,…
- `get_cluster_pods` _(read)_ — List pods in a Porter cluster, with status, readiness, restarts, node placement, and resource usage. Accepts a cluster name or ID. Requires project. No…
- `get_cluster_status` _(read)_ — Report how far a Porter cluster has got through provisioning, changing nothing. Provisioning can take up to an hour: poll until status is completed or failed,…
- `get_clusters` _(read)_ — List clusters in a Porter project. Accepts a project ID or exact name.
- `get_job_run` _(read)_ — Return one job run's status by its exact run name. Accepts an app name or UUID. Requires project. Searches the job's most recent 100 runs; job_run_name is the…
- `get_load_balancers` _(read)_ — List load balancers for a Porter cluster. Accepts a cluster name or ID. Requires project.
- `get_node_group_metrics` _(read)_ — Get provisioned node-group size over time for a Porter cluster. Fixed-size groups report node count (unit=count); cost-optimized (Karpenter) groups report…
- `get_notifications` _(read)_ — List runtime notification events for a Porter app (newest first), returning up to 20 at a time with cursor pagination. Each notification carries its error code…
- `get_project` _(read)_ — Return a Porter project's settings: currently whether it can claim a Porter Cloud cluster. Call it when get_clusters returns no clusters for the project. When…
- `get_projects` _(read)_ — List projects the caller can access.
- `get_sandbox` _(read)_ — Return one sandbox's current state on a Porter cluster that has sandboxes enabled. Use after create_sandbox to poll until phase is running before calling…
- `get_sandbox_settings` _(read)_ — Return whether sandboxes are enabled and ready on a Porter cluster, along with the cluster's sandbox settings: warm pool, egress enforcement, and domains. Use…
- `install_addon` _(write)_ — Install the QM addon (Porter's harness for agents to share context and files across an organization) onto a Porter cluster. Use for requests to set up,…
- `list_aws_quota_requests` _(read)_ — List quota increase requests filed with AWS for a cloud account in a region, with each request's status (pending, approved, denied), desired quota, and…
- `list_cloud_accounts` _(read)_ — List the cloud accounts connected to a Porter project, with each account's provider, the provider's own account ID, and where it sits in the connect flow. Use…
- `list_job_runs` _(read)_ — List recent runs for a job service on a Porter app, newest first. Omit job_name to include runs from all job services. Accepts an app name or UUID. Requires…
- `list_sandboxes` _(read)_ — List sandboxes on a Porter cluster that has sandboxes enabled, newest first, up to 100 per page. Sandboxes that already finished (succeeded, failed, or…
- `redeploy_application` _(destructive)_ — Redeploy an existing Porter app at its current configuration, restarting all services with zero configuration changes and creating a new revision. Calling this…
- `trigger_job_run` _(write)_ — Start a run of a job service on an existing Porter app. Calling this tool starts the run immediately; there is no dry run or confirmation parameter. The run…
- `update_addon` _(destructive)_ — Change the configuration of an installed QM addon and roll the change out. Only the fields given change, and a stored value cannot be cleared, only replaced.…
- `update_application` _(destructive)_ — Validate or deploy a delta to an existing Porter app. Dry run defaults to true: first validate, confirm the resulting configuration, then call again with…
- `update_sandbox_settings` _(destructive)_ — Change sandbox settings on a Porter cluster that has sandboxes enabled: the warm pool of pre-booted sandboxes, and whether egress allowlists are enforced. Only…

---

## Connect

Gateway URL: https://gateway.mewcp.com/personal/mcp

Every request carries one header:

    Authorization: Bearer <API_KEY>

Replace `API_KEY` with your own key from the dashboard (Developer).

## Apps

### Claude Desktop

Mac & Windows app

- macOS: `~/Library/Application Support/Claude/claude_desktop_config.json`
- Windows: `%APPDATA%\Claude\claude_desktop_config.json`

```json
{
  "mcpServers": {
    "mewcp": {
      "command": "npx",
      "args": [
        "-y",
        "mcp-remote@latest",
        "https://gateway.mewcp.com/personal/mcp",
        "--header",
        "Authorization:${AUTH_HEADER}"
      ],
      "env": {
        "AUTH_HEADER": "Bearer API_KEY"
      }
    }
  }
}
```

Already have an "mcpServers" section in your config? Just add the server entry inside it.

1. Open Claude Desktop → Settings → Developer → "Edit Config"
2. Paste the snippet inside the outer { } of the config file (merge with your existing "mcpServers" section if you have one)
3. Save the file, then quit Claude Desktop completely and reopen it
4. Start a new conversation — your tool will be available

### VS Code

Copilot / Cline

- Command Palette → "MCP: Open User Configuration" (opens mcp.json). For one project only, use .vscode/mcp.json instead.

```json
{
  "mcp.servers": {
    "mewcp": {
      "type": "http",
      "url": "https://gateway.mewcp.com/personal/mcp",
      "headers": {
        "Authorization": "Bearer API_KEY"
      }
    }
  }
}
```

Already have a "servers" section in your mcp.json? Just add the server entry inside it.

1. Open VS Code → Command Palette (Cmd+Shift+P / Ctrl+Shift+P)
2. Run "MCP: Open User Configuration" to open your mcp.json
3. Paste the snippet and save
4. Start the server when prompted (or from the MCP servers view) and use it in Copilot Chat

### Cursor

AI-first editor

- macOS: `~/.cursor/mcp.json`
- Windows: `%USERPROFILE%\.cursor\mcp.json`

```json
{
  "mcpServers": {
    "mewcp": {
      "url": "https://gateway.mewcp.com/personal/mcp",
      "headers": {
        "Authorization": "Bearer API_KEY"
      }
    }
  }
}
```

Already have an "mcpServers" section in your mcp.json? Just add the server entry inside it.

1. Open Cursor → Settings → Cursor Settings → MCP
2. Click "Add new global MCP server"
3. Paste the snippet and save
4. Restart Cursor

### Codex

OpenAI's CLI agent

- Add the snippet to your Codex MCP config or your standard MCP config file for the CLI tool you use.

```json
{
  "mcpServers": {
    "mewcp": {
      "type": "http",
      "url": "https://gateway.mewcp.com/personal/mcp",
      "headers": {
        "Authorization": "Bearer API_KEY"
      }
    }
  }
}
```

Codex generally reads a standard MCP server block, so you can add this alongside your other configured servers.

1. Open your Codex MCP config or project-level config file
2. Paste the MewCP server block inside the config JSON/TOML structure your tool expects
3. Save the file and restart Codex
4. Verify the tool is available inside a fresh session

### Claude Code

Anthropic's CLI agent

- ~/.claude.json (user scope) or .mcp.json in your project root — create it if it doesn't exist. Or skip the file and use the CLI command below.

```json
{
  "mcpServers": {
    "mewcp": {
      "type": "http",
      "url": "https://gateway.mewcp.com/personal/mcp",
      "headers": {
        "Authorization": "Bearer API_KEY"
      }
    }
  }
}
```

Already have an "mcpServers" section in your config? Just add the server entry inside it.

1. Open ~/.claude.json (or .mcp.json in your project root) in a text editor
2. Paste the snippet inside the outer { } (merge with your existing "mcpServers" section if you have one)
3. Save the file and start (or restart) Claude Code
4. Or skip the file entirely and run the CLI command below instead

### OpenCode

Open-source terminal agent

- ~/.config/opencode/opencode.json (global) or opencode.json in your project root — create it if it doesn't exist.

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "mewcp": {
      "type": "remote",
      "url": "https://gateway.mewcp.com/personal/mcp",
      "enabled": true,
      "headers": {
        "Authorization": "Bearer API_KEY"
      }
    }
  }
}
```

Already have an "mcp" section in your opencode.json? Just add the server entry inside it.

1. Open ~/.config/opencode/opencode.json (or opencode.json in your project root) in a text editor
2. Paste the snippet inside the outer { } (merge with your existing "mcp" section if you have one)
3. Save the file and start (or restart) OpenCode

### OpenClaw

Self-hosted agent gateway

- ~/.openclaw/openclaw.json — create it if it doesn't exist.

```json
{
  "mcp": {
    "servers": {
      "mewcp": {
        "transport": "streamable-http",
        "url": "https://gateway.mewcp.com/personal/mcp",
        "enabled": true,
        "headers": {
          "Authorization": "Bearer API_KEY"
        }
      }
    }
  }
}
```

Already have an "mcp" section in your openclaw.json? Just add the server entry inside "servers".

1. Open ~/.openclaw/openclaw.json in a text editor
2. Paste the snippet inside the outer { } (merge with your existing "mcp" section if you have one)
3. Save the file and restart OpenClaw

### Antigravity

Google's agentic IDE

- ~/.gemini/config/mcp_config.json (global) or .agents/mcp_config.json (workspace-local) — create it if it doesn't exist.

```json
{
  "mcpServers": {
    "mewcp": {
      "serverUrl": "https://gateway.mewcp.com/personal/mcp",
      "headers": {
        "Authorization": "Bearer API_KEY"
      }
    }
  }
}
```

Already have an "mcpServers" section in your config? Just add the server entry inside it. Remote servers must use the "serverUrl" field — the legacy "url"/"httpUrl" fields aren't supported.

1. In the editor's agent side panel, click "…" → "MCP Servers" → "Manage MCP Servers" → "View raw config" (Antigravity CLI: type /mcp instead to open the Interactive MCP Manager)
2. Paste the snippet inside the outer { } (merge with your existing "mcpServers" section if you have one)
3. Save the file — the server connects automatically

### Hermes

Nous Research's CLI agent

- config.yaml in your Hermes config directory (~/.hermes) — add this under a top-level "mcp_servers:" key.

```yaml
mcp_servers:
  mewcp:
    url: "https://gateway.mewcp.com/personal/mcp"
    headers:
      Authorization: "Bearer API_KEY"
```

Already have an "mcp_servers" section in your config.yaml? Just add the server entry inside it.

1. Open config.yaml in your Hermes config directory
2. Paste the snippet under the top-level "mcp_servers:" key (merge with existing entries if you have any)
3. Save the file, then run /reload-mcp in Hermes (or start a fresh session)
4. Ask Hermes "Tell me which MCP-backed tools are available right now" to confirm it connected

### DeepSeek Harness

DeepSeek's agent harness

- cordis.yml in your DSH project — or the patch file you mount plugins from.

```yaml
- id: mcp-mewcp
  name: '@deepseek-ai/dsh-mcp-client'
  config:
    serverName: mewcp
    transport: streamable-http
    url: https://gateway.mewcp.com/personal/mcp
    headers:
      Authorization: "Bearer API_KEY"
```

One plugin instance = one MCP server. Add this entry to your plugin list; don't nest it inside another entry.

1. Open cordis.yml (or your patch file) in your DSH project
2. Paste the entry into your plugin list, keeping the leading dash and indentation
3. Restart DSH (or let HMR reload) — tools register as mcp__mewcp__<tool_name>
4. Verify with: dsh web --dump-config | grep -A3 mcp

## SDKs

### Python

fastmcp client

```python
import asyncio
from fastmcp import Client
from fastmcp.client.transports import StreamableHttpTransport

SERVER_URL = "https://gateway.mewcp.com/personal/mcp"
API_KEY = "API_KEY"

transport = StreamableHttpTransport(
    url=SERVER_URL,
    headers={
        "Authorization": f"Bearer {API_KEY}",
    }
)

async def main():
    client = Client(transport)
    async with client:
        tools = await client.list_tools()
        print(tools)

asyncio.run(main())
```

1. Install fastmcp: pip install fastmcp
2. Copy the snippet into your project
3. Replace API_KEY with your key from the dashboard
4. Run your script

### TypeScript

MCP SDK

```typescript
import { Client } from "@modelcontextprotocol/sdk/client/index.js";
import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";

const SERVER_URL = "https://gateway.mewcp.com/personal/mcp";
const API_KEY = "API_KEY";

const transport = new StreamableHTTPClientTransport(new URL(SERVER_URL), {
  requestInit: {
    headers: {
      Authorization: `Bearer ${API_KEY}`,
    },
  },
});

const client = new Client({ name: "mewcp-client", version: "1.0.0" });
await client.connect(transport);

const tools = await client.listTools();
console.log(tools.tools.map((t) => t.name));
```

1. Install: npm install @modelcontextprotocol/sdk
2. Copy the snippet into your project
3. Replace API_KEY with your key from the dashboard
4. Run with Node 18+ as an ES module (e.g. npx tsx script.ts)