Build the agent. Delegate the document infrastructure.

Chunking and embeddings

Skip the chunking and embedding detour

For many document-agent features, you do not need to begin by building your own chunk store, embedding pipeline and vector retrieval service.

• No private chunking strategy for the first agent
• No embedding refresh jobs to own
• No vector database to operate alone
• No custom citation index for the MVP

Claix provides document context and multi-document querying through the document layer, so you can test the agent behaviour first. If your product later justifies a custom retrieval architecture, you still own your agent, backend and product data.

Delegate the document work you do not want to own

The builder problem

The agent is ready. The documents are not.

You can build the reasoning loop, tools and user experience yourself. The hidden work begins when real PDFs, invoices and contracts enter the system.

• Your product should not become a document-pipeline project

  Parsing, schemas, storage, retrieval and validation can fill your repository before users ever see the agent behaviour you wanted to ship.

• You do not have another platform to operate

  OCR, chunking, embeddings, vector storage, retrieval quality and reprocessing all drift over time. A layout change should not become an entire weekend of maintenance.

• Every new file type should not become a new engineering project

  When users ask for invoices, contracts or attachments, you should be adding an agent capability—not building a separate ingestion and retrieval stack.

• Your agent needs data its next tool can use

  A paragraph is difficult to validate or pass into another tool. Structured JSON gives your agent a predictable input for the next action.

• Give uncertainty somewhere to go

  If a total is missing or documents disagree, your agent needs a review path. Stopping safely is better than guessing and creating a support problem.

Before / with Claix

From a weekend of document plumbing to an agent feature

One integration does not replace your agent. It removes the infrastructure between the file and the next useful action.

One person, one integration

Designed for the way solo builders actually ship

Start with the smallest integration that proves the feature. Your first agent may start in n8n, move to a TypeScript backend, use MCP during development and later run as a production service. Claix gives you the same document capability across those runtimes.

1. 1.Upload one file.
2. 2.Define one schema.
3. 3.Receive one JSON response.
4. 4.Connect it to one agent action.
5. 5.Test with real documents.
6. 6.Add context, evidence and review as the workflow matures.

Agents you can ship

Things a solo builder can actually launch

Each one is an agent outcome, not a parser exercise.

• Invoice assistant without invoice infrastructure

  Extract supplier, dates, totals and line items into JSON. Let the agent draft an approval, create a ledger record or ask for review when information is incomplete.

• Contract copilot with traceable fields

  Return parties, terms, dates and obligations with evidence the user can inspect.

• Client onboarding agent

  Turn application PDFs and forms into the onboarding schema your backend expects. Complete records continue automatically; incomplete submissions wait for review.

• Support agent for attachments

  Convert attachments into searchable structured context so the agent can answer from the document instead of guessing from filenames.

• Research across documents

  Put related PDFs into a Knowledge Space and let the agent answer questions across them with source context.

• Operations agent

  Extract tasks, dates, amounts or entities and let the agent create records or request human review.

In your agent

Add document understanding without adding another platform

The flow stays small because the document infrastructure is delegated. Your code remains responsible for what the agent decides to do next.

1. 1

   The user provides a file

   A PDF, invoice, contract, spreadsheet or email attachment reaches your agent or application.

2. 2

   You call Claix

   Your agent, MCP server, n8n flow or backend sends the file and the schema for the task.

3. 3

   You receive typed data

   Claix returns JSON, source evidence and document context your next tool can use.

4. 4

   Your agent acts

   Your existing loop creates a task, drafts a message, updates a record or calls another tool.

5. 5

   The agent can ask again

   Later questions use the stored context instead of forcing you to re-upload, reparse or reconstruct the document memory.

6. 6

   Uncertainty becomes a controlled state

   Missing or conflicting data can stop for review instead of becoming a bad action.

Capabilities

What the document call gives your agent

You keep the agent. Claix handles the document side of the call.

• Give your tools predictable inputs

  Define the fields your agent needs and receive structured JSON instead of asking the next model call to interpret a blob of text.

• Let users inspect the value before they trust the action

  Pass source evidence alongside extracted fields so your agent can show where an invoice total, contract date or customer detail came from.

• Ask the second question without rebuilding the first step

  Keep document context available for later questions without re-uploading the file or creating a separate chat-memory and retrieval pipeline.

• Query related files without running your own vector index

  Group related documents and let the agent ask across them without building a custom cross-document retrieval layer.

• Stop safely when the document is not enough

  Route missing, ambiguous or conflicting data to a person instead of forcing the agent to invent a value.

• Use the runtime you already know

  Call Claix from Python, TypeScript, LangChain, MCP, n8n, Make or a custom backend. You do not need to rewrite your agent around a new framework.

Integrations

Use the runtime you already have

• REST API from a Python or TypeScript agent, including the Claix SDKs.
• Webhooks when processing finishes and your backend should continue.
• MCP so an IDE or agent host can expose document tools without a custom parser.
• n8n and Make when the product is a workflow rather than a long-running service.

Minimal call

One call in. Structured document context out.

Example against the public PDF endpoint. Create a schema in the dashboard and pass its schema_id.

import requests

with open("invoice.pdf", "rb") as file:
    response = requests.post(
        "https://claix.dev/api/pdf-json",
        headers={"x-api-key": CLAIX_API_KEY},
        files={"file": file},
        data={"schema_id": "3c7a9f21-4b8e-4d1a-9c6f-2e0d8a5b7c4f"},
    )

document = response.json()

Questions

Questions builders ask