Document parsingNew

The most accurate parser you can run yourself.

Cloud-class document understanding without sending a page to a cloud parser: tables kept whole, charts read as data, every element grounded to its page.

Start with the REST API, .NET, the CLI or MCP.

#1 self-hosted on ParseBench #1 on visual grounding No per-page API charge Edge, local or air-gapped
Page one of a two-column research paper with a table, a bar chart and a formula
ChartRead as data#16
Die temperatureRawCompensated
0 °C2.10.3
20 °C0.40.1
40 °C2.60.3
60 °C4.90.5
bbox [311, 345, 554, 532] · confidence 1.00

Third on ParseBench. First you can run yourself.

ParseBench grades what AI agents need from a page. LM-Kit ranks third overall, behind only a cloud service billed per page, and first of everything you can run yourself.

86.7 overall at High, ahead of every frontier model on the board
89.4 visual grounding, the highest of any method on ParseBench
#1 of every method you can run yourself, at all three levels
44.4 pages a minute at Low, the fastest level

The mean of the five ParseBench dimensions: tables, charts, content faithfulness, semantic formatting and visual grounding.

# Method Runs as Overall Per page
1 LlamaParse Agentic Plus Cloud API 90.2 5.6¢
2 LlamaParse Agentic Cloud API 87.0 1.3¢
3 LM-Kit High Self-hosted 86.7 local
4 LM-Kit Medium Self-hosted 83.7 local
5 LM-Kit Low Self-hosted 81.9 local
6 Pulse Ultra 2 Cloud API 81.6 1.5¢
9 Anthropic Opus 5.5 (Effort High) Frontier model 79.8 6.1¢
11 oi-parser Self-hosted 78.3 local
17 OpenAI GPT-5.6 Sol (Reasoning High) Frontier model 75.3 8.1¢
19 Google Gemini 3 Flash (Thinking High) Frontier model 75.0 2.4¢
49 Mistral OCR 4 (Annotation) Cloud API 68.2 0.5¢
89 Azure Document Intelligence (Layout) Cloud API 59.6 1.0¢
110 Google Cloud Document AI Cloud API 50.4 1.0¢
113 AWS Textract Cloud API 47.9 1.5¢

Ranks among all 142 methods on the public board plus LM-Kit's three levels; a dotted row marks methods not shown. LM-Kit scores: the public ParseBench evaluation code and dataset, charts graded without the optional LLM judge. Other methods: parsebench.ai leaderboard, October 3, 2026.

Explore a parse. Element by element.

Real output on three documents: tap a region, play the reading order, read the Markdown and JSON your code receives. LM-Kit One ships the same view.

Page two of a research paper
1 / 1 Tap a region on the page, or step through the reading order.

What you get: the whole page, as data.

Flat text extraction returns words. The answers your systems need live in charts, table spans, reading order and position, and that is what the parser returns.

Every answer can show its work.

Every element comes back with its page, box, reading position and confidence, so any answer can point to the exact region behind it. No method on ParseBench grounds better.

  • Reading order a person would follow. Columns, sidebars, captions and footnotes, never interleaved.
  • Boxes for citations and review. Highlight the source of any answer in your viewer.
  • Headings ranked across pages. A section keeps its level on every page it spans.

Ask about a value that only a chart shows.

No number is printed on these bars. The parser measures them and returns the table behind the picture, so retrieval finds a value that exists only as a drawing.

  • Measured from the drawing. Vector charts are read from their own geometry, not guessed from pixels.
  • Checked against the print. Series and categories must be words the figure prints; invented labels lose.
  • Every common form. Bars, stacks, lines, pies and multi-panel figures.

Tables keep every span, sign and total.

A financial statement keeps its period headers, its negatives in parentheses and its bold totals, so the numbers land in the right column of your pipeline.

  • Merged cells as HTML. Row and column spans survive as rowspan and colspan.
  • Judged against the printed grid. A second reading replaces the first only when the page's own rules agree.
  • Joined across breaks. A table the layout splits is merged back when its columns line up.

Scans and phone photos, not just clean PDFs.

