Skip to content

Releases

0.4.5

Choose a tag to compare

@arpitpatel25 arpitpatel25 released this 20 Nov 08:51
9a93298

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

Choose a tag to compare

@arpitpatel25 arpitpatel25 released this 19 Nov 17:06
c861431
  • 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

Choose a tag to compare

@arpitpatel25 arpitpatel25 released this 19 Nov 11:51
b461cec
  • 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: with review, each one not printed in the document is flagged filled_because_required. On a pack of 5
    order forms, True scored 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

Choose a tag to compare

@arpitpatel25 arpitpatel25 released this 19 Nov 11:05
b734ee3

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 as printed.
  • Review: no not_found_on_page for enum fields (a category the model picks is never printed as such); no
    list_may_be_incomplete for 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

Choose a tag to compare

@arpitpatel25 arpitpatel25 released this 19 Nov 09:28
71184aa
  • 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

Choose a tag to compare

@arpitpatel25 arpitpatel25 released this 19 Nov 07:28
7b33e00

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

Choose a tag to compare

@arpitpatel25 arpitpatel25 released this 18 Nov 19:11
587d451

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, MCP part_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 in READANYDOC_MODEL_LIMITS overrides
    them. An unknown model is an error naming part_tokens, never a guess. The output limit is the model's own.
  • One log line per run with every setting chosen (readanydoc logger, 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) (MCP parse_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

Choose a tag to compare

@arpitpatel25 arpitpatel25 released this 18 Nov 03:21

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 _block label 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_incomplete counted on rows
    with an amount, ...); alternatives=True or a list of fields (settings.alternatives) returns other values the
    document gives for a field, with where they are printed; derived_values=False asks 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

Choose a tag to compare

@arpitpatel25 arpitpatel25 released this 16 Nov 20:26
  • Field report: every extracted field says how it was found. conflict when the document gives two values (every
    candidate with its page), inferred when the document never states it, and blank, not_applicable,
    not_in_document or unreadable instead 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. In field_report (HTTP), report (Python),
    fields_to_check (MCP), and in warnings. On by default; settings.field_report: false turns it off.
  • Python 3.13 is supported.
  • readanydoc extract --instructions @rules.md reads 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

Choose a tag to compare

@arpitpatel25 arpitpatel25 released this 16 Nov 19:49
  • 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.