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

# MCP Server

> Connect Claude (and any MCP client) to Unsiloed for parsing, classification, and structured extraction, all over OAuth.

<Note>
  Unsiloed exposes a **remote Model Context Protocol server** at
  `https://mcp.unsiloed.ai/mcp`. Add it once in your MCP client
  (Claude.ai, Claude Desktop, Claude Code, Cursor, Lovable, ChatGPT,
  VS Code, and more) and your assistant can parse PDFs, classify
  documents, and extract structured JSON on your behalf. No API key
  pasting required.
</Note>

## What is the Unsiloed MCP Server?

The Unsiloed MCP Server is a remote
[Model Context Protocol](https://modelcontextprotocol.io) server that gives
Claude (and any MCP-compatible client) direct, authenticated access to
Unsiloed's document-processing tools.

You connect once via OAuth. Claude then has six tools at its disposal:

<CardGroup cols={2}>
  <Card title="parse_document" icon="file-lines">
    Convert a PDF, DOCX, PPTX, XLSX, or image into clean, LLM-ready markdown.
  </Card>

  <Card title="classify_document" icon="tags">
    Label a document against caller-defined categories (e.g. invoice vs contract vs receipt).
  </Card>

  <Card title="extract_data" icon="brackets-curly">
    Pull structured JSON from a PDF using a caller-provided JSON Schema.
  </Card>

  <Card title="get_*_status" icon="rotate">
    Poll long-running jobs (`get_parse_status`, `get_classify_status`, `get_extract_status`).
  </Card>
</CardGroup>

## How to connect

The walkthrough below uses Claude.ai; jump to
[Other MCP clients](#other-mcp-clients) for Claude Code, Cursor, Lovable,
ChatGPT, VS Code, n8n, and Windsurf.

<Steps>
  <Step title="Open Claude.ai or Claude Desktop">
    Navigate to **Settings → Connectors → Add custom connector**.
  </Step>

  <Step title="Paste the MCP server URL">
    Use the production endpoint:

    ```
    https://mcp.unsiloed.ai/mcp
    ```

    No API key is collected here. Authentication happens via OAuth in the next step.
  </Step>

  <Step title="Click Connect">
    Claude opens a popup to sign in via Unsiloed.
  </Step>

  <Step title="Sign in to Unsiloed">
    Use your normal Unsiloed account credentials. If you don't have an account
    yet, create one at <a href="https://www.unsiloed.ai">unsiloed.ai</a>. The
    free tier is enough to try it out.
  </Step>

  <Step title="Approve the consent screen">
    You'll see "Claude wants access to your Unsiloed organization, with scopes:
    `parse`, `classify`, `extract`, and `offline_access` (which lets the
    connection stay signed in). Click **Allow**.
  </Step>

  <Step title="Verify the connection">
    Back in Claude, the connector card should show **six tools** split into
    read-only (the three status pollers) and read/write groups (parse, classify, extract).

    Ask Claude in a new chat: *"List the tools available from the Unsiloed connector."*
    You should see all six listed by name.
  </Step>
</Steps>

## Other MCP clients

Any MCP client connects the same way: paste the URL, sign in, approve.

<AccordionGroup>
  <Accordion title="Claude Code (CLI)">
    ```bash theme={null}
    claude mcp add --transport http unsiloed https://mcp.unsiloed.ai/mcp
    ```

    Then run `/mcp` inside Claude Code, select **unsiloed**, and choose
    **Authenticate** to complete the browser sign-in.
  </Accordion>

  <Accordion title="Cursor">
    **Settings → MCP & Integrations → New MCP Server**, or add to
    `~/.cursor/mcp.json`:

    ```json theme={null}
    {
      "mcpServers": {
        "unsiloed": { "url": "https://mcp.unsiloed.ai/mcp" }
      }
    }
    ```

    Cursor triggers the OAuth flow on first use.
  </Accordion>

  <Accordion title="Lovable">
    **Connectors → Chat connectors → New MCP server** (workspace
    admin/owner required on Business and Enterprise plans):

    * **Server name**: `Unsiloed`
    * **Server URL**: `https://mcp.unsiloed.ai/mcp`
    * **Authentication**: OAuth (default)

    Click **Add & authorize** and complete the sign-in.
  </Accordion>

  <Accordion title="ChatGPT">
    **Settings → Apps → Advanced → Developer mode → Create app**, paste
    `https://mcp.unsiloed.ai/mcp`, and pick OAuth when prompted.
  </Accordion>

  <Accordion title="VS Code">
    Add to `.vscode/mcp.json` (or your user-level MCP config):

    ```json theme={null}
    {
      "servers": {
        "unsiloed": { "type": "http", "url": "https://mcp.unsiloed.ai/mcp" }
      }
    }
    ```
  </Accordion>

  <Accordion title="n8n">
    Add an **MCP Client Tool** node with:

    * **Server Transport**: `HTTP Streamable` (not the deprecated SSE option)
    * **Endpoint**: `https://mcp.unsiloed.ai/mcp`
    * **Authentication**: OAuth2

    n8n registers itself automatically and walks you through consent.
  </Accordion>

  <Accordion title="Windsurf and other stdio-only clients">
    Clients without native remote-OAuth support can bridge through
    [`mcp-remote`](https://github.com/geelen/mcp-remote). For Windsurf,
    add to `~/.codeium/windsurf/mcp_config.json`:

    ```json theme={null}
    {
      "mcpServers": {
        "unsiloed": {
          "command": "npx",
          "args": ["-y", "mcp-remote@latest", "https://mcp.unsiloed.ai/mcp"]
        }
      }
    }
    ```

    The same snippet works for any client that only launches local
    (stdio) MCP servers.
  </Accordion>
</AccordionGroup>

## Signing in

You sign in once with your normal Unsiloed account. No API keys.

On the consent screen you'll be asked to approve four permissions.
**Approve all of them** unless you have a specific reason not to:

| Permission       | What it enables                                                       |
| ---------------- | --------------------------------------------------------------------- |
| `parse`          | `parse_document` + `get_parse_status`                                 |
| `classify`       | `classify_document` + `get_classify_status`                           |
| `extract`        | `extract_data` + `get_extract_status`                                 |
| `offline_access` | Staying signed in. Without it you'll re-authenticate every 15 minutes |

Good to know:

* An **actively used connection stays signed in indefinitely**. Your
  client renews it automatically in the background.
* If a tool refuses with **"Missing required OAuth scope"**, you approved
  fewer permissions than that tool needs. Disconnect, reconnect, and
  approve everything.
* If your client ever shows **"reconnect required"** (for example after
  signing out of Unsiloed), just click Reconnect and approve again.

## The six tools

### Parse

<AccordionGroup>
  <Accordion title="parse_document: convert a document to markdown">
    Accepts PDF, DOCX, DOC, PPTX, PPT, XLSX, XLS, PNG, JPEG, and TIFF.
    Returns full markdown content plus per-chunk structure and job
    metadata.

    **Inputs**:

    * `file_url` *(string, optional)*: publicly fetchable HTTPS URL. Presigned S3 URLs work.
    * `file_base64` *(string, optional)*: base64-encoded file contents (provide either this OR `file_url`).
    * `file_name` *(string, optional)*: defaults to `document.pdf`. Required for non-PDF formats when using `file_base64`.
    * `mode` *(`fast` | `accurate` | `agentic`)*: see [Processing modes](#processing-modes).
    * `page_range` *(string, optional)*: e.g. `"1-5"`, `"2,4,6"`, `"1-3,7,10-12"`. Omit for the whole document.

    **Returns**: the merged markdown inline + job metadata (page count, total chunks, credit used, timestamps). For documents over \~30 pages, the call may exceed the tool timeout and return a `status: pending` envelope with a `job_id`. Poll with `get_parse_status`.
  </Accordion>

  <Accordion title="get_parse_status: poll a parse job">
    Use when `parse_document` returned `status: pending`.

    **Inputs**:

    * `job_id` *(UUID, required)*.
    * `include_chunks` *(boolean, default true)*: set false for a cheap status-only poll.

    **Returns**: full markdown + metadata once `status: Succeeded`. Otherwise just metadata.
  </Accordion>
</AccordionGroup>

#### Processing modes

All modes run through Unsiloed's parsing pipeline with smart layout
detection. Pick the one that matches your document complexity and latency
budget:

| Mode       | Best for                                                                                       |
| ---------- | ---------------------------------------------------------------------------------------------- |
| `fast`     | Clean born-digital PDFs (system-generated invoices, receipts). Lowest latency and lowest cost. |
| `accurate` | Most real-world documents: scanned PDFs, multi-column layouts, tables spanning pages.          |
| `agentic`  | Highest fidelity. Use for legal contracts, 10-K/10-Q filings, equations, handwriting.          |

### Classify

<AccordionGroup>
  <Accordion title="classify_document: label a document">
    **Inputs**:

    * `file_url` or `file_base64` (one required).
    * `categories` *(array, required)*: 1 to 20 objects shaped `{name: string, description?: string}`. Descriptions strongly improve accuracy by giving the classifier label hints.

    **Returns**: predicted classification plus per-page confidence scores.
  </Accordion>

  <Accordion title="get_classify_status: poll a classification job">
    Same shape as `get_parse_status`. Use when `classify_document` returned `status: pending`.
  </Accordion>
</AccordionGroup>

### Extract

<AccordionGroup>
  <Accordion title="extract_data: pull typed JSON via a JSON Schema">
    **Inputs**:

    * `file_url` or `file_base64` (one required).
    * `json_schema` *(object, required)*: JSON Schema (draft-07 compatible) defining the desired output. Per-field `description` values are passed to the underlying model as extraction hints.
    * `model` *(`alpha` | `beta` | `gamma` | `delta`)*: see [Model tiers](#model-tiers).
    * `enable_citations` *(boolean, default false)*: when true, includes bbox coordinates for each extracted value.

    **Returns**: the extracted object, typed against your schema, with per-field confidence scores.
  </Accordion>

  <Accordion title="get_extract_status: poll an extraction job">
    Same shape as `get_parse_status`. Use when `extract_data` returned `status: pending`.
  </Accordion>
</AccordionGroup>

#### Model tiers

| Tier              | Pick when…                                                                                  |
| ----------------- | ------------------------------------------------------------------------------------------- |
| `alpha`           | Simple key/value or shallow schemas; fastest and cheapest.                                  |
| `beta`            | Nested objects and arrays of structured items; mid-tier latency and cost.                   |
| `gamma` (default) | Strong balance of accuracy and latency. Recommended for production.                         |
| `delta`           | Highest accuracy. Use for complex contracts, dense tables, and strict numerical extraction. |

## Example prompts

Once connected, just talk to Claude naturally. Some prompts to try:

<CardGroup cols={1}>
  <Card title="Parse a PDF into markdown">
    *"Use the Unsiloed connector to parse the PDF at
    [https://www.w3.org/WAI/ER/tests/xhtml/testfiles/resources/pdf/dummy.pdf](https://www.w3.org/WAI/ER/tests/xhtml/testfiles/resources/pdf/dummy.pdf)
    and show me the markdown."*
  </Card>

  <Card title="Extract contract terms">
    *"Parse the MSA at `https://...` and extract `{parties: string[],
            governing_law: string, effective_date: string, termination_clause: string}`
    using the `delta` model."*
  </Card>

  <Card title="Classify a batch of documents">
    *"Classify these PDFs as `invoice`, `receipt`, or `purchase_order`, then for each
    invoice extract `line_items: [{description, quantity, unit_price, total}]`."*
  </Card>

  <Card title="Pull a 10-K's financials">
    *"Parse this 10-K filing and extract the income-statement figures with
    the schema `{revenue, cogs, gross_profit, operating_expenses, net_income}`."*
  </Card>
</CardGroup>

## Working with large documents

MCP clients have a limited context window, and many **truncate large tool
results**, so a 100-page parse can come back cut off in the chat even
though the server processed it fully. Work in slices instead of one big
dump:

<Steps>
  <Step title="Prefer extraction over full parsing">
    If you only need specific fields, use `extract_data` with a JSON
    Schema. It returns a compact JSON object instead of the full document
    markdown, usually 100x smaller and immune to truncation.
  </Step>

  <Step title="Parse in page ranges">
    Use `page_range` to process a big document in chunks the client can
    hold: *"Parse pages 1-20 of this PDF"*, then *"now pages 21-40"*, and
    so on. Ask your assistant to summarize or accumulate findings as it
    goes rather than echoing full text.
  </Step>

  <Step title="Poll cheaply">
    When checking on a long-running job, ask for a status-only poll
    (`include_chunks: false`) so the full content isn't re-sent on every
    check.
  </Step>

  <Step title="Let big jobs finish in the background">
    Documents over \~30 pages may return `status: pending` with a
    `job_id` instead of an immediate result. That's normal; the job keeps
    running. Ask your assistant to poll `get_parse_status` after a few
    seconds.
  </Step>
</Steps>

## Limits

* **Supported formats**: PDF, DOCX, DOC, PPTX, PPT, XLSX, XLS, PNG, JPEG,
  TIFF.
* **File delivery**: via a publicly fetchable HTTPS URL (presigned S3
  URLs work) or inline base64.
* **Long documents** run asynchronously. Expect a `job_id` + polling
  instead of an instant answer for anything past \~30 pages.
* **Result size**: the server returns complete results, but your MCP
  client may truncate what fits in the conversation. See
  [Working with large documents](#working-with-large-documents).
* **Credits**: each processed page consumes credits from your
  organization's plan. Track usage in
  <a href="https://app.unsiloed.ai/billing">your dashboard</a>.

## Troubleshooting

<AccordionGroup>
  <Accordion title="The Connect button does nothing / no popup opens">
    Browser pop-up blockers can intercept the OAuth window. Allow pop-ups for
    `claude.ai` and try Connect again. If still blocked, try Claude Desktop
    instead, which handles the redirect natively without relying on
    `window.open`.
  </Accordion>

  <Accordion title="I clicked Allow but Claude says 'reconnect required'">
    The OAuth tokens expire on signout and on admin revocation. Disconnect
    the Unsiloed connector and re-add it to mint a fresh pair. No
    re-registration is needed; Claude reuses the stored client\_id.
  </Accordion>

  <Accordion title="A tool call says 'Your Unsiloed organisation is currently suspended'">
    Your organization has been suspended by Unsiloed (usually for billing
    reasons). Contact <a href="mailto:support@unsiloed.ai">[support@unsiloed.ai](mailto:support@unsiloed.ai)</a>
    or visit <a href="https://app.unsiloed.ai/billing">your dashboard</a> to
    resolve. Once reactivated, the next tool call resumes within a minute,
    with no need to reconnect.
  </Accordion>

  <Accordion title="A tool call says 'Missing required OAuth scope'">
    During consent you approved fewer scopes than the tool needs. Disconnect
    the connector and reconnect. When the consent screen appears, approve
    all three of `parse`, `classify`, `extract`.
  </Accordion>

  <Accordion title="A tool call says 'Insufficient quota'">
    Your organization has exhausted its monthly parse credits. Top up at
    <a href="https://app.unsiloed.ai/billing">your dashboard</a> before
    retrying.
  </Accordion>

  <Accordion title="My client says 'Server does not support OAuth authentication'">
    Don't just retry the existing entry. Instead, **delete the connector entirely,
    then add it again as a new one**. If it persists, verify your network
    allows outbound HTTPS to `mcp.unsiloed.ai` and `hydra.unsiloed.ai`.
  </Accordion>

  <Accordion title="The connection keeps dropping or asks me to sign in again">
    Disconnect the Unsiloed connector and reconnect once. Connections stay
    signed in as long as they're in use; if yours doesn't, a fresh
    reconnect resolves it.
  </Accordion>

  <Accordion title="My client asks for a transport type. Which one?">
    Choose **Streamable HTTP** (sometimes labeled `streamable-http` or
    just `HTTP`). Do not select SSE.
  </Accordion>

  <Accordion title="The parsed result looks cut off or incomplete">
    The server processed the full document; your MCP client truncated the
    result to fit its context window. Re-run the request in smaller
    slices using `page_range` (for example pages 1-20, then 21-40), or
    switch to `extract_data` with a JSON Schema if you only need specific
    fields. See [Working with large documents](#working-with-large-documents).
  </Accordion>
</AccordionGroup>

## Support

<CardGroup cols={2}>
  <Card title="Support" icon="envelope" href="mailto:support@unsiloed.ai">
    [support@unsiloed.ai](mailto:support@unsiloed.ai)
  </Card>

  <Card title="General enquiries" icon="envelope" href="mailto:hello@unsiloed.ai">
    [hello@unsiloed.ai](mailto:hello@unsiloed.ai)
  </Card>
</CardGroup>

## See also

<CardGroup cols={2}>
  <Card title="Claude Tool-Use Integration" icon="code" href="/docs/integrations/claude-integration">
    Drop-in Anthropic tool-use schemas for direct API usage without the MCP layer.
  </Card>

  <Card title="REST API Reference" icon="server" href="/docs/api-reference/parser/parse-document">
    Call Unsiloed's parser, classifier, and extractor directly via REST.
  </Card>
</CardGroup>