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.

Get started

Install the SDK, set your API key, and make your first call.

Core concepts

Agents, datasources, batches, execution policies, and confidence scoring.

Guides

Task-first walkthroughs for agents, sessions, data, and documents.

API reference

Every endpoint, parameter, and response, with a live playground.

SDKs

Python, TypeScript, Go, and CLI. One client covers every primitive.

Tutorials

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.

1. Parse
2. Transform
3. Ingest
4. Agent

parse.py

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)

transform.py

# 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)

ingest.py

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)

agent.py

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.

01 · Parsing

Turn PDFs, spreadsheets, and images into typed content, with hierarchy, tables, and visual elements preserved.

02 · Transform

Reshape any source into your schema with per-field confidence scores.

03 · Datasources

A living, queryable store for structured and unstructured data, with no vector database to manage.

04 · Agents

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.

AgentsREASONING

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

IngestINDEX

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.

TransformSCHEMA

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

ParseFOUNDATION

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.

Unstructured data
Structured data
Tools

policy.json

{
  "datasources": {
    "ds_abc123": {
      "documents": {
        "filter": {
          "data_element.__id__": { "$in": ["de_abc", "de_def"] }
        }
      }
    }
  }
}

policy.json

{
  "datasources": {
    "ds_abc123": {
      "tables": {
        "filter": {
          "table.__name__": { "$in": ["orders", "customers"] },
          "orders.region": "EU"
        },
        "hidden_columns": {
          "customers": ["ssn", "credit_card"]
        }
      }
    }
  }
}

policy.json

{
  "tools": {
    "send_email": {
      "variables": {
        "to": "support@acme.com",
        "max_attachments": { "$lte": 3 }
      }
    },
    "web_search": { "disabled": true }
  }
}

Before the LLM call

Disabled tools and off-limits tables are stripped out of the schemas the agent sees. Constraints show up directly in parameter descriptions.

During data access

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.

At tool execution

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.

Install the SDK

pip install meibel

Verify your key

verify.py

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")

Make your first call

Head to the quickstart for a full walkthrough.

Powerful primitives. One API. Deeply integrated.

Browse the docs

Get started

Core concepts

Guides

API reference

SDKs

Tutorials

From data to agent

Powerful primitives

01 · Parsing

02 · Transform

03 · Datasources

04 · Agents

Deeply integrated.

Hardrails, not guardrails

Before the LLM call

During data access

At tool execution

Connected in under a minute

Powerful primitives.
One API.
Deeply integrated.