Claix is the controlled data retrieval and security layer for AI agents: it connects to your relational database and lets each agent retrieve only the tables and columns you allow and only execute the actions allowed following your rules and limits, without moving your data. Available via REST API, MCP, and A2A.

How do I get started?

Connect any SQL database with a read-only role (Claix drafts a Data Map for you to review), define routes and agents with your rules (no YAML or code), write Guard rules in plain English for the changes an agent may propose, then call one endpoint so your agent gets live typed answers and a verdict before any change, inside the perimeter you set.

Does Claix copy my data into a vector store?

No. Claix does not copy your data or build a vector index over it. Agents query your database where it lives, within the tables and columns you allow. Every query is validated before it runs and traced afterward.

Does Claix write to my database?

No. Claix never writes to your database. Retrieve connects with a read-only role. When an agent proposes an INSERT, UPDATE, or DELETE, Claix Guard answers allow or deny, with the reason, and your code executes. Loading documents into structured fields is a separate product, Claix Ingest, which you choose to use.

Which databases does Claix support?

Any SQL database, including Postgres, MySQL, and MariaDB, plus Postgres-compatible setups such as Supabase. You connect with a read-only role. Claix never executes writes: Guard only answers whether a proposed change is allowed, and your code runs it.

What are routes and agents?

A route is a retrieval capability: the tables and columns allowed plus a short guide with your rules and vocabulary. An agent is the identity that uses them—its own endpoint, business prompt, attached routes, and response mode (raw results or reasoned typed answers). Create a route once and attach it to as many agents as you need.

How do I call a Retrieve agent?

POST to /retrieve/{agent_name} with a JSON body of questions (each with an optional format such as string, int, boolean, json, or array:string). You get typed answers in order plus a log_id. The same agent is also reachable over MCP (claix.retrieve.ask) and A2A.

What answer formats can I request?

In reasoned mode you can ask for string, int, boolean, timestamp, timestamptz, date, json, array:string, or array:int. Typed values mean your workflow can branch on booleans, use numbers and lists directly, and skip parsing free text.

How does pricing work?

Every account gets 30 successful calls free each month, with no card. After that, Claix Managed AI is €0.10 per question. With your own LLM key (BYOK) from OpenAI, Google, Anthropic, or xAI, the Claix fee drops to €0.02 per question and you pay your provider’s tokens directly. Results with your own key depend on the model you choose—test in the Sandbox before going live. Claix Guard is €0.01 per call: each check of an INSERT, UPDATE, or DELETE. There is no model and no managed AI on that check.

Is agentic RAG the same as vector RAG?

No. They sit on different axes. “Agentic” is about who triggers retrieval (a fixed pipeline vs an agent calling a tool). “Vector” is about how results are matched (embeddings). An agent can call SQL, BM25, or embeddings; a fixed pipeline can use hybrid search. For relational business data, embeddings are often the wrong default.

Is SQL retrieval RAG?

Yes. RAG means retrieved information feeds the model. It does not require embeddings, and the retrieved information does not have to be text chunks. A SQL query that returns live records for the model is still retrieval.

When should I still use a vector database?

When you need semantic discovery over a large permanent text collection, heavy repeated search traffic, or a product where search is the product. For exact values, counts, dates, and live rows already in your SQL database, query the database where it lives with scoped access instead of copying it into an index.

Can I use Claix from LangChain, Cursor, or n8n?

Yes. Claix is not an agent framework—it is a retrieval layer you call from the stack you already use. Call REST from any HTTP client (including n8n), expose the agent as an MCP tool for Cursor and compatible clients, or connect over A2A so other agents can delegate data questions.

What happens when the answer is not in the allowed tables?

The field comes back empty instead of a guess. Queries only run inside the routes you attached to the agent; everything outside that perimeter does not exist for them. Traces show what was asked, which route answered, and what came back.

How is Claix different from giving an agent a database MCP server?

A generic database MCP connection is quick to wire up, but the access model depends on the server and the role you attach. Claix adds routes, per-agent allowlists, validation before queries run, typed multi-question answers, Claix Guard — which checks every proposed change against exact rules before your code runs — and a reviewable trace, so you define the boundary once and enforce it on every call.

Schemas · Update

Update a schema via API

Endpoint

PUThttps://claix.dev/api/update-schema/{schema_id}

Replaces the full configuration of an existing schema (same body as POST /api/create-schema). The schema_id goes in the URL; the body carries name, type, schema_definition, and options.

Always call https://claix.dev/api/update-schema/{schema_id}. POST is also accepted.

Intended for server-to-server integrations. This call is free: it is not billed and does not consume your extraction quota.

1. Authentication

Every request must include your API key. It is a personal server credential, distinct from any session token.

Option A — Dedicated header (recommended):

x-api-key: <YOUR_API_KEY>

Option B — Standard Authorization header:

Authorization: Bearer <YOUR_API_KEY>

