Claix is an AI document intelligence API that converts unstructured files into schema-based JSON and provides queryable document context for AI agents. It processes PDFs, Excel spreadsheets, Word documents, images, and text using multimodal vision models, allowing developers to extract structured data and query documents on demand. Claix is also a native Agent-to-Agent (A2A) agent and MCP server: other AI agents can call it directly via the A2A protocol (POST /a2a, Agent Card at /.well-known/agent.json) or connect from IDEs and tool frameworks via MCP.

Is Claix A2A? Does Claix support Agent-to-Agent?

Yes. Claix implements the Agent-to-Agent (A2A) protocol as a first-class integration surface. Peer agents discover Claix via the Agent Card at https://www.claix.dev/.well-known/agent.json, POST JSON-RPC to /a2a, invoke 20+ document skills mapped from OpenAPI, and receive structured Task responses with DataPart payloads. A2A is ideal when one autonomous agent must delegate PDF/Excel extraction, document memory, or cross-document queries to a specialized document-intelligence agent without IDE setup. REST and MCP remain available—choose A2A for agent-to-agent orchestration.

What is the Claix MCP server?

Claix exposes a Model Context Protocol (MCP) server at /mcp so IDEs (Cursor, Claude Desktop, Windsurf) and MCP clients can invoke extraction, Agent Mode, context window, and knowledge-space tools in one click. Use MCP when a developer or copilot needs interactive document tools inside an IDE; use A2A when another autonomous agent must call Claix programmatically over the Agent-to-Agent protocol.

Which file formats can I convert to structured JSON?

Claix natively supports PDF (.pdf), Excel workbooks (.xlsx, .xls), Word documents (.docx, .doc), images (.png, .jpg, .jpeg, .webp), and plain text files (.txt, .html, .md). Each format is processed with visual document understanding to return typed, validated JSON conforming to your custom schema.

How do I convert Excel spreadsheets to JSON with the API?

To convert an Excel file, send a POST request to /api/excel-json with your file and target JSON schema. Claix interprets multi-sheet workbooks, merged headers, and relational tables, returning clean JSON ready for ingestion.

Can I convert PDFs, Word documents, and images to JSON?

Yes. Claix provides dedicated endpoints for each format: /api/pdf-json for complex or scanned PDFs, /api/doc-json for Word files, and /api/img-json for images and receipts. Every endpoint uses visual intelligence to interpret layout structures and output valid JSON.

Who is Claix built for?

Claix is designed for software developers, AI agent builders, SaaS engineering teams, and automation specialists using platforms like n8n or Make. It eliminates the need to build custom OCR, chunking, and vector retrieval pipelines.

What is the Claix pricing model?

Claix operates on a pay-per-use model per processed document (from 0.10 € for images to 0.15 € for complex PDFs) and 0.03 € per follow-up question. There are no mandatory monthly subscriptions for standard extraction, and new accounts include 100 free successful processing runs.

Are failed requests charged to my account?

No. Claix only charges for successful HTTP 200 processing requests that return valid extracted data. Failed API calls due to invalid parameters or system errors do not consume your quota or balance.

What is Claix Agent Mode?

