MCP Server Quick Start

Deploy applications using AI coding assistants like Claude Code, Cursor, or Claude Desktop through the Clue2App MCP Server.

What is MCP?

The Model Context Protocol (MCP) allows AI assistants to interact with external tools and services. Clue2App's MCP server enables you to deploy and manage applications directly through natural language conversations with your AI assistant.

The MCP server is a thin layer over the Clue2App CLI — it authenticates as you, using the same credentials c2a login writes to disk.

Prerequisites

Python 3.10 or higher
An AI assistant that supports MCP (Claude Code, Cursor, Claude Desktop)

How you connect

The MCP server runs as a stdio subprocess your AI tool launches on demand — there is no server URL to paste anywhere. Authentication and backend selection are inherited from the Clue2App CLI's saved config:

You install and log in with the CLI — c2a login writes credentials to disk.
Your AI tool spawns clue2app-mcp on each request; the MCP process reads the same config and calls the same platform APIs as the CLI.
To point at a self-hosted backend, set api.base_url and auth.base_url with c2a config set (see CLI Quick Start → Self-hosted) before c2a login. The MCP server automatically follows.

Everything the MCP can do, you can do from the CLI, and vice versa.

Installation

The recommended path is a single install:

pip install clue2app-cli

Once a follow-up release bundles clue2app-mcp as a transitive dependency, this one command will pull in both the CLI and the MCP server. Today the bundling has not yet shipped, so MCP is a second step:

pip install clue2app-mcp

If you only need the MCP server — no CLI, e.g. you drive everything through Claude Desktop — you can install it on its own:

pip install clue2app-mcp

but you will still need c2a login to authenticate, so most users install both.

Log in and pick a project

c2a login

# Create a project (namespace is derived from the name)
c2a project create MyProject

# Switch to it as the active project
c2a project use MyProject

# Confirm the backend + active project
c2a config show
c2a status

Support Bot has its own MCP

The Support Bot is exported as a separate MCP server with a per-user scoped token minted from Access → Support MCP in the console. It is independent of the deployment MCP described here.

Configuration

Claude Code

claude mcp add clue2app --scope user -- clue2app-mcp

--scope user makes the server available in all your projects. Use --scope project to share it with your team via a checked-in .mcp.json, or --scope local to limit it to the current project only.
If clue2app-mcp is not on your PATH (common with pipx or uv tool install), pass the absolute path instead — e.g. -- ~/.local/bin/clue2app-mcp.

Verify the connection:

claude mcp get clue2app

You should see the server listed with a healthy connection status (the exact wording — e.g. Status: ✔ Connected — varies between Claude Code versions). If the server fails to start, jump to Troubleshooting below.

Claude Desktop

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

{
  "mcpServers": {
    "clue2app": {
      "command": "clue2app-mcp",
      "args": []
    }
  }
}

Restart Claude Desktop after editing the file.

Cursor

Add to your Cursor MCP settings:

{
  "mcpServers": {
    "clue2app": {
      "command": "clue2app-mcp",
      "args": []
    }
  }
}

Quick Deploy Flow

Example Conversations

Deploy an Application

You: Deploy my FastAPI app from https://github.com/user/fastapi-demo

Claude: Let me check the repo for deployment readiness first.

Uses c2a_analyze tool, then c2a_create_app

Your app has been deployed! It will be available at https://fastapi-demo.myproject.apps.clue2.app once the build completes.

Check Deployment Status

You: What's the status of my-api?

Claude: Let me check the status of your app.

Uses c2a_get_app tool

my-api Status:

Build: Ready (completed 5 minutes ago)

Runtime: Running

URL: https://my-api.myproject.apps.clue2.app

View Application Logs

You: Show me the logs for my-api

Claude: Here are the recent logs for my-api:

Uses c2a_app_logs tool
2024-01-15 10:30:15 INFO Starting application...
2024-01-15 10:30:16 INFO Connected to database
2024-01-15 10:30:17 INFO Server listening on :8080

Trigger a Rebuild

You: Rebuild my-api

Claude: I'll trigger a rebuild for my-api.

Uses c2a_rebuild_app tool

Rebuild triggered successfully! The new build has started.

Set Environment Variables

You: Set DATABASE_URL to postgresql://localhost/mydb for my-api

Claude: I'll set the environment variable for your app.

Uses c2a_set_env tool

Environment variable DATABASE_URL has been set. The app will restart with the new configuration.

Provision an LLM Gateway and bind it to an app

You: Give my-api access to an LLM — spin up a Daari LLM Gateway instance and bind it.

Claude: I'll create a per-project LLM Gateway instance and attach it to my-api.

