Preface¶

DeepSeek Harness (dsh for short) makes models, tools, conversations and interfaces all pluggable. Agents are handy when writing code and modifying configurations, but they get stuck when encountering scanned PDFs, formula-heavy papers, PPT handouts and Excel spreadsheets: models cannot see the layout, and regular extraction easily messes up multi-column layouts, headers and footers, and tables.

OpenDataLab’s MinerU specializes in this: converting PDF, images, DOCX, PPTX, XLSX into Markdown / JSON suitable for further processing by large models. It is an independent parsing engine with CLI, WebUI and FastAPI, and does not automatically appear in the dsh tool list.

dsh-plugin-mineru fills this gap: it registers a set of model-oriented tools in Harness and connects a running MinerU HTTP service into the agent loop. This article is organized after cross-checking with the community directory page, GitHub repository README / source code, npm package description, and official materials of MinerU and DeepSeek Harness.

What is this¶

dsh-plugin-mineru is a Tool & Capability type DeepSeek Harness plugin maintained by HuanLinOTO, with the repository at HuanLinOTO/dsh-plugin-mineru. The internal name of the plugin is dsh-mineru, the npm package name is @huanlin/dsh-plugin-mineru, and the current released version is 0.2.2 (2026-08-14). The main language is TypeScript, and Node.js 18 or higher is required. As of 2026-08-17, GitHub shows 30 stars; the community directory page showed 18 stars when the plugin was listed, please refer to the repository page for the latest count.

It solves a specific problem: enabling models in dsh to call MinerU to parse local documents into structured Markdown, and save the complete JSON result as a separate file, instead of letting the model guess the text in the PDF on its own.

You need to distinguish three layers of relationships:
1. DeepSeek Harness is the open-source agent runtime from DeepSeek, with the official slogan “Everything is a Plugin”, repository at deepseek-ai/deepseek-harness.
2. MinerU is the document parsing engine from OpenDataLab, repository at opendatalab/MinerU. The official documentation states that it supports PDF, images, DOCX, PPTX, XLSX, outputs Markdown / JSON, converts formulas to LaTeX and tables to HTML, and provides the mineru-api FastAPI.
3. This plugin is a community project that uses fetch to call MinerU’s /health, /tasks, /tasks/{id}, /tasks/{id}/result endpoints. It does not include a built-in parsing model, nor does it deploy MinerU for you.

The community plugin directory deepseek-harness-plugin.com is an independent site and has no official affiliation with DeepSeek / FunPlus. Do not treat it as an official app store. The directory page notes that this plugin is also included in the dshfind plugin marketplace.

The license is subject to the repository: package.json and LICENSE indicate AGPL-3.0 (the copyright page reads Copyright (C) 2026 Huanlin). GitHub’s license detection and directory page show NOASSERTION, which means the detection failed, not that there is a second license.

Core Features¶

The plugin is mounted as a bundle: cordis.patch.yml inserts a line for dsh-mineru, and package.json declares dsh.bundle.patch. The host side registers 5 tools, and the browser side has a Web UI settings page (when dsh.client.platform is web). Configuration changes are done via RPC, and there is no need to re-register tools.

Connect to a Deployed MinerU API¶

The client comments specify that it connects to the MinerU FastAPI (targeting v3.4.4 during development, protocol v2). Authentication is optional — the open-source MinerU service has no built-in authentication by default; if a key is parsed from the credential store or environment variables, the request will include an Authorization: Bearer header, and will refuse to follow redirects.

Supported local files are subject to tool parameters and client MIME mappings: PDF, DOCX, PPTX, XLSX, and images such as png / jpg / jpeg / gif / bmp / tiff / webp. They must be native filesystem paths; if you only have a URL, you must download it locally first before parsing.

Five Model-Oriented Tools¶

The README summarizes daily usage into the following set of tools.

mineru_parse_document (Recommended)

High-level wrapper: submit a file → poll at intervals → return Markdown. Most single parsing jobs can use this tool. You can override the backend, parsing method, language, formula/table switches, page range, and maximum wait time (default 10 minutes). The execution timeout for this tool in the source code is 900000 milliseconds.

