PaddleOCR is a production-grade OCR and document parsing toolkit built on PaddlePaddle. It provides a comprehensive suite of models for text detection, text recognition, layout analysis, table extraction, formula recognition, key information extraction (KIE), and document conversion (PDF/Image to Markdown/JSON). The system is deployed as a Python CLI, a Python library, a C++ inference engine, mobile SDKs (Android, iOS), a JavaScript browser SDK, a Go SDK, a TypeScript SDK, and a Model Context Protocol (MCP) server for AI agent integration. It also includes a cloud API client for remote inference. The architecture is modular: models are configurable via YAML, pipelines orchestrate multi-stage workflows, and deployment targets range from edge devices to cloud servers. The codebase is actively maintained with extensive testing, CI/CD, and support for multiple hardware accelerators (GPU, NPU, XPU, etc.). While primarily an application toolkit, it also contains research-grade training infrastructure, custom loss functions, and data augmentation modules, making it a hybrid project with a strong application focus.
RAGFlow is a production-grade, open-source Retrieval-Augmented Generation (RAG) engine that combines deep document understanding with agentic workflows. The system ingests heterogeneous documents (PDF, DOCX, images, web pages, etc.), parses them using a multi-stage pipeline (layout analysis, OCR, table recognition), chunks the content with various strategies (token, QA, page, etc.), indexes into vector stores (Elasticsearch, Infinity, OceanBase, SereneDB), and provides retrieval-augmented chat with LLM integration. Beyond basic RAG, it features a visual agent canvas for building complex workflows (parallel subgraphs, loops, tool calls), a sandboxed code execution environment, knowledge compilation (wiki, knowledge graphs, timelines), multi-tenant model management, and chat channel integrations (WhatsApp, Feishu, Discord). The architecture is a full-stack application with a Go backend (Gin), Python API (Flask/Quart), React/TypeScript frontend, and NATS message queue for async tasks. It is designed for enterprise deployment with Docker Compose and supports multiple LLM providers and embedding models.
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.
OpenDataLoader-PDF is a production-grade, multi-language PDF-to-structured-content extraction tool designed for AI/LLM pipelines, RAG systems, and accessibility workflows. It converts PDFs into JSON, Markdown, HTML, plain text, and tagged PDF (PDF/UA) with high accuracy (0.907 overall benchmark). The core engine is written in Java (veraPDF-based) and provides a rich CLI, while Python and Node.js SDKs bundle the Java JAR and expose idiomatic APIs. A hybrid mode routes pages to an external AI backend (Docling) for OCR, formula extraction, and picture descriptions, with a triage processor deciding per-page routing based on content signals. The project also includes an MCP server for AI agent integration, a LangChain loader, and an agent skill bundle for correct usage.
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.
Textract is a text extraction library and command-line tool that extracts text from over 30 file formats including PDF, DOC, DOCX, images, audio, email, and structured data formats. The architecture centers around a parser registry that routes files to format-specific parsers based on extension, with a unified Source abstraction handling file paths, bytes, and streams as input. Key entry points are the Python API (textract.process()) and CLI interface (textract.bin.textract). The system relies on external tools like Poppler, Tesseract, and LibreOffice for certain formats while using pure Python parsers for others. The codebase demonstrates strong engineering practices with a clean plugin architecture, comprehensive test suite, and modern tooling (uv, ruff, pytest).
Dolphin is a document image parsing tool that uses a two-stage analyze-then-parse approach with a VLM (Qwen2.5-VL). It takes images or PDFs, performs layout analysis to detect elements (text, tables, formulas, code, figures) with reading order, then parses each element in parallel batches. Outputs structured JSON and Markdown with visualized layout. The codebase is well-structured, offering CLI entry points for page-level, element-level, and layout-only parsing. It demonstrates good engineering practices with batching, coordinate mapping, and post-processing for formula/special characters. The core implementation wraps the Hugging Face Qwen2.5-VL model and includes utility modules for layout string parsing, PDF conversion, and markdown generation. The architecture is a CLI application with minimal coupling, making the utility modules potentially reusable across document parsing projects.
pymupdf4llm is a library and CLI tool that converts PDFs (and other documents) into clean Markdown, JSON, plain text, or layout-aware chunks specifically optimized for LLM and RAG workflows. It provides a high-level API (`to_markdown`, `to_json`, `to_text`, `to_chunks`) that internally uses either a legacy heuristic approach or an optional GNN-based layout parser (via `pymupdf-layout`) to extract text, tables, images, and reading order. The repository also includes a deterministic chunking pipeline that uses only PDF-native layout signals (box boundaries, font jumps, vertical gaps) to produce context-preserving chunks without embeddings. OCR support is built-in, with a hybrid decision model (ONNX-based) that selectively applies Tesseract, RapidOCR, or PaddleOCR to pages that need it. Framework integrations for LlamaIndex and LangChain are provided. The architecture is primarily a monolithic library with two parallel conversion paths (legacy and layout-based), a chunking subpackage, an OCR subsystem with abstract backends, and a batch converter for large-scale processing. While the code is generally well-structured, the presence of two parallel conversion paths and tight coupling to PyMuPDF internals introduce some maintenance risk.
KnowFlow (forked from RAGFlow) is a full-stack enterprise Retrieval-Augmented Generation (RAG) platform. It ingests documents (PDF, DOCX, Excel, images, etc.) via multiple parsing engines (DeepDOC, MinerU, PaddleOCR, DOTS), chunks them using configurable strategies (naive, smart, title, regex, parent-child, etc.), embeds them via LLM providers, and stores vectors in Elasticsearch/OpenSearch/Infinity. The platform provides a visual agent builder (React Flow canvas) where users compose workflows from nodes (retrieval, generate, categorize, iterate, code execution, etc.) and tools (web search, email, SQL, financial data, etc.). It also offers chat interfaces with SSE streaming, knowledge base management with RBAC, team sharing, and a Python SDK. The architecture is a Flask backend with separate task executors and a sandboxed code execution service, deployed via Docker Compose with MinIO, MySQL, Redis, and optional OCR microservices. The frontend is primarily React (with a legacy Vue codebase), using Ant Design and shadcn/ui components.
ScienceBeam Parser is a scientific document parsing library and service that converts PDF/DOCX documents into structured formats (TEI/JATS XML) using machine learning models. It provides a FastAPI-based web service with GROBID-compatible endpoints, a CLI for training data generation, and a modular pipeline of models for segmentation, header, citation, reference extraction, etc. The system includes benchmarking tools for performance evaluation against GROBID baselines and training utilities for model improvement. While it contains research-oriented components (benchmarking, training), its primary character is as a deployable application/library for document processing.
LibreraReader is a full-featured, multi-format e-book reader for Android (with an experimental iOS/desktop port via Kotlin Multiplatform). It supports PDF, EPUB, MOBI, DjVu, FB2, CBR/CBZ, DOC/DOCX, ODT, RTF, and many other formats through a combination of native C/C++ libraries (MuPDF, DjVuLibre, libmobi, libantiword, libwebp, liblame) and Java-based document translators (ODF/SVM/WMF to HTML/SVG). The app provides a rich reading experience with customizable themes, text-to-speech, OPDS catalog browsing, cloud sync (Google Drive, Dropbox), annotations, bookmarks, and a smart reflow feature for scanned documents. The codebase is large and monolithic, with significant third-party code vendored into the source tree. Development has been frozen (as noted in the README), so the project is in a maintenance-only state. Despite its age and complexity, it contains several well-crafted, reusable utility libraries (e.g., LWXML streaming XML framework, SVM-to-SVG translator, and general-purpose Android utilities) that could be extracted for other projects.