Uses c2a_daari_llm_create_instance then c2a_daari_llm_bind_app

Created LLM instance gpt4-default (binding secret gpt4-default-binding) and bound it to my-api. The app now sees OPENAI_API_KEY and OPENAI_BASE_URL in its C2A_SYSTEM_ENV on the next pod start.

Available MCP Tools

The server exposes 37 tools. Names below are exact — ask your assistant in plain language and it will pick the right one. These names come from the live MCP server registry in clue2app-mcp/src/clue2app_mcp/server.py. Tool names are stable — the natural-language examples in the sections above are illustrative of what a user might say, but the actual invocations use the names below.

Auth & Projects

Tool	Description	Required args
`c2a_status`	Overall status including auth and current project	—
`c2a_auth_status`	Check if authenticated with Clue2App	—
`c2a_login`	Log in to Clue2App	—
`c2a_list_projects`	List all projects	—
`c2a_show_project`	Show project details (active project if none given)	—
`c2a_use_project`	Switch to a project	`project`
`c2a_create_project`	Create a new project	`name`

Apps

Tool	Description	Required args
`c2a_analyze`	Analyze a repo for deployment readiness — run before `c2a_create_app`	—
`c2a_check_repo`	Check the current directory is a git repo with a GitHub remote	—
`c2a_list_apps`	List all applications in the current project	—
`c2a_get_app`	Get app details including service URL and status	`name`
`c2a_create_app`	Deploy a new application from Git	`name`, `git_url`
`c2a_deploy_current`	Deploy the current directory via its GitHub remote	—
`c2a_rebuild_app`	Trigger an application rebuild	`name`
`c2a_restart_app`	Restart a running app (triggers a new revision)	`name`
`c2a_delete_app`	Delete an application	`name`
`c2a_app_logs`	Application runtime logs	`name`
`c2a_build_logs`	Application build logs	`name`
`c2a_build_list`	List builds for the project or a specific app	—

Environment Variables

Tool	Description	Required args
`c2a_list_env`	List environment variables for an app	`name`
`c2a_set_env`	Set an environment variable on an app	`name`, `key`, `value`

Secrets

Tool	Description	Required args
`c2a_secrets_list`	List Git and registry secrets in the current project	—
`c2a_secrets_create`	Create a Git credential secret for private repos	`name`, `username`, `token`
`c2a_secrets_delete`	Delete a Git or registry secret by its K8s name	`name`

Custom Domains

Tool	Description	Required args
`c2a_domains_register`	Register a domain zone (`DELEGATION` / `SUBDOMAIN_DELEGATION` / `CNAME_ONLY`)	`domain`
`c2a_domains_add`	Add custom domains to an app; auto-registers the base domain if needed	`app_name`, `domains`
`c2a_domains_assign`	Assign a single subdomain — or apex with `@` — to an app	`subdomain`, `app_name`
`c2a_domains_assignments`	List FQDN → app mappings for the project	—
`c2a_domains_list`	List custom domains for an app or the whole project	—
`c2a_domains_info`	Show domain details and NS record setup instructions	`domain`
`c2a_domains_verify`	Verify NS records via live DNS lookup	`domain`
`c2a_domains_status`	Check delegation status via the platform API	`domain`
`c2a_domains_remove`	Remove a custom domain mapping	`domain`
`c2a_domains_delete`	Delete a registered domain and all its assignments	`domain`

See the Custom Domains guide for the full DNS setup walkthrough.

Daari LLM Gateway

Tool	Description	Required args
`c2a_daari_llm_list_instances`	List LLM Gateway instances in the active project	—
`c2a_daari_llm_create_instance`	Create a project-scoped gateway instance and binding secret	`name`
`c2a_daari_llm_bind_app`	Attach a gateway binding secret to an app via `envFrom`	`app_name`, `binding_name`

See the Daari Secrets guide for how bindings are injected.

Read-vs-write model

The MCP server is being aligned with the "advisor" model: read-only tools (list/get/logs/status) return data directly. Write tools (create/delete/set/rotate) return the exact CLI command and console URL that will make the change, so the operator confirms + executes them locally — the MCP server does not silently mutate account state. Older tool docs may still show writes as immediate; assume the CLI/console handoff as the safer default.

Common Workflows

Workflow 1: Full Deployment

You: Create a new project called "production" with namespace "prod"
Claude: [Creates project using c2a_create_project]

You: Deploy https://github.com/myorg/backend-api to the production project
Claude: [Switches with c2a_use_project, checks with c2a_analyze, deploys with c2a_create_app]

You: Set the environment variables: NODE_ENV=production, API_KEY=secret123
Claude: [Sets env vars using c2a_set_env]

