@talonic/docs 0.20.1 → 0.20.3

package/dist/content.js

@@ -1,23 +1,29 @@
 // src/content/helpers.ts
-function deriveBreadcrumbs(sections45, leafId, domain) {
+function deriveBreadcrumbs(sections47, leafId, domain) {
+  const domainLabels = {
+    api: "API Reference",
+    platform: "Platform Guide",
+    sdk: "Node SDK",
+    mcp: "MCP Server"
+  };
   const root = {
-    label: domain === "api" ? "API Reference" : "Platform Guide",
+    label: domainLabels[domain] ?? domain,
     slug: domain
   };
-  for (const group of sections45) {
+  for (const group of sections47) {
     const child = group.children?.find((c) => c.id === leafId);
     if (child) {
       return [root, { label: group.label, slug: group.id }, { label: child.label, slug: child.id }];
     }
   }
-  const topLevel = sections45.find((s) => s.id === leafId);
+  const topLevel = sections47.find((s) => s.id === leafId);
   if (topLevel) {
     return [root, { label: topLevel.label, slug: topLevel.id }];
   }
   return [root];
 }
-function derivePrevNext(sections45, leafId) {
-  const flat = sections45.flatMap(
+function derivePrevNext(sections47, leafId) {
+  const flat = sections47.flatMap(
     (s) => s.children ?? [{ id: s.id, label: s.label }]
   );
   const idx = flat.findIndex((c) => c.id === leafId);
@@ -347,6 +353,63 @@ var PLATFORM_NAV_SECTIONS = [
     { id: "shortcuts", label: "Keyboard Shortcuts" }
   ] }
 ];
+var SDK_NAV_SECTIONS = [
+  { id: "sdk-overview", label: "Overview", children: [
+    { id: "sdk-introduction", label: "Introduction" },
+    { id: "sdk-installation", label: "Installation" },
+    { id: "sdk-authentication", label: "Authentication" },
+    { id: "sdk-quickstart", label: "Quick Start" }
+  ] },
+  { id: "sdk-client", label: "Client", children: [
+    { id: "sdk-configuration", label: "Configuration" },
+    { id: "sdk-extract", label: "Extract" }
+  ] },
+  { id: "sdk-resources", label: "Resources", children: [
+    { id: "sdk-documents", label: "Documents" },
+    { id: "sdk-extractions", label: "Extractions" },
+    { id: "sdk-schemas", label: "Schemas" },
+    { id: "sdk-jobs", label: "Jobs" }
+  ] },
+  { id: "sdk-cli", label: "CLI", children: [
+    { id: "sdk-cli-usage", label: "Usage" }
+  ] },
+  { id: "sdk-errors", label: "Error Handling", children: [
+    { id: "sdk-error-classes", label: "Error Classes" },
+    { id: "sdk-retries", label: "Retries" }
+  ] }
+];
+var MCP_NAV_SECTIONS = [
+  { id: "mcp-overview", label: "Overview", children: [
+    { id: "mcp-introduction", label: "Introduction" },
+    { id: "mcp-installation", label: "Installation" },
+    { id: "mcp-authentication", label: "Authentication" }
+  ] },
+  { id: "mcp-clients", label: "Client Setup", children: [
+    { id: "mcp-claude-desktop", label: "Claude Desktop" },
+    { id: "mcp-cursor", label: "Cursor" },
+    { id: "mcp-cline", label: "Cline" },
+    { id: "mcp-continue", label: "Continue" },
+    { id: "mcp-cowork", label: "Cowork" }
+  ] },
+  { id: "mcp-tools", label: "Tools", children: [
+    { id: "mcp-talonic-extract", label: "talonic_extract" },
+    { id: "mcp-talonic-search", label: "talonic_search" },
+    { id: "mcp-talonic-filter", label: "talonic_filter" },
+    { id: "mcp-talonic-get-document", label: "talonic_get_document" },
+    { id: "mcp-talonic-to-markdown", label: "talonic_to_markdown" },
+    { id: "mcp-talonic-list-schemas", label: "talonic_list_schemas" },
+    { id: "mcp-talonic-save-schema", label: "talonic_save_schema" }
+  ] },
+  { id: "mcp-resources", label: "Resources", children: [
+    { id: "mcp-schemas-resource", label: "talonic://schemas" }
+  ] },
+  { id: "mcp-advanced", label: "Advanced", children: [
+    { id: "mcp-drag-drop", label: "Drag & Drop in Chat" },
+    { id: "mcp-architecture", label: "Architecture" },
+    { id: "mcp-configuration", label: "Configuration" },
+    { id: "mcp-troubleshooting", label: "Troubleshooting" }
+  ] }
+];
 
 // src/content/platform/overview.ts
 var sections = [
@@ -4441,10 +4504,11 @@ var sections17 = [
         params: [
           { name: "extract", type: "scope", description: "Submit documents for extraction (`POST /v1/extract`, `POST /v1/documents/:id/re-extract`)." },
           { name: "read", type: "scope", description: "Read operations \u2014 list and retrieve documents, extractions, schemas, jobs, sources, and other resources." },
-          { name: "write", type: "scope", description: "Write operations \u2014 create, update, and delete schemas, sources, jobs, delivery bindings, and other resources." }
+          { name: "write", type: "scope", description: "Write operations \u2014 create, update, and delete schemas, sources, jobs, delivery bindings, and other resources." },
+          { name: "billing", type: "scope", description: "Billing operations \u2014 trigger credit top-ups (`POST /v1/billing/topup`). Not included by default; add explicitly when creating the key." }
         ]
       },
-      { type: "paragraph", text: "If a request requires a scope your key does not carry, the API returns `403` with error code `insufficient_scope` and lists the required scopes in the response body." },
+      { type: "paragraph", text: "New keys default to `extract`, `read`, and `write`. The `billing` scope must be added explicitly. If a request requires a scope your key does not carry, the API returns `403` with error code `insufficient_scope` and lists the required scopes in the response body." },
       { type: "callout", text: "Keep your API key secret. Do not expose it in client-side code or version control. If a key is compromised, revoke it immediately from the dashboard." }
     ],
     related: [
@@ -4454,7 +4518,7 @@ var sections17 = [
     faq: [
       { question: "How do I authenticate with the Talonic API?", answer: "Include a Bearer token in the Authorization header of every request. API keys use the tlnc_ prefix." },
       { question: "Where do I get an API key?", answer: "Create and manage API keys from Settings \u2192 API Keys in the Talonic dashboard." },
-      { question: "What scopes are available?", answer: "Three scopes: extract (submit documents), read (list/retrieve resources), and write (create/update/delete resources). New keys get all three by default." }
+      { question: "What scopes are available?", answer: "Four scopes: extract (submit documents), read (list/retrieve resources), write (create/update/delete resources), and billing (trigger credit top-ups). New keys get extract, read, and write by default; billing must be added explicitly." }
     ],
     mentions: ["Bearer token", "API key", "Authorization header", "scopes", "extract", "read", "write"]
   },
@@ -4481,9 +4545,9 @@ var sections17 = [
     parentSlug: "overview",
     title: "Quick Start",
     seoTitle: "API Quick Start Guide \u2014 Talonic Docs",
-    description: "Get started with the Talonic API in under 60 seconds. Extract structured data from a document with a single curl command using sync mode.",
+    description: "Three modes, one API. Auto-detect extraction, schema-driven extraction, and document filtering \u2014 all with per-cell confidence and cost transparency.",
     content: [
-      { type: "paragraph", text: "Extract structured data from a document in a single API call. This guide uses **sync mode** (documents \u22645 pages return results immediately)." },
+      { type: "paragraph", text: "Three modes. One API. Auto-detect what's in the document. Send your own schema and get exactly that shape. Or skip the document entirely and query data you already ingested. Plus per-cell provenance, confidence scores, and cost transparency on every call." },
       { type: "heading", level: 3, id: "prerequisites", text: "Prerequisites" },
       { type: "list", items: [
         "A Talonic account \u2014 sign up at [app.talonic.com](https://app.talonic.com)",
@@ -4491,15 +4555,42 @@ var sections17 = [
         "A PDF or image file to extract (e.g. an invoice)"
       ] },
       { type: "code", language: "bash", title: "Set your API key", code: `export TALONIC_API_KEY="tlnc_live_..."` },
-      { type: "heading", level: 3, id: "step-1-extract", text: "1. Extract a document" },
-      { type: "paragraph", text: "Send a file with an inline schema describing the fields you want:" },
-      { type: "code", language: "bash", title: "curl \u2014 extract an invoice", code: `curl -X POST https://api.talonic.com/v1/extract \\
+      { type: "heading", level: 2, id: "mode-1-auto-detect", text: "Mode 1 \u2014 Auto-detect extract" },
+      { type: "paragraph", text: "Send a document with no schema. Talonic discovers every field automatically." },
+      { type: "code", language: "bash", title: "curl \u2014 auto-detect all fields", code: `curl -X POST https://api.talonic.com/v1/extract \\
+  -H "Authorization: Bearer $TALONIC_API_KEY" \\
+  -F "file=@invoice.pdf"` },
+      { type: "paragraph", text: "Returns every field the AI discovers \u2014 vendor, dates, amounts, line items, addresses \u2014 with per-field confidence scores. Use this when you don't know the document structure upfront." },
+      { type: "heading", level: 2, id: "mode-2-schema-extract", text: "Mode 2 \u2014 Schema-driven extract" },
+      { type: "paragraph", text: "Send a document AND the shape you want. Get exactly those fields back." },
+      { type: "code", language: "bash", title: "curl \u2014 extract with inline schema", code: `curl -X POST https://api.talonic.com/v1/extract \\
   -H "Authorization: Bearer $TALONIC_API_KEY" \\
   -F "file=@invoice.pdf" \\
   -F 'schema={"vendor_name":"string","invoice_number":"string","total_amount":"number","due_date":"date"}'` },
-      { type: "heading", level: 3, id: "step-1-response", text: "Response (200 OK)" },
-      { type: "paragraph", text: "For documents \u22645 pages, you get the extracted data immediately:" },
-      { type: "code", language: "json", title: "Sync response", code: `{
+      { type: "paragraph", text: "The response contains exactly the four fields you asked for \u2014 nothing more. Save the schema with `POST /v1/schemas` for reuse across future extractions." },
+      { type: "heading", level: 2, id: "mode-3-filter", text: "Mode 3 \u2014 Query ingested data" },
+      { type: "paragraph", text: "Don't send a document. Query data you already extracted \u2014 across all documents in your workspace." },
+      { type: "code", language: "bash", title: "curl \u2014 filter previously extracted documents", code: `curl -X POST https://api.talonic.com/v1/documents/filter \\
+  -H "Authorization: Bearer $TALONIC_API_KEY" \\
+  -H "Content-Type: application/json" \\
+  -d '{
+    "conditions": [
+      { "fieldId": "vendor_name", "operator": "eq", "value": "Acme GmbH" }
+    ],
+    "limit": 50
+  }'` },
+      { type: "paragraph", text: "Returns all documents matching your filter \u2014 no re-extraction, no AI cost. Ingest once, query forever." },
+      { type: "heading", level: 2, id: "cost-transparency", text: "Cost on every call" },
+      { type: "paragraph", text: "Every synchronous extraction response includes cost headers so you can track spend per call:" },
+      { type: "code", language: "bash", title: "Cost headers", code: `X-Talonic-Cost-Credits: 12
+X-Talonic-Cost-EUR: 0.012
+X-Talonic-Balance-Credits: 64918
+X-Talonic-Cells-Resolved-Registry: 3
+X-Talonic-Cells-Resolved-AI: 5` },
+      { type: "paragraph", text: "Fields resolved from the registry (`X-Talonic-Cells-Resolved-Registry`) cost nothing. Only AI-resolved fields consume credits." },
+      { type: "heading", level: 2, id: "example-response", text: "Example response" },
+      { type: "paragraph", text: "A synchronous extraction returns structured data with confidence scores:" },
+      { type: "code", language: "json", title: "Response (200 OK)", code: `{
   "extraction_id": "d1a2b3c4-5678-9abc-def0-1234567890ab",
   "request_id": "req_x7y8z9a0b1c2d3e4",
   "status": "complete",
@@ -4507,7 +4598,6 @@ var sections17 = [
     "id": "f0e1d2c3-b4a5-9687-8765-432109876543",
     "filename": "invoice.pdf",
     "pages": 2,
-    "size_bytes": 184320,
     "type_detected": "Invoice"
   },
   "data": {
@@ -4528,35 +4618,29 @@ var sections17 = [
   "processing": {
     "duration_ms": 1840,
     "pages_processed": 2
-  },
-  "links": {
-    "self": "/v1/extractions/d1a2b3c4-5678-9abc-def0-1234567890ab",
-    "document": "/v1/documents/f0e1d2c3-b4a5-9687-8765-432109876543"
   }
 }` },
-      { type: "heading", level: 3, id: "step-2-verify", text: "2. Verify it worked" },
-      { type: "paragraph", text: "Retrieve the extraction by ID to confirm the data is persisted:" },
-      { type: "code", language: "bash", title: "Verify extraction", code: `curl https://api.talonic.com/v1/extractions/d1a2b3c4-5678-9abc-def0-1234567890ab \\
-  -H "Authorization: Bearer $TALONIC_API_KEY"` },
-      { type: "paragraph", text: "You should see the same `data` object. The extraction is now stored and queryable across your workspace." },
       { type: "heading", level: 3, id: "next-steps", text: "Next steps" },
       { type: "list", items: [
         "**Reuse schemas** \u2014 save your schema with `POST /v1/schemas`, then pass `schema_id` on future extractions.",
         "**Large documents** \u2014 files >5 pages return `202 Accepted` with a `poll_url`. See [Processing Modes](extract-processing-mode).",
         "**Webhooks** \u2014 receive results via `extraction.complete` events instead of polling. See [Webhook Events](webhook-events).",
-        "**Batch mode** \u2014 process at 50% cost with `processing_mode=batch`. See [Batches](batches)."
+        "**Batch mode** \u2014 process at 50% cost with `processing_mode=batch`. See [Batches](batches).",
+        "**Credits** \u2014 check your balance anytime with `GET /v1/credits/balance`. See [Credits](credits-balance)."
       ] }
     ],
     related: [
       { label: "POST /v1/extract", slug: "post-extract" },
+      { label: "Filter Documents", slug: "filter-documents" },
       { label: "Schema Formats", slug: "extract-schemas" },
       { label: "Processing Modes", slug: "extract-processing-mode" }
     ],
     faq: [
-      { question: "How do I get started with the Talonic API?", answer: "Set your TALONIC_API_KEY environment variable, then send a file with an inline schema to POST /v1/extract. Documents \u22645 pages return results immediately in sync mode." },
-      { question: "Do I need to create a schema first?", answer: "No. You can pass an inline schema as a JSON object on your first extraction. Save it with POST /v1/schemas later for reuse." }
+      { question: "How do I get started with the Talonic API?", answer: "Three modes: (1) send a file with no schema for auto-detect, (2) send a file with a schema for exact extraction, (3) POST /v1/documents/filter to query already-ingested data." },
+      { question: "Do I need to create a schema first?", answer: "No. Mode 1 auto-detects all fields. Mode 2 accepts an inline schema. Save it with POST /v1/schemas later for reuse." },
+      { question: "Can I query previously extracted data without re-extracting?", answer: "Yes. POST /v1/documents/filter lets you search across all previously extracted documents by field values. No AI cost \u2014 ingest once, query forever." }
     ],
-    mentions: ["curl", "quick start", "sync mode", "TALONIC_API_KEY"]
+    mentions: ["curl", "quick start", "sync mode", "three modes", "auto-detect", "filter", "query", "cost headers"]
   },
   {
     slug: "pagination",
@@ -4851,9 +4935,34 @@ var sections18 = [
           { name: "400", type: "invalid_options", description: "The options field is not valid JSON." },
           { name: "401", type: "unauthorized", description: "Missing or invalid API key." },
           { name: "422", type: "extraction_failed", description: "Extraction completed but produced no usable output. Check the document quality or schema definition." },
-          { name: "429", type: "rate_limited", description: "Too many requests. Retry after the period indicated in the Retry-After header." }
+          { name: "429", type: "rate_limited", description: "Too many requests. Check X-RateLimit-Reset for when the window resets." }
         ]
-      }
+      },
+      { type: "heading", level: 2, id: "post-extract-cost-headers", text: "Cost Headers" },
+      { type: "paragraph", text: "Synchronous 200 responses include cost transparency headers so you can track spend per call without a separate API round-trip:" },
+      {
+        type: "param-table",
+        title: "Cost response headers",
+        params: [
+          { name: "X-Talonic-Cost-Credits", type: "integer", description: "Credits consumed by this extraction." },
+          { name: "X-Talonic-Cost-EUR", type: "number", description: "EUR cost of this extraction." },
+          { name: "X-Talonic-Balance-Credits", type: "integer", description: "Remaining credit balance after this call." },
+          { name: "X-Talonic-Cells-Resolved-Registry", type: "integer", description: "Fields resolved from the registry (no AI cost)." },
+          { name: "X-Talonic-Cells-Resolved-AI", type: "integer", description: "Fields resolved by the AI model." }
+        ]
+      },
+      {
+        type: "code",
+        language: "bash",
+        title: "Cost headers on a sync response",
+        code: `HTTP/1.1 200 OK
+X-Talonic-Cost-Credits: 12
+X-Talonic-Cost-EUR: 0.012
+X-Talonic-Balance-Credits: 64918
+X-Talonic-Cells-Resolved-Registry: 3
+X-Talonic-Cells-Resolved-AI: 5`
+      },
+      { type: "callout", text: "Cost headers are only present on synchronous (200) responses. For async (202) extractions, check the credits balance endpoint or listen for the `extraction.complete` webhook which includes cost data." }
     ],
     related: [
       { label: "Schema Formats", slug: "extract-schemas" },
@@ -17445,6 +17554,979 @@ X-RateLimit-Reset: 2026-04-26T00:00:00.000Z`
   }
 ];
 
+// src/content/sdk/sections.json
+var sections_default = [
+  {
+    slug: "sdk-introduction",
+    parentSlug: "sdk-overview",
+    title: "Introduction",
+    seoTitle: "Node SDK Introduction \u2014 Talonic Docs",
+    description: "Official Talonic SDK for Node.js and TypeScript. Extract structured, schema-validated data from any document with a single function call.",
+    content: [
+      { type: "paragraph", text: "The `@talonic/node` SDK is the official Node.js and TypeScript client for the Talonic API. Extract structured, schema-validated data from any document with a single function call." },
+      { type: "paragraph", text: "Zero runtime dependencies. Requires Node.js 18 or newer." },
+      { type: "callout", text: "Looking for the AI agent path? [`@talonic/mcp`](https://github.com/talonicdev/talonic-mcp) wraps this SDK as a Model Context Protocol server. Install it into Claude Desktop, Cursor, Cline, Continue, or Cowork and any MCP-aware agent can extract documents directly." }
+    ],
+    related: [
+      { label: "Installation", slug: "sdk-installation" },
+      { label: "Quick Start", slug: "sdk-quickstart" },
+      { label: "MCP Server", slug: "mcp-introduction" }
+    ],
+    faq: [
+      { question: "What is the Talonic Node SDK?", answer: "The official Node.js and TypeScript client for extracting structured, schema-validated data from documents via the Talonic API." },
+      { question: "What Node.js version is required?", answer: "Node.js 18 or newer. The SDK has zero runtime dependencies." }
+    ],
+    mentions: ["Node.js", "TypeScript", "SDK", "npm", "document extraction"]
+  },
+  {
+    slug: "sdk-installation",
+    parentSlug: "sdk-overview",
+    title: "Installation",
+    seoTitle: "Install Talonic Node SDK \u2014 Talonic Docs",
+    description: "Install the @talonic/node package via npm. Zero runtime dependencies, requires Node.js 18+.",
+    content: [
+      { type: "code", language: "bash", title: "Install via npm", code: "npm install @talonic/node" },
+      { type: "paragraph", text: "Requires Node.js 18 or newer. Zero runtime dependencies." }
+    ],
+    related: [
+      { label: "Authentication", slug: "sdk-authentication" },
+      { label: "Quick Start", slug: "sdk-quickstart" }
+    ],
+    faq: [
+      { question: "How do I install the Talonic Node SDK?", answer: "Run npm install @talonic/node. Requires Node.js 18 or newer. Zero runtime dependencies." }
+    ],
+    mentions: ["npm", "Node.js"]
+  },
+  {
+    slug: "sdk-authentication",
+    parentSlug: "sdk-overview",
+    title: "Authentication",
+    seoTitle: "SDK Authentication \u2014 Talonic Docs",
+    description: "Get a Talonic API key and configure it for the Node SDK. Each workspace is isolated with private documents and schemas.",
+    content: [
+      { type: "paragraph", text: "Every user runs against their own Talonic workspace, so each user needs their own key. Workspaces are isolated; your documents and schemas are private to you." },
+      { type: "list", ordered: true, items: [
+        "Sign up at [https://app.talonic.com](https://app.talonic.com). Free tier: 50 extractions per day, no credit card.",
+        "Settings → API Keys → Create New Key.",
+        "Copy the `tlnc_` value.",
+        "Set it as the `TALONIC_API_KEY` environment variable, or pass it directly to the client constructor."
+      ] },
+      { type: "callout", text: "Keep your API key secret. Do not expose it in client-side code or version control." }
+    ],
+    related: [
+      { label: "Configuration", slug: "sdk-configuration" },
+      { label: "API Authentication", slug: "authentication" }
+    ],
+    faq: [
+      { question: "Where do I get a Talonic API key?", answer: "Sign up at app.talonic.com, go to Settings \u2192 API Keys \u2192 Create New Key. Free tier includes 50 extractions per day." }
+    ],
+    mentions: ["API key", "authentication", "workspace"]
+  },
+  {
+    slug: "sdk-quickstart",
+    parentSlug: "sdk-overview",
+    title: "Quick Start",
+    seoTitle: "Node SDK Quick Start \u2014 Talonic Docs",
+    description: "Extract structured data from a document in five lines of TypeScript using the Talonic Node SDK.",
+    content: [
+      { type: "code", language: "typescript", title: "Extract an invoice", code: 'import { Talonic } from "@talonic/node"\n\nconst talonic = new Talonic({ apiKey: process.env.TALONIC_API_KEY! })\n\nconst result = await talonic.extract({\n  file_path: "./invoice.pdf",\n  schema: {\n    vendor_name: "string",\n    invoice_number: "string",\n    total_amount: "number",\n    due_date: "date",\n  },\n})\n\nconsole.log(result.data)\n// { vendor_name: "Acme Corp", invoice_number: "INV-2024-0847", total_amount: 14250, due_date: "2024-03-15" }' }
+    ],
+    related: [
+      { label: "Extract", slug: "sdk-extract" },
+      { label: "Configuration", slug: "sdk-configuration" },
+      { label: "Schemas", slug: "sdk-schemas" }
+    ],
+    faq: [
+      { question: "How do I extract data from a document with the SDK?", answer: "Call talonic.extract() with a file_path and a schema defining the fields you want. Returns structured JSON with confidence scores." }
+    ],
+    mentions: ["extract", "schema", "TypeScript", "quickstart"]
+  },
+  {
+    slug: "sdk-configuration",
+    parentSlug: "sdk-client",
+    title: "Configuration",
+    seoTitle: "SDK Configuration \u2014 Talonic Docs",
+    description: "Configure the Talonic client with API key, base URL, timeout, max retries, and custom fetch function.",
+    content: [
+      { type: "code", language: "typescript", title: "Client configuration", code: 'const talonic = new Talonic({\n  apiKey: process.env.TALONIC_API_KEY!,\n  baseUrl: "https://api.talonic.com",   // default\n  timeout: 60_000,                       // ms; default 60s\n  maxRetries: 3,                         // 429, 500, 502, 503, 504, network, timeout\n  fetch: customFetch,                    // optional override (e.g. for testing)\n})' },
+      { type: "param-table", title: "Constructor options", params: [
+        { name: "apiKey", type: "string", required: true, description: "Your Talonic API key. Starts with `tlnc_`." },
+        { name: "baseUrl", type: "string", description: "API base URL. Default: `https://api.talonic.com`." },
+        { name: "timeout", type: "number", description: "Request timeout in milliseconds. Default: `60000`." },
+        { name: "maxRetries", type: "number", description: "Maximum retry attempts for transient errors. Default: `3`." },
+        { name: "fetch", type: "function", description: "Custom fetch implementation for testing or proxying." }
+      ] }
+    ],
+    related: [
+      { label: "Retries", slug: "sdk-retries" },
+      { label: "Error Classes", slug: "sdk-error-classes" }
+    ],
+    faq: [],
+    mentions: ["configuration", "timeout", "retries", "fetch"]
+  },
+  {
+    slug: "sdk-extract",
+    parentSlug: "sdk-client",
+    title: "Extract",
+    seoTitle: "SDK Extract Method \u2014 Talonic Docs",
+    description: "The top-level talonic.extract() method for single-call document extraction with schema validation.",
+    content: [
+      { type: "paragraph", text: "The top-level `extract()` method is the fastest way to get structured data from a document. Provide a file and a schema, get back validated JSON." },
+      { type: "code", language: "typescript", title: "Basic extraction", code: 'const result = await talonic.extract({\n  file_path: "./invoice.pdf",\n  schema: {\n    vendor_name: "string",\n    invoice_number: "string",\n    total_amount: "number",\n  },\n})' },
+      { type: "paragraph", text: "You can also pass `file_url`, `schema_id` (for saved schemas), or a full JSON Schema definition." }
+    ],
+    related: [
+      { label: "Quick Start", slug: "sdk-quickstart" },
+      { label: "Schemas", slug: "sdk-schemas" },
+      { label: "POST /v1/extract", slug: "post-extract" }
+    ],
+    faq: [],
+    mentions: ["extract", "schema", "file_path", "file_url"]
+  },
+  {
+    slug: "sdk-documents",
+    parentSlug: "sdk-resources",
+    title: "Documents",
+    seoTitle: "SDK Documents Resource \u2014 Talonic Docs",
+    description: "List, get, delete, and re-extract documents using the Talonic Node SDK documents resource.",
+    content: [
+      { type: "code", language: "typescript", title: "Documents API", code: "// List documents with pagination\nawait talonic.documents.list({ per_page: 50 })\n\n// Get a single document\nawait talonic.documents.get(id)\n\n// Get OCR markdown\nawait talonic.documents.getMarkdown(id)\n\n// Re-extract a document\nawait talonic.documents.reExtract(id)\n\n// Delete a document\nawait talonic.documents.delete(id)" }
+    ],
+    related: [
+      { label: "Documents API", slug: "list-documents" },
+      { label: "Extractions", slug: "sdk-extractions" }
+    ],
+    faq: [],
+    mentions: ["documents", "list", "get", "delete", "markdown", "re-extract"]
+  },
+  {
+    slug: "sdk-extractions",
+    parentSlug: "sdk-resources",
+    title: "Extractions",
+    seoTitle: "SDK Extractions Resource \u2014 Talonic Docs",
+    description: "Query extraction results, retrieve structured data in JSON or CSV, and submit field corrections via the Node SDK.",
+    content: [
+      { type: "code", language: "typescript", title: "Extractions API", code: '// List extractions for a document\nawait talonic.extractions.list({ document_id })\n\n// Get extraction metadata\nawait talonic.extractions.get(id)\n\n// Get structured data as object\nawait talonic.extractions.getData(id)\n\n// Get structured data as CSV string\nawait talonic.extractions.getData(id, { format: "csv" })\n\n// Submit corrections\nawait talonic.extractions.patch(id, { corrections: [...] })' }
+    ],
+    related: [
+      { label: "Extractions API", slug: "list-extractions" },
+      { label: "Documents", slug: "sdk-documents" }
+    ],
+    faq: [],
+    mentions: ["extractions", "corrections", "CSV", "structured data"]
+  },
+  {
+    slug: "sdk-schemas",
+    parentSlug: "sdk-resources",
+    title: "Schemas",
+    seoTitle: "SDK Schemas Resource \u2014 Talonic Docs",
+    description: "Create, list, get, update, and delete reusable extraction schemas via the Talonic Node SDK.",
+    content: [
+      { type: "code", language: "typescript", title: "Schemas API", code: "// List all schemas\nawait talonic.schemas.list()\n\n// Get a schema\nawait talonic.schemas.get(id)\n\n// Create a new schema\nawait talonic.schemas.create({ name, definition })\n\n// Update a schema\nawait talonic.schemas.update(id, { ... })\n\n// Delete a schema\nawait talonic.schemas.delete(id)" }
+    ],
+    related: [
+      { label: "Schemas API", slug: "list-schemas" },
+      { label: "Extract", slug: "sdk-extract" }
+    ],
+    faq: [],
+    mentions: ["schemas", "create", "update", "delete"]
+  },
+  {
+    slug: "sdk-jobs",
+    parentSlug: "sdk-resources",
+    title: "Jobs",
+    seoTitle: "SDK Jobs Resource \u2014 Talonic Docs",
+    description: "Create, list, get results, and cancel asynchronous batch extraction jobs via the Node SDK.",
+    content: [
+      { type: "code", language: "typescript", title: "Jobs API", code: "// Create a batch job\nawait talonic.jobs.create({ schema_id, document_ids })\n\n// List all jobs\nawait talonic.jobs.list()\n\n// Get job status\nawait talonic.jobs.get(id)\n\n// Get job results\nawait talonic.jobs.getResults(id)\n\n// Cancel a running job\nawait talonic.jobs.cancel(id)" }
+    ],
+    related: [
+      { label: "Jobs API", slug: "list-jobs" },
+      { label: "Batch Inference", slug: "batch-overview" }
+    ],
+    faq: [],
+    mentions: ["jobs", "batch", "asynchronous", "cancel"]
+  },
+  {
+    slug: "sdk-cli-usage",
+    parentSlug: "sdk-cli",
+    title: "Usage",
+    seoTitle: "Talonic CLI Usage \u2014 Talonic Docs",
+    description: "Use the talonic CLI binary for command-line extraction, schema management, and document listing.",
+    content: [
+      { type: "paragraph", text: "The package ships with a `talonic` binary for command-line usage:" },
+      { type: "code", language: "bash", title: "CLI examples", code: `talonic schemas list
+talonic documents list --per-page=20
+talonic extract ./invoice.pdf \\
+  --schema='{"vendor_name":"string","total_amount":"number"}'
+talonic --help` }
+    ],
+    related: [
+      { label: "Extract", slug: "sdk-extract" },
+      { label: "Schemas", slug: "sdk-schemas" }
+    ],
+    faq: [
+      { question: "Does the Talonic SDK include a CLI?", answer: "Yes. The @talonic/node package ships a talonic binary for command-line extraction, schema management, and document operations." }
+    ],
+    mentions: ["CLI", "command line", "talonic binary"]
+  },
+  {
+    slug: "sdk-error-classes",
+    parentSlug: "sdk-errors",
+    title: "Error Classes",
+    seoTitle: "SDK Error Classes \u2014 Talonic Docs",
+    description: "Typed error hierarchy for the Talonic Node SDK: TalonicError base class with subclasses for auth, validation, rate limit, server, network, and timeout errors.",
+    content: [
+      { type: "paragraph", text: "Every failure is a `TalonicError` subclass with `code`, `status`, `requestId`, and `message` properties:" },
+      { type: "param-table", title: "Error classes", params: [
+        { name: "TalonicAuthError", type: "401, 403", description: "Authentication or authorization failure." },
+        { name: "TalonicNotFoundError", type: "404", description: "Resource not found." },
+        { name: "TalonicValidationError", type: "400, 409, 413, 422", description: "Request validation failure." },
+        { name: "TalonicRateLimitError", type: "429", description: "Rate limit exceeded (after retries exhausted). Includes `rateLimit.resetAt`." },
+        { name: "TalonicServerError", type: "5xx", description: "Server error (after retries exhausted)." },
+        { name: "TalonicNetworkError", type: "\u2014", description: "DNS or TCP connection failure." },
+        { name: "TalonicTimeoutError", type: "\u2014", description: "Request exceeded configured timeout." }
+      ] },
+      { type: "code", language: "typescript", title: "Error handling", code: 'import {\n  TalonicError,\n  TalonicRateLimitError,\n} from "@talonic/node"\n\ntry {\n  await talonic.extract({ ... })\n} catch (err) {\n  if (err instanceof TalonicRateLimitError) {\n    console.log(`Reset at ${err.rateLimit.resetAt}`)\n  } else if (err instanceof TalonicError) {\n    console.error(`${err.code} (status ${err.status}, request ${err.requestId}): ${err.message}`)\n  }\n}' }
+    ],
+    related: [
+      { label: "Retries", slug: "sdk-retries" },
+      { label: "Error Codes", slug: "error-codes" }
+    ],
+    faq: [
+      { question: "What error types does the Talonic SDK throw?", answer: "TalonicAuthError (401/403), TalonicNotFoundError (404), TalonicValidationError (400/409/413/422), TalonicRateLimitError (429), TalonicServerError (5xx), TalonicNetworkError, and TalonicTimeoutError." }
+    ],
+    mentions: ["TalonicError", "error handling", "typed errors"]
+  },
+  {
+    slug: "sdk-retries",
+    parentSlug: "sdk-errors",
+    title: "Retries",
+    seoTitle: "SDK Retry Behavior \u2014 Talonic Docs",
+    description: "Automatic retry behavior for the Talonic Node SDK: exponential backoff with jitter on transient errors and rate limits.",
+    content: [
+      { type: "paragraph", text: "The SDK retries automatically on `429` (respecting `X-RateLimit-Reset`), `500`, `502`, `503`, `504`, network errors, and timeouts. Backoff is exponential with jitter, capped at 16 seconds." },
+      { type: "paragraph", text: "The API may set `retryable: false` on a specific error; the SDK respects that and does not retry." },
+      { type: "paragraph", text: "Configure the maximum number of retries via the `maxRetries` constructor option (default: `3`)." }
+    ],
+    related: [
+      { label: "Configuration", slug: "sdk-configuration" },
+      { label: "Error Classes", slug: "sdk-error-classes" },
+      { label: "Rate Limits", slug: "rate-limits" }
+    ],
+    faq: [
+      { question: "Does the SDK retry failed requests?", answer: "Yes. Automatic retries on 429, 500, 502, 503, 504, network errors, and timeouts with exponential backoff capped at 16s. Configure via maxRetries (default: 3)." }
+    ],
+    mentions: ["retries", "exponential backoff", "rate limit", "429"]
+  }
+];
+
+// src/content/sdk/index.ts
+var sections45 = sections_default;
+
+// src/content/mcp/sections.json
+var sections_default2 = [
+  {
+    slug: "mcp-introduction",
+    parentSlug: "mcp-overview",
+    title: "Introduction",
+    seoTitle: "MCP Server Introduction \u2014 Talonic Docs",
+    description: "Official Talonic MCP server for AI agents. Seven tools and one resource for structured document extraction via the Model Context Protocol.",
+    content: [
+      { type: "paragraph", text: "The `@talonic/mcp` package is the official Talonic MCP server. It gives AI agents seven tools for extracting structured, schema-validated data from any document via the [Model Context Protocol](https://modelcontextprotocol.io)." },
+      { type: "paragraph", text: "When an agent needs to pull structured data out of a PDF, scan, image, or messy document, the usual approach is raw OCR plus an LLM call. Results are unreliable; tables get mangled, dates get misread, totals drift." },
+      { type: "paragraph", text: "With this MCP server installed, the agent has a `talonic_extract` tool that returns schema-validated JSON with per-field confidence scores, a detected document type, and stable IDs for follow-up calls." },
+      { type: "callout", text: "Listed on the [official MCP Registry](https://registry.modelcontextprotocol.io/) as `io.github.talonicdev/talonic-mcp`." }
+    ],
+    related: [
+      { label: "Installation", slug: "mcp-installation" },
+      { label: "Tools", slug: "mcp-talonic-extract" },
+      { label: "Node SDK", slug: "sdk-introduction" }
+    ],
+    faq: [
+      { question: "What is the Talonic MCP server?", answer: "An official Model Context Protocol server that gives AI agents seven tools for document extraction, search, filtering, and schema management via the Talonic API." }
+    ],
+    mentions: ["MCP", "Model Context Protocol", "AI agents", "document extraction"]
+  },
+  {
+    slug: "mcp-installation",
+    parentSlug: "mcp-overview",
+    title: "Installation",
+    seoTitle: "Install Talonic MCP Server \u2014 Talonic Docs",
+    description: "Two ways to connect: hosted MCP at mcp.talonic.com (zero install) or local via npx. Full config examples for both.",
+    content: [
+      { type: "paragraph", text: "Two ways to connect. The hosted server at `mcp.talonic.com` requires zero install \u2014 paste one URL into any MCP client. Or run locally via `npx` if you prefer." },
+      { type: "heading", level: 3, text: "Hosted (recommended)" },
+      { type: "paragraph", text: "No install, no Node.js required. Works with every MCP client that supports remote servers. The hosted server runs the latest published version and is maintained by Talonic." },
+      { type: "code", language: "json", title: "Hosted config", code: '{\n  "mcpServers": {\n    "talonic": {\n      "url": "https://mcp.talonic.com/mcp",\n      "headers": {\n        "Authorization": "Bearer tlnc_your_key_here"\n      }\n    }\n  }\n}' },
+      { type: "paragraph", text: "Your API key is sent via the `Authorization: Bearer` header on every request. The server creates an authenticated session per client connection." },
+      { type: "heading", level: 3, text: "Local (npx)" },
+      { type: "paragraph", text: "Runs on your machine. Requires Node.js 18+. Use this if your MCP client does not support remote servers, or if you need to point at a custom API base URL:" },
+      { type: "code", language: "json", title: "Local config", code: '{\n  "mcpServers": {\n    "talonic": {\n      "command": "npx",\n      "args": ["-y", "@talonic/mcp@latest"],\n      "env": {\n        "TALONIC_API_KEY": "tlnc_your_key_here"\n      }\n    }\n  }\n}' },
+      { type: "paragraph", text: "The `-y` flag skips the npm install prompt. Pinning to `@latest` means new versions are picked up on the next client restart." },
+      { type: "heading", level: 3, text: "Hosted vs Local" },
+      { type: "paragraph", text: "**Use hosted when:** you want zero setup, your client supports remote MCP servers (Claude Desktop, Cursor, Cline, Continue, Cowork), you don't want to install Node.js, or you're deploying to a team and want everyone on the same server version." },
+      { type: "paragraph", text: "**Use local when:** your MCP client only supports stdio transport, you need to override `TALONIC_BASE_URL` for staging/testing, or you need an air-gapped environment." }
+    ],
+    related: [
+      { label: "Claude Desktop", slug: "mcp-claude-desktop" },
+      { label: "Cursor", slug: "mcp-cursor" },
+      { label: "Authentication", slug: "mcp-authentication" }
+    ],
+    faq: [
+      { question: "How do I install the Talonic MCP server?", answer: "Use the hosted server at mcp.talonic.com/mcp \u2014 set the URL and your API key in any MCP client config. No install needed. Alternatively, run locally via npx @talonic/mcp." },
+      { question: "What is the difference between hosted and local MCP?", answer: "Hosted runs at mcp.talonic.com with zero install \u2014 just a URL and API key. Local runs on your machine via npx, useful when your client only supports stdio or you need a custom base URL." }
+    ],
+    mentions: ["npx", "npm", "MCP client", "install", "hosted", "mcp.talonic.com"]
+  },
+  {
+    slug: "mcp-authentication",
+    parentSlug: "mcp-overview",
+    title: "Authentication",
+    seoTitle: "MCP Authentication \u2014 Talonic Docs",
+    description: "Get a Talonic API key for the MCP server. Hosted uses Authorization header; local uses env var.",
+    content: [
+      { type: "paragraph", text: "Each user runs against their own isolated Talonic workspace. Your documents and schemas are private to you." },
+      { type: "list", ordered: true, items: [
+        "Sign up at [https://app.talonic.com](https://app.talonic.com). Free tier: 50 extractions per day, no credit card.",
+        "Settings \u2192 API Keys \u2192 Create New Key.",
+        "Copy the `tlnc_` value into your MCP client config."
+      ] },
+      { type: "heading", level: 3, text: "Auth for hosted server" },
+      { type: "paragraph", text: "The hosted server at `mcp.talonic.com` accepts the API key in two ways:" },
+      { type: "list", ordered: false, items: [
+        "`Authorization: Bearer tlnc_...` header (recommended, used in the `headers` config block)",
+        "`?apiKey=tlnc_...` query parameter (convenience for clients that don't support custom headers)"
+      ] },
+      { type: "heading", level: 3, text: "Auth for local server" },
+      { type: "paragraph", text: "Set `TALONIC_API_KEY` in the `env` block of your MCP client config. The server reads it at startup." }
+    ],
+    related: [
+      { label: "Installation", slug: "mcp-installation" },
+      { label: "API Authentication", slug: "authentication" }
+    ],
+    faq: [
+      { question: "How do I authenticate with the hosted MCP server?", answer: "Pass your API key via the Authorization: Bearer header in the MCP client config headers block, or as a ?apiKey= query parameter on the URL." }
+    ],
+    mentions: ["API key", "workspace", "authentication", "Authorization", "Bearer"]
+  },
+  {
+    slug: "mcp-claude-desktop",
+    parentSlug: "mcp-clients",
+    title: "Claude Desktop",
+    seoTitle: "MCP Setup for Claude Desktop \u2014 Talonic Docs",
+    description: "Step-by-step setup for the Talonic MCP server in Claude Desktop on macOS and Windows. Hosted and local configs.",
+    content: [
+      { type: "paragraph", text: "Edit `~/Library/Application Support/Claude/claude_desktop_config.json` (macOS) or `%APPDATA%\\Claude\\claude_desktop_config.json` (Windows)." },
+      { type: "heading", level: 3, text: "Hosted (recommended)" },
+      { type: "code", language: "json", title: "claude_desktop_config.json", code: '{\n  "mcpServers": {\n    "talonic": {\n      "url": "https://mcp.talonic.com/mcp",\n      "headers": {\n        "Authorization": "Bearer tlnc_your_key_here"\n      }\n    }\n  }\n}' },
+      { type: "heading", level: 3, text: "Local (npx)" },
+      { type: "code", language: "json", title: "claude_desktop_config.json", code: '{\n  "mcpServers": {\n    "talonic": {\n      "command": "npx",\n      "args": ["-y", "@talonic/mcp@latest"],\n      "env": {\n        "TALONIC_API_KEY": "tlnc_your_key_here"\n      }\n    }\n  }\n}' },
+      { type: "paragraph", text: "Fully restart Claude Desktop (Cmd+Q on macOS, not just close the window). Talonic appears in the connected servers list with all seven tools." }
+    ],
+    related: [
+      { label: "Cursor", slug: "mcp-cursor" },
+      { label: "Tool Reference", slug: "mcp-talonic-extract" }
+    ],
+    faq: [
+      { question: "How do I add Talonic to Claude Desktop?", answer: "Edit claude_desktop_config.json, add the Talonic MCP server config (hosted URL or local npx) with your API key, and fully restart Claude Desktop (Cmd+Q on macOS)." }
+    ],
+    mentions: ["Claude Desktop", "macOS", "Windows"]
+  },
+  {
+    slug: "mcp-cursor",
+    parentSlug: "mcp-clients",
+    title: "Cursor",
+    seoTitle: "MCP Setup for Cursor \u2014 Talonic Docs",
+    description: "Configure the Talonic MCP server in Cursor IDE. Hosted and local configs.",
+    content: [
+      { type: "paragraph", text: "Edit `~/.cursor/mcp.json` (or open Cursor settings \u2192 MCP \u2192 edit config):" },
+      { type: "heading", level: 3, text: "Hosted (recommended)" },
+      { type: "code", language: "json", title: "~/.cursor/mcp.json", code: '{\n  "mcpServers": {\n    "talonic": {\n      "url": "https://mcp.talonic.com/mcp",\n      "headers": {\n        "Authorization": "Bearer tlnc_your_key_here"\n      }\n    }\n  }\n}' },
+      { type: "heading", level: 3, text: "Local (npx)" },
+      { type: "code", language: "json", title: "~/.cursor/mcp.json", code: '{\n  "mcpServers": {\n    "talonic": {\n      "command": "npx",\n      "args": ["-y", "@talonic/mcp@latest"],\n      "env": {\n        "TALONIC_API_KEY": "tlnc_your_key_here"\n      }\n    }\n  }\n}' }
+    ],
+    related: [
+      { label: "Claude Desktop", slug: "mcp-claude-desktop" },
+      { label: "Cline", slug: "mcp-cline" }
+    ],
+    faq: [
+      { question: "How do I add Talonic MCP to Cursor?", answer: "Edit ~/.cursor/mcp.json and add the Talonic MCP server config with your API key. Hosted or local." }
+    ],
+    mentions: ["Cursor", "IDE"]
+  },
+  {
+    slug: "mcp-cline",
+    parentSlug: "mcp-clients",
+    title: "Cline",
+    seoTitle: "MCP Setup for Cline \u2014 Talonic Docs",
+    description: "Configure the Talonic MCP server in the Cline VS Code extension. Hosted and local configs.",
+    content: [
+      { type: "paragraph", text: "Open the Cline panel \u2192 settings (gear icon) \u2192 MCP Servers \u2192 Edit." },
+      { type: "heading", level: 3, text: "Hosted (recommended)" },
+      { type: "code", language: "json", code: '{\n  "mcpServers": {\n    "talonic": {\n      "url": "https://mcp.talonic.com/mcp",\n      "headers": {\n        "Authorization": "Bearer tlnc_your_key_here"\n      }\n    }\n  }\n}' },
+      { type: "heading", level: 3, text: "Local (npx)" },
+      { type: "code", language: "json", code: '{\n  "mcpServers": {\n    "talonic": {\n      "command": "npx",\n      "args": ["-y", "@talonic/mcp@latest"],\n      "env": {\n        "TALONIC_API_KEY": "tlnc_your_key_here"\n      }\n    }\n  }\n}' },
+      { type: "paragraph", text: "Save and restart the panel." }
+    ],
+    related: [
+      { label: "Continue", slug: "mcp-continue" },
+      { label: "Cursor", slug: "mcp-cursor" }
+    ],
+    faq: [
+      { question: "How do I add Talonic MCP to Cline?", answer: "Open the Cline panel settings, go to MCP Servers, click Edit, and add the Talonic config entry." }
+    ],
+    mentions: ["Cline", "VS Code"]
+  },
+  {
+    slug: "mcp-continue",
+    parentSlug: "mcp-clients",
+    title: "Continue",
+    seoTitle: "MCP Setup for Continue \u2014 Talonic Docs",
+    description: "Configure the Talonic MCP server in Continue for VS Code and JetBrains. Hosted and local configs.",
+    content: [
+      { type: "paragraph", text: "Edit `~/.continue/config.json`. Add to the `mcpServers` array:" },
+      { type: "heading", level: 3, text: "Hosted (recommended)" },
+      { type: "code", language: "json", title: "~/.continue/config.json", code: '{\n  "name": "talonic",\n  "url": "https://mcp.talonic.com/mcp",\n  "headers": {\n    "Authorization": "Bearer tlnc_your_key_here"\n  }\n}' },
+      { type: "heading", level: 3, text: "Local (npx)" },
+      { type: "code", language: "json", title: "~/.continue/config.json", code: '{\n  "name": "talonic",\n  "command": "npx",\n  "args": ["-y", "@talonic/mcp@latest"],\n  "env": {\n    "TALONIC_API_KEY": "tlnc_your_key_here"\n  }\n}' }
+    ],
+    related: [
+      { label: "Cowork", slug: "mcp-cowork" },
+      { label: "Cline", slug: "mcp-cline" }
+    ],
+    faq: [
+      { question: "How do I add Talonic MCP to Continue?", answer: "Edit ~/.continue/config.json and add a Talonic entry to the mcpServers array with your API key." }
+    ],
+    mentions: ["Continue", "VS Code", "JetBrains"]
+  },
+  {
+    slug: "mcp-cowork",
+    parentSlug: "mcp-clients",
+    title: "Cowork",
+    seoTitle: "MCP Setup for Cowork \u2014 Talonic Docs",
+    description: "Configure the Talonic MCP server in Cowork. Hosted and local configs.",
+    content: [
+      { type: "paragraph", text: "Open Cowork settings \u2192 MCP Servers \u2192 Add." },
+      { type: "heading", level: 3, text: "Hosted (recommended)" },
+      { type: "code", language: "json", code: '{\n  "mcpServers": {\n    "talonic": {\n      "url": "https://mcp.talonic.com/mcp",\n      "headers": {\n        "Authorization": "Bearer tlnc_your_key_here"\n      }\n    }\n  }\n}' },
+      { type: "heading", level: 3, text: "Local (npx)" },
+      { type: "code", language: "json", code: '{\n  "mcpServers": {\n    "talonic": {\n      "command": "npx",\n      "args": ["-y", "@talonic/mcp@latest"],\n      "env": {\n        "TALONIC_API_KEY": "tlnc_your_key_here"\n      }\n    }\n  }\n}' }
+    ],
+    related: [
+      { label: "Claude Desktop", slug: "mcp-claude-desktop" },
+      { label: "Tool Reference", slug: "mcp-talonic-extract" }
+    ],
+    faq: [
+      { question: "How do I add Talonic MCP to Cowork?", answer: "Open Cowork settings, go to MCP Servers, click Add, and paste the standard Talonic config with your API key." }
+    ],
+    mentions: ["Cowork"]
+  },
+  {
+    slug: "mcp-talonic-extract",
+    parentSlug: "mcp-tools",
+    title: "talonic_extract",
+    seoTitle: "talonic_extract MCP Tool \u2014 Talonic Docs",
+    description: "Extract structured, schema-validated data from a document. Full input schema, output schema, confidence scores, and usage examples.",
+    content: [
+      { type: "paragraph", text: "Extract structured, schema-validated data from a document. Returns clean JSON matching the schema, with per-field confidence scores and document metadata." },
+      { type: "heading", level: 3, text: "When to use" },
+      { type: "list", ordered: false, items: [
+        "The user has a document (PDF, image, scan, DOCX) and wants specific fields pulled out.",
+        "You need structured data (vendor name, total amount, dates, parties, terms) rather than free text.",
+        "The user uploads or references any invoice, contract, certificate, statement, or form.",
+        "You want validated JSON instead of trying to OCR + parse with raw LLM calls."
+      ] },
+      { type: "heading", level: 3, text: "When NOT to use" },
+      { type: "list", ordered: false, items: [
+        "The user just wants full text content \u2192 use `talonic_to_markdown`.",
+        "The user wants to find documents matching a query \u2192 use `talonic_search` or `talonic_filter`."
+      ] },
+      { type: "heading", level: 3, text: "Input schema" },
+      { type: "param-table", title: "File source (provide exactly one)", params: [
+        { name: "file_data", type: "string", description: "Base64-encoded file bytes. **Recommended for chat clients** (Claude Desktop, Cursor). Pair with `filename` for MIME type inference." },
+        { name: "filename", type: "string", description: "Original filename with extension, e.g. `invoice.pdf`. Required when using `file_data`." },
+        { name: "file_path", type: "string", description: "Local filesystem path. Only works if the MCP server process can read it \u2014 sandboxed clients should use `file_data` instead." },
+        { name: "file_url", type: "string", description: "Public URL. The Talonic API fetches it server-side." },
+        { name: "document_id", type: "string", description: "Re-extract an already-uploaded document with a new schema." }
+      ] },
+      { type: "param-table", title: "Schema (provide at most one)", params: [
+        { name: "schema", type: "object", description: 'Inline schema definition. **Use full JSON Schema format** (`{type: "object", properties: {...}}`) for best results. Flat key-type maps (`{vendor_name: "string"}`) are accepted but normalized server-side \u2014 if you get a \'no fields\' error, switch to full JSON Schema.' },
+        { name: "schema_id", type: "string", description: "ID of a saved schema. Accepts UUID or `SCH-XXXXXXXX` short ID. Mutually exclusive with `schema`." }
+      ] },
+      { type: "param-table", title: "Options", params: [
+        { name: "instructions", type: "string", description: "Natural-language guidance for the extractor, e.g. `Focus on the billing section. Amounts are in EUR.`" },
+        { name: "include_markdown", type: "boolean", description: "Include OCR-converted markdown alongside structured data in the response." }
+      ] },
+      { type: "heading", level: 3, text: "Response shape" },
+      { type: "code", language: "json", title: "Example response", code: '{\n  "data": {\n    "vendor_name": "Acme Corp",\n    "invoice_number": "INV-2024-0847",\n    "total_amount": 14250.00,\n    "due_date": "2024-03-15"\n  },\n  "confidence": {\n    "vendor_name": 0.97,\n    "invoice_number": 0.99,\n    "total_amount": 0.94,\n    "due_date": 0.91\n  },\n  "document": {\n    "id": "d_abc123",\n    "filename": "invoice.pdf",\n    "documentType": "invoice",\n    "language": "en",\n    "pageCount": 2\n  },\n  "extraction": {\n    "id": "ext_xyz789",\n    "schemaId": "sch_def456"\n  }\n}' },
+      { type: "heading", level: 3, text: "Confidence scores and human escalation" },
+      { type: "paragraph", text: "Each field in the `confidence` object is a float from 0.0 to 1.0. Values above **0.90** are high confidence. Values between **0.70\u20130.90** should be treated with caution \u2014 flag them to the user for verification. Values below **0.70** indicate low confidence \u2014 the agent should ask the user to verify the value or re-extract with more specific instructions." },
+      { type: "callout", variant: "warning", text: "Always provide either a `schema` or `schema_id`. Auto-discovery (no schema) currently returns 500 on production." },
+      { type: "heading", level: 3, text: "Cost" },
+      { type: "paragraph", text: "Each `talonic_extract` call with a new file consumes **one extraction credit**. Re-extracting the same `document_id` with a different schema also consumes one credit. To avoid unnecessary cost, check if a document has already been extracted before calling again \u2014 use `talonic_search` or `talonic_filter` to find existing results." },
+      { type: "heading", level: 3, text: "Errors" },
+      { type: "param-table", title: "Common errors", params: [
+        { name: "unauthorized", type: "401", description: "Invalid or missing API key." },
+        { name: "validation_error", type: "422", description: "Missing schema, invalid schema format, or no file source provided." },
+        { name: "unsupported_file_type", type: "422", description: "MIME type inferred as `application/octet-stream`. Ensure the filename has a recognized extension (pdf, docx, png, jpg, etc.)." },
+        { name: "rate_limit_exceeded", type: "429", description: "Too many requests. The SDK retries automatically with backoff." },
+        { name: "insufficient_credits", type: "402", description: "Extraction credit balance exhausted. Upgrade plan or wait for daily reset (free tier)." }
+      ] }
+    ],
+    related: [
+      { label: "SDK Extract", slug: "sdk-extract" },
+      { label: "POST /v1/extract", slug: "post-extract" },
+      { label: "Cost & Rate Limits", slug: "mcp-cost-and-limits" }
+    ],
+    faq: [
+      { question: "What does talonic_extract return?", answer: "Structured JSON matching your schema, per-field confidence scores (0.0\u20131.0), document metadata (type, language, page count), and extraction/schema IDs for follow-up calls." },
+      { question: "How do I handle low confidence scores?", answer: "Scores above 0.90 are reliable. Between 0.70\u20130.90, flag to the user for verification. Below 0.70, ask the user to verify or re-extract with more specific instructions." }
+    ],
+    mentions: ["talonic_extract", "file_data", "schema", "confidence", "extraction"]
+  },
+  {
+    slug: "mcp-talonic-search",
+    parentSlug: "mcp-tools",
+    title: "talonic_search",
+    seoTitle: "talonic_search MCP Tool \u2014 Talonic Docs",
+    description: "Omnisearch across documents, fields, sources, and schemas. Full input/output schema, examples, and usage guidance.",
+    content: [
+      { type: "paragraph", text: "Omnisearch across documents, extracted field values, field names, sources, and schemas in the workspace. Returns ranked results across all entity types in one call." },
+      { type: "heading", level: 3, text: "When to use" },
+      { type: "list", ordered: false, items: [
+        "The user wants to find documents but doesn't know the exact filename or ID.",
+        "The query is conceptual: 'contracts mentioning indemnification', 'Acme invoices'.",
+        "You need to narrow a large workspace before calling `talonic_extract` or `talonic_filter`.",
+        "The user asks 'do I have any docs about X' or 'find anything related to X'.",
+        "You need to discover canonical field names before using `talonic_filter`."
+      ] },
+      { type: "heading", level: 3, text: "When NOT to use" },
+      { type: "list", ordered: false, items: [
+        "The user has a specific `document_id` \u2192 use `talonic_get_document`.",
+        "The user wants structured field-value filters like 'amount > 1000' \u2192 use `talonic_filter`.",
+        "The user wants to extract data from a new document \u2192 use `talonic_extract`."
+      ] },
+      { type: "heading", level: 3, text: "Input schema" },
+      { type: "param-table", title: "Parameters", params: [
+        { name: "query", type: "string", required: true, description: "Natural-language search query, e.g. `indemnification clauses` or `Acme invoices Q4`." },
+        { name: "limit", type: "number", description: "Maximum results per entity type. Default: 5. Increase for broader exploration." }
+      ] },
+      { type: "heading", level: 3, text: "Response shape" },
+      { type: "code", language: "json", title: "Example response", code: '{\n  "documents": [\n    {\n      "id": "d_abc123",\n      "filename": "acme-invoice-q4.pdf",\n      "documentType": "invoice",\n      "score": 0.92\n    }\n  ],\n  "fieldMatches": [\n    {\n      "documentId": "d_abc123",\n      "fieldName": "vendor.name",\n      "canonicalName": "vendor.name",\n      "value": "Acme Corp",\n      "score": 0.88\n    }\n  ],\n  "sources": [],\n  "schemas": [\n    {\n      "id": "sch_def456",\n      "name": "Standard Invoice",\n      "score": 0.75\n    }\n  ],\n  "fields": [\n    {\n      "id": "f_ghi789",\n      "canonicalName": "vendor.name",\n      "displayName": "Vendor Name",\n      "score": 0.85\n    }\n  ]\n}' },
+      { type: "callout", text: "The `fields[].canonicalName` values are what you pass to `talonic_filter` as the `field` parameter. Always use search to discover field names before filtering." },
+      { type: "heading", level: 3, text: "Cost" },
+      { type: "paragraph", text: "Search calls are **free** \u2014 they do not consume extraction credits. Use search liberally to explore before extracting." },
+      { type: "heading", level: 3, text: "Errors" },
+      { type: "param-table", title: "Common errors", params: [
+        { name: "unauthorized", type: "401", description: "Invalid or missing API key." },
+        { name: "validation_error", type: "422", description: "Empty or missing `query` parameter." }
+      ] }
+    ],
+    related: [
+      { label: "talonic_filter", slug: "mcp-talonic-filter" },
+      { label: "Omnisearch", slug: "omnisearch" }
+    ],
+    faq: [
+      { question: "Does talonic_search cost credits?", answer: "No. Search calls are free and do not consume extraction credits." },
+      { question: "What entities does talonic_search return?", answer: "Documents, field matches (with canonical names and values), sources, schemas, and field definitions \u2014 all ranked by relevance score." }
+    ],
+    mentions: ["talonic_search", "omnisearch", "canonicalName", "field discovery"]
+  },
+  {
+    slug: "mcp-talonic-filter",
+    parentSlug: "mcp-tools",
+    title: "talonic_filter",
+    seoTitle: "talonic_filter MCP Tool \u2014 Talonic Docs",
+    description: "Filter documents by extracted field values. Full operator reference, input/output schema, and composable condition examples.",
+    content: [
+      { type: "paragraph", text: "Filter documents by extracted field values using composable conditions. Conditions accept canonical field names (e.g. `vendor.name`, `policy.0_coverage_type`) or field UUIDs. The Talonic API resolves names to IDs server-side." },
+      { type: "heading", level: 3, text: "When to use" },
+      { type: "list", ordered: false, items: [
+        "The user wants documents matching specific structured criteria: 'invoices over 1000 EUR', 'contracts expiring before 2026-12-31', 'COIs from Acme'.",
+        "The query is value-based on extracted fields, not a free-text concept search.",
+        "You need a sortable, paginated list filtered by field conditions."
+      ] },
+      { type: "heading", level: 3, text: "When NOT to use" },
+      { type: "list", ordered: false, items: [
+        "The user wants conceptual / free-text search \u2192 use `talonic_search`.",
+        "The user wants a single document by ID \u2192 use `talonic_get_document`.",
+        "The user wants to extract from a new document \u2192 use `talonic_extract`."
+      ] },
+      { type: "heading", level: 3, text: "Input schema" },
+      { type: "param-table", title: "Top-level parameters", params: [
+        { name: "conditions", type: "array", required: true, description: "One or more filter conditions, AND-ed together." },
+        { name: "search", type: "string", description: "Optional free-text search applied alongside the filters." },
+        { name: "sort", type: "object", description: "Optional sort: `{ field, direction }` where direction is `asc` or `desc`." },
+        { name: "page", type: "number", description: "Page number for pagination (1-based)." },
+        { name: "limit", type: "number", description: "Results per page. Default: 50." },
+        { name: "source_connection_id", type: "string", description: "Optionally scope to a specific source connection." }
+      ] },
+      { type: "param-table", title: "Condition object", params: [
+        { name: "field", type: "string", description: "Canonical field name (e.g. `vendor.name`). Mutually exclusive with `field_id`. Discover via `talonic_search`." },
+        { name: "field_id", type: "string", description: "Talonic field UUID. Mutually exclusive with `field`." },
+        { name: "operator", type: "string", required: true, description: "One of: `eq`, `neq`, `gt`, `gte`, `lt`, `lte`, `between`, `contains`, `is_empty`, `is_not_empty`." },
+        { name: "value", type: "any", description: "Value to compare against. Not needed for `is_empty` / `is_not_empty`." },
+        { name: "value_to", type: "any", description: "Upper bound for `between` operator; ignored otherwise." }
+      ] },
+      { type: "heading", level: 3, text: "Operator reference" },
+      { type: "param-table", title: "Operators", params: [
+        { name: "eq", type: "=", description: "Exact equality." },
+        { name: "neq", type: "!=", description: "Not equal." },
+        { name: "gt / gte", type: "> / >=", description: "Greater than (or equal). Works on numbers and dates." },
+        { name: "lt / lte", type: "< / <=", description: "Less than (or equal). Works on numbers and dates." },
+        { name: "between", type: "range", description: "Inclusive range. Requires both `value` (lower) and `value_to` (upper)." },
+        { name: "contains", type: "substring", description: "Case-insensitive substring match on string fields." },
+        { name: "is_empty", type: "null check", description: "Field has no value." },
+        { name: "is_not_empty", type: "presence", description: "Field has a value. **Note:** currently underreports \u2014 use a more specific operator when possible." }
+      ] },
+      { type: "heading", level: 3, text: "Example" },
+      { type: "code", language: "json", title: "Find invoices over 1000 from Acme", code: '{\n  "conditions": [\n    { "field": "vendor.name", "operator": "contains", "value": "Acme" },\n    { "field": "total_amount", "operator": "gt", "value": 1000 }\n  ],\n  "sort": { "field": "total_amount", "direction": "desc" },\n  "limit": 10\n}' },
+      { type: "heading", level: 3, text: "Response shape" },
+      { type: "code", language: "json", title: "Example response", code: '{\n  "documents": [\n    {\n      "id": "d_abc123",\n      "filename": "acme-invoice-q4.pdf",\n      "documentType": "invoice",\n      "extractedFields": {\n        "vendor.name": "Acme Corp",\n        "total_amount": 14250.00\n      }\n    }\n  ],\n  "total": 1,\n  "page": 1,\n  "perPage": 10\n}' },
+      { type: "heading", level: 3, text: "Cost" },
+      { type: "paragraph", text: "Filter calls are **free** \u2014 they query already-extracted data and do not consume extraction credits." },
+      { type: "heading", level: 3, text: "Errors" },
+      { type: "param-table", title: "Common errors", params: [
+        { name: "unauthorized", type: "401", description: "Invalid or missing API key." },
+        { name: "no_field_match", type: "422", description: "Field name not found. Use `talonic_search` to discover canonical field names first." },
+        { name: "validation_error", type: "422", description: "Missing conditions array, invalid operator, or missing `value` for operators that require it." }
+      ] }
+    ],
+    related: [
+      { label: "talonic_search", slug: "mcp-talonic-search" },
+      { label: "Filter & Search API", slug: "field-autocomplete" }
+    ],
+    faq: [
+      { question: "Does talonic_filter cost credits?", answer: "No. Filter queries already-extracted data and is free." },
+      { question: "How do I find field names for filtering?", answer: "Call talonic_search first. The fields[].canonicalName values from the response are what you pass as the field parameter in filter conditions." }
+    ],
+    mentions: ["talonic_filter", "filter", "conditions", "operators", "canonical field name"]
+  },
+  {
+    slug: "mcp-talonic-get-document",
+    parentSlug: "mcp-tools",
+    title: "talonic_get_document",
+    seoTitle: "talonic_get_document MCP Tool \u2014 Talonic Docs",
+    description: "Fetch full metadata for a single document by ID, including processing log and link URLs.",
+    content: [
+      { type: "paragraph", text: "Fetch full metadata for a single document by ID. Returns filename, page count, detected document type, language, processing log, and link URLs." },
+      { type: "heading", level: 3, text: "When to use" },
+      { type: "list", ordered: false, items: [
+        "You need details about a specific document already extracted or uploaded.",
+        "You have a `document_id` from a previous extract or search and want more context.",
+        "The user asks 'tell me about document X'."
+      ] },
+      { type: "heading", level: 3, text: "When NOT to use" },
+      { type: "list", ordered: false, items: [
+        "The user wants full text content \u2192 use `talonic_to_markdown`.",
+        "The user wants extracted structured data \u2192 use `talonic_extract`.",
+        "The user has a file but no `document_id` yet \u2192 call `talonic_extract` first."
+      ] },
+      { type: "heading", level: 3, text: "Input schema" },
+      { type: "param-table", title: "Parameters", params: [
+        { name: "document_id", type: "string", required: true, description: "The Talonic document ID. Get this from a previous `talonic_extract` or `talonic_search` response." }
+      ] },
+      { type: "heading", level: 3, text: "Response shape" },
+      { type: "code", language: "json", title: "Example response", code: '{\n  "id": "d_abc123",\n  "filename": "invoice.pdf",\n  "documentType": "invoice",\n  "language": "en",\n  "pageCount": 2,\n  "processingLog": [...],\n  "links": {\n    "self": "https://api.talonic.com/v1/documents/d_abc123",\n    "extractions": "https://api.talonic.com/v1/documents/d_abc123/extractions",\n    "dashboard": "https://app.talonic.com/documents/d_abc123"\n  }\n}' },
+      { type: "heading", level: 3, text: "Cost" },
+      { type: "paragraph", text: "Free \u2014 metadata lookups do not consume extraction credits." }
+    ],
+    related: [
+      { label: "SDK Documents", slug: "sdk-documents" },
+      { label: "Get Document", slug: "get-document" }
+    ],
+    faq: [],
+    mentions: ["talonic_get_document", "metadata", "document_id"]
+  },
+  {
+    slug: "mcp-talonic-to-markdown",
+    parentSlug: "mcp-tools",
+    title: "talonic_to_markdown",
+    seoTitle: "talonic_to_markdown MCP Tool \u2014 Talonic Docs",
+    description: "Get OCR-converted markdown for a document. Full input schema, file source options, cost guidance, and usage examples.",
+    content: [
+      { type: "paragraph", text: "Get OCR-converted markdown for a document. Accepts an existing `document_id` (cheapest \u2014 one API call, no re-processing), or raw file bytes, a local path, or a URL." },
+      { type: "heading", level: 3, text: "When to use" },
+      { type: "list", ordered: false, items: [
+        "The user wants the full text content of a document for summarisation, translation, or analysis.",
+        "A previous tool call returned a `document_id` and you want to inspect its content.",
+        "The user asks 'what does the document say' or 'summarise this PDF'.",
+        "The user has a raw PDF / scan / image and wants markdown directly without designing a schema."
+      ] },
+      { type: "heading", level: 3, text: "When NOT to use" },
+      { type: "list", ordered: false, items: [
+        "The user wants specific structured fields \u2192 use `talonic_extract` with a schema."
+      ] },
+      { type: "heading", level: 3, text: "Input schema" },
+      { type: "paragraph", text: "Provide **exactly one** of the following:" },
+      { type: "param-table", title: "Parameters", params: [
+        { name: "document_id", type: "string", description: "ID of an already-ingested document. **Cheapest path** \u2014 one API call, no re-processing or credit usage." },
+        { name: "file_data", type: "string", description: "Base64-encoded file bytes. **Recommended for chat clients.** Pair with `filename`. Consumes one extraction credit (auto-ingests the file first)." },
+        { name: "filename", type: "string", description: "Original filename with extension. Required when using `file_data`." },
+        { name: "file_path", type: "string", description: "Local path. Only works if the MCP server has read access." },
+        { name: "file_url", type: "string", description: "Public URL. Talonic API fetches server-side. Consumes one extraction credit." }
+      ] },
+      { type: "heading", level: 3, text: "Response shape" },
+      { type: "code", language: "json", title: "Example response", code: '{\n  "documentId": "d_abc123",\n  "markdown": "# Invoice INV-2024-0847\\n\\n**Vendor:** Acme Corp\\n**Date:** 2024-01-15\\n\\n| Item | Qty | Unit Price | Total |\\n|------|-----|------------|-------|\\n| Widget A | 100 | 42.50 | 4,250.00 |\\n| Widget B | 200 | 50.00 | 10,000.00 |\\n\\n**Total: 14,250.00 EUR**"\n}' },
+      { type: "heading", level: 3, text: "Cost" },
+      { type: "paragraph", text: "**Free when using `document_id`** \u2014 the document is already ingested. When passing a raw file (`file_data`, `file_path`, `file_url`), the tool auto-ingests via extract first, consuming **one extraction credit**. To avoid unnecessary cost: if you've already extracted a document, reuse the `document_id` from that response." },
+      { type: "heading", level: 3, text: "Errors" },
+      { type: "param-table", title: "Common errors", params: [
+        { name: "missing_input_source", type: "client", description: "No file source provided. Provide exactly one of `document_id`, `file_data`, `file_path`, `file_url`." },
+        { name: "multiple_input_sources", type: "client", description: "More than one file source provided." },
+        { name: "not_found", type: "404", description: "The `document_id` does not exist in the workspace." },
+        { name: "unsupported_file_type", type: "422", description: "Unrecognized file extension. Use a known extension (pdf, docx, png, jpg, etc.)." }
+      ] }
+    ],
+    related: [
+      { label: "talonic_extract", slug: "mcp-talonic-extract" },
+      { label: "SDK getMarkdown", slug: "sdk-documents" }
+    ],
+    faq: [
+      { question: "Does talonic_to_markdown cost credits?", answer: "Free when using document_id (already ingested). Costs one extraction credit when passing a raw file, since the file must be ingested first." },
+      { question: "How do I avoid paying twice for markdown?", answer: "If you already called talonic_extract, reuse the document_id from that response to call talonic_to_markdown for free." }
+    ],
+    mentions: ["talonic_to_markdown", "OCR", "markdown", "document_id"]
+  },
+  {
+    slug: "mcp-talonic-list-schemas",
+    parentSlug: "mcp-tools",
+    title: "talonic_list_schemas",
+    seoTitle: "talonic_list_schemas MCP Tool \u2014 Talonic Docs",
+    description: "List all saved schemas with IDs, names, descriptions, field counts, and full JSON Schema definitions.",
+    content: [
+      { type: "paragraph", text: "List all saved schemas in the workspace. Returns each schema with its ID, name, description, version, field count, and full JSON Schema definition." },
+      { type: "heading", level: 3, text: "When to use" },
+      { type: "list", ordered: false, items: [
+        "The user asks what schemas they have, or wants to see existing schemas.",
+        "Before designing a new schema, check if one already covers the use case.",
+        "The user asks to extract from a known document type \u2014 find a matching saved schema.",
+        "You need a `schema_id` for `talonic_extract`."
+      ] },
+      { type: "heading", level: 3, text: "When NOT to use" },
+      { type: "list", ordered: false, items: [
+        "The user wants to extract data and provides an inline schema \u2192 call `talonic_extract` directly."
+      ] },
+      { type: "heading", level: 3, text: "Input schema" },
+      { type: "paragraph", text: "No parameters required." },
+      { type: "heading", level: 3, text: "Cost" },
+      { type: "paragraph", text: "Free \u2014 listing schemas does not consume extraction credits." }
+    ],
+    related: [
+      { label: "talonic_save_schema", slug: "mcp-talonic-save-schema" },
+      { label: "SDK Schemas", slug: "sdk-schemas" }
+    ],
+    faq: [],
+    mentions: ["talonic_list_schemas", "schemas", "schema_id"]
+  },
+  {
+    slug: "mcp-talonic-save-schema",
+    parentSlug: "mcp-tools",
+    title: "talonic_save_schema",
+    seoTitle: "talonic_save_schema MCP Tool \u2014 Talonic Docs",
+    description: "Save a schema definition to the workspace for reuse. Full input schema, definition formats, and examples.",
+    content: [
+      { type: "paragraph", text: "Save a schema definition to the workspace for reuse across future extractions. Returns the saved schema with its assigned `id` (UUID) and `short_id` (`SCH-XXXXXXXX`)." },
+      { type: "heading", level: 3, text: "When to use" },
+      { type: "list", ordered: false, items: [
+        "The user asks to save a schema, store a template, or reuse the schema across docs.",
+        "You have iterated on a schema with the user and they confirmed it should be saved.",
+        "The user wants to standardise extraction across many documents of the same type."
+      ] },
+      { type: "heading", level: 3, text: "When NOT to use" },
+      { type: "list", ordered: false, items: [
+        "The user just wants to extract once with an inline schema \u2192 call `talonic_extract` directly.",
+        "The user has not confirmed the schema design \u2014 avoid creating clutter."
+      ] },
+      { type: "heading", level: 3, text: "Input schema" },
+      { type: "param-table", title: "Parameters", params: [
+        { name: "name", type: "string", required: true, description: "Human-readable name, e.g. `Standard Invoice`." },
+        { name: "definition", type: "object", required: true, description: "Schema definition. **Use full JSON Schema format** (`{type: \"object\", properties: {...}}`) for best results. Flat key-type maps are accepted but normalized server-side \u2014 if you get a 'no fields' error, switch to full JSON Schema." },
+        { name: "description", type: "string", description: "Optional description of what this schema extracts." }
+      ] },
+      { type: "heading", level: 3, text: "Schema format guidance" },
+      { type: "paragraph", text: "**Full JSON Schema (recommended):**" },
+      { type: "code", language: "json", title: "JSON Schema format", code: '{\n  "type": "object",\n  "properties": {\n    "vendor_name": { "type": "string" },\n    "total_amount": { "type": "number" },\n    "line_items": {\n      "type": "array",\n      "items": {\n        "type": "object",\n        "properties": {\n          "description": { "type": "string" },\n          "quantity": { "type": "number" },\n          "unit_price": { "type": "number" }\n        }\n      }\n    }\n  }\n}' },
+      { type: "paragraph", text: "**Flat key-type map (convenience, normalized server-side):**" },
+      { type: "code", language: "json", title: "Flat format", code: '{\n  "vendor_name": "string",\n  "total_amount": "number",\n  "due_date": "date"\n}' },
+      { type: "callout", variant: "warning", text: "Flat key-type maps are normalized to JSON Schema server-side. If you encounter a 'no fields' error, switch to full JSON Schema format. For schemas with nested objects or arrays, always use full JSON Schema." },
+      { type: "heading", level: 3, text: "Cost" },
+      { type: "paragraph", text: "Free \u2014 saving a schema does not consume extraction credits." }
+    ],
+    related: [
+      { label: "talonic_list_schemas", slug: "mcp-talonic-list-schemas" },
+      { label: "Schemas API", slug: "create-schema" }
+    ],
+    faq: [
+      { question: "What schema format should I use?", answer: "Full JSON Schema ({type: 'object', properties: {...}}) is most reliable. Flat key-type maps ({field: 'type'}) work for simple schemas but are normalized server-side and may produce errors with complex structures." }
+    ],
+    mentions: ["talonic_save_schema", "schema", "JSON Schema", "flat key-type"]
+  },
+  {
+    slug: "mcp-schemas-resource",
+    parentSlug: "mcp-resources",
+    title: "talonic://schemas",
+    seoTitle: "talonic://schemas MCP Resource \u2014 Talonic Docs",
+    description: "The MCP resource URI that exposes saved schemas to clients that browse resources separately, like Claude Desktop and Cowork.",
+    content: [
+      { type: "paragraph", text: "The `talonic://schemas` resource exposes the saved-schemas list to clients that browse MCP resources separately. Claude Desktop and Cowork render these in the UI." }
+    ],
+    related: [
+      { label: "talonic_list_schemas", slug: "mcp-talonic-list-schemas" }
+    ],
+    faq: [],
+    mentions: ["MCP resource", "talonic://schemas"]
+  },
+  {
+    slug: "mcp-cost-and-limits",
+    parentSlug: "mcp-advanced",
+    title: "Cost & Rate Limits",
+    seoTitle: "MCP Cost and Rate Limits \u2014 Talonic Docs",
+    description: "Which MCP tool calls cost extraction credits, rate limit behavior, insufficient-credit handling, and how to avoid re-extraction.",
+    content: [
+      { type: "heading", level: 3, text: "What costs credits" },
+      { type: "paragraph", text: "Only extraction operations consume credits. Everything else is free:" },
+      { type: "param-table", title: "Credit cost per tool", params: [
+        { name: "talonic_extract", type: "1 credit", description: "Each call with a new file or re-extraction of an existing document." },
+        { name: "talonic_to_markdown (raw file)", type: "1 credit", description: "When passing `file_data`, `file_path`, or `file_url` \u2014 auto-ingests first." },
+        { name: "talonic_to_markdown (document_id)", type: "free", description: "Document already ingested \u2014 just fetches stored markdown." },
+        { name: "talonic_search", type: "free", description: "Queries indexed data." },
+        { name: "talonic_filter", type: "free", description: "Queries extracted field values." },
+        { name: "talonic_get_document", type: "free", description: "Metadata lookup." },
+        { name: "talonic_list_schemas", type: "free", description: "Lists saved schemas." },
+        { name: "talonic_save_schema", type: "free", description: "Persists a schema definition." }
+      ] },
+      { type: "heading", level: 3, text: "Avoiding re-extraction" },
+      { type: "paragraph", text: "Agents should avoid extracting the same document twice. Best practices:" },
+      { type: "list", ordered: false, items: [
+        "After calling `talonic_extract`, save the returned `document.id` and `extraction.id`. Use these for follow-up calls (`talonic_to_markdown`, `talonic_get_document`) instead of re-uploading the file.",
+        "Before extracting, call `talonic_search` to check if the document already exists in the workspace.",
+        "Use `talonic_filter` to query already-extracted data instead of re-extracting with a different schema when the fields you need are already captured."
+      ] },
+      { type: "heading", level: 3, text: "Rate limits" },
+      { type: "paragraph", text: "The Talonic API enforces per-key rate limits. When exceeded, the server returns `429 Too Many Requests` with a `X-RateLimit-Reset` header. The MCP server (and the underlying Node SDK) retries automatically with exponential backoff up to `maxRetries` (default: 3). If retries are exhausted, the tool returns an error with the reset timestamp." },
+      { type: "heading", level: 3, text: "Insufficient credits" },
+      { type: "paragraph", text: "When extraction credits are exhausted, the API returns `402 Payment Required`. The tool surfaces this as an error. The agent should inform the user that their credit balance is depleted and suggest upgrading their plan or waiting for the daily reset (free tier: 50 extractions/day, resets at midnight UTC)." },
+      { type: "heading", level: 3, text: "Free tier limits" },
+      { type: "paragraph", text: "The free tier includes 50 extractions per day (resets at midnight UTC). Search, filter, metadata, and schema operations are unlimited. No credit card required." }
+    ],
+    related: [
+      { label: "talonic_extract", slug: "mcp-talonic-extract" },
+      { label: "Authentication", slug: "mcp-authentication" },
+      { label: "SDK Retries", slug: "sdk-retries" }
+    ],
+    faq: [
+      { question: "Which MCP tool calls cost credits?", answer: "Only talonic_extract and talonic_to_markdown (with raw file) cost one credit each. Search, filter, get_document, list_schemas, and save_schema are all free." },
+      { question: "What happens when I run out of credits?", answer: "The API returns 402 Payment Required. The agent should inform the user and suggest upgrading their plan or waiting for the daily reset (free tier resets at midnight UTC)." },
+      { question: "How do rate limits work?", answer: "The API returns 429 with a reset timestamp. The SDK retries automatically with exponential backoff (up to 3 retries by default)." }
+    ],
+    mentions: ["credits", "rate limits", "429", "402", "free tier", "cost"]
+  },
+  {
+    slug: "mcp-drag-drop",
+    parentSlug: "mcp-advanced",
+    title: "Drag & Drop in Chat",
+    seoTitle: "MCP Drag and Drop File Handling \u2014 Talonic Docs",
+    description: "How file_data + filename solves the sandboxed file path problem for drag-and-drop in Claude Desktop, Cursor, and Cowork.",
+    content: [
+      { type: "paragraph", text: "When a user drag-drops a file into a chat-style MCP host (Claude Desktop, Cowork, Cursor), the file lands in a host-owned sandbox directory the MCP server cannot read. The path the host hands the agent is meaningless to a separately-running `npx` MCP process." },
+      { type: "paragraph", text: "From `@talonic/mcp@0.1.4`, agents can pass **`file_data`** (base64-encoded file bytes) and **`filename`** on `talonic_extract` and `talonic_to_markdown`. The agent reads the file bytes from the conversation, base64-encodes them, and passes them through the MCP tool call. The MCP server decodes, infers MIME type from the filename, and uploads to the Talonic API as a normal multipart request." },
+      { type: "paragraph", text: "Tool descriptions advertise `file_data` as the recommended input for chat-style clients, so well-trained agents reach for it automatically. No client-side configuration required." }
+    ],
+    related: [
+      { label: "talonic_extract", slug: "mcp-talonic-extract" },
+      { label: "Installation", slug: "mcp-installation" }
+    ],
+    faq: [
+      { question: "How does file upload work in MCP chat clients?", answer: "From v0.1.4, agents pass file_data (base64) + filename instead of a file path. This handles drag-and-drop in sandboxed chat clients like Claude Desktop." }
+    ],
+    mentions: ["drag and drop", "file_data", "base64", "sandbox"]
+  },
+  {
+    slug: "mcp-architecture",
+    parentSlug: "mcp-advanced",
+    title: "Architecture",
+    seoTitle: "MCP Server Architecture \u2014 Talonic Docs",
+    description: "How the Talonic MCP server connects agents to the Talonic API. Hosted (HTTP) and local (stdio) transport modes.",
+    content: [
+      { type: "paragraph", text: "The MCP server sits between the AI agent and the Talonic API:" },
+      { type: "code", language: "text", title: "Architecture", code: "Agent (Claude Desktop / Cursor / Cline / etc.)\n  \u2193 MCP protocol (stdio or HTTP)\nTalonic MCP server\n  \u2193 HTTPS, Bearer auth\napi.talonic.com" },
+      { type: "paragraph", text: "**Local mode (stdio):** The MCP client spawns the server as a child process. Communication is via stdin/stdout using the MCP protocol." },
+      { type: "paragraph", text: "**Hosted mode (HTTP):** The server runs at `mcp.talonic.com` using Streamable HTTP transport. Each `initialize` request creates a new session keyed by a UUID (`Mcp-Session-Id` header). Subsequent requests route to the same session. If a session is lost (deploy, restart), the server returns 404 and the client re-initializes \u2014 standard MCP reconnection." },
+      { type: "paragraph", text: "Each tool call is one HTTP request to the Talonic API using your API key. The server handles auth, retries on transient failures (429, 5xx), MIME-type detection on file uploads, multipart serialisation, and structured error formatting." }
+    ],
+    related: [
+      { label: "Configuration", slug: "mcp-configuration" },
+      { label: "Introduction", slug: "mcp-introduction" }
+    ],
+    faq: [],
+    mentions: ["architecture", "stdio", "HTTP", "Streamable HTTP", "session"]
+  },
+  {
+    slug: "mcp-configuration",
+    parentSlug: "mcp-advanced",
+    title: "Configuration",
+    seoTitle: "MCP Server Configuration \u2014 Talonic Docs",
+    description: "Environment variables for the local MCP server and header options for the hosted server.",
+    content: [
+      { type: "heading", level: 3, text: "Local server (env vars)" },
+      { type: "paragraph", text: "Set via the `env` block in your MCP client config:" },
+      { type: "param-table", title: "Environment variables", params: [
+        { name: "TALONIC_API_KEY", type: "string", required: true, description: "Your Talonic API key. Starts with `tlnc_`." },
+        { name: "TALONIC_BASE_URL", type: "string", description: "Override the API base URL. Default: `https://api.talonic.com`." }
+      ] },
+      { type: "heading", level: 3, text: "Hosted server (headers)" },
+      { type: "paragraph", text: "The hosted server at `mcp.talonic.com` is configured entirely via the MCP client config:" },
+      { type: "code", language: "json", code: '{\n  "url": "https://mcp.talonic.com/mcp",\n  "headers": {\n    "Authorization": "Bearer tlnc_your_key_here"\n  }\n}' },
+      { type: "paragraph", text: "No environment variables needed. The API key is passed via the `Authorization` header on every request." }
+    ],
+    related: [
+      { label: "Installation", slug: "mcp-installation" },
+      { label: "Authentication", slug: "mcp-authentication" }
+    ],
+    faq: [],
+    mentions: ["TALONIC_API_KEY", "TALONIC_BASE_URL", "configuration", "headers"]
+  },
+  {
+    slug: "mcp-troubleshooting",
+    parentSlug: "mcp-advanced",
+    title: "Troubleshooting",
+    seoTitle: "MCP Server Troubleshooting \u2014 Talonic Docs",
+    description: "Common issues and fixes for the Talonic MCP server: missing API key, invisible server, 500 errors, and filter problems.",
+    content: [
+      { type: "heading", level: 3, id: "ts-api-key", text: "TALONIC_API_KEY environment variable is required" },
+      { type: "paragraph", text: "The `env` block in your MCP client config is missing or not being read. Double-check the JSON shape. After editing, fully restart the client (not just the conversation)." },
+      { type: "heading", level: 3, id: "ts-hosted-401", text: "Hosted server returns 401 Unauthorized" },
+      { type: "paragraph", text: 'The `Authorization` header is missing or malformed. Ensure the config has `"headers": { "Authorization": "Bearer tlnc_..." }`. The key must start with `tlnc_`.' },
+      { type: "heading", level: 3, id: "ts-not-visible", text: "Talonic does not appear in connected servers" },
+      { type: "paragraph", text: 'For local: make sure the `command` is `npx` and `args` are exactly `["-y", "@talonic/mcp@latest"]`. Sanity check: run `npx -y @talonic/mcp@latest --version` in a terminal. For hosted: ensure the `url` is `https://mcp.talonic.com/mcp` (note the `/mcp` path).' },
+      { type: "heading", level: 3, id: "ts-500", text: "talonic_extract returns 500 with auto-discovery" },
+      { type: "paragraph", text: "Always provide either an inline `schema` or a `schema_id`. The auto-discovery code path is not yet stable." },
+      { type: "heading", level: 3, id: "ts-unsupported", text: "unsupported_file_type error" },
+      { type: "paragraph", text: "The MIME type was inferred as `application/octet-stream`. Ensure the filename has a recognized extension (pdf, docx, png, jpg, etc.)." },
+      { type: "heading", level: 3, id: "ts-filter-validation", text: "talonic_filter: No field matches name" },
+      { type: "paragraph", text: "Field names must be canonical names from the field registry (e.g. `vendor.name`). Call `talonic_search` first; canonical names appear in `fields[].canonicalName`." },
+      { type: "heading", level: 3, id: "ts-402", text: "402 Payment Required / insufficient credits" },
+      { type: "paragraph", text: "Extraction credit balance is exhausted. Free tier: 50 extractions/day, resets at midnight UTC. Upgrade plan or wait for reset." },
+      { type: "heading", level: 3, id: "ts-cached", text: "Tool descriptions look wrong" },
+      { type: "paragraph", text: "Some MCP clients cache tool descriptions. Restart the client after a server update." },
+      { type: "heading", level: 3, id: "ts-session-lost", text: "Hosted server: session_not_found (404)" },
+      { type: "paragraph", text: "Sessions are in-memory on the hosted server. After a deploy or restart, existing sessions are lost. The client should re-initialize without the `Mcp-Session-Id` header \u2014 most MCP clients handle this automatically." }
+    ],
+    related: [
+      { label: "Installation", slug: "mcp-installation" },
+      { label: "Configuration", slug: "mcp-configuration" },
+      { label: "Cost & Rate Limits", slug: "mcp-cost-and-limits" }
+    ],
+    faq: [],
+    mentions: ["troubleshooting", "debugging", "errors", "401", "402", "500"]
+  }
+];
+
+// src/content/mcp/index.ts
+var sections46 = sections_default2;
+
 // src/content/index.ts
 var ALL_PLATFORM_RAW = [
   ...sections,
@@ -17494,6 +18576,8 @@ var ALL_API_RAW = [
   ...sections43,
   ...sections44
 ];
+var ALL_SDK_RAW = [...sections45];
+var ALL_MCP_RAW = [...sections46];
 function enrich(raw, navSections, domain) {
   return raw.map((r) => {
     const { prev, next } = derivePrevNext(navSections, r.slug);
@@ -17519,6 +18603,20 @@ function getApiSectionsAll() {
   }
   return _apiSections;
 }
+var _sdkSections = null;
+var _mcpSections = null;
+function getSdkSectionsAll() {
+  if (!_sdkSections) {
+    _sdkSections = enrich(ALL_SDK_RAW, SDK_NAV_SECTIONS, "sdk");
+  }
+  return _sdkSections;
+}
+function getMcpSectionsAll() {
+  if (!_mcpSections) {
+    _mcpSections = enrich(ALL_MCP_RAW, MCP_NAV_SECTIONS, "mcp");
+  }
+  return _mcpSections;
+}
 function getPlatformSection(slug) {
   return getPlatformSectionsAll().find((s) => s.slug === slug) ?? null;
 }
@@ -17531,9 +18629,25 @@ function getApiSection(slug) {
 function getAllApiSections() {
   return getApiSectionsAll();
 }
+function getSdkSection(slug) {
+  return getSdkSectionsAll().find((s) => s.slug === slug) ?? null;
+}
+function getAllSdkSections() {
+  return getSdkSectionsAll();
+}
+function getMcpSection(slug) {
+  return getMcpSectionsAll().find((s) => s.slug === slug) ?? null;
+}
+function getAllMcpSections() {
+  return getMcpSectionsAll();
+}
 export {
   getAllApiSections,
+  getAllMcpSections,
   getAllPlatformSections,
+  getAllSdkSections,
   getApiSection,
-  getPlatformSection
+  getMcpSection,
+  getPlatformSection,
+  getSdkSection
 };