A page shot on a desk, at an angle, under uneven light, comes back with its headings, its numbered list and its table, as if it had been born digital.

  • Skew, curl and orientation. The page is measured and set straight before it is read.
  • A text layer earns its trust. Fonts that print one thing and encode another are caught and read from pixels.
  • One call for every input. PDF, scan or photo: same parser, same output.

LLMs can't read pages. They read what you give them.

Most RAG errors start before retrieval: flattened to text, a page loses its tables, charts and column order. The parser is the document-understanding layer LLMs lack.

Plain text extraction what the LLM gets
1 Introduction Table 1. Mean absolute error over the full thermal cycle, before and after compensation. Arrays built for battery-powered deployments trade thermal isolation for power. Their elements then read Error (mV) Arraydifferently at every temperature, and a field device Before After rarely has the budget for a reference sensor. We show that a small table held on the device is enough to A-16 4.8 0.6 correct them, and that the table can be fitted once, at A-32 5.1 0.7 production time. A-64 6.3 0.9

Drift 2 […] 1 […] 0 0 °C 20 °C 40 °C 60 °C Die temperature

Table cells land inside sentences. The chart gives axis ticks and no values.

Parsed with LM-Kit same page
## 1 Introduction
Arrays built for battery-powered deployments trade thermal
isolation for power. […] fitted once, at production time.

**Table 1.** Mean absolute error over the full thermal cycle, […]
<th colspan="2">Error (mV)</th> […]
<tr><td>A-32</td><td>5.1</td><td>0.7</td></tr>

#### Legend: Drift (mV)
<tr><td>60 °C</td><td>4.9</td><td>0.5</td></tr>

Sections intact, the table whole, the chart as values, each with its page and box.

Chunk

Chunks that follow the document

Split on headings, keep a table or a chart whole: no chunk starts mid-table or mid-sentence.

Retrieve

Numbers you can find

Table cells and chart values become text the index can match, so a question about a figure finds the figure.

Cite

Answers that show their source

Every chunk keeps its page, element and box, so an answer can highlight exactly where it came from.

Focus

Less noise in every prompt

Running heads, page numbers and footers are tagged, so they stay out of chunks and out of the context window.

Build it with Document RAG, or start from the parsed-document RAG demo.

Run your first parse. In any language.

LM-Kit One serves the parser over REST to any language, on the command line and to agents over MCP. LM-Kit.NET embeds it in your .NET application.

LM-Kit One

The server, for any language and agent

LM-Kit.NET

The SDK, inside your .NET application

LM-Kit One · parse.py
import base64, requests

pdf = base64.b64encode(open("annual-report.pdf", "rb").read()).decode()

r = requests.post(
    "http://localhost:5189/lmkit/v1/document-parsing",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"input": pdf, "effort": "Medium", "output_format": "Markdown"},
)
print(r.json()["content"])

One setting. Speed or fidelity, your call.

Three levels, one model file, one API. Choose per workload: throughput for ingestion, fidelity for filings, the balance for everything in between.

Low

81.9ParseBench overall
44.4pages a minute
1.35 s per page

High-volume ingestion and search indexes, where throughput leads. 94% of High's score at 2.2x its throughput.

MediumDefault

83.7ParseBench overall
29.6pages a minute
2.03 s per page

Most business documents. 97% of High's score in two thirds of the time.

High

86.7ParseBench overall
19.8pages a minute
3.03 s per page

Reports, filings and papers, where every table, chart and heading counts.

Measured over the full ParseBench dataset on one RTX 5090, four documents at a time. The public LM-Kit One container reproduces the High score with its default configuration.

Edge or local. Never someone else's cloud.

Parse where documents arrive, on any machine, or on your private servers. Fully air-gapped: no call home, no per-page API charge, and no page ever leaves your network.

What a machine needs to run the parser:

Processors
CPU, or a GPU through NVIDIA CUDA, Vulkan or Apple Metal
GPU memory
8 GB of VRAM minimum
Systems
Windows, Linux and macOS
Model
One 2.15 GB file, downloaded once or shipped with your app
Network
Fully offline after installation
Interfaces
.NET, REST, command line and MCP

Privacy

No third party reads a page.

Contracts, medical records and financial filings are parsed by software you run, with no processor to disclose. Privacy and compliance

Sovereignty