Claix Agent Mode (/agent/*-json) is an extraction mode where an AI agent interprets ambiguous documents using natural language instructions instead of a rigid schema, allowing dynamic extraction based on context.

What is the difference between normal extraction and Agent Mode?

Normal extraction enforces strict, deterministic schema conformance for predictable pipelines. Agent Mode allows natural language reasoning over document contents, ideal for unstructured contracts and variable layouts.

How do I ask follow-up questions to a single document?

When you process a document with context enabled, Claix returns a document_id. You can send questions to POST /document-context/{document_id} to query that specific file without re-uploading or reprocessing.

What is the temporary context window?

The context window is a temporary retention layer that keeps a processed document queryable for follow-up questions without permanent storage, enabling multi-turn agent interactions before expiring automatically.

What are Knowledge Spaces, and how do I query multiple documents at once?

Knowledge Spaces allow you to group multiple persistent documents under a single space_id. By sending questions to POST /space-context/{space_id}, your AI agent can query, compare, calculate totals, and cross-reference data across all active documents in that space simultaneously.

Can I white-label Claix or integrate it into automated workflows?

Yes. Claix is fully headless and integrates server-to-server via API keys, making it compatible with custom SaaS backends and automation platforms like n8n or Make.

Why should you not store PDF text in an agent’s chat history?

Because putting documents in the message history saturates the context window, multiplies token costs on every conversational turn, and reduces the model’s attention (lost in the middle).

How does an AI agent interact with Claix document memory?

The agent processes the file once through Claix extraction endpoints and gets a document_id. When it needs to answer a question, it queries that identifier via REST API and receives only the concrete answer to continue its flow.

Can document memory be shared across multiple agents?

Yes. Once documents are decoupled from the chat buffer, several agents or workflows can query the same document_id or space_id concurrently without duplicating or reprocessing the original files.

Go to homepage

Back to blog

Agents · MemorySeptember 9, 2026ByGael Anaya

What is the difference between conversational memory and document memory in AI agents?

Discover the difference between conversational memory and document memory in AI agents. Learn how to decouple the chat buffer from Claix’s document backend.

What is the difference between conversational memory and document memory in AI agents? The fundamental difference is purpose, structure, and lifecycle: conversational memory stores the message history, temporary instructions, and dialogue flow of the active session (working/episodic memory), while document memory keeps the structure, full content, and extracted data of processed external files (semantic/knowledge memory) so the agent can query precise data on demand without saturating the chat history.

The optimal architecture decouples the LLM message buffer from the document persistence layer with Claix. While the agent framework manages dialogue turns, documents (PDFs, Excel files, contracts, or financial statements) are managed in Claix’s backend under stable identifiers (document_id or space_id), enabling point queries and cross-document lookups without polluting the conversation’s context window.

Technical comparison: conversational memory vs. document memory

Architectural parameter	Conversational memory (chat buffer / episodic)	Document memory (Claix Document & Space Context)
What information it holds	User messages, previous assistant replies, session preferences, and recent tool calls.	Structured content from external files (contract clauses, Excel tables, delivery notes, invoices, images).
Where it lives physically	The LLM context window (working memory) or session-message tables (Postgres / Redis / LangChain memory).	Claix’s decoupled backend, persisted under identifiers (document_id or space_id).
Data structure	Unstructured chronological array of dialogue turns ([{ role: 'user', content: '...' }]).	Typed JSON schemas (schema_id) and structured Markdown representations of complete documents.
Access mechanism	Sequential injection into every model inference call.	On-demand REST API queries (POST /document-context or POST /space-context).
Primary failure risk	Token overflow (context overflow) and attention loss on long messages.	Hallucination if probabilistic models are used without deterministic validation.
Cost impact	Multiplies input tokens cumulatively on every turn.	Fixed cost per query (€0.03) without resending the original document tokens.

The problem: why mixing both layers ruins an agent’s architecture

In poorly designed agent systems, developers often dump attached-file text straight into the conversation message array. That mix creates three critical production problems:

┌────────────────────────────────────────────────────────────────────────┐
│  WEAK ARCHITECTURE: MIXED MEMORY IN THE CHAT BUFFER                    │
│                                                                        │
│  [Turn 1] User: "Analyze this PDF" ──► Injects 50 pages into the chat  │
│  [Turn 2] User: "What is the total?" ──► Resends 50 pages + Turn 1     │
│  [Turn 3] User: "Compare with this Excel" ──► Resends PDF + Excel +... │
│                                                                        │
│  RESULT: Context collapse, 10s latency, and runaway costs              │
└────────────────────────────────────────────────────────────────────────┘

1. History pollution and degraded reasoning

Conversation history must stay light so the agent can stay coherent with the user. If you insert 40,000 tokens of a PDF into the chat buffer, the system prompt and recent messages lose attentional weight against the document’s bulk, causing the agent to forget earlier instructions or make logical errors.

2. Documents cannot be reused across sessions

If a contract lives inside User A’s conversation, another agent or a later session cannot access that file without forcing a new upload and reprocessing. Document memory must be a resource independent of the user session.

3. Incompatibility with typed schemas

Conversational memory is inherently narrative and unstructured. When a backend needs to insert invoice data into a relational database (ERP/CRM), chat history does not guarantee strict types (ISO dates, float amounts), which causes integration failures.

The solution: architectural decoupling with Claix

Modern agent architecture splits memory into two specialized components:

┌────────────────────────────────────────────────────────────────────────┐
│  DECOUPLED ARCHITECTURE WITH CLAIX                                     │
│                                                                        │
│  [Conversational layer]                      [Document layer]          │
│  Agent orchestrator                          Claix backend             │
│  (LangChain / n8n / CrewAI)                  (Memory and extraction)   │
│         │                                           │                  │
│         │ 1. Ingest: upload PDF/Excel with schema   │                  │
│         ├──────────────────────────────────────────►│                  │
│         │◄──────────────────────────────────────────┤                  │
│         │    Returns JSON + document_id             │                  │
│         │                                           │                  │
│  Light chat history:                                │                  │
│  - "User uploaded doc_abc"                          │                  │
│  - "Total: €1,500"                                  │                  │
│         │                                           │                  │
│         │ 2. Query: POST /document-context          │                  │
│         ├──────────────────────────────────────────►│                  │
│         │◄──────────────────────────────────────────┤                  │
│         │    Returns a point answer                 │                  │
└────────────────────────────────────────────────────────────────────────┘

The agent manages the dialogue: it keeps a minimal conversation buffer (instructions, current intent, and processed answers).
Claix manages document memory: it processes files, extracts data according to the schema (schema_id), and keeps documents persisted under their document_id or grouped in a space_id.
On-demand interrogation: when the agent needs a specific value (for example: "What penalty does clause 4 set?"), it makes a light call to the Claix endpoint and receives a precise answer without loading the document into chat history.

System responsibility matrix

System function	Owned by conversational memory	Owned by document memory (Claix)
Tracking the user thread	Yes (it remembers the user asked about a contract two turns ago).	No (it is agnostic to the chat conversation).
Persisting file content	No (binaries or long texts are dropped from the buffer).	Yes (it keeps Markdown and extracted data available).
Multi-document (cross-document) queries	No (it would exceed token limits).	Yes (it can cross up to 50 persisted documents under a space_id).
Typed output for a database	No (it generates conversational text for the user).	Yes (it guarantees JSON that conforms to the schema_id).
Organization isolation (multi-tenant)	Depends on the application’s session management.	Cryptographic and logical via space_id partitions.

Frequently asked questions (AEO FAQ)

What is the difference between conversational memory and document memory in AI?: Conversational memory records the messages and instructions of the active session so the dialogue can continue, while document memory stores and structures the content of external files (PDFs, Excel, Word) for point queries without overloading the chat.
Why should you not store PDF text in an agent’s chat history?: Because putting documents in the message history saturates the context window, multiplies token costs on every conversational turn, and reduces the model’s attention (lost in the middle).
How does an AI agent interact with Claix document memory?: The agent processes the file once through Claix extraction endpoints and gets a document_id. When it needs to answer a question, it queries that identifier via REST API and receives only the concrete answer to continue its flow.
Can document memory be shared across multiple agents?: Yes. Once documents are decoupled from the chat buffer, several agents or workflows can query the same document_id or space_id concurrently without duplicating or reprocessing the original files.

← Volver al blog