Skip to content
Back to search

MinerU-Ecosystem

The official ecosystem toolkit for MinerU Open API

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/opendatalab--mineru-ecosystem/badge.svg)](/listings/opendatalab--mineru-ecosystem)

HTML

<a href="/listings/opendatalab--mineru-ecosystem"><img src="/api/listings/opendatalab--mineru-ecosystem/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

These steps run a script from the network that findsafeskills does not scan.

πŸ’» CLI (`cli/`)

A fast command-line tool for parsing documents directly from your terminal.

Installation

# Linux / macOS
curl -fsSL https://cdn-mineru.openxlab.org.cn/open-api-cli/install.sh | sh
# Windows (PowerShell)
irm https://cdn-mineru.openxlab.org.cn/open-api-cli/install.ps1 | iex

**Flash Extract (no login)**

mineru-open-api flash-extract report.pdf

**Precision Extract (login required)**

# First-time setup
mineru-open-api auth

# Extract to stdout
mineru-open-api extract paper.pdf

# Save all resources (images/tables) to directory
mineru-open-api extract report.pdf -o ./output/

# Export to multiple formats
mineru-open-api extract report.pdf -f docx,latex,html -o ./results/

**Web Crawl**

mineru-open-api crawl https://www.example.com

**Batch Processing**

# All PDFs in current directory
mineru-open-api extract *.pdf -o ./results/

# From a file list
mineru-open-api extract --list filelist.txt -o ./results/

---

🐍 Python SDK

Installation

pip install mineru-open-sdk

**Flash Extract (no token)**

from mineru import MinerU

client = MinerU()
result = client.flash_extract("https://cdn-mineru.openxlab.org.cn/demo/example.pdf")
print(result.markdown)

**Precision Extract (token required)**

from mineru import MinerU

client = MinerU("your-api-token")
result = client.extract("https://cdn-mineru.openxlab.org.cn/demo/example.pdf")
print(result.markdown)
print(result.images)  # extracted image list

---

🐹 Go SDK

Installation

go get github.com/opendatalab/MinerU-Ecosystem/sdk/go@latest

**Flash Extract**

package main

import (
    "context"
    "fmt"
    mineru "github.com/opendatalab/MinerU-Ecosystem/sdk/go"
)

func main() {
    client := mineru.NewFlash()
    result, err := client.FlashExtract(
        context.Background(),
        "https://cdn-mineru.openxlab.org.cn/demo/example.pdf",
    )
    if err != nil {
        panic(err)
    }
    fmt.Println(result.Markdown)
}

**Precision Extract**

client, err := mineru.New("your-api-token")
if err != nil {
    panic(err)
}
result, err := client.Extract(
    context.Background(),
    "https://cdn-mineru.openxlab.org.cn/demo/example.pdf",
)
if err != nil {
    panic(err)
}
fmt.Println(result.Markdown)

**Precision Extract with options**

result, err := client.Extract(ctx, "./paper.pdf",
    mineru.WithModel("vlm"),
    mineru.WithLanguage("en"),
    mineru.WithPages("1-20"),
    mineru.WithExtraFormats("docx"),
    mineru.WithPollTimeout(10*time.Minute),
)
if err != nil {
    panic(err)
}
if err := result.SaveAll("./output"); err != nil {
    panic(err)
}

**Batch Processing**

ch, err := client.ExtractBatch(ctx, []string{"a.pdf", "b.pdf"})
if err != nil {
    panic(err)
}
for result := range ch {
    fmt.Printf("%s: %s\n", result.Filename, result.State)
}

**Web Crawling**

result, err := client.Crawl(ctx, "https://www.example.com")
if err != nil {
    panic(err)
}
fmt.Println(result.Markdown)

---

🟦 TypeScript / JavaScript SDK

Installation

npm install mineru-open-sdk

**Flash Extract**

import { MinerU } from "mineru-open-sdk";

const client = new MinerU();
const result = await client.flashExtract(
  "https://cdn-mineru.openxlab.org.cn/demo/example.pdf"
);
console.log(result.markdown);

**Precision Extract**

import { MinerU } from "mineru-open-sdk";

const client = new MinerU("your-api-token");
const result = await client.extract(
  "https://cdn-mineru.openxlab.org.cn/demo/example.pdf"
);
console.log(result.markdown);
console.log(result.images);

