> ## Documentation Index
> Fetch the complete documentation index at: https://docs.venture.caplia.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# MCP Server

> Connect Claude, Cursor, or ChatGPT to your own company on Caplia - read your CRI, get improvement guidance, and iterate your pitch deck to Caplia Verified in natural language.

**Caplia is an MCP server for founders to improve their own company.** Point Claude Desktop, Cursor, ChatGPT, or any MCP client at the Caplia MCP server with a founder key, and the agent can read your CRI score, explain the rubric's recommendations, and run the [private deck-scoring loop](/founder/deck-loop) - regenerating your pitch deck between scores until it clears Caplia Verified.

It's the same MCP server and the same hosts as the [Venture API](/integrations/mcp), but your key decides what you get: a `cap_fnd_*` key sees the **founder toolset** below, scoped to your one company.

## What you can do

<CardGroup cols={2}>
  <Card title="Iterate your deck to 700" icon="arrows-rotate">
    "Score my deck privately, rebuild the weak slides in Canva to address the feedback, and resubmit until my CRI is at least 700." The agent loops `caplia_submit_deck_draft` → `caplia_get_deck_draft` → publish.
  </Card>

  <Card title="Understand your score" icon="gauge-high">
    "What's my CRI and what's holding it back?" The agent calls `caplia_get_my_scores` and walks you through each domain and recommendation.
  </Card>

  <Card title="Keep your profile current" icon="pen-to-square">
    "Update my stage to Series A and fix my website." The agent calls `caplia_update_my_company`.
  </Card>

  <Card title="Manage your data room" icon="folder-open">
    "Upload this financial model to my data room." The agent calls `caplia_upload_document` - which also unlocks the financial-model points in your CRI.
  </Card>
</CardGroup>

## Endpoints

```
Production:    https://mcp.venture.caplia.ai/
Sandbox:       https://mcp-sandbox.venture.caplia.ai/
```

Transport: **Streamable HTTP** (single POST endpoint, JSON-RPC 2.0). Protocol version `2024-11-05`.

<Note>
  The Founder API is **live in production**. Use the sandbox host with a `cap_fnd_test_*` key to test; the deck-loop tools need a `write`-scoped key.
</Note>

## Authentication

Bearer-token, same model as the REST API. The `cap_fnd_*` prefix is what makes the founder toolset appear:

```
Authorization: Bearer cap_fnd_live_<32 chars>   # production
Authorization: Bearer cap_fnd_test_<32 chars>   # sandbox
```

See [Authentication](/founder/authentication) for the company-scoped key model and how to get one.

## Tools

11 founder tools, scoped to your own company. They appear automatically when you connect with a `cap_fnd_*` key (an investor key sees the venture toolset instead).

### Read tools (require `read` scope)

| Tool | What an agent asks for it |
| - | - |
| `caplia_get_my_company` | "What does Caplia have on record for my company?" |
| `caplia_get_my_scores` | "What's my CRI score and what should I fix?" |
| `caplia_get_my_metrics` | "What traction metrics do investors see for me?" |
| `caplia_list_my_documents` | "What's in my data room?" |
| `caplia_get_document_url` | "Download my current pitch deck." |
| `caplia_list_deck_drafts` | "Show me the CRI across all my deck drafts." |
| `caplia_get_deck_draft` | "What did my latest draft score?" |

### Write tools (require `write` scope)

| Tool | What an agent asks for it |
| - | - |
| `caplia_update_my_company` | "Update my company stage and website." |
| `caplia_upload_document` | "Add this financial model to my data room." |
| `caplia_submit_deck_draft` | "Score this deck privately." |
| `caplia_publish_deck_draft` | "Publish the winning draft as my live deck." |

Every tool resolves your company from the key - there are no company ids to pass, and the agent can't touch any company but yours.

## Connect your AI assistant

Connect once, then drive the whole [deck loop](/founder/deck-loop) in plain English. First, get three things ready:

