Docling is a production-grade Python library for converting diverse document formats (PDF, DOCX, PPTX, XLSX, HTML, LaTeX, EPUB, images, audio, video, email, EBCDIC, and more) into a unified, structured `DoclingDocument` representation. It is designed to serve as the document understanding layer for AI workflows, particularly Retrieval-Augmented Generation (RAG), agentic AI, and document extraction pipelines. The system provides a rich Python SDK, a Typer-based CLI (`docling convert`), a service client for remote conversion via `docling-serve`, and an MCP server. It supports multiple output formats including Markdown, JSON, HTML, DocTags, and plain text. Architecturally, Docling employs a modular pipeline system with pluggable backends for each input format and a stage-based processing model. The core pipeline (`StandardPdfPipeline`, `VlmPipeline`, `AsrPipeline`) orchestrates page-level operations (preprocessing, OCR, layout detection, table structure recognition, picture classification, reading order) and document-level enrichments (code/formula extraction, heading hierarchy, picture description). Inference engines are abstracted behind factory patterns supporting ONNX Runtime, HuggingFace Transformers, vLLM, MLX, KServe v2, and remote APIs. The library integrates with over 20 OCR engines and vision-language models, and includes a plugin system for extensibility. Key entry points include the `DocumentConverter` class, the CLI (`docling.cli.main`), and the service client (`docling.service_client`). External dependencies span PDF libraries (pypdfium2, docling-parse), ML frameworks (torch, transformers, onnxruntime), OCR engines (Tesseract, EasyOCR, RapidOCR), and cloud services (KServe, Azure, S3). The codebase is actively maintained with frequent releases, extensive test coverage, and a clear migration path from legacy components.
OfficeCLI is a cross-platform CLI application written in C#/.NET that creates, reads, and mutates OOXML Office documents (Word .docx, Excel .xlsx, PowerPoint .pptx) without requiring Microsoft Office. It is explicitly engineered as an agent-facing tool: every document element is addressable through a uniform path syntax (e.g. /slide[1]/shape[2]), all commands emit structured JSON with error codes and suggestions, and it ships AI-skill files for Claude/Copilot/Cursor/Codex, an MCP server, plus Python and Node SDKs. The core operation model is a batch command language: documents are mutated by replayable JSON items (add/set/remove/get) executed atomically through the CLI or over a named pipe to a resident process. Architecturally the repo is a single .NET binary (embedded runtime) with a CommandBuilder layer, a DocumentHandlerFactory dispatching to three large partial-class handlers (WordHandler, ExcelHandler, PowerPointHandler), and a shared Core layer containing chart-to-SVG rendering, a formula evaluator implementing 350+ Excel functions with statistical distributions, pivot table construction, Mermaid diagram parsing, OOXML theme/table-style resolution, HTML/PNG/SVG preview rendering, and a plugin protocol for foreign-format dump-readers and exporters. Security is taken seriously: SsrfGuard validates remote fetch targets, HyperlinkUriValidator allowlists URI schemes, XmlTextValidator and DocumentLimits guard against decompression bombs and DOM sprawl, and AtomicPackageWriter prevents torn file writes. Quality is strong but carries real maintenance debt. The code demonstrates deep OOXML craftsmanship - schema-order-correct XML insertion, exact EMU unit round-trips, Lanczos-based gamma functions, and curated chart-style galleries. However, handlers are split across dozens of partial-class files that evolved from former god methods, the property API is stringly-typed (props dictionaries parsed per key), examples must be maintained in parallel shell and Python twins, and the tool deliberately tolerates 'UNSUPPORTED props' warnings (exit code 2), which can mask incomplete feature coverage. The best reuse targets are the self-contained Core utilities rather than the format handlers. The project is actively maintained with multi-platform CI publishing to npm and PyPI.
MinerU is a production-grade document parsing engine that converts PDFs, images, and Office documents (DOCX, PPTX, XLSX) into structured Markdown and JSON. It supports multiple backends: a fast pipeline (layout analysis + OCR + formula/table recognition), a high-accuracy hybrid mode combining VLM and OCR, and a pure VLM mode using vLLM/LMDeploy. The system is deployed as a CLI tool, FastAPI service, Gradio web UI, or Docker container, with integrations for RAG frameworks like LangChain, LlamaIndex, and Dify. The codebase is well-architected with clean abstractions for data I/O (file/S3), model initialization (singleton pattern), and output generation (client-side rendering). It handles 109 languages and includes specialized modules for mathematical formula recognition (UniMERNet), table structure recovery (SLANet+/UNet), and office document normalization. While the code is actively maintained and functionally rich, it carries some technical debt from its PaddleOCR heritage (vendored code, eval-based builders) and has a complex optional dependency matrix for hardware accelerators.
This repository contains 'officeParser', a robust Node.js and browser library for parsing 12 office document formats (DOCX, PPTX, XLSX, ODT, ODP, ODS, PDF, RTF, CSV, MD, HTML, EPUB) into a unified abstract syntax tree (AST) and generating high-fidelity output in 9 formats (JSON, text, Markdown, HTML, CSV, RTF, PDF, EPUB, and RAG-focused chunks). It provides a first-class CLI (`npx officeparser`) and a programmatic API (`parseOffice()` → AST → `.to(format, config?)`), with extensive configuration for OCR, chunking strategies, security limits, and format-specific dialects. The architecture follows a strict pipeline: format-specific parsers normalize documents into `OfficeParserAST`, then format-agnostic generators produce the desired output, enabling cross-format conversion and round-trip fidelity. The codebase demonstrates high craftsmanship with reusable utility modules (sanitization, typed error/warning systems, lazy ZIP handling, MathML-to-LaTeX conversion) and a comprehensive test suite covering parser baselines, generator baselines, security injection tests, and exhaustively tested edge cases. It supports browser and Node runtimes via dual CJS/ESM packages and bundled builds, including slim variants that minimize dependencies for browser environments. Key data flows include document metadata extraction, attachment handling (images, charts), OCR via Tesseract.js, PDF generation via Puppeteer, and semantic chunking for LLM ingestion. External dependencies include `pdfjs-dist`, `tesseract.js`, `fflate`, `chart.js`, and `puppeteer` (optional). While the repository is actively maintained with recent commits and CI across multiple Node versions, it shows some technical drift: deprecated API fields remain documented alongside replacements, and large files (e.g., OpenOfficeParser.ts at ~1600 lines) increase maintenance complexity. The builder has addressed past packaging issues (webpack context-module) and maintains sophisticated browser shims. Overall, it is a production-grade document conversion toolkit with exceptional reusability in its core utilities and a clean separation between parsing and generation.
unioffice is a commercial Go library for creating, reading, and editing Office Open XML (OOXML) documents: Word (.docx), Excel (.xlsx), and PowerPoint (.pptx). It provides a high-level API for common document operations such as text formatting, tables, images, headers/footers, charts, and slide management, while also exposing low-level access to the underlying XML via an `X()` method on wrapper types. The library includes experimental Word-to-PDF conversion and spreadsheet formula evaluation. Its architecture is modular, with top-level packages for each document type (`document`, `spreadsheet`, `presentation`), internal packages for schema types, license management, temporary storage, and utilities, and a large set of generated schema packages under `schema/` that mirror the OOXML specification. The codebase is heavily generated from OOXML schemas and obfuscated using the `unitwist` tool, which hinders direct debugging but ensures fidelity to the standard. External dependencies include other UniDoc modules (`unipdf`, `unichart`, `unitype`, `emf`) and third-party libraries for testing, font rendering, and image processing. The library requires a commercial license key, with a free tier available via cloud.unidoc.io. It is actively maintained, with recent commits and a responsive issue tracker.