SeaGit MCP Server

Before you start

• A paid plan (Pro, Startup or Enterprise). The MCP server authenticates with an API key, and API keys are not available on the Free plan; see plans.
• An API key. Create one under Settings → API keys. It starts with sgt_live_ and is shown once. Use a separate key for each assistant so you can revoke one without the others.
• Optional: open Scopes on the key and allow only get and list for a read-only assistant.

Keep the key out of files you commit. The examples below read it from an environment variable, SEAGIT_API_KEY, or prompt for it.

Connect your assistant

Claude Code

claude mcp add --transport http seagit https://seagit.com/api/mcp \
  --header "Authorization: Bearer $SEAGIT_API_KEY"

This stores the server in your own Claude Code config. To share it with your team through .mcp.json, add --scope project and use single quotes around the header, so the file keeps ${SEAGIT_API_KEY} and each person’s own key is read from their environment instead of yours being committed. Run /mcp inside Claude Code to check the connection.

Cursor

Add this to ~/.cursor/mcp.json, or to .cursor/mcp.json in a project:

{
  "mcpServers": {
    "seagit": {
      "url": "https://seagit.com/api/mcp",
      "headers": { "Authorization": "Bearer ${env:SEAGIT_API_KEY}" }
    }
  }
}

Cursor reads SEAGIT_API_KEY from the environment it was started in, so set the variable and restart Cursor. If a shared repository holds the project file, keep the key itself out of it.

VS Code

Add this to .vscode/mcp.json. VS Code asks for the key the first time and stores it securely:

{
  "inputs": [
    {
      "type": "promptString",
      "id": "seagit-api-key",
      "description": "SeaGit API key (sgt_live_…)",
      "password": true
    }
  ],
  "servers": {
    "seagit": {
      "type": "http",
      "url": "https://seagit.com/api/mcp",
      "headers": { "Authorization": "Bearer ${input:seagit-api-key}" }
    }
  }
}

Claude Desktop

Claude Desktop’s config file starts local servers, so connect through the mcp-remote bridge, which needs Node.js. Add this to claude_desktop_config.json and restart the app:

{
  "mcpServers": {
    "seagit": {
      "command": "npx",
      "args": [
        "-y", "mcp-remote", "https://seagit.com/api/mcp",
        "--header", "Authorization:${SEAGIT_AUTH}"
      ],
      "env": { "SEAGIT_AUTH": "Bearer sgt_live_…" }
    }
  }
}

Other clients and a quick test

Any client that supports the Streamable HTTP transport can connect: point it at https://seagit.com/api/mcp and send Authorization: Bearer sgt_live_…. To check your key without a client, list the tools with curl:

curl -s https://seagit.com/api/mcp \
  -H "Authorization: Bearer $SEAGIT_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/list"}'

Tools

Lists return at most 100 rows and only the fields an assistant needs, so a single call does not flood its context.

SeaGit’s model is organization → environments and clusters, and application → one instance per environment → deployments. Each instance has one main deployment, the production slot, and can have preview deployments on their own URLs; see Deployments. Assistants usually go list_applications → list_app_instances → list_deployments → get_deployment_logs.

Things to ask

• “Which deployments in prod are failing, and why?”
• “Show me the last 200 log lines of the checkout preview for pull request 42.”
• “List my clusters that are stopped.”
• “Redeploy the api deployment in staging.”
• “The preview for my branch looks good. Promote it to main.” The assistant asks you to confirm before it runs.
• “Which stack templates can I launch on my plan?”

Permissions and safety

• Same rules as the API. Each tool calls the same endpoint as the REST API with your key, so the key’s scopes, your plan and your team’s roles and policies all apply.
• Write tools are labelled. redeploy and promote_deployment are marked as write tools and promote as destructive, so MCP clients ask before running them.
• Promotion gates still apply. If the environment requires passing evaluations before promotion, the tool returns the same refusal the dashboard shows.
• Everything is logged. Calls appear in the audit log under the key’s name, and the key list shows when each key was last used.
• Revoke at any time. Revoking or rotating a key in Settings → API keys cuts the assistant off on its next call.

Limits

• The server is stateless: no sessions, no server-sent notifications. A GET on the endpoint returns 405, which MCP clients expect.
• Lists stop at 100 rows and say so. Narrow by organization, environment or application to see the rest.
• Creating clusters, launching stacks and changing settings are not tools yet. Use the dashboard or the REST API.

Troubleshooting

• 401 “send a SeaGit API key”: the header is missing or holds something other than an sgt_ key. Account sign-in tokens are not accepted because they expire after an hour.
• 401 “Invalid API key” or “API key expired”: the key was revoked, rotated or has passed its expiry date. Create a new one.
• “API key does not have permission for this action”: the key’s scopes do not cover that tool. Edit its scopes.
• Claude Desktop shows no tools: check that Node.js is installed (npx must run) and restart the app after editing the config.

FAQ

Next steps

• A worked example: deploy and debug Kubernetes apps from Claude Code.
• How it compares with kubectl-level servers: Kubernetes MCP servers compared.
• New to MCP? What is an MCP server.