> ## Documentation Index
> Fetch the complete documentation index at: https://www.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.

## 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:

> [card] parse\_document
>
> Convert a PDF, DOCX, PPTX, XLSX, or image into clean, LLM-ready markdown.

> [card] classify\_document
>
> Label a document against caller-defined categories (e.g. invoice vs contract vs receipt).

> [card] extract\_data
>
> Pull structured JSON from a PDF using a caller-provided JSON Schema.

> [card] get\_\*\_status
>
> Poll long-running jobs (`get_parse_status`, `get_classify_status`, `get_extract_status`).

## 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.

**1. Open Claude.ai or Claude Desktop**

Navigate to **Settings → Connectors → Add custom connector**.

**2. 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.

**3. Click Connect**

Claude opens a popup to sign in via Unsiloed.

**4. Sign in to Unsiloed**

Use your normal Unsiloed account credentials. If you don't have an account
yet, create one at [unsiloed.ai](https://www.unsiloed.ai). The
free tier is enough to try it out.

**5. 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**.

**6. 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.

## Other MCP clients

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

> [accordion] 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] 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] 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] ChatGPT
>
> **Settings → Apps → Advanced → Developer mode → Create app**, paste
> `https://mcp.unsiloed.ai/mcp`, and pick OAuth when prompted.

> [accordion] 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] 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] 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.

## 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

> [accordion] 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] 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.

#### 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

> [accordion] 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] get\_classify\_status: poll a classification job
>
> Same shape as `get_parse_status`. Use when `classify_document` returned `status: pending`.

### Extract

> [accordion] 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] get\_extract\_status: poll an extraction job
>
> Same shape as `get_parse_status`. Use when `extract_data` returned `status: pending`.

#### 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:

> [card] 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] 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] 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] 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}`."*

## 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:

**1. 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.

**2. 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.

**3. 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.

**4. 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.

## 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
  [your dashboard](https://app.unsiloed.ai/billing).

## Troubleshooting

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

> [accordion] 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] A tool call says 'Insufficient quota'
>
> Your organization has exhausted its monthly parse credits. Top up at
> [your dashboard](https://app.unsiloed.ai/billing) before
> retrying.

> [accordion] 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] 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] My client asks for a transport type. Which one?
>
> Choose **Streamable HTTP** (sometimes labeled `streamable-http` or
> just `HTTP`). Do not select SSE.

> [accordion] 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).

## Support

> [card] [Support](mailto:support@unsiloed.ai)
>
> [support@unsiloed.ai](mailto:support@unsiloed.ai)

> [card] [General enquiries](mailto:hello@unsiloed.ai)
>
> [hello@unsiloed.ai](mailto:hello@unsiloed.ai)

## See also

> [card] [Claude Tool-Use Integration](https://www.unsiloed.ai/docs/integrations/claude-integration.md)
>
> Drop-in Anthropic tool-use schemas for direct API usage without the MCP layer.

> [card] [REST API Reference](https://www.unsiloed.ai/docs/api-reference/parser/parse-document.md)
>
> Call Unsiloed's parser, classifier, and extractor directly via REST.


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