MCP Server - Unsiloed AI

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

parse_document

Convert a PDF, DOCX, PPTX, XLSX, or image into clean, LLM-ready markdown.

classify_document

Label a document against caller-defined categories (e.g. invoice vs contract vs receipt).

extract_data

Pull structured JSON from a PDF using a caller-provided JSON Schema.

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 for Claude Code, Cursor, Lovable, ChatGPT, VS Code, n8n, and Windsurf.

Open Claude.ai or Claude Desktop

Navigate to Settings → Connectors → Add custom connector.

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.

Click Connect

Claude opens a popup to sign in via Unsiloed.

Use your normal Unsiloed account credentials. If you don’t have an account yet, create one at unsiloed.ai. The free tier is enough to try it out.

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.

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.

Claude Code (CLI)

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.

Cursor

Settings → MCP & Integrations → New MCP Server, or add to ~/.cursor/mcp.json:

{
  "mcpServers": {
    "unsiloed": { "url": "https://mcp.unsiloed.ai/mcp" }
  }
}

Cursor triggers the OAuth flow on first use.

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.

ChatGPT

Settings → Apps → Advanced → Developer mode → Create app, paste https://mcp.unsiloed.ai/mcp, and pick OAuth when prompted.

VS Code

Add to .vscode/mcp.json (or your user-level MCP config):

{
  "servers": {
    "unsiloed": { "type": "http", "url": "https://mcp.unsiloed.ai/mcp" }
  }
}

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.

Windsurf and other stdio-only clients

Clients without native remote-OAuth support can bridge through mcp-remote. For Windsurf, add to ~/.codeium/windsurf/mcp_config.json:

{
  "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

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

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

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.

get_classify_status: poll a classification job

Same shape as get_parse_status. Use when classify_document returned status: pending.

Extract

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

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:

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 and show me the markdown.”

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

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}].”

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:

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.

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.

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.

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.
Credits: each processed page consumes credits from your organization’s plan. Track usage in your dashboard.

Troubleshooting

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.

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 or visit your dashboard to resolve. Once reactivated, the next tool call resumes within a minute, with no need to reconnect.

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.

A tool call says 'Insufficient quota'

Your organization has exhausted its monthly parse credits. Top up at your dashboard before retrying.

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.

My client asks for a transport type. Which one?

Choose Streamable HTTP (sometimes labeled streamable-http or just HTTP). Do not select SSE.

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.

Support

support@unsiloed.ai

General enquiries

hello@unsiloed.ai

Claude Tool-Use Integration

Drop-in Anthropic tool-use schemas for direct API usage without the MCP layer.

REST API Reference

Call Unsiloed’s parser, classifier, and extractor directly via REST.

​What is the Unsiloed MCP Server?

parse_document

classify_document

extract_data

get_*_status

​How to connect

​Other MCP clients

​Signing in

​The six tools

​Parse

​Processing modes

​Classify

​Extract

​Model tiers

​Example prompts

Parse a PDF into markdown

Extract contract terms

Classify a batch of documents

Pull a 10-K's financials

​Working with large documents

​Limits

​Troubleshooting

​Support

Support

General enquiries

​See also

Claude Tool-Use Integration

REST API Reference

What is the Unsiloed MCP Server?

How to connect

Other MCP clients

Signing in

The six tools

Parse

Processing modes

Classify

Extract

Model tiers

Example prompts

Working with large documents

Limits

Troubleshooting

Support

See also