mineru_submit_parse_job

Submit asynchronously and return a task_id immediately. Suitable for large documents, or when you need to submit multiple files in parallel. The tool documentation notes that one PDF page takes approximately 1–2 seconds, and large documents may take several minutes.

mineru_get_parse_status

Query the task status, returning pending / processing / completed / failed. When queued, it may also return queued_ahead.

mineru_get_parse_result

Retrieve the result of a completed task. Markdown is returned inline; if it exceeds maxMdOutputChars (default 200,000 characters), it will be truncated, and the full text will be written to a temporary file; the complete structured JSON is always written to raw_result_path, which can be viewed using a file reading tool.

mineru_health

No parameters. Checks whether the service is healthy, as well as its version, queue depth and maximum concurrency, suitable for a pre-flight check before batch tasks.

Configurable Parsing Defaults¶

Configure them in the DSH GUI settings page or cordis.patch.yml, with fields subject to the repository README:

The first-time startup seed for cordis.patch.yml is:

- insert:
  - id: dsh-mineru
    name: '@huanlin/dsh-plugin-mineru'
    config:
      baseURL: 'http://localhost:18000'

This is only the plugin’s own seed value. The official MinerU documentation uses port 8000 for the mineru-api example (mineru-api --host 0.0.0.0 --port 8000), and the Docker Compose api profile also maps port 8000. After installing the plugin, you must change the baseURL in the GUI to your actual deployed address, do not assume that 18000 is the port MinerU is listening on by default.

Installation and Enablement¶

The installation command given on the directory page is as follows, run it in the DeepSeek Harness terminal:

dsh plugin add github:HuanLinOTO/dsh-plugin-mineru

For reproducible installations, the directory page specifies using a fixed commit hash:

dsh plugin add github:HuanLinOTO/dsh-plugin-mineru#commit

Replace #commit with the specific hash. The repository README also currently recommends installing from npm and specifying the web profile (the settings page uses the Web UI):

dsh plugin --profile web add @huanlin/dsh-plugin-mineru

The README for version 0.2.2 on npm still mentions installing from git; the GitHub master branch had a push on 2026-08-15, which is later than the npm release time, so please refer to the repository README and directory page as the authoritative source.

If you use git installation and pnpm ≥ 10, the README requires allowing builds in the corresponding profile’s pnpm-workspace.yaml:

allowBuilds:
  '@huanlin/dsh-plugin-mineru': true

Example local development installation (modify the path according to your checkout location):

dsh plugin --profile web add link:D:\Projects\deepseek-harness\dsh-mineru

The directory page reminds you: the plugin runs with the permissions of the current dsh process, and may execute code during installation. You should check the source code repository and license before installing.

Before enabling the plugin, you need an accessible MinerU instance. The official quick start command is:

mineru-api --host 0.0.0.0 --port 8000

You can open http://127.0.0.1:8000/docs in your browser to view the API documentation. The plugin will not help you pull models, install GPU drivers or select a backend — all of these are handled on the MinerU side.

Typical Usage¶

Below is a reproducible workflow based on the official tool documentation, without additional fabricated conversation logs.

1. Update baseURL

After starting MinerU, override baseURL in the MinerU settings in the DSH GUI. If the service is listening on the official example port, it should look like:

http://127.0.0.1:8000

Test instances usually do not require an API key. If your gateway requires authentication, place the key in the environment variable or credential reference specified by MINERU_API_KEY.

2. Perform a health check first

Ask the model to call mineru_health. Under normal circumstances, it should return healthy, along with the version, number of queued/processing tasks and maximum concurrency. Check the capacity before submitting batch files to avoid overloading the queue.

3. Daily use: Complete parsing in one command

Pass the local file path to the agent, for example docs/paper.pdf in the workspace. The model should call mineru_parse_document, with the required parameter file_path. Common optional parameters:
- backend: Defaults to pipeline (the tool documentation notes it is hallucination-free and multi-lingual). hybrid-engine requires a VLM; CPU-only services should continue to use pipeline.
- parse_method: auto / txt / ocr (valid for pipeline / hybrid backends).
- lang_list: Only valid for the pipeline backend, defaults to ['ch']; ignored by VLM / hybrid backends.
- formula_enable / table_enable: Both default to true.
- start_page_id / end_page_id: PDF page numbers, counted from 0; end_page_id defaults to 99999 (meaning go to the end of the document as much as possible), not the literal “last page”.
- poll_timeout_ms: Modify this only if you cannot wait the default 10 minutes.

