# Changelog This document records the release history of MinerU, including major capability changes, compatibility updates, and notable fixes. ## 4.2.3 - **Add per-file execution timeouts and managed recovery**. WebUI, Router, and API Server support `--task-timeout`, defaulting to `3600` seconds from acquiring an execution slot through parsing and server-side artifact packaging. Timed-out tasks return `task_timeout`. A standalone API stops accepting new work and relies on its deployment host to recreate the service. Router supervises local workers from the parent process, reclaims timed-out workers and model subprocesses, and restarts the service even when execution threads, the event loop, or cancellation cleanup stall. - **Improve WebUI recovery and process cleanup**. Local WebUI uses Router to manage a single worker, displays recovery status, and resumes queued requests awaiting submission once the service is ready. Other unfinished requests on the replaced worker return `worker_restarted`, and affected files can be retried manually. Improve Windows process-tree, temporary-directory, and control-channel cleanup, surface model preload failures, and stop automatic recovery after three consecutive startup failures. - **Keep image payloads out of Doclib full-text indexes**. Build search text from body content, formulas, and figure or table descriptions before applying the character budget, preventing embedded image base64 data from crowding out searchable text. Rebuild existing indexes from cached parse results during upgrade while preserving cross-page continuations. Documents with incomplete caches record a migration reason and can resume migration after restoring or reparsing the cache and restarting Doclib. - **Check vLLM and Transformers compatibility before startup**. Detect the incompatible combination of `vllm<0.29.0` and `transformers>=5.23.0` before engine initialization, with actionable guidance to upgrade vLLM or select a compatible Transformers range. - **Update DocVortex**. Raise the minimum version to `0.6.24` for native document parsing and shared rendering improvements. **Configuration note**. Router now defaults `--worker-tier` to `auto`, allowing each worker to select its tier ceiling from its device environment. Specify `flash`, `basic`, `standard`, or `advanced` for a fixed ceiling. `--task-timeout` requires a positive integer. Uploads, queueing, client downloads, and model startup preloading use their own waiting and lifecycle settings. ## 4.2.2 - **Improve local VLM failure propagation and lifecycle management**. Consume shared health and failure contracts for LMDeploy, vLLM, llama.cpp, and MLX. Confirmed engine failure invalidates cached instances and notifies their hosts, preventing a global outage from silently becoming a local recognition fallback. Ordinary per-crop failures retain the existing fallback behavior. - **Strengthen parse-server health checks and task cleanup**. Periodically probe initialized runtimes that support health checks. Temporary unavailability rejects new inference until health recovers. Confirmed engine death produces explicit health and capability errors and cleans up running and queued tasks through the existing lifecycle boundaries; recovery remains the host's responsibility. Improve the ordering of active probes, cancellation, and resource release during shutdown. - **Correct batch input validation and error handling**. Validate file content signatures and containers so Office lock files do not stop subsequent documents, while valid documents beginning with `~$` remain supported. Report known corrupt, encrypted, resource-limited, missing, or inaccessible inputs as individual failures and continue. Engine, service, and output failures stop the batch. Summaries distinguish succeeded, skipped, failed, and unprocessed inputs; partial failure returns a nonzero exit code. - **Correct batch output-path handling**. Directory and multiple-file inputs always produce directory output, even when only one document remains. Accept existing and new dotted directory names such as `results.v1` and `results.md`, and reject existing regular files as batch destinations. Explicit single-file output continues to support overwriting its destination. - **Clarify reading and exporting**. Markdown from `mineru read` remains a progressive stdout or JSON read with continuation hints; `--output PATH` is reserved for images. Save the current text fragment through redirection or the SDK, and use `mineru parse ... -o ...` to export a complete page range without the reading budget. - **Improve service startup and shutdown**. Print directly accessible API documentation URLs after successful binding, avoid interrupt tracebacks on normal Ctrl+C shutdown, and remove unimplemented webhook capability declarations and documentation. - **Update runtime dependencies**. Require `mineru-llama-cpp 0.2.1` and `mineru-vl-utils 2.0.9` or newer compatible versions for the shared lifecycle contracts. **Compatibility note**. Replace `mineru read -o part.md` with stdout redirection or SDK saving. For complete exports, use `mineru parse --pages -o result.md`. Batch callers should interpret the result summary and exit code to distinguish full success, partial failure, and an aborted batch. ## 4.2.1 - **Complete Doclib continuation after truncation**. Markdown document and single-page reads with `context=0` use both `next_request.locator` and `next_request.after` to resume the unfinished page after reaching the output limit, then suggest the next page. CLI continuation markers and SDK documentation follow the same contract. - **Bound managed parse-server recovery**. Stop automatic retries after repeated startup or restart failures and clean up remaining processes. Setting the managed mode or tier again, or restarting the document library server, allows recovery to resume. Improve process and control-channel cleanup during mode changes, tier changes, and shutdown. - **Correct Windows managed-port probing**. Match the server's actual binding behavior and skip occupied or system-reserved ports when strict-port mode is disabled, reducing startup failures after a successful port probe. - **Graceful document library shutdown**. Use a host shutdown callback to run lifecycle cleanup, including background tasks, managed parsing processes, and database resources on Windows. - **Restore Windows GPU memory information**. Improve PCI-address matching between DXGI and the hardware inventory, and retain consistent memory and device properties when same-model entries have ambiguous identities. - **Preserve native PDF body text**. Accept normal text directions close to 360° due to floating-point error, preventing horizontal text from being filtered during native text restoration. **Integration note**. Embedded Doclib hosts must provide a `shutdown` callback to support the shutdown endpoint. A missing callback returns `service_unavailable`. The standard `mineru server` entry point already provides the callback. ## 4.2.0 MinerU 4.2.0 upgrades WebUI interaction and source tracing, improves parsing of complex PDFs, formulas, and tables, and strengthens device selection, model caching, service management, and input security. These are cumulative changes since 4.1.0, including improvements released in 4.1.x. ### WebUI interaction and source tracing - **Bidirectional source navigation:** Click a region in a PDF or image to locate and highlight its parsed content, or click a parsed paragraph, heading, formula, or figure to return to its source. Content merged across pages supports switching source pages. - **Improved layout visualization:** Merged paragraphs, lists, and tables can reference multiple source regions, with connecting lines to help inspect reading order, content ownership, and cross-page merges. - **Result outline navigation:** A collapsible heading outline provides quick access to document sections. - **Redesigned uploads and controls:** File selection, drag and drop, paste, file types, upload progress, and cancellation share one upload area. Compact tier and page-range controls improve selection and dragging, while showing the parsing service's CPU/GPU state. - **Faster PDF previews and exports:** Preview local PDFs directly in the browser while uploading, preserve the mounted viewer and zoom after parsing, and overlay layout annotations. Reuse prepared inputs, semantic results, and assets to avoid repeated PDF and preview generation. ### PDF, formula, and table parsing - **Improved inline formulas:** Standard/Advanced use VLM recognition for inline formula regions outside tables in the native PDF text path, retaining local formula recognition when the result is empty or invalid. - **Footnote formulas and page-edge regions:** Preserve formula identity and reduce incorrect ownership between formulas, numbers, and body text. - **Nested and overlapping regions:** Reduce duplicate text and excessive merging, correct annotations inside figures, and improve the reading order of merged images. - **Consistent layout detection:** Restore per-class output thresholds in both ONNX and Torch. - **Native text recovery:** Improve character recovery with empty ToUnicode maps and remove residual Unicode private-use characters after post-OCR processing and fallback restoration. - **Sheared body text:** Preserve normal body text when every character in a line has a shear transformation. - **Rotated tables:** Account for page rotation when interpreting native text orientation. - **Atomic table content:** Keep images and formulas intact during table reconstruction rather than splitting them across cells. - **Cross-page tables:** Preserve text boundaries between joined cells and improve blank continuations, sparse blank rows, and shared row spans. ### Native document parsing - **Tagged PDF semantics:** Flash native PDF text parsing can use Tagged PDF/PDF/UA structure and reading order, with geometric rules handling uncovered or untrusted content. - **Paragraph continuation:** Use indentation, sentence endings, and other page evidence to improve uppercase-leading continuations and paragraph merging across pages and columns. - **Native tables:** Correct row segmentation affected by unusual glyph bounds and row-span ownership in some numeric tables. - **Font weight:** Improve embedded-font weight interpretation to reduce normal body text incorrectly marked as bold. - **Office images:** Use placeholders for some images exceeding processing limits so that one image does not fail the whole document. ### Device selection, tier recommendations, and diagnostics - **Shared process device selection:** Model loading, automatic tier recommendations, and llama.cpp automatic mode reuse the selected runtime device, reducing duplicate probes and differences between entry points. - **Multiple GPUs:** Match Windows GPU and memory information by physical PCI address. - **Automatic tiers:** Recommend tiers from the actual small-model device. GPUs can enable all tiers; CPUs enable Basic from 4 available logical cores and Standard from 12. - **ONNX discrete-GPU selection:** Windows/Linux automatic mode checks total dedicated memory. Direct GPU selection requires a capacity that rounds to at least 6 GiB; insufficient or unconfirmed capacity uses the CPU. - **Runtime state:** Service health can report initialized CPU/GPU state without triggering device selection. - **Faster diagnostics and CLI startup:** Run isolated runtime probes concurrently, stream reports by section, standardize capacity and device summaries, and retain full diagnostics and candidate reasons in JSON. Help and version commands load their entry points on demand. - **Cleaner shutdown:** Improve VLM shutdown and resource release. ### Router and APIs - **Dynamic upstream management:** Query, register, and remove remote parsing nodes without restarting the Router. - **Graceful removal:** Stop assigning new work, then wait for existing tasks, transfers, and result references to finish. - **Router cascading:** Connect a downstream Router as an upstream using the existing V1 protocol and result leases. - **Separate administration credentials:** Authenticate dynamic node management independently from parsing requests. - **Paths and filenames:** Correct CLI detection of relative and hidden-file paths, and consistently reject path-like filenames and control characters in Tasks, Router, and synchronous uploads. ### Model downloads and cache validation - **File manifests:** Record expected files and sizes for repository, directory, and single-file resources; detect missing or truncated files, broken links, and invalid manifests before reuse. - **Offline reuse and incremental repair:** Validate normal caches without network access or hashing large weights. Repair missing or incorrectly sized files while reusing valid files. - **Legacy completion markers:** Continue offline reuse after required-file and shard checks. When online, verify remote metadata for the recorded revision and upgrade manifests without updating model weights. ### Local authentication and input security - **Persistent Doclib bearer tokens:** SDK default local discovery reads credentials automatically; direct HTTP calls require a valid token. - **Credential protection:** Set and verify POSIX private permissions and macOS/Windows ACLs. - **URL SSRF protection:** Validate all resolved addresses and connect to a validated public IP, rejecting private, loopback, link-local, cloud metadata, and other special addresses. - **Direct URL downloads:** Do not follow redirects or use HTTP/HTTPS/ALL proxy environment settings. - **Document resource limits:** Stop decompression or structural expansion beyond configured budgets, including OOXML archives and XLSX merged ranges. Return a clear `resource_limit` error and preserve per-file Tasks failures. ### Upgrade notes - Direct Doclib HTTP clients must provide a bearer token. Default SDK discovery reads it automatically; explicit service addresses or socket paths require an explicit token. - Deployments using private URLs, redirects, or environment proxies for input downloads must adjust their input workflow. Upload private documents through the client. - Restart the relevant process after changing device configuration. Runtime device selection stays stable within a process; the new ONNX memory threshold applies only to automatic mode. - Minimum dependencies are **DocVortex 0.6.21** and **ModelScope 1.39.1**. ## 4.1.7 - **Local document library authentication:** Doclib requires a persistent bearer token. The SDK reads local credentials automatically, while direct HTTP integrations must send the token. Credential files use private POSIX permissions or native macOS/Windows ACL protection. - **Layout detection:** Restore per-class output thresholds consistently across ONNX and Torch, and position absorbed image regions according to their geometry in the reading order. - **Native document parsing:** Require DocVortex 0.6.13. ## 4.1.2 - **Hardware diagnostics and output:** `mineru-kit hardware info` runs isolated runtime probes concurrently and flushes text sections in a fixed order as they become available. Capacity formatting and device summaries are clearer, while JSON retains full diagnostics and adds the read-only ONNX device candidate and selection reason. - **On-demand CLI help:** Root help, hardware help, and version queries no longer initialize the runtime or read user configuration. Command entry points load only when executed. - **Issue reporting:** Separate English and Chinese forms require less information, default the parsing tier to “Unknown,” and automatically offer the five most recent stable versions after each release. - **CI and release workflows:** Issue-form changes use lightweight checks, while release reruns retain the full test suite and are protected from cancellation by later branch pushes. ## 4.1.1 - **Windows GPU identification:** Match GPUs and memory information by physical PCI address, improving identification on systems with multiple GPUs or identical models. - **llama.cpp runtime policy:** Automatic mode on Linux and Windows reuses the small-model backend's CPU/GPU selection and lets llama.cpp choose the specific GPU. On these platforms, GPU models default to 4 generation threads while preserving explicit user settings. - **Automatic tier recommendations:** Use the device actually selected by the small-model backend without requiring a GPU memory threshold. GPU execution can enable all tiers; CPU execution enables Basic with at least 4 available cores and Standard with at least 12. Default requests still prefer Standard → Basic → Flash → Advanced; Advanced is selected automatically only when it is the sole available tier. - **PDF text cleanup:** Replace residual Unicode private-use characters with spaces after post-OCR processing and fallback restoration in native body text, covering both basic and supplementary private-use areas. ## 4.1.0 - **Automatic acceleration across major platforms and GPUs:** The default installation supports CPU inference on Windows, Linux, and macOS, plus accelerated inference on compatible Intel, AMD, NVIDIA, and Apple Silicon GPUs, including integrated graphics. MinerU automatically selects suitable GPU or CPU execution; representative core inference workloads run at approximately **2–3× CPU speed**. - **A unified asynchronous Tasks API:** `/v1/tasks` replaces the previous `/v1/uploads` and `/v1/parse/jobs` workflow, supporting file manifests, URL inputs, cached-upload reuse, per-file execution and downloads, status queries, and cancellation. See the [Tasks API reference](../usage/tasks.md). - **Recoverable synchronous file parsing:** The standalone `file-parse-server` provides `/v1/file_parse` for single-file uploads and attachment responses, with queries after wait timeouts and request IDs for recovering known tasks. See the [file-parse API reference](../usage/file_parse.md). - **Hardware diagnostics and tier recommendations:** New `mineru-kit hardware detect` and `hardware info` commands help select a suitable service tier and inspect devices, runtime versions, and calibration information. **Upgrade note:** Supported Python versions are now **3.11–3.14**. This release includes breaking HTTP API changes; upgrade servers, Routers, SDKs, and clients together. See the [4.1 migration guide](migration_4_1.md). ## 4.0 MinerU 4.0 brings document parsing, a local document library, and service tools into one workflow for document conversion, application integration, and agent reading. - **Four parsing tiers**: Flash for fast previews and indexing, Basic for OCR and model-based parsing, and Standard / Advanced for more demanding layouts and quality requirements. - **Multiple input formats**: PDF, images, DOC/DOCX, PPT/PPTX, XLS/XLSX, RTF, ODT/ODS/ODP, EPUB, OFD, HTML/MHTML, and CSV/TSV. [DocVortex](https://github.com/myhloli/docvortex) provides native document parsing. - **Document library and agent reading**: discover files, cache results, search content, continue by page or block, and preserve stable citation locators. - **Independent model configuration**: ONNX or Torch for small models; llama.cpp, vLLM, or LMDeploy for the VLM. - **Unified tools**: Python SDK, V1 API, stateless batch conversion, multi-service Router, and a Gradio-based WebUI. - **Structured results and rendering**: one document model supports nine rendering targets: Markdown, HTML, LaTeX, DOCX, EPUB, PDF, Structured Content, and Content List V1/V2. Each CLI/API exposes its own subset of exports; see [Output Formats and Result Contract](output_files.md). PDF and images support all four tiers. Office, OpenDocument, EPUB, OFD, HTML/MHTML, and CSV/TSV use local Flash native parsing. Plain text is read directly rather than parsed. Documents are not automatically uploaded to the official service; remote parsing requires explicit configuration. See the [4.0 migration guide](migration_4.md) for API and deployment changes. ## 3.x release history - 2026/06/18 3.4 Released This release focuses on **OCR capability upgrades for the pipeline backend**, **OCR processing pipeline optimization**, and **model download experience improvements**. The main updates include: - OCR model upgrade and processing acceleration - The OCR model for the `pipeline` backend has been upgraded to `PP-OCRv6`, improving OCR accuracy by about `11%` on OmniDocBench v1.6. - Removed Japanese, Traditional Chinese, English, and Latin options from OCR language selection. These scenarios are now routed to the `ch` OCR model, simplifying model configuration and language selection. - Optimized the OCR inference and processing pipeline, increasing OCR processing speed by about `100%` and significantly improving parsing efficiency for batch documents and OCR-intensive documents. - Model download logic optimization - Added automatic model source selection, allowing first-time installations to choose a better model source based on the current network environment. - Before downloading models, MinerU now prioritizes checking locally downloaded model cache files. Cache hits can be reused directly, reducing repeated downloads and unnecessary remote requests. - For more details about model source configuration, automatic source selection, and local model usage, see the [Model Source Documentation](https://opendatalab.github.io/MinerU/usage/model_source/). With the 3.4 release, MinerU further improves the parsing accuracy and processing efficiency of the `pipeline` backend in OCR scenarios. It also optimizes model downloads, cache reuse, and local configuration write-back, making first-time installation, model updates, and multi-environment deployment more stable and automated. - 2026/06/11 3.3 Released This release focuses on **Hybrid parsing performance optimization** and **VLM model capability upgrades**. The main updates include: - New `effort` parsing-strength parameter for the Hybrid backend - Added two parsing-strength levels, `medium` and `high`, allowing users to balance parsing speed, parsing accuracy, and feature requirements. - On OmniDocBench v1.6, `medium` reduces overall accuracy by only `0.13` points compared with `high`, while delivering `35%` ~ `220%` parsing speed improvements across different devices and scenarios. - The default Hybrid backend now uses `effort=medium`, significantly improving overall parsing efficiency while maintaining high parsing accuracy. - The `medium` level does not support `image analysis`; for maximum parsing accuracy or `image analysis` support, switch to `effort=high`. - VLM model upgraded to `MinerU2.5-Pro-2605-1.2B` - Fixed multiple model issues found in the `2604` version, further improving parsing stability on complex documents. - Added native multilingual OCR support, reducing the need for extra language-parameter configuration. - 2026/04/18 3.1.0 Released This release focuses on **licensing openness, parsing accuracy, and full-format native support**. The main updates include: - License upgrade - MinerU has officially moved from `AGPLv3` to the [MinerU Open Source License](https://github.com/opendatalab/MinerU/blob/master/LICENSE.md), a custom license based on `Apache 2.0`. - This change significantly reduces adoption friction for both community users and commercial deployments, making MinerU easier to integrate into real-world workflows. - VLM main model upgrade - The primary VLM model has been upgraded to `MinerU2.5-Pro-2604-1.2B`, bringing overall parsing accuracy to a state-of-the-art level. - The new model now supports image and chart parsing, truncated paragraph merging, cross-page table merging, and image recognition inside tables, further strengthening performance on complex document layouts. - Full-format native parsing support - Native parsing support has now been extended to `PPTX` and `XLSX`. - MinerU now fully supports parsing across images, `PDF`, `DOCX`, `PPTX`, and `XLSX`, providing a more complete multi-format document understanding workflow. With the 3.1.0 release, MinerU becomes more open, more accurate, and easier to adopt in production. The new license lowers the barrier for both community and commercial use, `MinerU2.5-Pro-2604-1.2B` improves parsing quality on complex content, and native `PPTX` / `XLSX` support completes end-to-end coverage of mainstream document formats. - 2026/03/29 3.0.0 Released This release delivers a systematic upgrade centered on **parsing capability, system architecture, and engineering usability**. The main updates include: - Native `DOCX` parsing - Official support for native `DOCX` parsing, delivering high-precision results without hallucinations. - Compared with the traditional workflow of first converting `DOCX` to `PDF` and then parsing it, end-to-end speed is improved by tens of times, making it better suited for scenarios with high requirements for both accuracy and throughput. - `pipeline` backend upgrade - The `pipeline` backend achieves a score of `86.2` on OmniDocBench (v1.5), surpassing the accuracy of the previous-generation mainstream VLM `MinerU2.0-2505-0.9B`. - Added support for parsing images/formulas inside tables, seal text recognition, vertical text support, and interline formula numbering recognition, continuously improving parsing quality for complex document scenarios. - While maintaining high accuracy, it keeps resource usage extremely low and continues to support inference in pure CPU environments. - `API / CLI / Router` orchestration upgrade - `mineru` now runs as an orchestration client based on `mineru-api`; when `--api-url` is not provided, it will automatically start a local temporary service. - `mineru-api` adds a new asynchronous task endpoint `POST /tasks`, supporting task submission, status querying, and result retrieval; meanwhile, it retains the synchronous parsing endpoint `POST /file_parse` for compatibility with legacy plugins. - Added `mineru-router`, designed for unified entry deployment and task routing across multiple services and multiple GPUs; its interfaces are fully compatible with `mineru-api` and support automatic task load balancing. - Deployment and usability improvements - Resolved compatibility issues with `torch >= 2.8`; the base image has been upgraded to `vllm0.11.2 + torch2.9.0`, unifying installation paths across different Compute Capabilities. - Optimized the parsing pipeline with a sliding-window mechanism, significantly reducing peak memory usage in long-document scenarios, so documents with tens of thousands of pages no longer need to be split manually. - Batch inference in `pipeline` now supports streaming writes to disk, allowing completed parsing results to be written out in time and further improving the experience for long-running tasks. - Completed thread-safety optimization and now fully supports multi-threaded concurrent inference; together with `mineru-router`, this enables one-click multi-GPU deployment and makes it easy to build high-concurrency, high-throughput parsing systems. - Completely removed the use of two AGPLv3 models (`doclayoutyolo` and `mfd_yolov8`) and one CC-BY-NC-SA 4.0 model (`layoutreader`). This update is not just a set of feature enhancements, but a key leap forward in MinerU's overall system capabilities. We specifically addressed the peak memory usage issue in long-document parsing. Through optimizations such as sliding windows and streaming writes to disk, ultra-long document parsing has moved from “requiring manual splitting and careful handling” to being “stable, scalable, and ready for production workloads.” At the same time, we completed thread-safety optimization and fully enabled multi-threaded concurrent inference, further improving single-machine resource utilization and runtime stability under high-concurrency workloads. On top of this, with `mineru-router` and the new `API / CLI` orchestration framework, MinerU now supports one-click multi-GPU deployment, unified access across multiple services, and automatic task load balancing, significantly reducing the difficulty of large-scale deployment. As a result, MinerU is evolving from a standalone data production tool into a large-scale document parsing foundation for high-concurrency and high-throughput scenarios, providing enterprise-grade document data processing with infrastructure that is more stable, more efficient, and easier to scale. ## 2.7 Series Versions ### 2.7.6 (2026/02/06) - Added support for the Kunlunxin and Tecorigin domestic computing platforms. - Officially or vendor-adapted domestic platforms now include Ascend, T-Head, METAX, Hygon, Enflame, Moore Threads, IluvatarCorex, Cambricon, Kunlunxin, Tecorigin, and Biren. - MinerU continues to support domestic hardware platforms and mainstream chip architectures for document digitization workloads. ### 2.7.4 (2026/01/30) - Added support for the IluvatarCorex and Cambricon domestic computing platforms. ### 2.7.2 (2026/01/23) - Added support for the Hygon, Enflame, and Moore Threads domestic computing platforms. - Improved cross-page table merging success rate and merge quality. ### 2.7.1 (2026/01/06) - Bug fix: #4300 - Updated the `pdfminer.six` dependency to resolve [CVE-2025-64512](https://github.com/advisories/GHSA-wf5f-4jwr-ppcp) - Added automatic EXIF orientation correction for input images to improve OCR accuracy. #4283 ### 2.7.0 (2025/12/30) - Simplified installation. `uv pip install mineru[all]` now installs dependencies for all optional backends without requiring separate VLM engine installation. - Added the new `hybrid` backend, which combines the strengths of `pipeline` and `vlm`: - Direct text extraction from text PDFs with native multilingual support and much lower hallucination risk; - OCR in 109 languages for scanned PDFs when the OCR language is specified; - An independent inline-formula toggle for improved rendering when inline formulas are not needed. - Simplified engine selection for `vlm/hybrid` backends. Users only need to choose `*-auto-engine` and MinerU selects an appropriate local inference engine automatically. - Switched the default backend from `pipeline` to `hybrid-auto-engine` for better out-of-the-box consistency. - Added i18n support to the Gradio application, enabling Chinese/English switching. --- ## 2.6 Series Versions ### 2.6.7 (2025/12/12) - Bug fix: #4168 ### 2.6.6 (2025/12/02) **`mineru-api` tool optimizations** - Added descriptive text to `mineru-api` interface parameters to improve API documentation readability. - You can use the environment variable `MINERU_API_ENABLE_FASTAPI_DOCS` to control whether the auto-generated interface documentation page is enabled (enabled by default). - Added concurrency configuration options for the `vlm-vllm-async-engine`, `vlm-lmdeploy-engine`, and `vlm-http-client` backends. Users can use the environment variable `MINERU_API_MAX_CONCURRENT_REQUESTS` to set the maximum number of concurrent API requests (unlimited by default). ### 2.6.5 (2025/11/26) - Added support for a new backend vlm-lmdeploy-engine. Its usage is similar to vlm-vllm-(async)engine, but it uses lmdeploy as the inference engine and additionally supports native inference acceleration on Windows platforms compared to vllm. ### 2.6.4 (2025/11/04) - Added timeout configuration for PDF image rendering, default is 300 seconds, can be configured via environment variable `MINERU_PDF_RENDER_TIMEOUT` to prevent long blocking of the rendering process caused by some abnormal PDF files. - Added CPU thread count configuration options for ONNX models, default is the system CPU core count, can be configured via environment variables `MINERU_INTRA_OP_NUM_THREADS` and `MINERU_INTER_OP_NUM_THREADS` to reduce CPU resource contention conflicts in high concurrency scenarios. ### 2.6.3 (2025/10/31) - Added support for a new backend `vlm-mlx-engine`, enabling MLX-accelerated inference for the MinerU2.5 model on Apple Silicon devices. Compared to the `vlm-transformers` backend, `vlm-mlx-engine` delivers a 100%–200% speed improvement. - Bug fixes: #3849, #3859 ### 2.6.2 (2025/10/24) **`pipeline` backend optimizations** - `OCR` speed significantly improved by 200%~300%, thanks to the optimization solution provided by [@cjsdurj](https://github.com/cjsdurj) - `OCR` models optimized for improved accuracy and coverage of Latin script recognition, and updated Cyrillic, Arabic, Devanagari, Telugu (te), and Tamil (ta) language systems to `ppocr-v5` version, with accuracy improved by over 40% compared to previous models **`vlm` backend optimizations** - `table_caption` and `table_footnote` matching logic optimized to improve the accuracy of table caption and footnote matching and reading order rationality in scenarios with multiple consecutive tables on a page - Optimized CPU resource usage during high concurrency when using `vllm` backend, reducing server pressure - Adapted to `vllm` version 0.11.0 **General optimizations** - Cross-page table merging effect optimized, added support for cross-page continuation table merging, improving table merging effectiveness in multi-column merge scenarios - Added environment variable configuration option `MINERU_TABLE_MERGE_ENABLE` for table merging feature. Table merging is enabled by default and can be disabled by setting this variable to `0` --- ## 2.5 Series Versions ### 2.5.4 (2025/09/26) - 🎉🎉 The MinerU2.5 [Technical Report](https://arxiv.org/abs/2509.22186) is now available! We welcome you to read it for a comprehensive overview of its model architecture, training strategy, data engineering and evaluation results. - Fixed an issue where some `PDF` files were mistakenly identified as `AI` files, causing parsing failures ### 2.5.3 (2025/09/20) - Dependency version range adjustment to enable Turing and earlier architecture GPUs to use vLLM acceleration for MinerU2.5 model inference. - `pipeline` backend compatibility fixes for torch 2.8.0. - Reduced default concurrency for vLLM async backend to lower server pressure and avoid connection closure issues caused by high load. - More compatibility-related details can be found in the [announcement](https://github.com/opendatalab/MinerU/discussions/3548) ### 2.5.2 (2025/09/19) We are officially releasing MinerU2.5, currently the most powerful multimodal large model for document parsing. With only 1.2B parameters, MinerU2.5's accuracy on the OmniDocBench benchmark comprehensively surpasses top-tier multimodal models like Gemini 2.5 Pro, GPT-4o, and Qwen2.5-VL-72B. It also significantly outperforms leading specialized models such as dots.ocr, MonkeyOCR, and PP-StructureV3. The model has been released on [HuggingFace](https://huggingface.co/opendatalab/MinerU2.5-2509-1.2B) and [ModelScope](https://modelscope.cn/models/opendatalab/MinerU2.5-2509-1.2B) platforms. Welcome to download and use! **Core Highlights** - SOTA Performance with Extreme Efficiency: As a 1.2B model, it achieves State-of-the-Art (SOTA) results that exceed models in the 10B and 100B+ classes, redefining the performance-per-parameter standard in document AI. - Advanced Architecture for Across-the-Board Leadership: By combining a two-stage inference pipeline (decoupling layout analysis from content recognition) with a native high-resolution architecture, it achieves SOTA performance across five key areas: layout analysis, text recognition, formula recognition, table recognition, and reading order. **Key Capability Enhancements** - Layout Detection: Delivers more complete results by accurately covering non-body content like headers, footers, and page numbers. It also provides more precise element localization and natural format reconstruction for lists and references. - Table Parsing: Drastically improves parsing for challenging cases, including rotated tables, borderless/semi-structured tables, and long/complex tables. - Formula Recognition: Significantly boosts accuracy for complex, long-form, and hybrid Chinese-English formulas, greatly enhancing the parsing capability for mathematical documents. **Repository Adjustments** Additionally, with the release of vlm 2.5, we have made some adjustments to the repository: - The vlm backend has been upgraded to version 2.5, supporting the MinerU2.5 model and no longer compatible with the MinerU2.0-2505-0.9B model. The last version supporting the 2.0 model is mineru-2.2.2. - VLM inference-related code has been moved to [mineru_vl_utils](https://github.com/opendatalab/mineru-vl-utils), reducing coupling with the main mineru repository and facilitating independent iteration in the future. - The vlm accelerated inference framework has been switched from `sglang` to `vllm`, achieving full compatibility with the vllm ecosystem, allowing users to use the MinerU2.5 model and accelerated inference on any platform that supports the vllm framework. - Due to major upgrades in the vlm model supporting more layout types, we have made some adjustments to the structure of the parsing intermediate file `middle.json` and result file `content_list.json`. Please refer to the [documentation](https://opendatalab.github.io/MinerU/reference/output_files/) for details. **Other Repository Optimizations** - Removed file extension whitelist validation for input files. When input files are PDF documents or images, there are no longer requirements for file extensions, improving usability. --- ## 2.2 - 2.4 Series Versions ### 2.2.2 (2025/09/10) - Fixed the issue where the new table recognition model would affect the overall parsing task when some table parsing failed ### 2.2.1 (2025/09/08) - Fixed the issue where some newly added models were not downloaded when using the model download command. ### 2.2.0 (2025/09/05) **Major Updates** - In this version, we focused on improving table parsing accuracy by introducing a new [wired table recognition model](https://github.com/RapidAI/TableStructureRec) and a brand-new hybrid table structure parsing algorithm, significantly enhancing the table recognition capabilities of the `pipeline` backend. - We also added support for cross-page table merging, which is supported by both `pipeline` and `vlm` backends, further improving the completeness and accuracy of table parsing. **Other Updates** - The `pipeline` backend now supports 270-degree rotated table parsing, bringing support for table parsing in 0/90/270-degree orientations - `pipeline` added OCR capability support for Thai and Greek, and updated the English OCR model to the latest version. English recognition accuracy improved by 11%, Thai recognition model accuracy is 82.68%, and Greek recognition model accuracy is 89.28% (by PPOCRv5) - Added `bbox` field (mapped to 0-1000 range) in the output `content_list.json`, making it convenient for users to directly obtain position information for each content block - Removed the `pipeline_old_linux` installation option, no longer supporting legacy Linux systems such as `CentOS 7`, to provide better support for `uv`'s `sync`/`run` commands --- ## 2.1 Series Versions ### 2.1.10 (2025/08/01) - Fixed an issue in the `pipeline` backend where block overlap caused the parsing results to deviate from expectations #3232 ### 2.1.9 (2025/07/30) - `transformers` 4.54.1 version adaptation ### 2.1.8 (2025/07/28) - `sglang` 0.4.9.post5 version adaptation ### 2.1.7 (2025/07/27) - `transformers` 4.54.0 version adaptation ### 2.1.6 (2025/07/26) - Fixed table parsing issues in handwritten documents when using `vlm` backend - Fixed visualization box position drift issue when document is rotated #3175 ### 2.1.5 (2025/07/24) - `sglang` 0.4.9 version adaptation, synchronously upgrading the dockerfile base image to sglang 0.4.9.post3 ### 2.1.4 (2025/07/23) **Bug Fixes** - Fixed the issue of excessive memory consumption during the `MFR` step in the `pipeline` backend under certain scenarios #2771 - Fixed the inaccurate matching between `image`/`table` and `caption`/`footnote` under certain conditions #3129 ### 2.1.1 (2025/07/16) **Bug fixes** - Fixed text block content loss issue that could occur in certain `pipeline` scenarios #3005 - Fixed issue where `sglang-client` required unnecessary packages like `torch` #2968 - Updated `dockerfile` to fix incomplete text content parsing due to missing fonts in Linux #2915 **Usability improvements** - Updated `compose.yaml` to facilitate direct startup of `sglang-server`, `mineru-api`, and `mineru-gradio` services - Launched brand new [online documentation site](https://opendatalab.github.io/MinerU/), simplified readme, providing better documentation experience ### 2.1.0 (2025/07/05) This is the first major update of MinerU 2, which includes a large number of new features and improvements, covering significant performance optimizations, user experience enhancements, and bug fixes. The detailed update contents are as follows: **Performance Optimizations** - Significantly improved preprocessing speed for documents with specific resolutions (around 2000 pixels on the long side). - Greatly enhanced post-processing speed when the `pipeline` backend handles batch processing of documents with fewer pages (<10 pages). - Layout analysis speed of the `pipeline` backend has been increased by approximately 20%. **Experience Enhancements** - Built-in ready-to-use `fastapi service` and `gradio webui`. For detailed usage instructions, please refer to [Documentation](../usage/quick_usage.md). - Adapted to `sglang` version `0.4.8`, significantly reducing the GPU memory requirements for the `vlm-sglang` backend. It can now run on graphics cards with as little as `8GB GPU memory` (Turing architecture or newer). - Added transparent parameter passing for all commands related to `sglang`, allowing the `sglang-engine` backend to receive all `sglang` parameters consistently with the `sglang-server`. - Supports feature extensions based on configuration files, including `custom formula delimiters`, `enabling heading classification`, and `customizing local model directories`. For detailed usage instructions, please refer to [Documentation](https://opendatalab.github.io/MinerU/usage/quick_usage/#extending-mineru-functionality-with-configuration-files). **New Features** - Updated the `pipeline` backend with the PP-OCRv5 multilingual text recognition model, supporting text recognition in 37 languages such as French, Spanish, Portuguese, Russian, and Korean, with an average accuracy improvement of over 30%. [Details](https://paddlepaddle.github.io/PaddleOCR/latest/en/version3.x/algorithm/PP-OCRv5/PP-OCRv5_multi_languages.html) - Introduced limited support for vertical text layout in the `pipeline` backend. --- ## 2.0 Series Versions ### 2.0.6 (2025/06/20) - Fixed occasional parsing interruptions caused by invalid block content in `vlm` mode - Fixed parsing interruptions caused by incomplete table structures in `vlm` mode ### 2.0.5 (2025/06/17) - Fixed the issue where models were still required to be downloaded in the `sglang-client` mode - Fixed the issue where the `sglang-client` mode unnecessarily depended on packages like `torch` during runtime. - Fixed the issue where only the first instance would take effect when attempting to launch multiple `sglang-client` instances via multiple URLs within the same process ### 2.0.3 (2025/06/15) - Fixed a configuration file key-value update error that occurred when downloading model type was set to `all` - Fixed the issue where the formula and table feature toggle switches were not working in `command line mode`, causing the features to remain enabled. - Fixed compatibility issues with sglang version 0.4.7 in the `sglang-engine` mode. - Updated Dockerfile and installation documentation for deploying the full version of MinerU in sglang environment ### 2.0.0 (2025/06/13) **New Architecture** MinerU 2.0 has been deeply restructured in code organization and interaction methods, significantly improving system usability, maintainability, and extensibility. - **Removal of Third-party Dependency Limitations**: Completely eliminated the dependency on `pymupdf`, moving the project toward a more open and compliant open-source direction. - **Ready-to-use, Easy Configuration**: No need to manually edit JSON configuration files; most parameters can now be set directly via command line or API. - **Automatic Model Management**: Added automatic model download and update mechanisms, allowing users to complete model deployment without manual intervention. - **Offline Deployment Friendly**: Provides built-in model download commands, supporting deployment requirements in completely offline environments. - **Streamlined Code Structure**: Removed thousands of lines of redundant code, simplified class inheritance logic, significantly improving code readability and development efficiency. - **Unified Intermediate Format Output**: Adopted standardized `middle_json` format, compatible with most secondary development scenarios based on this format, ensuring seamless ecosystem business migration. **New Model** MinerU 2.0 integrates our latest small-parameter, high-performance multimodal document parsing model, achieving end-to-end high-speed, high-precision document understanding. - **Small Model, Big Capabilities**: With parameters under 1B, yet surpassing traditional 72B-level vision-language models (VLMs) in parsing accuracy. - **Multiple Functions in One**: A single model covers multilingual recognition, handwriting recognition, layout analysis, table parsing, formula recognition, reading order sorting, and other core tasks. - **Ultimate Inference Speed**: Achieves peak throughput exceeding 10,000 tokens/s through `sglang` acceleration on a single NVIDIA 4090 card, easily handling large-scale document processing requirements. - **Online Experience**: You can experience our brand-new VLM model on [MinerU.net](https://mineru.net/OpenSourceTools/Extractor), [Hugging Face](https://huggingface.co/spaces/opendatalab/MinerU), and [ModelScope](https://www.modelscope.cn/studios/OpenDataLab/MinerU). **Incompatible Changes Notice** To improve overall architectural rationality and long-term maintainability, this version contains some incompatible changes: - Python package name changed from `magic-pdf` to `mineru`, and the command-line tool changed from `magic-pdf` to `mineru`. Please update your scripts and command calls accordingly. - For modular system design and ecosystem consistency considerations, MinerU 2.0 no longer includes the LibreOffice document conversion module. If you need to process Office documents, we recommend converting them to PDF format through an independently deployed LibreOffice service before proceeding with subsequent parsing operations. --- ## 1.x Series Historical Versions ### 1.3.12 (2025/05/24) Added support for PPOCRv5 models, updated `ch_server` model to `PP-OCRv5_rec_server`, and `ch_lite` model to `PP-OCRv5_rec_mobile` (model update required) - In testing, we found that PPOCRv5(server) has some improvement for handwritten documents, but has slightly lower accuracy than v4_server_doc for other document types, so the default ch model remains unchanged as `PP-OCRv4_server_rec_doc`. - Since PPOCRv5 has enhanced recognition capabilities for handwriting and special characters, you can manually choose the PPOCRv5 model for Japanese-Traditional Chinese mixed scenarios and handwritten documents - You can select the appropriate model through the lang parameter `lang='ch_server'` (Python API) or `--lang ch_server` (command line): - `ch`: `PP-OCRv4_server_rec_doc` (default) (Chinese/English/Japanese/Traditional Chinese mixed/15K dictionary) - `ch_server`: `PP-OCRv5_rec_server` (Chinese/English/Japanese/Traditional Chinese mixed + handwriting/18K dictionary) - `ch_lite`: `PP-OCRv5_rec_mobile` (Chinese/English/Japanese/Traditional Chinese mixed + handwriting/18K dictionary) - `ch_server_v4`: `PP-OCRv4_rec_server` (Chinese/English mixed/6K dictionary) - `ch_lite_v4`: `PP-OCRv4_rec_mobile` (Chinese/English mixed/6K dictionary) Added support for handwritten documents through optimized layout recognition of handwritten text areas - This feature is supported by default, no additional configuration required - You can refer to the instructions above to manually select the PPOCRv5 model for better handwritten document parsing results The `huggingface` and `modelscope` demos have been updated to versions that support handwriting recognition and PPOCRv5 models, which you can experience online ### 1.3.10 (2025/04/29) - Added support for custom formula delimiters, which can be configured by modifying the `latex-delimiter-config` section in the `magic-pdf.json` file in your user directory. ### 1.3.9 (2025/04/27) - Optimized formula parsing functionality, improved formula rendering success rate ### 1.3.8 (2025/04/23) The default `ocr` model (`ch`) has been updated to `PP-OCRv4_server_rec_doc` (model update required) - `PP-OCRv4_server_rec_doc` is trained on a mixture of more Chinese document data and PP-OCR training data based on `PP-OCRv4_server_rec`, adding recognition capabilities for some traditional Chinese characters, Japanese, and special characters. It can recognize over 15,000 characters and improves both document-specific and general text recognition abilities. - [Performance comparison of PP-OCRv4_server_rec_doc/PP-OCRv4_server_rec/PP-OCRv4_mobile_rec](https://paddlepaddle.github.io/PaddleX/latest/module_usage/tutorials/ocr_modules/text_recognition.html#_3) - After verification, the `PP-OCRv4_server_rec_doc` model shows significant accuracy improvements in Chinese/English/Japanese/Traditional Chinese in both single language and mixed language scenarios, with comparable speed to `PP-OCRv4_server_rec`, making it suitable for most use cases. - In some pure English scenarios, `PP-OCRv4_server_rec_doc` may have word adhesion issues, while `PP-OCRv4_server_rec` performs better in these cases. Therefore, we've kept the `PP-OCRv4_server_rec` model, which users can access by adding the parameter `lang='ch_server'` (Python API) or `--lang ch_server` (command line). ### 1.3.7 (2025/04/22) - Fixed the issue where the lang parameter was ineffective during table parsing model initialization - Fixed the significant speed reduction of OCR and table parsing in `cpu` mode ### 1.3.4 (2025/04/16) - Slightly improved OCR-det speed by removing some unnecessary blocks - Fixed page-internal sorting errors caused by footnotes in certain cases ### 1.3.2 (2025/04/12) - Fixed dependency version incompatibility issues when installing on Windows with Python 3.13 - Optimized memory usage during batch inference - Improved parsing of tables rotated 90 degrees - Enhanced parsing of oversized tables in financial report samples - Fixed the occasional word adhesion issue in English text areas when OCR language is not specified (model update required) ### 1.3.1 (2025/04/08) Fixed several compatibility issues - Added support for Python 3.13 - Made final adaptations for outdated Linux systems (such as CentOS 7) with no guarantee of continued support in future versions, [installation instructions](https://github.com/opendatalab/MinerU/issues/1004) ### 1.3.0 (2025/04/03) **Installation and compatibility optimizations** - Resolved compatibility issues caused by `detectron2` by removing `layoutlmv3` usage in layout - Extended torch version compatibility to 2.2~2.6 (excluding 2.5) - Added CUDA compatibility for versions 11.8/12.4/12.6/12.8 (CUDA version determined by torch), solving compatibility issues for users with 50-series and H-series GPUs - Extended Python compatibility to versions 3.10~3.12, fixing the issue of automatic downgrade to version 0.6.1 when installing in non-3.10 environments - Optimized offline deployment process, eliminating the need to download any model files after successful deployment **Performance optimizations** - Enhanced parsing speed for batches of small files by supporting batch processing of multiple PDF files ([script example](https://github.com/opendatalab/MinerU/blob/ae9fd9adaa336c171938f0ccd509cdf13a09087b/demo/batch_demo.py)), with formula parsing speed improved by up to 1400% and overall parsing speed improved by up to 500% compared to version 1.0.1 - Reduced memory usage and improved parsing speed by optimizing MFR model loading and usage (requires re-running the [model download process](https://github.com/opendatalab/MinerU/blob/magic_pdf-1.1.0-released/docs/how_to_download_models_zh_cn.md) to get incremental updates to model files) - Optimized GPU memory usage, requiring only 6GB minimum to run this project - Improved running speed on MPS devices **Parsing effect optimizations** - Updated MFR model to `unimernet(2503)`, fixing line break loss issues in multi-line formulas **Usability optimizations** - Completely replaced the `paddle` framework and `paddleocr` in the project by using `paddleocr2torch`, resolving conflicts between `paddle` and `torch`, as well as thread safety issues caused by the `paddle` framework - Added real-time progress bar display during parsing, allowing precise tracking of parsing progress and making the waiting process more bearable ### 1.2.1 (2025/03/03) Fixed some issues - Fixed the impact on punctuation marks during full-width to half-width conversion of letters and numbers - Fixed caption matching inaccuracies in certain scenarios - Fixed formula span loss issues in certain scenarios ### 1.2.0 (2025/02/24) This version includes several fixes and improvements to enhance parsing efficiency and accuracy: **Performance Optimization** - Increased classification speed for PDF documents in auto mode. **Parsing Optimization** - Improved parsing logic for documents containing watermarks, significantly enhancing the parsing results for such documents. - Enhanced the matching logic for multiple images/tables and captions within a single page, improving the accuracy of image-text matching in complex layouts. **Bug Fixes** - Fixed an issue where image/table spans were incorrectly filled into text blocks under certain conditions. - Resolved an issue where title blocks were empty in some cases. ### 1.1.0 (2025/01/22) In this version we have focused on improving parsing accuracy and efficiency: **Model capability upgrade** (requires re-executing the [model download process](https://github.com/opendatalab/MinerU/blob/master/docs/how_to_download_models_en.md) to obtain incremental updates of model files) - The layout recognition model has been upgraded to the latest `doclayout_yolo(2501)` model, improving layout recognition accuracy. - The formula parsing model has been upgraded to the latest `unimernet(2501)` model, improving formula recognition accuracy. **Performance optimization** - On devices that meet certain configuration requirements (16GB+ VRAM), by optimizing resource usage and restructuring the processing pipeline, overall parsing speed has been increased by more than 50%. **Parsing effect optimization** - Added a new heading classification feature (testing version, enabled by default) to the online demo ([mineru.net](https://mineru.net/OpenSourceTools/Extractor)/[huggingface](https://huggingface.co/spaces/opendatalab/MinerU)/[modelscope](https://www.modelscope.cn/studios/OpenDataLab/MinerU)), which supports hierarchical classification of headings, thereby enhancing document structuring. ### 1.0.1 (2025/01/10) This is our first official release, where we have introduced a completely new API interface and enhanced compatibility through extensive refactoring, as well as a brand new automatic language identification feature: **New API Interface** - For the data-side API, we have introduced the Dataset class, designed to provide a robust and flexible data processing framework. This framework currently supports a variety of document formats, including images (.jpg and .png), PDFs, Word documents (.doc and .docx), and PowerPoint presentations (.ppt and .pptx). It ensures effective support for data processing tasks ranging from simple to complex. - For the user-side API, we have meticulously designed the MinerU processing workflow as a series of composable Stages. Each Stage represents a specific processing step, allowing users to define new Stages according to their needs and creatively combine these stages to customize their data processing workflows. **Enhanced Compatibility** - By optimizing the dependency environment and configuration items, we ensure stable and efficient operation on ARM architecture Linux systems. - We have deeply integrated with Huawei Ascend NPU acceleration, providing autonomous and controllable high-performance computing capabilities. This supports the localization and development of AI application platforms in China. [Ascend NPU Acceleration](https://github.com/opendatalab/MinerU/blob/master/docs/README_Ascend_NPU_Acceleration_zh_CN.md) **Automatic Language Identification** - By introducing a new language recognition model, setting the `lang` configuration to `auto` during document parsing will automatically select the appropriate OCR language model, improving the accuracy of scanned document parsing. --- ## 0.x Series Historical Versions ### 0.10.0 (2024/11/22) Introducing hybrid OCR text extraction capabilities: - Significantly improved parsing performance in complex text distribution scenarios such as dense formulas, irregular span regions, and text represented by images. - Combines the dual advantages of accurate content extraction and faster speed in text mode, and more precise span/line region recognition in OCR mode. ### 0.9.3 (2024/11/15) Integrated [RapidTable](https://github.com/RapidAI/RapidTable) for table recognition, improving single-table parsing speed by more than 10 times, with higher accuracy and lower GPU memory usage. ### 0.9.2 (2024/11/06) Integrated the [StructTable-InternVL2-1B](https://huggingface.co/U4R/StructTable-InternVL2-1B) model for table recognition functionality. ### 0.9.0 (2024/10/31) This is a major new version with extensive code refactoring, addressing numerous issues, improving performance, reducing hardware requirements, and enhancing usability: - Refactored the sorting module code to use [layoutreader](https://github.com/ppaanngggg/layoutreader) for reading order sorting, ensuring high accuracy in various layouts. - Refactored the paragraph concatenation module to achieve good results in cross-column, cross-page, cross-figure, and cross-table scenarios. - Refactored the list and table of contents recognition functions, significantly improving the accuracy of list blocks and table of contents blocks, as well as the parsing of corresponding text paragraphs. - Refactored the matching logic for figures, tables, and descriptive text, greatly enhancing the accuracy of matching captions and footnotes to figures and tables, and reducing the loss rate of descriptive text to near zero. - Added multi-language support for OCR, supporting detection and recognition of 84 languages. For the list of supported languages, see [OCR Language Support List](https://paddlepaddle.github.io/PaddleOCR/latest/en/ppocr/blog/multi_languages.html#5). - Added memory recycling logic and other memory optimization measures, significantly reducing memory usage. The memory requirement for enabling all acceleration features except table acceleration (layout/formula/OCR) has been reduced from 16GB to 8GB, and the memory requirement for enabling all acceleration features has been reduced from 24GB to 10GB. - Optimized configuration file feature switches, adding an independent formula detection switch to significantly improve speed and parsing results when formula detection is not needed. - Integrated [PDF-Extract-Kit 1.0](https://github.com/opendatalab/PDF-Extract-Kit): - Added the self-developed `doclayout_yolo` model, which speeds up processing by more than 10 times compared to the original solution while maintaining similar parsing effects, and can be freely switched with `layoutlmv3` via the configuration file. - Upgraded formula parsing to `unimernet 0.2.1`, improving formula parsing accuracy while significantly reducing memory usage. - Due to the repository change for `PDF-Extract-Kit 1.0`, you need to re-download the model. Please refer to [How to Download Models](https://github.com/opendatalab/MinerU/blob/master/docs/how_to_download_models_en.md) for detailed steps. ### 0.8.1 (2024/09/27) Fixed some bugs, and providing a [localized deployment version](https://github.com/opendatalab/MinerU/blob/master/projects/web_demo/README.md) of the [online demo](https://opendatalab.com/OpenSourceTools/Extractor/PDF/) and the [front-end interface](https://github.com/opendatalab/MinerU/blob/master/projects/web/README.md). ### 0.8.0 (2024/09/09) Supporting fast deployment with Dockerfile, and launching demos on Huggingface and Modelscope. ### 0.7.1 (2024/08/30) Add paddle tablemaster table recognition option ### 0.7.0b1 (2024/08/09) Simplified installation process, added table recognition functionality ### 0.6.2b1 (2024/08/01) Optimized dependency conflict issues and installation documentation ### Initial Open-Source Release (2024/07/05) MinerU project's first open-source release