Cantila MCP server

Cantila publishes a remote MCP (Model Context Protocol) server. Add it once to Claude (Claude Code, the Claude app, Cowork, any MCP host) and every Claude surface gets cantila_deploy, cantila_provision_db, cantila_add_domain, and the rest of the Cantila toolset as native capabilities. Any project you build in Claude ships to Cantila by asking.

There's a marketing overview for the why; this is the how.

The MCP server is one of two ways Cantila connects to Claude. The other is to connect your Claude account so the Chat Deploy assistant reasons on your own subscription. They're independent — use either, both, or neither.

Quick install (one line)

The fastest path — no API key, no config file. Run the installer and it registers the Cantila MCP server with the Claude Code CLI for you:

# Windows (PowerShell)
iwr -useb https://mcp.cantila.app/install.ps1 | iex

# macOS / Linux
curl -fsSL https://mcp.cantila.app/install.sh | sh

That's it. The script runs claude mcp add --transport http cantila https://mcp.cantila.app/v1/mcp. The first time Claude uses a Cantila tool, a browser sign-in opens (OAuth) and links the server to your account — so there's no key to copy or store.

The one-liner needs the Claude Code CLI on your PATH; if it's missing the script tells you where to get it. For CI, headless agents, or non-CLI hosts (Claude Desktop, Cowork), use the API-key methods below instead.

Mint an API key

Prefer to wire it by hand, or running somewhere without a browser? Mint a key instead.

Console → Settings → API keys → Create key. Pick a scope:

Account — every project, every domain, full surface.
Project — locked to one project. Best for repo-scoped agents.

Copy the key (ct_live_...) — Cantila hashes it on save, so it's only visible once.

Add to Claude Code

In your repo, create .mcp.json:

{
  "mcpServers": {
    "cantila": {
      "url": "https://api.cantila.app/v1/mcp",
      "headers": {
        "Authorization": "Bearer ${CANTILA_API_KEY}"
      }
    }
  }
}

Set CANTILA_API_KEY in your shell:

export CANTILA_API_KEY=ct_live_...

Restart Claude Code. The Cantila tools appear in the tool list — try /tools to confirm.

Add to Claude Desktop

Edit claude_desktop_config.json (location depends on OS — see Anthropic docs). Add:

{
  "mcpServers": {
    "cantila": {
      "command": "npx",
      "args": ["-y", "@cantila/mcp"],
      "env": {
        "CANTILA_API_KEY": "ct_live_..."
      }
    }
  }
}

Restart the app. The "Cantila" provider appears in the connectors list.

Add to Cowork / Claude.ai

The HTTP endpoint is hosted — paste it into Cowork or claude.ai's MCP connector:

URL:    https://api.cantila.app/v1/mcp
Auth:   Bearer ct_live_...

No local proxy needed.

The tool list

All 28 tools the server exposes, listed inline — no separate reference to chase. Tools marked † call an LLM (your configured ops model); every other tool is deterministic and costs nothing in model tokens.

Tool	What it does
`cantila_deploy`	Ship a project (files or repo); returns a live URL.
`cantila_create_project`	Create a project — auto-wired services land on first deploy.
`cantila_push_files`	Push files (path + contents) into a project's repo.
`cantila_list_projects`	List projects and their status.
`cantila_status`	Report a project's health, services, domains, and recent deploys.
`cantila_get_logs`	Fetch build and runtime logs.
`cantila_set_env`	Set or update an environment variable.
`cantila_provision_db`	Create a managed database (default Postgres) and wire it in.
`cantila_add_domain`	Attach a domain and issue SSL.
`cantila_connect_git`	Connect a repo for push-to-deploy.
`cantila_scale`	Resize vCPU/memory/disk or set auto-scaling bounds.
`cantila_list_instances`	List a project's running instances.
`cantila_deploy_preview`	Spin up a preview (ephemeral) deployment.
`cantila_list_previews`	List active preview deployments.
`cantila_destroy_preview`	Tear down a preview deployment.
`cantila_rollback`	Roll back to a previous deployment.
`cantila_create_backup`	Take a point-in-time backup.
`cantila_list_backups`	List a project's backups, newest first.
`cantila_restore_backup`	Restore a project from a backup.
`cantila_delete_database`	Delete a project's managed database.
`cantila_delete_project`	Permanently delete a project.
`cantila_agents_status`	Read what the brain decided and what's queued for review.
`cantila_troubleshoot` †	Diagnose a failed or unhealthy deployment.
`cantila_optimise_cost` †	Recommend cost optimisations for an account.
`cantila_create_automation`	Spin up an automation project (e.g. n8n).
`cantila_list_automations`	List automations for an account.
`cantila_list_connections`	List an account's stored provider connections.
`cantila_create_connection`	Connect a provider (openai, stripe, sendgrid, …).

What one ask looks like

ship the repo in this folder to Cantila with a Postgres
and the domain blogapp.dev

Claude calls three tools in sequence and reports back:

cantila_deploy             ok  build started for repo (next.js detected)
cantila_provision_db       ok  postgres-17 created, wired into env
cantila_add_domain         ok  blogapp.dev attached, SSL issued
live · https://blogapp.dev

Security

API keys are hashed at rest; only the prefix is logged.
Each tool call is recorded in Activity with the source key fingerprint.
Revoke a key from Settings → API keys at any time — the next tool call fails with 401.

Project-scoped keys can only call tools whose target resolves inside the scoped project. cantila_list_projects returns just that project; cantila_deploy against another project's id returns 403.