Either one is sufficient. If you send both, x-api-key takes priority.

The system checks that the key exists, is active, and the account is not suspended. On failure it returns 401.

2. Request format

Method: PUT (POST also accepted) · Content-Type: application/json · Path: schema_id (UUID)

Field	Type	Required	Description
schema_id	uuid	Yes (URL)	Identifier of the schema to update.
name	string	Yes	Visible schema name (max 200).
type	string	Yes	excel-json, json-excel, pdf-json, doc-json, img-json, txt-json, or audio-json.
schema_definition	object	Yes	Fields to extract. Each key is the output JSON name.
is_agent_mode	boolean	No	Enables Agent mode. If omitted but agent_definition is sent, true is assumed.
agent_definition	object	If agent mode	Parameters to reason over. Required when is_agent_mode is true.
resumen_agent	string	No	Extra instruction for the agent phase (max 500).
window_context	boolean	No	Enables Save Data. When true, JSON extractions can insert the mapped row into the connected database (connection and mapping rules required). Defaults to false.
cita_por_campo	boolean	No	Enables source verification: links each extracted field to its location in the original document and checks the value appears in the content. Default false.

Each field in schema_definition must look like:

{
  "nombre_dni": {
    "type": "string",
    "description": "nombre de la persona del dni"
  }
}

Allowed extraction types: string, integer, number, boolean. description is required.

Each agent_definition parameter uses boolean, string, closed, or integer. If type is closed, options must be a non-empty array.

The json-excel type does not support Agent mode.

3. How to build the call

Get the schema_id from GET /api/schemas or GET /api/get-schema/{schema_id}.
Build a PUT JSON request to https://claix.dev/api/update-schema/{schema_id}.
Include name, type, and schema_definition (full replacement).
For Agent mode, add is_agent_mode: true and agent_definition.
Check the HTTP status: 200 means it was updated.

4. Request examples

See the right-hand panel for cURL, JavaScript, Node.js, Python, PHP, and n8n examples.

5. Successful response

200 OK · Content-Type: application/json

{
  "success": true,
  "schema": {
    "id": "b980cfe7-61ef-4a5a-9724-881c8a5541e2",
    "name": "DNI cliente",
    "type": "img-json",
    "schema_definition": {
      "nombre_dni": {
        "type": "string",
        "description": "nombre de la persona del dni"
      },
      "numero_dni": {
        "type": "string",
        "description": "numero de dni"
      },
      "fecha_caducidad": {
        "type": "string",
        "description": "fecha de caducidad del dni"
      }
    },
    "is_agent_mode": true,
    "agent_definition": {
      "edad": {
        "type": "integer",
        "description": "Edad exacta de la persona pero restale 3"
      },
      "calidad_foto": {
        "type": "closed",
        "options": ["buena calidad", "mala calidad", "ilegible", "perfecta"],
        "description": "La calidad de la imagen y la legibilidad de sus datos"
      },
      "es_mayor_edad": {
        "type": "boolean",
        "description": "Es mayor de edad actualmente la persona del dni?"
      },
      "fecha_vencimiento": {
        "type": "string",
        "description": "Cuado le vence el dni y cuanto tiempo queda para ello"
      }
    },
    "resumen_agent": null,
    "window_context": false,
    "window_time": null,
    "cita_por_campo": false,
    "created_at": "2026-08-17T13:10:00.000Z"
  }
}

Field	Type	Description
success	boolean	Always true when HTTP is 200.
schema	object	Updated schema, including its UUID id.
schema.id	uuid	Matches the schema_id in the URL.
schema.schema_definition	object	Normalized definition.
schema.agent_definition	object \| null	Null when is_agent_mode is false.
schema.window_context	boolean	Whether Save Data is on: JSON extractions insert the mapped row into the connected database.
schema.cita_por_campo	boolean	Whether source verification is enabled on the schema.

6. Error codes

{
  "error": "Descripción legible del problema.",
  "detalle": "Información técnica adicional (solo presente en algunos casos).",
  "log_id": "7c2e1a90-4b3d-4f8a-9e21-6d5c8b0a1f34"
}

400 — Invalid payload: missing name/type/definition, unknown type, empty description, closed without options, json-excel with Agent mode, or invalid schema_id in the URL.

401 — Auth failed: missing, unknown, or inactive key, or suspended account.

404 — The schema does not exist or is not yours.

405 — Method other than PUT or POST. · 500 — Internal error.

7. Status code summary

Code	Category	Retry?
200	Success	—
400	Client error (malformed data)	No — fix the request first
401	Authentication error	No — fix credentials first
404	Resource not found	No — fix schema_id first
405	Incorrect HTTP method	No — fix the method first
500	Internal server error	Yes, with caution

8. Best practices

Use https://claix.dev/api/update-schema/{schema_id}.
The body replaces the whole configuration: send the full desired state, not a partial patch.
type must match the extraction endpoint you will call later.
Never put your API key in frontend code or public repos.