Repository navigation
Releases
0.4.5
Values the output left out are warned by default. printed_but_empty and row_not_extracted (code only, no model call) are now listed in warnings on every extraction, without review; repeats on one field are one line with a count. Turn off with left_out_warnings=False, --no-left-out-warnings or settings.left_out_warnings: false. The noisier review flags stay behind review.
0.4.4
- Review flags values the output left out, by code with no model call:
printed_but_empty(a field is empty but
the document prints a value for it that nothing took, for example a dropped billing contact) and
row_not_extracted(a list took some rows of a table and left another out). They replace
list_may_be_incomplete. On planted misses in 47 documents: 84-100% of emptied lists and 89-95% of blanked
fields caught, about 0.1 flags per document on real outputs. What it does not catch, and the model-based option
we did not build, are in the extraction guide ("Values the output left out").
0.4.3
fill_required(Python, CLI--fill-required, MCP,settings.fill_required): which required fields always get
a value."choices"(default, as in 0.4.2): required yes/no and enum fields.True: also every required number
and text field. A list of field paths: the choices and those fields.False: none. Forced numbers and text may be
guesses: withreview, each one not printed in the document is flaggedfilled_because_required. On a pack of 5
order forms,Truescored 98.3% of fields right against 100% for the default (it filled end dates the answer
key leaves empty).- Review: a total row whose label spans the columns ("Monthly recurring | USD 1,500.00") no longer counts as a
missing list item.
0.4.2
From a user's test of 0.4.0 on a pack of 5 order forms (their scorer: 97.9% of fields right). After these fixes,
one run: 534 of 534 fields right, $0.012-0.015 per form.
- Required yes/no and enum fields come back in the schema's type. A field the schema requires and does not allow
null (a boolean, an enum) has no empty choice: the model has to answer it, so the output passes the schema's
own validation (4 of 5 forms returned null for a required boolean). In the coded format such fields are marked
"always answer". An optional section the document does not have is still null, and a list item is never made up
for such a field. Numbers and text are never forced: a required one the document does not give stays null, with
a warning. - Alternatives (
alternatives=True) come back in the field's own format and type ("2026-03-01", 4500), with the
printed text kept asprinted. - Review: no
not_found_on_pagefor enum fields (a category the model picks is never printed as such); no
list_may_be_incompletefor a total row under the items; "&" in a name is matched against "&" in the parsed
table (a printed name was flagged as not printed).
0.4.1
readanydoc bench: a small sample now covers the set's hard documents (photos, scans, handwriting, multi-page) and mixes difficulties.- BENCHMARKS.md: a 20-invoice extraction run against Reducto and a plain model.
0.4.0
Test it yourself: compare ReadAnyDoc with other systems on public test sets or your own documents.
readanydoc bench: compare ReadAnyDoc with Reducto, a plain model call or its own other modes, on 8 public test
sets (invoices, receipts, quarterly reports, credit agreements, research papers, resumes, result tables, long
reports) or on your own documents, with your own keys. Cost estimate and confirmation before spending, a budget
cap, resumable runs, scoring by code against answer keys, and an HTML report with every system's citation boxes on
the page. Also as MCP tools (list_test_sets,run_test) and in Python (readanydoc.bench).
0.3.0
Every extraction call is enforced by the API, whatever the schema's size, and reads one cached copy of the
document; citations point where a person checking a value would look; and a cheaper one-stage mode.
- Enforced output at any size. A schema the API refuses as one structured-output call is asked in one fixed answer
format ({"values": [{"code", "item", "value"}]}, codes from your schema's own fields), the same in every call,
and turned back into your exact shape. No call is ever made just to fix the shape. - The document is cached within a run: after the first group of fields, every group reads it at a tenth of the
price. Nothing is reused between runs. - Page parts are sized in tokens:
part_tokens(default 30,000, capped by the model's own limit;extract(..., part_tokens=...),settings.part_tokens, MCPpart_tokens). Measured on a 43-page 10-Q: 30,000 kept the
accuracy of small parts at lower cost; one 43-page part lost a third of the values. - Model limits (context, output, price jump, prices) come from a snapshot of LiteLLM's public model list, about
4,300 models, or an OpenAI-compatible server's/models; your own file inREADANYDOC_MODEL_LIMITSoverrides
them. An unknown model is an error namingpart_tokens, never a guess. The output limit is the model's own. - One log line per run with every setting chosen (
readanydoclogger,extract settings: {...}), and
READANYDOC_TRACE=<file.jsonl>: one line per model call (tokens, cache reads and writes, cost, seconds, why the
call was made, the reply) and per decision. - A value stated once for a whole table or page (a unit, "in thousands", a period in a heading) is written on every
item it covers; of two copies of the same list item, the less complete one is dropped; names are copied in full. - Citations: the table the model read each row from is kept across page parts; worked-out values (a period from a
column heading, a scale from "in millions", a code from a name) are boxed on the printed words they come from;
a category chosen from your schema's list is never boxed on the same word elsewhere; a number is matched only as
a whole number; a short value printed in several places is not boxed at a guess. On a 10-Q, numbers boxed on the
right row: 94% (Reducto 81%); category boxes on the cover page: 128 to 0. extract(..., parse=False)(MCPparse_first=false): one stage, off by default. The model reads the file itself
(PDF, scans, images, Office files) and citations come from the PDF's own words or local OCR, with no model. About
half the cost and 2.5 times faster on a 43-page 10-Q, but less accurate (102-110 values against 99-129) and with
3-4 times fewer citations.- A value the document does not give stays null, also for a required field: never an invented value.
Full research record: docs/research/extraction.md.
0.2.0
Extraction costs what the answer costs again, and stays reliable on schemas of any size. Breaking: the
field_report response key (report in Python, fields_to_check in MCP) is gone; its useful parts are opt-in.
- The model writes only your schema's fields. 0.1.8 asked for a source, a printed form and notes for every value in
the same reply, also with citations off; on large schemas that reply ran past the length limit, and the recovery
(pages and fields in halves) multiplied the calls. That is removed. - Structured outputs for any schema size: your schema is rewritten in code (every field required, "" for a value
the document does not have, numbers and yes/no as text), the API enforces it, and the answer is turned back into
your types and checked against your schema, patterns and ranges included. Schemas over 40 fields are asked in
groups before any call, in parallel, each seeing the whole document; a group the API will not compile is split
further (a one-token check, remembered on disk per schema). - Citations are found by code: each value is looked up on the parsed pages, including dates and numbers printed
another way (03/04/2025,$4,200.00); a value printed in several places is cited next to the rest of its object
(one short_blocklabel per object, removed from the result). A value whose words were not placed by the parser
is found in the page's own words (form amounts printed apart from their labels). - A reply that is cut off is split by fields, lists apart from the rest, with all pages in view; only a single long
list is split by pages. A field is reported as unreadable only if it is still empty at the end. - Opt-in:
review=True(settings.review) lists values to check, found by code with no model call
(not_found_on_page,ambiguous_date,struck_through,void_page,list_may_be_incompletecounted on rows
with an amount, ...);alternatives=Trueor a list of fields (settings.alternatives) returns other values the
document gives for a field, with where they are printed;derived_values=Falseasks for printed values only.
CLI:--review,--alternatives [FIELD ...],--printed-only. - No more "inferred" lines in
warnings, and no automatic re-ask for lists that look short. - Enum values that differ only in case are matched ("PAID" to "paid").
- Each group of a large schema is told which fields are asked separately, so neighbouring objects (buyer and
seller) are not mixed up. An optional object the document does not have comes back as null, and "null" written
as text is null where your schema allows it. A value the document gives in another form ("USA" for a country
code) is written in the field's form; a field the document does not answer stays empty instead of guessed. - Measured on 12 test documents against 0.1.8: 2.6x cheaper and 2.8x faster at extraction, about the cost and time
of 0.1.6; citations on the right words 93.6% (0.1.8: 84.7%). On a 5-contract test pack: 98.5% of fields right
(0.1.8: 98.7%), at a quarter of the cost and an eighth of the time.
0.1.8
- Field report: every extracted field says how it was found.
conflictwhen the document gives two values (every
candidate with its page),inferredwhen the document never states it, andblank,not_applicable,
not_in_documentorunreadableinstead of a bare null. Flags for conversions to check (day/month order,
parentheses, "in thousands", percentages, currency), crossed-out values and pages stamped VOID. Lists with fewer
items than their table are asked for again, then reported. Infield_report(HTTP),report(Python),
fields_to_check(MCP), and inwarnings. On by default;settings.field_report: falseturns it off. - Python 3.13 is supported.
readanydoc extract --instructions @rules.mdreads long instructions from a file.- The "figure blocks could not be located" warning only appears when figure images, descriptions or chart data were
asked for.
0.1.7
- Extract on deep schemas with citations on no longer comes back empty. A broken model reply is never read as a
fragment: it is repaired only when the result fits the schema exactly, otherwise asked for again, then in halves.
A field that still cannot be read says so ("could not be read") instead of "not found in the document". - Citations are asked for as a flat source list next to the data, not by wrapping every value: less for the model to
get wrong on deep schemas. Fields the model writes one level off are put back. - Structured outputs are used on the Anthropic API whenever the schema fits the API's limits.