Meibel documentation

Powerful primitives.
One API.
Deeply integrated.

Parse documents, transform their content into your schema, ingest it into a queryable datasource, and put agents on top. Each through a single API, with no vector store to run, no graph database to wire up, and no separate orchestration layer to maintain.

Get started API reference

Where to go next

Browse the docs

Jump into any section of the documentation.

Install the SDK, set your API key, and make your first call. Agents, datasources, batches, execution policies, and confidence scoring. Task-first walkthroughs for agents, sessions, data, and documents. Every endpoint, parameter, and response, with a live playground. Python, TypeScript, Go, and CLI. One client covers every primitive. End-to-end examples like asking a million-row CSV precise questions.

The pipeline in code

From data to agent

One pipeline, four stages: parse a document, transform to your schema, ingest into a datasource, put an agent on top.

```python parse.py theme={null} import os from meibel import MeibelClient client = MeibelClient(api_key=os.environ["MEIBEL_API_KEY"]) # Parse any document into structured content, with # hierarchy, tables, and visual elements preserved. with open("rfq.pdf", "rb") as f: parsed = client.documents.process(file=f, file_name="rfq.pdf") print(parsed.result) ``` ```python transform.py theme={null} # Reshape document content into your schema, # with per-field confidence scores. Reference a # schema by name, or pass a dict or Pydantic model. extracted = client.documents.transform( file="rfq.pdf", schema="quote_v3", ) print(extracted.data) ``` ```python ingest.py theme={null} from meibel.models import MoveDocumentsRequest # Move the parsed document straight into a new datasource, # by job ID. No re-upload, no vector store to manage. moved = client.documents.move( body=MoveDocumentsRequest( documents=[parsed.job_id], new_datasource_name="rfqs", ) ) client.datasources.ingest.trigger(datasource_id=moved.datasource_id) ``` ```python agent.py theme={null} from meibel.models import ( CreateAgentDefinitionRequest, ChatMessageRequest, ) # An agent binds to one or more datasources, holding # unstructured documents, structured tables, or both. agent = client.agents.create( body=CreateAgentDefinitionRequest( display_name="Quote reviewer", instructions="Answer using only the ingested RFQs.", datasources=[moved.datasource_id], ) ) # Open a session, then chat. session = client.agents.sessions.create(agent_id=agent.id) reply = client.agents.sessions.send_chat_message( session_id=session.session_id, body=ChatMessageRequest(user_message="Draft a response to this RFQ."), ) print(reply.assistant_response) ```

Building blocks

Powerful primitives

Each through a single API. Use one, or compose them into a full pipeline.

Turn PDFs, spreadsheets, and images into typed content, with hierarchy, tables, and visual elements preserved. Reshape any source into your schema with per-field confidence scores. A living, queryable store for structured and unstructured data, with no vector database to manage. Reasoning that knows your data and your rules, scoped by execution policies and run one-off or in batches.

How the stack composes

Deeply integrated.

The primitives aren't just co-located. Each one folds its output into the next, so quality compounds down the pipeline instead of degrading. What parsing captures, transform reshapes; what transform yields, ingestion indexes; what ingestion structures, agents reason over; and policy and confidence thread through all of it.

Agents REASONING

Reason over structured and unstructured data, on retrieval sharpened by everything below. The cleaner the layers below, the sharper the answers.

Ingest INDEX

Runs two paths at once: structured data lands in typed, queryable tables, while unstructured content is chunked along semantic boundaries into dense and sparse embeddings for hybrid retrieval. Both live in one datasource, with no vector store to manage.

Transform SCHEMA

Reshapes parsed content into your business schema, with per-field confidence. The structured fields it yields fold into ingestion and sharpen what agents retrieve.

Parse FOUNDATION

Captures deep structure (sections, headings, tables, lists) plus context for charts, graphs and formulas. Every extracted token carries a confidence score. Everything above inherits this structure.

structure & quality compound upward

Enforced by the platform

Hardrails, not guardrails

Lock agents to the data and tools you trust, enforced in code, not vibes. Execution policies strictly define what an agent can see and do. They're evaluated by the platform, outside the LLM, so the model can't bypass them through prompting.

The result: agents that stay in-bounds by construction, not persuasion.

```json policy.json theme={null} { "datasources": { "ds_abc123": { "documents": { "filter": { "data_element.__id__": { "$in": ["de_abc", "de_def"] } } } } } } ``` ```json policy.json theme={null} { "datasources": { "ds_abc123": { "tables": { "filter": { "table.__name__": { "$in": ["orders", "customers"] }, "orders.region": "EU" }, "hidden_columns": { "customers": ["ssn", "credit_card"] } } } } } ``` ```json policy.json theme={null} { "tools": { "send_email": { "variables": { "to": "support@acme.com", "max_attachments": { "$lte": 3 } } }, "web_search": { "disabled": true } } } ```

Disabled tools and off-limits tables are stripped out of the schemas the agent sees. Constraints show up directly in parameter descriptions. Table filters are pushed down into SQL and document filters into vector search. The agent never even sees rows or documents that don't match. Every tool call is validated against the policy before it runs. Non-compliant calls are blocked: no side effects, no exceptions.

Get started

Connected in under a minute

Install the SDK, verify your key, and make your first call.

```bash theme={null} pip install meibel ``` ```python verify.py theme={null} import os from meibel import MeibelClient client = MeibelClient(api_key=os.environ["MEIBEL_API_KEY"]) result = client.datasources.list() print(f"Connected: {len(result.datasources)} datasource(s) found") ``` Head to the [quickstart](/quickstart) for a full walkthrough.