**Precision Extract with options**

import { MinerU, saveAll } from "mineru-open-sdk";

const client = new MinerU("your-api-token");
const result = await client.extract("./paper.pdf", {
  model: "vlm",       // "vlm" | "pipeline" | "html"

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md Β· README Β· 570 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. <div align="center">
  2. # MinerU-Ecosystem
  3. **The official ecosystem toolkit for [MinerU](https://github.com/opendatalab/MinerU) Open API**
  4. Empowering developers and AI agents with seamless document parsing capabilities β€” PDF Β· Word Β· PPT Β· Images Β· Web pages β†’ Markdown / JSON Β· VLM+OCR dual engine Β· 109 languages Β· MCP Server Β· LangChain / RAGFlow / Dify / FastGPT native integration.
  5. [![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](LICENSE)
  6. [![MinerU](https://img.shields.io/badge/Powered%20by-MinerU-orange)](https://github.com/opendatalab/MinerU)
  7. [![Online](https://img.shields.io/badge/Online-mineru.net-purple)](https://mineru.net)
  8. [δΈ­ζ–‡ζ–‡ζ‘£](README.zh-CN.md)
  9. </div>
  10. ---
  11. ## πŸ“– Overview
  12. **MinerU-Ecosystem** provides a full suite of tools, SDKs, and integrations built on top of the [MinerU Open API](https://mineru.net/apiManage/docs). Whether you're building production pipelines, integrating with LangChain for RAG, or enabling AI agents to parse documents on the fly β€” this repository has you covered.
  13. [MinerU](https://github.com/opendatalab/MinerU) is an open-source, high-accuracy document parsing engine that converts unstructured documents (PDFs, images, Office files, etc.) into machine-readable Markdown and JSON, purpose-built for LLM pre-training, RAG, and agentic workflows.
  14. **Core capabilities:**
  15. - Formulas β†’ LaTeX Β· Tables β†’ HTML, accurate complex layout reconstruction
  16. - Supports scanned docs, handwriting, multi-column layouts, cross-page table merging
  17. - Output follows human reading order with automatic header/footer removal
  18. - VLM + OCR dual engine, 109-language OCR recognition
  19. ---
  20. ## πŸ—οΈ Repository Structure
  21. ```
  22. MinerU-Ecosystem/
  23. β”œβ”€β”€ cli/ # Command-line tool for document parsing
  24. β”œβ”€β”€ sdk/ # Multi-language SDKs
  25. β”‚ β”œβ”€β”€ python/ # Python SDK
  26. β”‚ β”œβ”€β”€ go/ # Go SDK
  27. β”‚ └── typescript/ # TypeScript SDK
  28. β”œβ”€β”€ langchain_mineru/ # LangChain document loader integration
  29. β”œβ”€β”€ llama-index-readers-mineru/ # LlamaIndex document reader integration
  30. β”œβ”€β”€ mcp/ # Model Context Protocol server (Python)
  31. └── skills/ # AI agent skills (Claude Code, OpenClaw, etc.)
  32. ```
  33. ---
  34. ## πŸ”‘ Supported APIs
  35. All components support both API modes:
  36. | Comparison | 🎯 Precision Extract API | ⚑ Quick Parse API (Agent-Oriented) |
  37. | --------------- | ----------------------------------------------------------- | ----------------------------------- |
  38. | Auth | βœ… Token required | ❌ Not required (IP rate-limited) |
  39. | Model Versions | `pipeline` (default) / `vlm` (recommended) / `MinerU-HTML` | Fixed lightweight pipeline model |
  40. | File Size Limit | ≀ 200 MB | ≀ 10 MB |
  41. | Page Limit | ≀ 200 pages | ≀ 20 pages |
  42. | Batch Support | βœ… Supported (≀ 200 files) | ❌ Single file only |
  43. | Output Formats | Markdown, JSON, Zip; optional export to DOCX / HTML / LaTeX | Markdown only |
  44. ## 🧭 Choose Your Integration Path
  45. Not sure where to start? Pick the path that matches your use case:
  46. ```text
  47. I want to...
  48. β”‚
  49. β”œβ”€β”€ 🌐 Try it instantly, with no install and no code
  50. β”‚ └── Web App β†’ https://mineru.net/OpenSourceTools/Extractor
  51. β”‚
  52. β”œβ”€β”€ πŸ’» Parse documents from the terminal
  53. β”‚ └── CLI β†’ cli/
  54. β”‚ flash-extract: no token, best for quick previews
  55. β”‚ extract: full features, better for production workflows
  56. β”‚
  57. β”œβ”€β”€ 🐍 Integrate it into my Python / Go / TypeScript project
  58. β”‚ └── SDK β†’ sdk/python/ | sdk/go/ | sdk/typescript/
  59. β”‚
  60. β”œβ”€β”€ πŸ€– Enable my AI agent to parse documents
  61. β”‚ β”œβ”€β”€ Call the CLI directly β†’ cli/
  62. β”‚ β”œβ”€β”€ Use natural-language skills (OpenClaw, ZeroClaw, etc.) β†’ skills/
  63. β”‚ └── Use MCP protocol (Cursor, Claude Desktop, Windsurf, etc.) β†’ mcp/
  64. β”‚
  65. β”œβ”€β”€ πŸ“š Build a RAG pipeline / knowledge base
  66. β”‚ β”œβ”€β”€ LangChain Loader β†’ langchain_mineru/
  67. β”‚ └── LlamaIndex Reader β†’ llama-index-readers-mineru/
  68. β”‚ flash mode: zero-token quick start
  69. β”‚ precision mode: OCR, tables, formulas, and higher fidelity
  70. ```
  71. ---
  72. ## πŸš€ Quick Start
  73. ### πŸ’» CLI (`cli/`)
  74. A fast command-line tool for parsing documents directly from your terminal.
  75. #### Installation
  76. ```bash
  77. # Linux / macOS
  78. curl -fsSL https://cdn-mineru.openxlab.org.cn/open-api-cli/install.sh | sh
  79. ```
  80. ```powershell
  81. # Windows (PowerShell)
  82. irm https://cdn-mineru.openxlab.org.cn/open-api-cli/install.ps1 | iex
  83. ```
  84. **Flash Extract (no login)**
  85. ```bash
  86. mineru-open-api flash-extract report.pdf
  87. ```
  88. **Precision Extract (login required)**
  89. ```bash
  90. # First-time setup
  91. mineru-open-api auth
  92. # Extract to stdout
  93. mineru-open-api extract paper.pdf
  94. # Save all resources (images/tables) to directory
  95. mineru-open-api extract report.pdf -o ./output/
  96. # Export to multiple formats
  97. mineru-open-api extract report.pdf -f docx,latex,html -o ./results/
  98. ```
  99. **Web Crawl**
  100. ```bash
  101. mineru-open-api crawl https://www.example.com
  102. ```
  103. **Batch Processing**
  104. ```bash
  105. # All PDFs in current directory
  106. mineru-open-api extract *.pdf -o ./results/
  107. # From a file list
  108. mineru-open-api extract --list filelist.txt -o ./results/
  109. ```
  110. ---
  111. ### 🐍 Python SDK
  112. #### Installation
  113. ```bash
  114. pip install mineru-open-sdk
  115. ```
  116. **Flash Extract (no token)**
  117. ```python
  118. from mineru import MinerU
  119. client = MinerU()
  120. result = client.flash_extract("https://cdn-mineru.openxlab.org.cn/demo/example.pdf")
  121. print(result.markdown)
  122. ```
  123. **Precision Extract (token required)**
  124. ```python
  125. from mineru import MinerU
  126. client = MinerU("your-api-token")
  127. result = client.extract("https://cdn-mineru.openxlab.org.cn/demo/example.pdf")
  128. print(result.markdown)
  129. print(result.images) # extracted image list
  130. ```
  131. ---
  132. ### 🐹 Go SDK
  133. #### Installation
  134. ```bash
  135. go get github.com/opendatalab/MinerU-Ecosystem/sdk/go@latest
  136. ```
  137. **Flash Extract**
  138. ```go
  139. package main
  140. import (
  141. "context"
  142. "fmt"
  143. mineru "github.com/opendatalab/MinerU-Ecosystem/sdk/go"
  144. )
  145. func main() {
  146. client := mineru.NewFlash()
  147. result, err := client.FlashExtract(
  148. context.Background(),
  149. "https://cdn-mineru.openxlab.org.cn/demo/example.pdf",
  150. )
  151. if err != nil {
  152. panic(err)
  153. }
  154. fmt.Println(result.Markdown)
  155. }
  156. ```
  157. **Precision Extract**
  158. ```go
  159. client, err := mineru.New("your-api-token")
  160. if err != nil {
  161. panic(err)
  162. }
  163. result, err := client.Extract(
  164. context.Background(),
  165. "https://cdn-mineru.openxlab.org.cn/demo/example.pdf",
  166. )
  167. if err != nil {
  168. panic(err)
  169. }
  170. fmt.Println(result.Markdown)
  171. ```
  172. **Precision Extract with options**
  173. ```go
  174. result, err := client.Extract(ctx, "./paper.pdf",
  175. mineru.WithModel("vlm"),
  176. mineru.WithLanguage("en"),
  177. mineru.WithPages("1-20"),
  178. mineru.WithExtraFormats("docx"),
  179. mineru.WithPollTimeout(10*time.Minute),
  180. )
  181. if err != nil {
  182. panic(err)
  183. }
  184. if err := result.SaveAll("./output"); err != nil {
  185. panic(err)
  186. }
  187. ```
  188. **Batch Processing**
  189. ```go
  190. ch, err := client.ExtractBatch(ctx, []string{"a.pdf", "b.pdf"})
  191. if err != nil {
  192. panic(err)
  193. }
  194. for result := range ch {
  195. fmt.Printf("%s: %s\n", result.Filename, result.State)
  196. }
  197. ```
  198. **Web Crawling**
  199. ```go
  200. result, err := client.Crawl(ctx, "https://www.example.com")
  201. if err != nil {
  202. panic(err)
  203. }
  204. fmt.Println(result.Markdown)
  205. ```
  206. ---
  207. ### 🟦 TypeScript / JavaScript SDK
  208. #### Installation
  209. ```bash
  210. npm install mineru-open-sdk
  211. ```
  212. **Flash Extract**
  213. ```typescript
  214. import { MinerU } from "mineru-open-sdk";
  215. const client = new MinerU();
  216. const result = await client.flashExtract(
  217. "https://cdn-mineru.openxlab.org.cn/demo/example.pdf"
  218. );
  219. console.log(result.markdown);
  220. ```
  221. **Precision Extract**
  222. ```typescript
  223. import { MinerU } from "mineru-open-sdk";
  224. const client = new MinerU("your-api-token");
  225. const result = await client.extract(
  226. "https://cdn-mineru.openxlab.org.cn/demo/example.pdf"
  227. );
  228. console.log(result.markdown);
  229. console.log(result.images);
  230. ```
  231. **Precision Extract with options**
  232. ```typescript
  233. import { MinerU, saveAll } from "mineru-open-sdk";
  234. const client = new MinerU("your-api-token");
  235. const result = await client.extract("./paper.pdf", {
  236. model: "vlm", // "vlm" | "pipeline" | "html"
  237. language: "en",
  238. pages: "1-20",
  239. extraFormats: ["docx"],
  240. timeout: 600,
  241. });
  242. await saveAll(result, "./output");
  243. ```
  244. **Batch Processing**
  245. ```typescript
  246. for await (const result of client.extractBatch(["a.pdf", "b.pdf"])) {
  247. console.log(`${result.filename}: ${result.state}`);
  248. }
  249. ```
  250. **Web Crawling**
  251. ```typescript
  252. const result = await client.crawl("https://www.example.com");
  253. console.log(result.markdown);
  254. ```
  255. ---
  256. ## πŸ€– Use with Claude / Cursor (MCP Server)
  257. MinerU provides an official MCP Server allowing Claude Desktop, Cursor, Windsurf, and any MCP-compatible AI client to parse documents as a native tool.
  258. > No API key needed β€” Flash mode works out of the box, free, up to 20 pages / 10 MB per file.
  259. **Configure: `claude_desktop_config.json` / `.cursor/mcp.json`**
  260. ```json
  261. {
  262. "mcpServers": {
  263. "mineru": {
  264. "command": "uvx",
  265. "args": ["mineru-open-mcp"],
  266. "env": {
  267. "MINERU_API_TOKEN": "your_key_here"
  268. }
  269. }
  270. }
  271. }
  272. ```
  273. **Streamable HTTP mode (web-based MCP clients)**
  274. ```bash
  275. MINERU_API_TOKEN=your_key mineru-open-mcp --transport streamable-http --port 8001
  276. ```
  277. ```json
  278. {
  279. "mcpServers": {
  280. "mineru": {
  281. "type": "streamableHttp",
  282. "url": "http://127.0.0.1:8001/mcp"
  283. }
  284. }
  285. }
  286. ```
  287. **Tools exposed via MCP:**
  288. | Tool | Description |
  289. |---|---|
  290. | `parse_documents` | Convert PDF, DOCX, PPTX, images, HTML to Markdown |
  291. | `get_ocr_languages` | List all 109 supported OCR languages |
  292. | `clean_logs` | Delete old server log files (when `ENABLE_LOG=true`) |
  293. **Environment Variables:**
  294. | Variable | Description | Default |
  295. |---|---|---|
  296. | `MINERU_API_TOKEN` | MinerU cloud API token | β€” |
  297. | `OUTPUT_DIR` | Directory for saved output | `~/mineru-downloads` |
  298. | `ENABLE_LOG` | Set `true` to write log files | disabled |
  299. | `MINERU_LOG_DIR` | Override log file directory | `~/.mineru-open-mcp/logs/` |
  300. ---
  301. ## 🦜 Use in RAG with LangChain
  302. `langchain-mineru` is an official LangChain Document Loader β€” parse any document into LangChain `Document` objects with one line of code.
  303. #### Installation
  304. ```bash
  305. pip install langchain-mineru
  306. ```
  307. **Minimal example (no token)**
  308. **1. Basic usage (`flash` mode by default, no token required)**
  309. ```python
  310. from langchain_mineru import MinerULoader
  311. loader = MinerULoader(source="demo.pdf") # flash mode, no token needed
  312. docs = loader.load()
  313. print(docs[0].page_content[:500])
  314. print(docs[0].metadata)
  315. ```
  316. Default is `mode="flash"`, which is ideal for quick previews and lightweight integrations.
  317. **2. Precision mode (token required)**
  318. Best for long documents, larger files, and workflows that need higher-fidelity extraction or standard API outputs. Flash mode also supports OCR, table, and formula switches within flash API limits.
  319. ```python
  320. from langchain_mineru import MinerULoader
  321. loader = MinerULoader(
  322. source="/path/to/manual.pdf",
  323. mode="precision",
  324. token="your-api-token", # or set MINERU_TOKEN
  325. split_pages=True,
  326. pages="1-5",
  327. )
  328. docs = loader.load()
  329. for doc in docs:
  330. print(doc.metadata.get("page"), doc.page_content[:200])
  331. ```
  332. **3. Use it in a LangChain RAG pipeline**
  333. ```python
  334. from langchain_mineru import MinerULoader
  335. from langchain_text_splitters import RecursiveCharacterTextSplitter
  336. from langchain_openai import OpenAIEmbeddings
  337. from langchain_community.vectorstores import FAISS
  338. loader = MinerULoader(source="demo.pdf", split_pages=True)
  339. docs = loader.load()
  340. splitter = RecursiveCharacterTextSplitter(chunk_size=1200, chunk_overlap=200)
  341. chunks = splitter.split_documents(docs)
  342. vs = FAISS.from_documents(chunks, OpenAIEmbeddings())
  343. results = vs.similarity_search("What are the key conclusions in this document?", k=3)
  344. for r in results:
  345. print(r.page_content[:200])
  346. ```
  347. Default is `mode="flash"` (no API token required). Switch to `mode="precision"` for higher fidelity with token auth. For RAG use cases, `split_pages=True` is usually a better default for PDFs because it gives you page-level `Document` granularity.
  348. ### ## Use in RAG with LlamaIndex
  349. A document reader for LlamaIndex that parses PDFs, Word files, PPTs, images, and Excel files through MinerU and returns LlamaIndex-compatible `Document` objects for indexing and retrieval.
  350. #### Installation
  351. ```bash
  352. pip install llama-index-readers-mineru
  353. ```
  354. #### Usage
  355. **1. Flash mode (default, no token required)**
  356. Good for quick setup and lightweight parsing. Output is returned as Markdown.
  357. ```python
  358. from llama_index.readers.mineru import MinerUReader
  359. reader = MinerUReader()
  360. documents = reader.load_data("https://cdn-mineru.openxlab.org.cn/demo/example.pdf")
  361. print(documents[0].text[:500])
  362. print(documents[0].metadata)
  363. ```
  364. **2. Precision mode (token required)**
  365. Best for longer documents, larger files, and use cases that need higher-fidelity extraction or standard API outputs. Flash mode also supports OCR, formula, and table switches within flash API limits.
  366. ```python
  367. from llama_index.readers.mineru import MinerUReader
  368. reader = MinerUReader(
  369. mode="precision",
  370. token="your-api-token", # or set MINERU_TOKEN
  371. pages="1-20",
  372. )
  373. documents = reader.load_data("/path/to/paper.pdf")
  374. ```
  375. **3. Use it in a LlamaIndex pipeline**
  376. ```python
  377. from llama_index.core import VectorStoreIndex
  378. from llama_index.readers.mineru import MinerUReader
  379. reader = MinerUReader(split_pages=True)
  380. documents = reader.load_data("/path/to/paper.pdf")
  381. index = VectorStoreIndex.from_documents(documents)
  382. query_engine = index.as_query_engine()
  383. response = query_engine.query("Summarize the main findings of this document")
  384. print(response)
  385. ```
  386. Default is `mode="flash"` with no token required. Switch to `mode="precision"` when you need higher parsing fidelity. For PDF-based RAG pipelines, `split_pages=True` is recommended so each page becomes a separate `Document`.
  387. ---
  388. ## πŸ€– AI Agent Skills (`skills/`)
  389. Pre-built skills for AI coding agents, wrapping the `mineru-open-api` CLI for use in agent workflows.
  390. - **[OpenClaw / ClawHub](https://clawhub.ai/MinerU-Extract/mineru-ai)** β€” View skill details
  391. - **[One-click download](https://cdn-mineru.openxlab.org.cn/open-api-cli/skill.zip)** β€” Skill package
  392. - Compatible with Claude Code, OpenClaw, ZeroClaw, and other skill-interface agents
  393. ---
  394. ## πŸ”— All Integrations
  395. | Framework / Tool | Status | Notes |
  396. |---|---|---|
  397. | LangChain | βœ… Official | `pip install langchain-mineru` |
  398. | LlamaIndex | βœ… Community | See MinerU-Ecosystem |
  399. | RAGFlow | βœ… Supported | Document loader integration |
  400. | RAG-Anything | βœ… Supported | Multi-modal RAG pipeline |
  401. | Flowise | βœ… Supported | Node-based RAG builder |
  402. | Dify | βœ… Native Plugin | Built-in document loader |
  403. | FastGPT | βœ… Native Plugin | Integration guide |
  404. | Claude Desktop | βœ… MCP | `uvx mineru-open-mcp` |
  405. | Cursor | βœ… MCP | `.cursor/mcp.json` config |
  406. | Windsurf | βœ… MCP | stdio / streamable-http |
  407. | OpenClaw / ZeroClaw | βœ… Agent Skill | ClawHub |
  408. | Go SDK | βœ… Official | `go get .../sdk/go@latest` |
  409. | TypeScript SDK | βœ… Official | `npm install mineru-open-sdk` |
  410. | Python SDK | βœ… Official | `pip install mineru-open-sdk` |
  411. ---
  412. ## πŸ“š Documentation
  413. | Resource | Link |
  414. |---|---|
  415. | MinerU Open API Docs | [mineru.net/apiManage/docs](https://mineru.net/apiManage/docs) |
  416. | MinerU Online Demo | [mineru.net/OpenSourceTools/Extractor](https://mineru.net/OpenSourceTools/Extractor) |
  417. | MinerU Open Source | [github.com/opendatalab/MinerU](https://github.com/opendatalab/MinerU) |
  418. ---
  419. ## πŸ“„ License
  420. This project is licensed under the [Apache License 2.0](LICENSE).

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.