<Steps>
  <Step title="Get a founder key">
    Mint a `cap_fnd_*` key in the founder portal (see [Authentication](/founder/authentication)). Give it the **`write`** scope so the assistant can submit and publish decks. Use a `cap_fnd_test_*` key to test against sandbox, or `cap_fnd_live_*` for your real company.
  </Step>

  <Step title="Note the server URL">
    Sandbox: `https://mcp-sandbox.venture.caplia.ai/` for `cap_fnd_test_*` keys. Production: `https://mcp.venture.caplia.ai/` for `cap_fnd_live_*` keys. The environments are strict — a test key is rejected by the production host and vice versa. The examples below use the sandbox.
  </Step>

  <Step title="Install Node.js — only if you use Claude Desktop">
    Claude Desktop reaches the server through a small helper (`npx mcp-remote`) that needs [Node.js](https://nodejs.org) (the LTS installer). Claude Code and Codex don't need it - skip this step for those.
  </Step>
</Steps>

Now set up your assistant:

<Warning>
  **Using Claude in the browser or on mobile?** Caplia isn't in Anthropic's connector directory yet, and the **Settings → Connectors → Add custom connector** flow on claude.ai currently only completes for OAuth-based servers. Caplia authenticates with a static API key, so adding the Caplia URL there fails — typically with *"Couldn't register with sign-in service"*. Use the **Claude Desktop** or **Claude Code** tab below instead; both send your API key with every request.
</Warning>

<Tabs>
  <Tab title="Claude Desktop">
    The simplest option if you don't live in a terminal.

    1. Open (or create) your Claude config file:
       * **macOS**: `~/Library/Application Support/Claude/claude_desktop_config.json`
       * **Windows**: `%APPDATA%\Claude\claude_desktop_config.json`
    2. Paste this, with your key in place of `cap_fnd_test_YOUR_KEY`:

    ```json theme={null}
    {
      "mcpServers": {
        "caplia": {
          "command": "npx",
          "args": [
            "-y",
            "mcp-remote",
            "https://mcp-sandbox.venture.caplia.ai/",
            "--header",
            "Authorization: Bearer cap_fnd_test_YOUR_KEY"
          ]
        }
      }
    }
    ```

    3. **Quit Claude Desktop completely and reopen it** (closing the window isn't enough).
    4. Open a new chat and click the **tools (plug) icon** - the `caplia` tools should be listed. Ask *"What's my CRI on Caplia?"* to confirm.

    <Note>Requires Node.js (step 3 above). At launch, swap the URL to `https://mcp.venture.caplia.ai/` and use your `cap_fnd_live_*` key.</Note>
  </Tab>

  <Tab title="Claude Code">
    One command - no file editing:

    ```bash theme={null}
    claude mcp add --transport http caplia https://mcp-sandbox.venture.caplia.ai/ \
      --header "Authorization: Bearer cap_fnd_test_YOUR_KEY"
    ```

    Then run `/mcp` inside Claude Code (or `claude mcp list` in your shell) to confirm `caplia` connected and shows its tools. Add `--scope user` to make it available in every project.
  </Tab>

  <Tab title="Codex">
    Codex connects to remote MCP servers natively. It reads the key from an environment variable by **name** (never inline), so export it first:

    ```bash theme={null}
    export CAPLIA_API_KEY="cap_fnd_test_YOUR_KEY"   # add to ~/.zshrc to persist it
    ```

    Then add the server:

    ```bash theme={null}
    codex mcp add caplia \
      --url https://mcp-sandbox.venture.caplia.ai/ \
      --bearer-token-env-var CAPLIA_API_KEY
    ```

    Run `/mcp` in the Codex TUI (or `codex mcp list`) to confirm. This writes a `[mcp_servers.caplia]` block to `~/.codex/config.toml`.
  </Tab>

  <Tab title="Cursor / other clients">
    Most other MCP clients need the same three things:

    1. **URL**: `https://mcp-sandbox.venture.caplia.ai/` (or the production host)
    2. **Authorization header**: `Bearer cap_fnd_(live|test)_<key>`
    3. (Optional) a **name**: `caplia`

    In **Cursor**: Settings → **Features → MCP → Add new MCP server**, set the type to `sse` (streamable HTTP), then paste the URL and the `Authorization` header. For Windsurf, ChatGPT, and others, check your client's MCP docs for where the config lives.
  </Tab>
</Tabs>

## Run the deck loop from your assistant

Once connected - in Claude, Codex, or any MCP client - drive the whole [deck loop](/founder/deck-loop) in natural language. Give the assistant access to a deck tool (Canva, Google Slides, a local generator) and ask:

> "Submit my pitch deck `seed-deck.pdf` to Caplia for private scoring. Read the recommendations, rebuild the weak slides to address them, and resubmit. Keep iterating until my CRI is at least 700, then show me the best draft before we publish it."

The agent submits drafts, reads the private CRI and recommendations, regenerates the deck, and resubmits - looping until you're Verified. Drafts stay private the whole time; only `caplia_publish_deck_draft` makes a public update.

## Quick test from the terminal

```bash theme={null}
# Liveness + protocol check (no auth) — a real MCP server answers `initialize`
curl -X POST https://mcp-sandbox.venture.caplia.ai/ \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2024-11-05","capabilities":{},"clientInfo":{"name":"curl","version":"1"}}}'

# List the founder tools (send your founder key so the founder toolset is advertised)
curl -X POST https://mcp-sandbox.venture.caplia.ai/ \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer cap_fnd_test_..." \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/list"}'

# Read your scores
curl -X POST https://mcp-sandbox.venture.caplia.ai/ \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer cap_fnd_test_..." \
  -d '{"jsonrpc":"2.0","id":2,"method":"tools/call","params":{"name":"caplia_get_my_scores","arguments":{}}}'
```

## Troubleshooting

| Symptom | Likely cause | Fix |
| - | - | - |
| *"Couldn't register with sign-in service"* when adding a custom connector on claude.ai | claude.ai custom connectors require OAuth; Caplia uses API keys | Use the **Claude Desktop** or **Claude Code** setup above |
| Tools are listed, but every call returns `Missing Authorization header` | Your client connected without sending the key — `initialize` and `tools/list` don't require auth, so setup can look successful even with a missing or mistyped header | Re-check the `Authorization` header (or `--header` line) in your config, then restart the client |
| `401` / invalid key, even though the key looks right | Key and host environments don't match | `cap_fnd_test_*` keys only work on `mcp-sandbox.venture.caplia.ai`; `cap_fnd_live_*` keys only on `mcp.venture.caplia.ai` |
| Investor tools appear instead of the founder tools | The key isn't a `cap_fnd_*` key | Mint a founder key in the founder portal (see [Authentication](/founder/authentication)) |
| No Caplia tools in Claude Desktop after editing the config | App not fully quit, a JSON syntax error, or Node.js missing (`mcp-remote` needs it) | Validate the JSON, install [Node.js](https://nodejs.org), then quit Claude Desktop completely and reopen it |
| Deck-loop tools fail with a permissions error | Key has `read` scope only | Mint a `write`-scoped `cap_fnd_*` key |

## Limitations

* **Sandbox for testing.** Rehearse against the `-sandbox` host with a `cap_fnd_test_*` key before going live.
* **No streaming responses.** Each tool call is a single request-response; deck scoring is polled via `caplia_get_deck_draft`.
* **50 MB max** per deck or document, base64-encoded.
* **JSON output only.** Each tool returns raw JSON from the REST endpoint as a text content block.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.