docling.rs

docling.rs

docling.rs converts documents — PDF, Office, HTML, scans, audio — into Markdown, docling JSON and the other shapes an LLM or a RAG pipeline can read. It is a Rust port of IBM's docling: the same output, byte-for-byte, from one static binary. No Python, no PyTorch.

Pulling text out of a PDF is easy. Keeping its *structure* — headings in order, tables as tables, scanned pages read — takes layout analysis, table recognition and OCR. docling has the models for that, and a Python stack to match. docling.rs runs the same models from a single binary: PDF 4.3× faster than Python docling at under half the RAM, Office and HTML 20–60× faster, and tables that survive — cell recall 0.94 where MarkItDown gets 0.31 (numbers, method).

Coming from [MarkItDown](https://github.com/microsoft/markitdown)? pip install docling-rs, swap one import — from docling_rs.markitdown import MarkItDown — and keep its API, every format it converts included, with real layout analysis, tables and OCR behind it: guide, measured side by side.

Coming from [Marker](https://github.com/datalab-to/marker)? pip install docling-rs, swap the imports — from docling_rs.marker.converters.pdf import PdfConverter — and keep its API: create_model_dict, text_from_rendered, the JSON block tree, chunks, marker_single's CLI and output layout, with docling's layout analysis, TableFormer and OCR behind it and no PyTorch or inference server: guide, measured side by side.

Coming from [MinerU](https://github.com/opendatalab/MinerU)? pip install docling-rs, swap the imports — from docling_rs.mineru.parser import parse — and keep MinerU 4's SDK: ParseResult, markdown(), the Middle JSON, Content Lists and Structured Content, save()'s layout and mineru-kit parse, with docling's layout analysis, TableFormer and OCR behind it and no DocVortex or llama.cpp: guide, measured side by side.

Install

# CLI + models (Linux x64/arm64/s390x + macOS arm64 prebuilt; builds from source elsewhere)

curl -fsSL https://raw.githubusercontent.com/docling-project/docling.rs/master/scripts/install/install.sh | bash docling-rs example.pdf # Markdown on stdout

or from crates.io; --cli puts the models where the installed binary looks

cargo install docling-cli curl -fsSL https://raw.githubusercontent.com/docling-project/docling.rs/master/scripts/install/download_dependencies.sh | sh -s -- --cli

pip install docling-rs # Python — drop-in for docling's, MarkItDown's, Marker's and MinerU's APIs npm install docling.rs # Node.js / Bun cargo add docling # Rust library

containers, models baked in (-cuda variants for NVIDIA)

docker run --rm -v "$PWD:/data" ghcr.io/docling-project/docling-rs paper.pdf docker run -p 127.0.0.1:5001:5001 ghcr.io/docling-project/docling-rs-serve

Office, HTML, Markdown and e-mail need no models. PDF, images and audio need the ONNX models (layout, OCR, TableFormer, Whisper; under 1 GB): install.sh, --cli and the containers bring them along; with pip, run python -c "import docling_rs; docling_rs.download_models()" once; with npm or a checkout, run download_dependencies.sh where you convert (details). Windows: docs/WINDOWS.md.

▶ [Try it in your browser](https://docling-project.github.io/docling.rs/) first — the converter as wasm, OCR included; nothing leaves your device.

Use

docling-rs report.pdf > report.md               # Markdown (streamed page by page)

docling-rs report.pdf --to json # docling JSON; also html, text, latex, dclx, chunks, images docling-rs --input ./docs --output ./out # a directory tree; --jobs N in parallel docling-rs https://example.com/paper.pdf # URLs, data: URIs and stdin (-) too docling-rs https://www.youtube.com/watch?v=ID # a YouTube video: title, description, caption transcript (--to vtt keeps the timing) docling-rs --help # every flag: OCR, page ranges, images, enrichment, redaction …

from docling_rs import DocumentConverter       # was: from docling.document_converter import …

doc = DocumentConverter().convert("report.pdf").document print(doc.export_to_markdown())

import { convertFileAsync } from 'docling.rs'

const { content } = await convertFileAsync('report.pdf', { to: 'markdown' })

use docling::{DocumentConverter, SourceDocument};

let result = DocumentConverter::new().convert(SourceDocument::from_file("report.pdf")?)?; println!("{}", result.document.export_to_markdown());

curl -F file=@report.pdf 'localhost:5001/v1/convert?to=md'   # the server; OpenAPI at /openapi.yaml

Same options, same outputs on every surface — every option in docs/OPTIONS.md.

Highlights

• From Python docling: from docling_rs import DocumentConverter; result.document is a genuine DoclingDocument (migration notes).
• Every docling format, and a few it lacks — the table under Status, each validated against live docling (Conformance).
• Every output docling has: Markdown (docling's, or a stricter dialect), docling JSON, HTML, plain text, DocLang, LaTeX, Pandoc AST (→ DOCX, EPUB, Typst… through pandoc), WebVTT subtitles, RAG chunks and page images (output formats).
• From any language: Rust, Python, Node.js / Bun, the browser (wasm, fully client-side), C, C++, C#, Go, Java and Swift through one C header, any HTTP client, the shell (Integration).
• A drop-in server for docling-serve: Open WebUI uses it as its Docling content-extraction engine — point *Docling Server URL* at http:// :5001 — and n8n, Dify and LangChain clients work unchanged (docling-rs serve, Open WebUI setup).
• AI agents (MCP): docling-rs mcp gives Claude Desktop, Claude Code, Cursor or VS Code MarkItDown's convert_to_markdown tool, plus convert for JSON, chunks and the rest — uvx docling-rs-mcp, or claude mcp add docling -- docling-rs mcp (MCP server).
• LangChain: pip install "docling-rs[langchain]" — langchain-docling's DoclingLoader on the Rust engine, one import to swap (details).
• AutoGen: pip install "docling-rs[autogen]" — DoclingIndexer fills any AutoGen memory with chunks that carry their pages, DoclingConvertTool lets an agent read documents (details).
• Microsoft Agent Framework: pip install "docling-rs[agent-framework]" — AutoGen's successor: DoclingIndexer fills any Agent Framework vector store, DoclingContextProvider puts the relevant chunks with their pages into each turn (details).
• Your own formats: register a backend for a format docling.rs does not read — or to read one of its formats your way — from Rust, Python (@docling_rs.register_backend(extensions=["rtf2"]), and MarkItDown's register_converter and plugins) or Node.js, ahead of the built-in formats (pluggable backends).
• RAG: docling-rag — chunk, embed and search with a REST API and a web UI (RAG subsystem).
• Runs where you are: Linux x64 / arm64 / s390x, macOS (Apple Silicon) and Windows prebuilt (CLI, wheels, npm), Intel macs from source, containers for amd64 and arm64; NVIDIA CUDA and TensorRT, DirectML (a prebuilt Windows CLI), CoreML and WebGPU in the browser as opt-in accelerators (GPU, IBM Z).

Developed with Claude Code and _TENET_ (minimalistic AI-driven development framework).

Status

Every format in docling's pipeline converts — plus a few docling lacks. A file with no or an unknown extension, stdin, an upload or a data: URL is typed by its content (InputFormat::detect, docling_rs.detect_format, detectFormat: the packages, the OLE files, PDF, images, audio and video, iWork, XML, JSON, notebooks, messages, …), and a file that fails under its extension is checked by content and converted as what it really is, with a warning.

| XML · docling native | JATS, USP