Your hardware, your jurisdiction.

Documents stay on machines you administer. LM-Kit never receives them. Sovereignty

Security

Inside your perimeter.

The parser runs under your access controls and your audit, with no external document-processing endpoint and no third-party data path. Trust Center

Local says where the model runs; private says where the data goes. Private AI or local AI sets out the difference.

Real-world PDFs lie. The parser checks.

A text layer is a claim, not a fact. Before trusting a word, the engine checks it against the page as it renders, then reads what the layer gets wrong.

Fonts that map the wrong charactersBroken or missing Unicode maps and renumbered subsets are caught, decoded, or read from the pixels.
Text nobody can seeWords drawn outside their clip, under an image or in the paper's colour are dropped, not indexed.
Another engine's OCRThe hidden layer of a searchable scan is treated as a hint, never as the truth.
Scans mixed with live textEach region's text layer must match the ink it sits on before it is used.
Bold with no nameWeight is measured from the rendered stroke, so faux bold and nameless faces still read as bold.
Letter-spaced display typeTracked headings come back as words, not as one letter per word.
Missing or wrong tagsStructure comes from the page itself, so untagged and badly tagged files parse like any other.
Columns, breaks and turned pagesWords split across columns rejoin, running heads reunite, sideways pages read upright.
Every script on the pageAccents restored, Chinese, Japanese and Thai read glyph by glyph, Indic scripts kept in their own letters.

Built by a team with 25+ years in PDF, imaging and document analysis.

Category leadersin document processing, same leadership 150+ releasesshipped since 2024, roughly one a week

Not one model. An engine that checks every reading.

Models read. The engine decides what to read, with which reader, and which reading stands, from evidence the page itself prints. That is where the score comes from.

Models change. Your code does not.

Document AI research moves every month. LM-Kit keeps integrating the strongest new readers, layout models and techniques into the engine, and a component ships only when it beats the one it replaces.

  • Many technologies, one verdict.OCR, vision-language readers, layout detection, NLP and the page's own geometry, weighed by our scoring equations and metrics. Only the reading the evidence backs stands.
  • One verified file.Every reader the engine uses ships inside one versioned, checksummed model file.
  • Same three settings.Low, Medium and High get faster and more accurate with no change to your code.
  1. Route before readingEach page and region is sorted first. Text a trusted text layer prints is served from it; tables, figures, formulas and scans go to the readers.
  2. Locate every regionA layout detector draws each region and its class, fused with the page reader's own regions so nothing goes unread.
  3. Read, then read againA vision reader transcribes the page. A second, independent reader takes figures, tables and doubtful text again.
  4. Settle by evidenceChart values are checked against the drawing, labels against the printed words, tables against the printed grid.
  5. Assemble the documentReading order, heading levels across pages, captions bound to their figures, then Markdown, JSON, HTML and DocLang.

Every token goes through Dynamic Sampling.

At inference time, LM-Kit's adaptive layer tracks the structure being written, from the taxonomy of elements to a table's grid and a chart's series, and steers every token to fit it, with grammar where the form must be exact. That is how small models out-read frontier ones.

Dynamic Sampling
1 fileevery reader inside, versioned and verified on load
1 GPUa single desktop card is enough; CPU works too
4 backendsCPU, CUDA, Vulkan and Metal
3 systemsWindows, Linux and macOS, from one codebase

Part of one stack. Nothing else to run.

No Python service, no separate OCR engine, no GPU sidecar. The parser shares one runtime, one scheduler and one release with everything else LM-Kit does.

The parsing pipeline you assemble

  • PDF library
  • OCR engine
  • Layout detection model
  • Vision model server
  • Table recognizer
  • Chart extraction service
  • GPU scheduling
  • Embedding service
  • Vector database
  • Queue and workers

LM-Kit

  • Parsing, OCR, layout and every reader in one engine
  • One thread budget and one GPU scheduler shared with chat, embeddings and agents
  • Parsed pages flow straight into RAG, search and structured extraction
  • One release: an improvement reaches every workload at once
  • Embedded in your .NET process, or served by LM-Kit One

Why integration beats assembly: the private AI stack is the product.

Document parsing

Parse your hardest documents on your own hardware.