You: What's the deployment status?
Claude: [Checks status using c2a_get_app]

Workflow 2: Debug a Failing App

You: My app backend-api seems to be having issues
Claude: [Checks status using c2a_get_app]
       The build failed. Let me get the build logs.
       [Gets logs using c2a_build_logs]

       I see the issue - there's a missing dependency in requirements.txt.

You: I've fixed it, rebuild please
Claude: [Triggers rebuild using c2a_rebuild_app]

Workflow 3: Monitor Multiple Apps

You: List all my apps and their status
Claude: [Lists apps using c2a_list_apps]

       Here are your apps:
       - api-server: Running
       - frontend: Running
       - worker: Scaled to 0 (no traffic)

Workflow 4: Put an App on a Custom Domain

You: Point api.example.com at my backend-api app
Claude: [Registers the zone if needed, then c2a_domains_add]
       Domain added. Here are the NS records to set at your registrar.

You: Did the delegation go through?
Claude: [Runs c2a_domains_verify — live DNS lookup]
       Delegation is healthy. TLS cert issued.

Private Repositories

For private repositories, create a git secret first:

c2a secrets create git --name my-git-creds --username git --token ghp_xxxx

Then in your AI conversation:

You: Deploy https://github.com/myorg/private-repo using my-git-creds secret

Your assistant can also do this end-to-end with c2a_secrets_list to find existing credentials, or c2a_secrets_create to make new ones.

Deployment Readiness

c2a_analyze catches the most common deployment failures before you burn a build. One case worth knowing about up front:

Static sites (Vite / React / Vue) need a server.js built on Node.js built-ins. node_modules is pruned at runtime by the buildpack, so npx and serve are not available in the running container.

See Deployment Requirements for the full list.

Troubleshooting

MCP Server Not Connecting

Verify the MCP server is installed:
```
which clue2app-mcp
```
In Claude Code, check the server's health directly:
```
claude mcp get clue2app
```

If the command isn't found, re-register it with an absolute path:

claude mcp remove clue2app -s user
claude mcp add clue2app --scope user -- "$(which clue2app-mcp)"

For Claude Desktop and Cursor, check your config file is valid JSON and restart the app.

Authentication Issues

The MCP server has no credentials of its own — it reuses the CLI's. If tools report authentication errors, fix it at the CLI level:

c2a login
c2a status

Tools Not Available

Ensure you have the latest version:
```
pip install --upgrade clue2app-mcp
```
Confirm the tool name is current — several tools were renamed. If your assistant is reaching for c2a_get_app_status, c2a_get_app_logs, c2a_get_build_logs, or c2a_set_env_vars, those are old names. The current equivalents are c2a_get_app, c2a_app_logs, c2a_build_logs, and c2a_set_env.

Benefits of MCP Integration

Natural Language Deployment

Instead of memorizing CLI commands, just describe what you want:

"Deploy my app" instead of c2a app create ... --git-url ...
"Show me the logs" instead of c2a app logs my-api
"What's wrong with my app?" instead of stitching together c2a status, c2a build logs, c2a app logs

Context-Aware Assistance

Your AI assistant can:

Suggest fixes when deployments fail
Explain build errors in plain English
Recommend configuration improvements
Help debug application issues

Seamless Workflow

Deploy directly from your coding session:

Write code in your editor
Push to Git
Ask your AI to deploy
Get status updates through conversation

Next Steps

CLI Reference - Full command documentation
Console Guide - Web console walkthrough
Deployment Guide - Understanding the deployment process
Custom Domains - Bring your own domain

Need help? Visit our GitHub Issues or contact support.

What is MCP?​

Prerequisites​

How you connect​

Installation​

Log in and pick a project​

Configuration​

Claude Code​

Claude Desktop​

Cursor​

Quick Deploy Flow​

Example Conversations​

Deploy an Application​

Check Deployment Status​

View Application Logs​

Trigger a Rebuild​

Set Environment Variables​

Provision an LLM Gateway and bind it to an app​

Available MCP Tools​

Auth & Projects​

Apps​

Environment Variables​

Secrets​

Custom Domains​

Daari LLM Gateway​

Read-vs-write model​

Common Workflows​

Workflow 1: Full Deployment​

Workflow 2: Debug a Failing App​

Workflow 3: Monitor Multiple Apps​

Workflow 4: Put an App on a Custom Domain​

Private Repositories​

Deployment Readiness​

Troubleshooting​

MCP Server Not Connecting​

Authentication Issues​

Tools Not Available​

Benefits of MCP Integration​

Natural Language Deployment​

Context-Aware Assistance​

Seamless Workflow​

Next Steps​