The md_content in the return value is the Markdown for the model to summarize, extract excerpts from, or cross-reference with code. The quality of restored formulas and tables depends on the MinerU backend, not this HTTP wrapper layer.

4. Large files or batches: Split into submit / poll / retrieve result

The workflow is clearly described in the README and tool descriptions:
1. Submit with mineru_submit_parse_job and get a task_id
2. Poll with mineru_get_parse_status until the status becomes completed or failed
3. Retrieve the Markdown with mineru_get_parse_result; the complete JSON is stored at raw_result_path

Tasks are retained on the server for approximately 24 hours, do not reuse old task_ids across sessions repeatedly. The result filename is the stem of the original file with the extension removed, and the file_names in the submission response is the reliable reference.

5. View temporary files when output is too large

The default inline Markdown limit is 200,000 characters. If exceeded, the tool will write the full text to a temporary directory (filename format: mineru-{taskId}.md) and provide the path in the return value. To get intermediate layout results or images, enable return_middle_json / return_content_list / return_images during the submission phase; return_images may return large base64 strings, and the plugin development documentation recommends using zip responses for documents with many images instead of embedding all images inline into the context.

Applicable Scenarios and Notes¶

This plugin is suitable for these scenarios:
- Performing RAG, paper reading, requirement/design document cross-referencing in DeepSeek Harness, where the source materials are PDF or Office files
- Scanned documents, multi-column layouts, documents with formulas or tables that need to be structured before being processed by models
- You have already (or plan to) self-host MinerU and want agents to directly call parsing instead of writing curl polling scripts yourself

Please note the following points, all from the directory page, repository documentation or MinerU documentation, not additional speculation:
1. The plugin is not equal to MinerU. Tool calls will fail without starting mineru-api (or an equivalent HTTP endpoint). GPU setup, model files and backend selection are all handled on the MinerU deployment side.
2. baseURL must match the actual port. The plugin seed is http://localhost:18000, while the official MinerU example uses port 8000. mineru_health will immediately reveal issues if the address is incorrect.
3. Only local paths are accepted. Remote URLs must be downloaded first. The plugin reads these files with the permissions of the current dsh process, meaning any local content accessible to the process may be sent to MinerU.
4. Backend and hardware must match. pipeline is suitable for environments without a VLM; hybrid-engine requires a VLM. lang_list only applies to the pipeline backend.
5. Results will enter the model context. Although超长 Markdown is truncated, the complete JSON is still saved to the temporary file. Do not arbitrarily send directories containing keys or original contract documents to the parsing service, especially when baseURL points to a non-local machine.
6. License is AGPL-3.0. If you modify the plugin and provide services over the network, the terms are stricter than common MIT plugins. You should read the LICENSE file yourself before installing.
7. Security boundary. The directory page notes: the plugin runs with the permissions of the current dsh process, and may execute code during installation. The source code is on GitHub, so you should review it before installing.

Summary¶

dsh-plugin-mineru does not reimplement a PDF parsing system, but connects MinerU’s FastAPI to DeepSeek Harness’s tool layer: use mineru_parse_document for daily tasks, use submit/poll/retrieve for large batches, and manage the API address via the settings page. For people already using dsh who need to turn documents into model-friendly Markdown / JSON, what is often missing is not “writing another prompt”, but this stable HTTP tool layer.

Repository and directory links:
- Community directory: https://deepseek-harness-plugin.com/zh-CN/plugins/dsh-plugin-mineru/
- GitHub: https://github.com/HuanLinOTO/dsh-plugin-mineru
- npm: https://www.npmjs.com/package/@huanlin/dsh-plugin-mineru
- MinerU: https://github.com/opendatalab/MinerU
- DeepSeek Harness: https://github.com/deepseek-ai/deepseek-harness