| # API |
|
|
| This is the public facing API for the toolkit. There are three main entry points: |
|
|
| - `score`: score a document's prediction against the ground truth. |
| - `predict`: predict extractions for a document with one of our providers. |
| - `benchmark`: run our benchmark. |
|
|
| The first two are the primitives the last one is built around. Each works in your code and |
| from the cli. The cli is a thin wrapper, except that `benchmark` shows you the plan and waits |
| -- nothing in the library ever reads stdin. |
|
|
| 1. **[score](#score)** — grade one prediction against one ground truth. |
| 2. **[predict](#predict)** — one document, one vendor. |
| 3. **[benchmark](#benchmark)** — the whole corpus, every vendor, resumable. |
| 4. **[providers](#providers)** — what you can run, and what each one takes. |
| 5. **[What a benchmark writes](#what-a-benchmark-writes)** — the files, and what's in them. |
|
|
|
|
| ## score |
|
|
| Just the base install. No network, no API keys, no vendor packages. |
|
|
| Use in your own code. |
|
|
| ```python |
| from omni_extract_bench import score |
| |
| score( |
| pred, # the prediction, a dict |
| gt, # the ground truth, a dict |
| schema, # the JSON Schema the prediction was generated against |
| order_matters=(), # arrays where position is part of the answer, e.g. ["steps"] |
| verdicts=False, # also return one verdict per address |
| ) |
| ``` |
|
|
| ```python |
| result = score(prediction, ground_truth, schema) |
| result["accuracy"] # matched addresses / addresses either document used |
| result["precision"] |
| result["recall"] |
| ``` |
|
|
| or from the command line. |
|
|
| ```bash |
| oeb score --pred pred.json --gt gold.json --schema schema.json |
| ``` |
| ```json |
| { |
| "accuracy": 0.5294117647058824, |
| "precision": 0.5625, |
| "recall": 0.8181818181818182, |
| "f1": 0.6666666666666666, |
| ...truncated for display |
| ``` |
|
|
| Every argument is a flag of the same name, underscores as dashes, so `order_matters` is |
| `--order-matters`. It goes to stdout, so `oeb score ... | jq .accuracy` is one pipe. |
|
|
| The README has a [worked example](../README.md#score) and |
| [`docs/METRIC_SPEC.md`](./METRIC_SPEC.md) is the full specification. |
|
|
|
|
| ## predict |
|
|
| Needs the harness extra. |
|
|
| ```bash |
| uv pip install 'omni-extract-bench[harness]' |
| ``` |
|
|
| Use in your own code. |
|
|
| ```python |
| from omni_extract_bench.harness import predict |
| |
| predict( |
| provider, # a vendor name, or an OpenRouter model id |
| pdf, # path to the document |
| schema, # the JSON Schema to extract against |
| timeout=1800.0, # seconds this document may take, end to end |
| overlay=True, # state the gold's conventions in the field descriptions |
| **options, # anything the provider takes, e.g. mode="accurate" |
| ) |
| ``` |
|
|
| Keys come from the environment and nowhere else -- `DATALAB_API_KEY`, `REDUCTO_API_KEY`, |
| `OPENROUTER_API_KEY` and so on. Options are recorded in the run, and a key should never be. |
|
|
| You get back the answer and the evidence for it. |
|
|
| ```python |
| record = predict("datalab", "invoice.pdf", schema, mode="accurate") |
| record["result"] # the extraction, shaped like your schema |
| record["raw"] # the vendor's response, as received |
| record["cost"] # what the vendor said this cost, plus wall_s and attempts |
| record["error"] # None, or what went wrong |
| record["run_manifest"] # what the vendor was actually sent |
| ``` |
|
|
| Score directly from the prediction. |
|
|
| ```python |
| from omni_extract_bench import score |
| score(record["result"], gold, schema) |
| ``` |
|
|
| You can also use the cli: |
|
|
| ```bash |
| oeb predict --provider datalab --doc invoice.pdf --schema schema.json \ |
| --options '{"mode": "accurate"}' |
| ``` |
| ```json |
| { |
| "result": {"invoice_id": "INV-4417", "total_due": 1240.0, ...}, |
| "error": null, |
| "provider": "datalab", |
| "cost": {"usd": 1.4, "wall_s": 172.4, "attempts": 1, ...}, |
| ...truncated for display |
| ``` |
|
|
| Three types of errors raise: |
|
|
| ```python |
| MissingCredential # an unset API key |
| MissingDependency # an adapter whose SDK isn't installed |
| AccountFailure # the account can't pay |
| ``` |
|
|
| Everything else comes back in `record["error"]` with the prediction beside it. |
|
|
|
|
| ## benchmark |
|
|
| Needs the benchmark extra. |
|
|
| ```bash |
| uv pip install 'omni-extract-bench[benchmark]' |
| ``` |
|
|
| **!!NOTE!!**: running this will cost money and you will need your API keys set. |
|
|
| Use in your own code. |
|
|
| ```python |
| from omni_extract_bench.benchmark import BenchmarkRun |
| |
| BenchmarkRun( |
| providers, # e.g. ["datalab"] |
| out="runs", # where runs go |
| data_root=None, # where the corpus lands. Default: the HuggingFace cache |
| manifest=None, # own manifest instead of ours |
| repo=None, # a different HuggingFace dataset. Default: ours |
| suites=None, # limit to these suites |
| limit=0, # first N documents |
| timeout=1800.0, |
| predict_workers=None, # documents in flight per vendor |
| score_workers=0, # processes used to score |
| verdicts=True, # write verdicts; False to skip them |
| rescore=False, # score every document again |
| score_only=False, # score the predictions; call no vendor |
| options=None, # per-provider settings: {"datalab": {"mode": "accurate"}} |
| ) |
| ``` |
|
|
| ```python |
| summary = BenchmarkRun(["datalab", "reducto"], limit=5).execute() |
| summary["datalab-f46415c9"]["accuracy"] # e.g. 0.9145 |
| ``` |
|
|
| ### Three levels of abstraction |
|
|
| ```python |
| BenchmarkRun # every Run, grouped by adapter, predicted then graded |
| ProviderRun # every Run using a provider, through one pool sized to that service |
| Run # a provider plus its options |
| ``` |
|
|
| - A `Run` is a provider plus its options. For example, `datalab` at `mode=accurate`. It has its own self-contained directory of results. |
| - A `ProviderRun` is every Run for one provider sharing one pool of threads. The cap belongs to the provider. |
|
|
|
|
|
|
| ### From the cli |
|
|
|
|
| ```bash |
| oeb benchmark --out runs/ --limit 1 --providers datalab reducto |
| ``` |
| ``` |
| benchmark |
| out runs |
| runs 2 over 2 adapters |
| corpus huggingface datalab-to/omni_extract_bench |
| documents 1 document selected |
| timeout 1800s per document |
| score only false |
| rescoring false |
| |
| ╭─────────┬─────────┬──────────────────┬─────────────────────────────────┬─────────┬───────╮ |
| │ adapter │ at once │ run │ settings │ predict │ grade │ |
| ├─────────┼─────────┼──────────────────┼─────────────────────────────────┼─────────┼───────┤ |
| │ datalab │ 10 │ datalab-f46415c9 │ base_url=https://www.datalab.to │ 1 │ 1 │ |
| │ │ │ │ ─────────────────────────────── │ │ │ |
| │ │ │ │ mode=balanced │ │ │ |
| │ │ │ │ ─────────────────────────────── │ │ │ |
| │ │ │ │ poll_interval=5.0 │ │ │ |
| ├─────────┼─────────┼──────────────────┼─────────────────────────────────┼─────────┼───────┤ |
| │ reducto │ 3 │ reducto-e54d3a1d │ agentic_table_mode=max │ 1 │ 1 │ |
| │ │ │ │ ─────────────────────────────── │ │ │ |
| │ │ │ │ deep_extract_model=v2 │ │ │ |
| │ │ │ │ ─────────────────────────────── │ │ │ |
| │ │ │ │ poll_interval=5 │ │ │ |
| │ │ │ │ ─────────────────────────────── │ │ │ |
| │ │ │ │ system_prompt='' │ │ │ |
| ╰─────────┴─────────┴──────────────────┴─────────────────────────────────┴─────────┴───────╯ |
| proceed? [y/N] |
| ``` |
|
|
| You can pass `-y` to skip the interactive confirmation. The execution looks like: |
|
|
| ``` |
| run done ok err in flight cost avg dur |
| ──────────────────────────────────────────────────────────────────────────────────────────── |
| datalab-f46415c9 ━━━━━━━━━━━━━━━━ 20/20 20 0 $6.20 1m58s 3.0s |
| datalab-01a72762 ━━━━━━━━━━━━━━━━ 20/20 20 0 $6.20 2m02s 3.0s |
| reducto-e54d3a1d ━━━━━━━━━━━━━━━━ 20/20 19 1 5,820 cr 2m19s 3.0s |
| mistral-44136fa3 ━━━━━━━━━━━━━━━━ 20/20 20 0 2m13s 3.0s |
| 80/80 documents 1 failed $12.40 + 5,820 cr 3.0s elapsed |
| ``` |
|
|
|
|
| ### Settings per provider |
|
|
| `--options` can give one provider a **list**, and each entry is its own `Run`. For example: |
|
|
| ```bash |
| oeb benchmark \ |
| --providers datalab reducto \ |
| --options '{"datalab": [{"mode": "balanced"}, {"mode": "accurate"}], |
| "reducto": [{"agentic_table_mode": "max"}, |
| {"agentic_table_mode": "default"}]}' \ |
| --out runs/ |
| ``` |
|
|
| That's 4 runs. |
|
|
| ### A manifest of your own |
|
|
| ```bash |
| oeb benchmark --providers datalab --manifest my/corpus/manifest.parquet |
| ``` |
|
|
| Same parquet shape as [ours](https://huggingface.co/datasets/datalab-to/omni_extract_bench). Or |
| you can point to your own HuggingFace dataset, which is fetched the same way ours is. |
|
|
| ```bash |
| oeb benchmark --providers datalab --repo someone/their-corpus |
| ``` |
|
|
| Whichever you use, the run records it in `settings.json` and refuses a directory that already |
| holds another one. |
|
|
| ### Resuming |
|
|
| It's **resumable**, and safe to run twice. |
|
|
| - A document is predicted again only when it has no record. The record is written last, so |
| its presence means the prediction beside it is complete. |
| - A document is graded again only when it has no row in `scores.jsonl`. |
|
|
| So a Ctrl-C, a crash or a credit ceiling costs you the documents in flight, and nothing else. |
| Reinvoke the same command to carry on. |
|
|
|
|
| ## providers |
|
|
| See providers: |
|
|
| ```bash |
| oeb providers |
| ``` |
| ``` |
| provider |
| ─────────────────────── |
| azure-cu |
| datalab |
| extend |
| llamaextract |
| mistral |
| reducto |
| |
| openai/gpt-5.6-sol |
| anthropic/claude-opus-5 |
| google/gemini-3.7-flash |
| |
| the three model ids are examples: any OpenRouter org/model id works. |
| ``` |
|
|
| See what settings each takes and its default values. For example, datalab: |
|
|
| ```bash |
| oeb providers datalab |
| ``` |
| ``` |
| datalab |
| option default |
| ────────────────────────────────────── |
| mode balanced |
| base_url https://www.datalab.to |
| poll_interval 5.0 |
| |
| oeb benchmark --providers datalab --options '{"datalab": {"mode": ...}}' |
| ``` |
|
|
| Those defaults are the vendor's maximum tier. Parity here is "as much as the vendor will give", |
| not one number for everyone. |
|
|
| In your code: |
|
|
| ```python |
| from omni_extract_bench.harness import PROVIDERS, settings_for |
| |
| PROVIDERS |
| # ['azure-cu', 'datalab', 'extend', 'llamaextract', 'mistral', 'reducto'] |
| |
| settings_for("datalab") |
| # {'mode': 'balanced', 'base_url': 'https://www.datalab.to', 'poll_interval': 5.0} |
| |
| settings_for("datalab", {"mode": "accurate"}) |
| # {'mode': 'accurate', 'base_url': 'https://www.datalab.to', 'poll_interval': 5.0} |
| ``` |
|
|
|
|
| ## What a benchmark writes |
|
|
| One directory per run. |
|
|
| ``` |
| runs/ |
| ├── datalab-f46415c9/ |
| │ ├── settings.json |
| │ ├── summary.json |
| │ ├── predictions/<doc_id>.json |
| │ ├── records/<doc_id>.json |
| │ ├── scores.jsonl |
| │ └── verdicts/<doc_id>.jsonl # unless --no-verdicts |
| ├── datalab-01a72762/ |
| └── reducto-e54d3a1d/ |
| ``` |
|
|
| Each is named for the provider and an eight-character digest of everything it was asked. That's |
| what keeps two configurations of one vendor apart. `datalab-f46415c9` is the balanced run, |
| `datalab-01a72762` is the accurate one, and neither can be handed the other's answers. |
|
|
| The digest isn't meant to be read. `settings.json` is where you read what a run was. |
|
|
| ### settings.json |
|
|
| What the run asked for, written **before** the first document -- so an interrupted run still |
| says what it is. |
|
|
| ```json |
| { |
| "run": "datalab-f46415c9", |
| "provider": "datalab", |
| "settings": { |
| "mode": "balanced", |
| "base_url": "https://www.datalab.to", |
| "poll_interval": 5.0 |
| }, |
| "timeout_s": 1800.0, |
| "corpus": "huggingface datalab-to/omni_extract_bench" |
| } |
| ``` |
|
|
| `settings` is the whole resolved configuration, not just what you passed. |
|
|
| ### summary.json |
|
|
| What it came to, written as soon as that run is graded rather than when the whole invocation |
| finishes. |
|
|
| ```json |
| { |
| "run": "datalab-f46415c9", |
| "provider": "datalab", |
| "settings": {"mode": "balanced", "base_url": "https://www.datalab.to", "poll_interval": 5.0}, |
| "documents": 6, |
| "scored": 6, |
| "coverage": 1.0, |
| "accuracy": 0.8076406248606786, |
| "precision": 0.8101146573593331, |
| "recall": 0.9539514921288181, |
| "misread_rate": 0.03748563782596681, |
| "unfound_rate": 0.002711187188462559, |
| "fabricated_rate": 0.14784472888803452, |
| "invented_item_rate": 0.0043178212368574645, |
| "invented_field_rate": 0.0, |
| "per_suite": { |
| "extractbench": {"documents": 6, "scored": 6, "coverage": 1.0, "accuracy": 0.8076406248606786, |
| "...": "the same block, per suite"} |
| } |
| } |
| ``` |
|
|
| The run and each suite are the same shape, so whatever you read at the top you can read per |
| suite as well. |
|
|
|
|
| ### predictions/<doc_id>.json |
| |
| The bare extraction, shaped like the schema. This is what scoring reads, and it's the same |
| thing `predict` returns as `record["result"]`. |
| |
| ### records/<doc_id>.json |
|
|
| Everything else about that document. Two files because scoring wants the answer and an audit |
| wants all of it. |
|
|
| ```json |
| { |
| "result": "...", |
| "raw": "...", |
| "error": null, |
| "provider": "datalab", |
| "cost": { |
| "usd": 1.4, |
| "source": "cost_breakdown.final_cost_cents", |
| "tokens_in": null, |
| "tokens_out": null, |
| "credits": null, |
| "wall_s": 172.4, |
| "attempts": 1, |
| "billed_out_of_band": false |
| }, |
| "job_id": "32RBrjAbYxN0yDlOF__lDQ", |
| "schema_sent": {"...": "the schema this vendor received"}, |
| "run_manifest": { |
| "timeout_s": 1800, |
| "settings": {"mode": "balanced", "base_url": "https://www.datalab.to", "poll_interval": 5.0}, |
| "model": null, |
| "timed_out": false, |
| "conventions_applied": false, |
| "captured_at": "2026-09-18T15:06:13" |
| } |
| } |
| ``` |
|
|
|
|
| ### scores.jsonl |
|
|
| One line per document, in document order whatever order the workers finished in. |
|
|
| ```json |
| { |
| "doc_id": "long__dd1155_schedule_continuation_0011", |
| "suite": "extractbench", |
| "provider": "datalab", |
| "status": "scored", |
| "accuracy": 0.9555555555555556, |
| "precision": 0.9555555555555556, |
| "recall": 1.0, |
| "f1": 0.9772727272727273, |
| "total": 90, |
| "matched": 86, |
| "misread": 0, |
| "unfound": 0, |
| "fabricated": 4, |
| "invented_item": 0, |
| "invented_field": 0, |
| "asserted": 90, |
| "addresses_found": 0.9555555555555556, |
| "addresses_read_right": 1.0, |
| "gt_rows": 20, |
| "pred_rows": 20, |
| "matched_rows": 20, |
| "matching_exact": true, |
| "approximated": [], |
| "skipped_open_maps": [] |
| } |
| ``` |
|
|
|
|
| ### verdicts/<doc_id>.jsonl |
| |
| One line per address: what happened there, and what each side was compared as. This is the |
| same shape `score(..., verdicts=True)` returns, and it's a low-level address breakdown of how |
| scoring happened. |
| |
| Written by default, because it's what lets a number be argued with rather than only quoted. |
| It's also the bulk of what a run writes -- around five times the gold it grades, so a |
| four-provider run over our corpus is a couple of gigabytes. Pass `--no-verdicts` and you get |
| `scores.jsonl` and `summary.json` and nothing else. |
| |
| One line looks like this: |
| |
| ```json |
| {"address": [["k", "line_items"], ["i", 0], ["k", "unit_price"]], "gold_raw": 12.5, "pred_raw": 12.05, "gold_canon": "12.5", "pred_canon": "12.05", "verdict": "misread"} |
| ``` |
| |
| `address` is the path to the scalar, one step at a time: `["k", name]` walks into a key, |
| `["i", n]` into an array element. So that one reads `line_items[0].unit_price`. |
| |
| `gold_raw` and `pred_raw` are what each document said; `gold_canon` and `pred_canon` are what |
| they were actually compared as, after normalising. |
| |
| There are six verdicts, and every address gets exactly one: |
| |
| ``` |
| matched both documents addressed it and agree |
| misread both addressed it and the values disagree |
| unfound the gold has it, the prediction doesn't |
| fabricated the schema offered the slot, the document is silent |
| invented_field a name the schema never declared |
| invented_item a value under an array row that paired with nothing |
| ``` |
| |
| `fabricated` keys off the **schema**, not gold's `null`s. The schema offered `purchase_order`, |
| the document doesn't cite one, and the model produced `PO-88231` from nowhere. |
|
|
| And in the `invented_item` line the index is `"p2"`, not a number. A predicted row that paired |
| with a gold row takes gold's index; one that paired with nothing gets a made-up label |
| instead. |
|
|
| [`METRIC_SPEC.md`](./METRIC_SPEC.md) §4 has the full vocabulary and how the counts add up. |
|
|
