MinerU Administrator & Developer Guide

This guide is for operators, integrators, and developers running MinerU in production or embedding it into a larger pipeline. It covers the full system architecture, every configuration knob, deployment topologies, security posture, performance tuning, code internals, and integration points.

For end-user usage, parsing recipes, and CLI quick-start, see the MinerU User Guide.

1. Architecture Overview

MinerU is a self-contained document-parsing engine that converts PDFs, images, and Office files (DOCX, PPTX, XLSX) into structured Markdown and JSON. The system is organized into three distinct layers, each with clear responsibilities.

1.1 Three-Layer Architecture

┌─────────────────────────────────────────────────────────────┐
│                      CLI / API Layer                        │
│  mineru (client.py)  │  mineru-api (fast_api.py)            │
│  mineru-gradio       │  mineru-router (router.py)           │
│  mineru-openai-server│  download-models                     │
├─────────────────────────────────────────────────────────────┤
│                     Backend Layer                           │
│  Pipeline Backend    │  VLM Backend    │  Hybrid Backend    │
│  (OCR + layout +     │  (vision-lang   │  (pipeline + VLM   │
│   formula + table)   │   model direct) │   combined)        │
│                      │                 │                    │
│  Office Backend (DOCX / PPTX / XLSX)                       │
├─────────────────────────────────────────────────────────────┤
│                      Model Layer                            │
│  Layout (DocLayoutV2)  │  OCR (PytorchPaddle)               │
│  Formula (Unimernet/FormulaNet+)  │  Table (SLANet+/UNet)  │
│  VLM (vLLM/LMDeploy)  │  Orientation Classification        │
│  Office Converters (DOCX/PPTX/XLSX)                        │
├─────────────────────────────────────────────────────────────┤
│                   Support Modules                           │
│  utils/ (31 modules)  │  data/ (I/O abstraction)           │
│  resources/ (static assets, language model)                 │
└─────────────────────────────────────────────────────────────┘

1.2 Layer Responsibilities

CLI / API Layer (mineru/cli/): All user-facing entry points. The main mineru CLI command handles local and API-based parsing. mineru-api exposes a FastAPI server for programmatic access. mineru-router provides load balancing across multiple API instances. mineru-gradio offers a browser-based UI. mineru-openai-server exposes a VLM endpoint with OpenAI-compatible protocol.

Backend Layer (mineru/backend/): Processing pipelines that orchestrate model inference:

Model Layer (mineru/model/): Thin wrappers around deep learning models. Each model type has its own subdirectory with initialization, inference, and post-processing logic.

1.3 Key Design Decisions

• Filesystem-only state: No database. Jobs, outputs, and configuration all live on the filesystem.
• Singleton model loading: ModelSingleton ensures each ML model is loaded exactly once per process, preventing VRAM waste.
• Protocol versioning: API_PROTOCOL_VERSION constant in api_protocol.py ensures client/server compatibility. Mismatched versions raise explicit errors.
• Atomic task management: AsyncTaskManager handles concurrent parse requests with thread-safe task tracking.

1.4 Processing Pipeline Flow

The pipeline backend (the most complex path) processes documents through these stages:

Input (PDF/Image)
    │
    ▼
PDF Classification ─── auto-detect "txt" vs "ocr" method
    │                   (pdf_classify.py)
    ▼
Page Rendering ──────── PDF pages → images via pypdfium2
    │                   (pdf_image_tools.py)
    ▼
Batch Analysis ──────── All models run in batched inference
    │                   (batch_analyze.py)
    │
    ├── Layout Detection (DocLayoutV2)
    │       → region classification
    ├── OCR Text Extraction (PytorchPaddle)
    ├── Formula Recognition (Unimernet/FormulaNet+)
    ├── Table Detection
    │       ├── Wireless tables (SLANet+)
    │       ├── Wired tables (UNet)
    │       └── Table classification fallback
    └── Orientation Classification
    │
    ▼
MagicModel ──────────── Post-processing, 25+ methods
    │                   (pipeline_magic_model.py)
    ▼
Model JSON → Middle JSON conversion
    │   (model_json_to_middle_json.py)
    ▼
Paragraph Splitting ─── (para_split.py)
    │
    ▼
Table Merging ───────── Cross-page table merging
    │                   (table_merge.py)
    ▼
Content Generation ──── Markdown + content_list output
                        (pipeline_middle_json_mkcontent.py)

Note

The VLM and hybrid backends skip most of these steps. VLM sends page images directly to a vision-language model. Hybrid combines both approaches, using pipeline for structure and VLM for content enhancement.

2. System Requirements

2.1 Hardware Requirements

Important

GPU is strongly recommended for production use. Without GPU acceleration, the pipeline backend falls back to CPU inference, which is dramatically slower. The MINERU_DEVICE_MODE environment variable controls device selection.

2.2 Software Requirements

2.3 Supported Accelerator Platforms

MinerU provides dedicated Dockerfiles for each platform:

China-specific variants (with _cn suffix) use domestic mirror sources.

3. Configuration Reference

3.1 Configuration File: mineru.json

Located by default at ~/mineru.json, overridden by the MINERU_TOOLS_CONFIG_JSON environment variable. The configuration reader is in mineru/utils/config_reader.py.

{
    "bucket_info": {
        "bucket-name-1": ["access_key", "secret_key", "endpoint"]
    },
    "latex-delimiter-config": {
        "display": {"left": "$$", "right": "$$"},
        "inline": {"left": "$", "right": "$"}
    },
    "llm-aided-config": {
        "title_aided": {
            "api_key": "your_api_key",
            "base_url": "https://dashscope.aliyuncs.com/compatible-mode/v1",
            "model": "qwen3.5-plus",
            "enable_thinking": false,
            "enable": false
        }
    },
    "models-dir": {
        "pipeline": "",
        "vlm": ""
    },
    "config_version": "1.3.1"
}

Field reference:

3.2 Environment Variables — Complete Reference

All 24 environment variables extracted from source, grouped by function:

Core Runtime

Feature Toggles

API Server

Router / Load Balancer

Model & Performance

PDF Rendering

External

Tip

For production deployments, always set MINERU_API_OUTPUT_ROOT to a persistent directory. Without it, outputs go to a temporary directory that may be cleaned up by the OS.

3.3 Key Constants

These constants are defined in source and affect system behavior:

4. Deployment & Scaling

4.1 Docker Deployment

MinerU provides a compose.yaml with four profiles:

Warning

All Docker profiles require NVIDIA GPU with the NVIDIA Container Toolkit installed. The containers will fail to start without GPU access.

Starting the API server:

docker compose --profile api up -d

Starting the router with multiple GPUs:

docker compose --profile router up -d

Starting the Gradio UI:

docker compose --profile gradio up -d

4.2 Bare-Metal Deployment

# Install MinerU
pip install mineru

# Download models
download-models -s huggingface

# Start API server
mineru-api --host 0.0.0.0 --port 8000

Caution

When binding to 0.0.0.0, the --allow-public-http-client flag must be passed explicitly. Without it, the server enforces public_http_client_policy.py restrictions that block non-localhost connections. This is a deliberate security measure.

4.3 Multi-GPU Scaling with Router

The router (mineru-router) distributes parse requests across multiple API server instances:

# Option 1: Explicit upstream URLs
mineru-router --host 0.0.0.0 --port 8002 \
  --upstream-url http://gpu1:8000 \
  --upstream-url http://gpu2:8000 \
  --upstream-url http://gpu3:8000

# Option 2: Auto-spawn workers on local GPUs
mineru-router --host 0.0.0.0 --port 8002 \
  --local-gpus 0,1,2,3

Router architecture:

Client Request
    │
    ▼
┌──────────────────┐
│  mineru-router    │  Port 8002
│  (RouterSettings) │
│  (WorkerPool)     │
│  (RouterTaskRegistry)│
├──────────────────┤
│  Load Balancing   │
│  (round-robin)    │
└──┬───┬───┬───────┘
   │   │   │
   ▼   ▼   ▼
┌────┐┌────┐┌────┐
│GPU0││GPU1││GPU2│  mineru-api instances
│:8000│:8001│:8002│
└────┘└────┘└────┘

Key classes in the router:

4.4 VLM Preloading

For backends using VLM models, preloading prevents cold-start latency:

# API server with VLM preloading
mineru-api --host 0.0.0.0 --port 8000 --enable-vlm-preload

# Router with VLM preloading on workers
mineru-router --host 0.0.0.0 --port 8002 \
  --local-gpus 0,1 --enable-vlm-preload

The vlm_preload.py module handles model warmup during server startup rather than on first request.

5. Operations

5.1 API Endpoints — Complete Reference

FastAPI Server (mineru-api)

Synchronous parse (POST /file_parse):

curl -X POST http://localhost:8000/file_parse \
  -F "file=@document.pdf" \
  -F "method=auto" \
  -F "backend=hybrid-auto-engine"

Async parse workflow:

# 1. Submit task
TASK_ID=$(curl -s -X POST http://localhost:8000/submit_parse_task \
  -F "file=@document.pdf" | jq -r '.task_id')

# 2. Poll status (repeats every 1 second)
curl -s "http://localhost:8000/get_async_task_status?task_id=$TASK_ID"

# 3. Get result when complete
curl -s "http://localhost:8000/get_async_task_result?task_id=$TASK_ID"

Router (mineru-router)

5.2 CLI Command Reference (Server-Side)

mineru-api — FastAPI Server

mineru-api [OPTIONS]

mineru-router — Load Balancer

mineru-router [OPTIONS]

mineru-openai-server — VLM Server

mineru-openai-server [OPTIONS]

download-models — Model Downloader

download-models [OPTIONS]

5.3 Logging

MinerU uses loguru for structured logging throughout the codebase.

Log level control:

# Via environment variable
export MINERU_LOG_LEVEL=DEBUG
mineru-api --host 0.0.0.0 --port 8000

Valid levels: DEBUG, INFO, WARNING, ERROR, CRITICAL.

Access log suppression:

When the CLI spawns a local API server, it sets MINERU_API_DISABLE_ACCESS_LOG internally to reduce noise. For production deployments where you manage the API server directly, access logs are enabled by default.

5.4 Health Checks

The /health endpoint on both the API server and router returns server status:

# API server health
curl http://localhost:8000/health

# Router health (includes upstream worker status)
curl http://localhost:8002/health

Tip

Use the health endpoint in container orchestration (Docker health checks, Kubernetes liveness probes). The endpoint verifies model readiness, not just HTTP responsiveness.

5.5 Model Management

Downloading models:

# From Hugging Face (default)
download-models -s huggingface

# From ModelScope (faster in China)
export MINERU_MODEL_SOURCE=modelscope
download-models -s modelscope

Custom model directories:

Set in mineru.json:

{
    "models-dir": {
        "pipeline": "/opt/models/pipeline",
        "vlm": "/opt/models/vlm"
    }
}

Model singleton behavior:

The ModelSingleton class in mineru/backend/pipeline/model_init.py ensures each model type is loaded exactly once. Models are loaded lazily on first use unless VLM preloading is enabled. The AtomicModel enum defines all model types:

6. Performance

6.1 Batch Size Tuning

Model inference uses batched processing. Base batch sizes scale with available VRAM:

VRAM override:

# Force VRAM size detection (MB)
export MINERU_VIRTUAL_VRAM_SIZE=8192

The model_utils.py module manages VRAM detection and batch size calculation.

6.2 Processing Window

The MINERU_PROCESSING_WINDOW_SIZE variable controls how many pages are processed in each batch window. Larger windows improve throughput on long documents but increase peak memory usage.

6.3 PDF Rendering Performance

# Set render timeout per page (seconds)
export MINERU_PDF_RENDER_TIMEOUT=30

# Parallel rendering threads
export MINERU_PDF_RENDER_THREADS=4

The pdf_image_tools.py module uses pypdfium2 for PDF-to-image conversion. Thread count defaults to a system-appropriate value when unset.

6.4 Concurrent Request Limiting

# Limit API server to 4 concurrent parse requests
export MINERU_API_MAX_CONCURRENT_REQUESTS=4

Without this limit, the server accepts all incoming requests, which can exhaust GPU memory.

6.5 Table Merging

Cross-page table merging (table_merge.py) detects tables that span page boundaries and stitches them together. This adds post-processing time proportional to the number of tables detected.

# Disable if not needed (slight speedup on table-heavy documents)
export MINERU_TABLE_MERGE_ENABLE=false

The TableMergeState class tracks merge state across pages.

6.6 Multi-GPU Throughput

For maximum throughput, deploy one mineru-api instance per GPU behind a mineru-router:

# 4-GPU setup
mineru-router --port 8002 --local-gpus 0,1,2,3

Each worker gets exclusive access to one GPU via CUDA_VISIBLE_DEVICES isolation. The router distributes requests across workers.

7. Security

7.1 Network Security

Public binding protection:

The public_http_client_policy.py module enforces a security policy when the API server binds to non-localhost addresses. Without the explicit --allow-public-http-client flag, the server rejects requests from external IPs.

# Secure: localhost only (default)
mineru-api --host 127.0.0.1 --port 8000

# Explicit public access (requires flag)
mineru-api --host 0.0.0.0 --port 8000 --allow-public-http-client

Warning

MinerU's API endpoints have no authentication. When exposing publicly, place the server behind a reverse proxy with authentication (e.g., nginx with basic auth, Traefik with middleware, or an API gateway).

7.2 Authentication

MinerU does not implement authentication or authorization at the application level. All API endpoints are unauthenticated. For production deployments:

• Use a reverse proxy with authentication
• Restrict network access via firewall rules
• Use Docker network isolation
• Consider VPN-only access for internal services

7.3 S3 Credential Handling

S3 credentials in mineru.json are stored as plaintext. The bucket_info field maps bucket names to credential arrays:

{
    "bucket_info": {
        "my-bucket": ["ACCESS_KEY", "SECRET_KEY", "https://s3.endpoint.com"]
    }
}

Caution

Protect mineru.json with appropriate file permissions (chmod 600) when it contains S3 credentials. Do not commit credentials to version control.

7.4 LLM API Key Handling

The llm-aided-config section stores API keys for LLM-assisted title extraction. Same plaintext storage concern as S3 credentials.

7.5 Input Validation

The system validates inputs at multiple points:

• File type validation: only PDF, DOCX, PPTX, XLSX, and image formats accepted
• Page range validation: --start and --end flags are bounds-checked
• URL validation: --url inputs are validated before fetching
• File size: implicitly limited by FastAPI's upload handling

7.6 Managed Server Lifecycle

The ReusableLocalAPIServer and LocalAPIServer classes in api_client.py spawn child API server processes. The MINERU_API_SHUTDOWN_ON_STDIN_EOF mechanism ensures child servers terminate when the parent process exits, preventing orphaned GPU-consuming processes.

8. Developer Internals

8.1 Module Reference

Core Engine (mineru/backend/pipeline/)

CLI Layer (mineru/cli/)

Model Layer (mineru/model/)

Data I/O (mineru/data/)

Exception classes in mineru/data/utils/:

Utilities (mineru/utils/ — 31 modules)

8.2 Key Enums and Types

class AtomicModel(Enum):
    Layout = "layout"
    MFD = "mfd"
    MFR = "mfr"
    OCR = "ocr"
    WirelessTable = "wireless_table"
    WiredTable = "wired_table"
    TableCls = "table_cls"
    ImgOrientationCls = "img_orientation_cls"

class BlockType:       # Layout block classification
class ContentType:     # Output content types (v1)
class ContentTypeV2:   # Output content types (v2)
class MakeMode:        # Markdown generation mode
class ModelPath:       # Model weight paths
class SplitFlag:       # Paragraph split markers
class ImageType:       # Image format types
class NotExtractType:  # Regions to skip during extraction

8.3 Code Patterns and Conventions

Singleton pattern for models:

class ModelSingleton:
    _instance = None
    _models = {}

    def __new__(cls):
        if cls._instance is None:
            cls._instance = super().__new__(cls)
        return cls._instance

All model loading goes through ModelSingleton to prevent duplicate VRAM allocation.

Backend dispatch:

The common.py module dispatches to the appropriate backend based on the --backend CLI flag:

Async task lifecycle:

class AsyncTaskManager:
    # Thread-safe task registry
    # submit_task() → task_id
    # get_status(task_id) → status dict
    # get_result(task_id) → output data

Tasks follow: submitted → processing → completed | failed.

Data I/O abstraction:

All file operations go through data_reader_writer/ classes, allowing transparent switching between local filesystem and S3 storage. The S3Config class validates bucket credentials from mineru.json.

8.4 Repository Structure

mineru/
├── __init__.py
├── version.py                     # __version__ = "3.1.0"
├── cli/
│   ├── api_client.py              # HTTP client + local server management
│   ├── api_protocol.py            # API_PROTOCOL_VERSION
│   ├── client.py                  # Main `mineru` CLI (1091+ lines)
│   ├── common.py                  # Shared parse logic, backend dispatch
│   ├── fast_api.py                # FastAPI server (1563+ lines)
│   ├── gradio_app.py              # Gradio web UI (1079+ lines)
│   ├── models_download.py         # download-models CLI
│   ├── output_paths.py            # Output path resolution
│   ├── public_http_client_policy.py # Public binding security
│   ├── router.py                  # Load balancing router (1465+ lines)
│   ├── visualization.py           # Layout visualization
│   ├── vlm_preload.py             # VLM model preloading
│   └── vlm_server.py              # OpenAI-compatible VLM server
├── backend/
│   ├── pipeline/                  # Traditional OCR pipeline
│   │   ├── batch_analyze.py       # Batched model inference
│   │   ├── model_init.py          # ModelSingleton initialization
│   │   ├── model_json_to_middle_json.py
│   │   ├── model_list.py          # AtomicModel enum
│   │   ├── para_split.py          # Paragraph splitting
│   │   ├── pipeline_analyze.py    # Main pipeline entry
│   │   ├── pipeline_magic_model.py # MagicModel (25+ methods)
│   │   └── pipeline_middle_json_mkcontent.py
│   ├── vlm/                       # VLM-based parsing
│   ├── hybrid/                    # Hybrid pipeline+VLM
│   ├── office/                    # Office document parsing
│   └── utils/                     # Backend utilities
├── model/
│   ├── layout/                    # DocLayoutV2
│   ├── ocr/                       # PytorchPaddle OCR
│   ├── mfr/                       # Math formula recognition
│   ├── table/                     # Table recognition
│   ├── ori_cls/                   # Orientation classification
│   ├── vlm/                       # VLM model integration
│   ├── docx/                      # DocxConverter
│   ├── pptx/                      # PptxConverter
│   └── xlsx/                      # XlsxConverter
├── data/
│   ├── data_reader_writer/        # File I/O (local, S3)
│   ├── io/                        # Input readers (HTTP, S3)
│   └── utils/                     # Exceptions, schemas
├── utils/                         # 31 utility modules
│   ├── config_reader.py
│   ├── pdf_classify.py
│   ├── pdf_image_tools.py
│   ├── table_merge.py
│   ├── ocr_utils.py
│   ├── model_utils.py
│   ├── models_download_utils.py
│   └── ...
└── resources/
    ├── header.html
    └── fasttext-langdetect/lid.176.ftz

8.5 Testing

Tests are located in tests/unittest/. The test_e2e.py file contains end-to-end tests that exercise the full pipeline from input to output.

9. Integration Points

9.1 S3 Storage Integration

MinerU supports S3-compatible storage for both input and output:

{
    "bucket_info": {
        "my-input-bucket": ["ACCESS_KEY", "SECRET_KEY", "https://s3.amazonaws.com"],
        "my-output-bucket": ["ACCESS_KEY", "SECRET_KEY", "https://s3.amazonaws.com"]
    }
}

The MultiBucketS3 reader/writer supports multiple buckets with different credentials. Input files can be read directly from S3, and output can be written back to S3.

9.2 HTTP Input

Documents can be fetched from URLs for parsing:

mineru -u https://example.com/document.pdf -o ./output

The data/io/ module handles HTTP fetching with appropriate timeout and error handling.

9.3 LLM-Assisted Processing

The llm-aided-config section enables LLM-assisted title extraction:

{
    "llm-aided-config": {
        "title_aided": {
            "api_key": "your_api_key",
            "base_url": "https://dashscope.aliyuncs.com/compatible-mode/v1",
            "model": "qwen3.5-plus",
            "enable_thinking": false,
            "enable": true
        }
    }
}

When enabled, ambiguous titles detected during layout analysis are sent to the configured LLM for disambiguation.

9.4 VLM Server Integration

The mineru-openai-server command exposes a VLM endpoint compatible with the OpenAI API format:

# Start VLM server with vLLM engine
mineru-openai-server -e vllm

# Or with LMDeploy engine
mineru-openai-server -e lmdeploy

This allows MinerU's VLM capabilities to be consumed by any OpenAI-compatible client.

9.5 Programmatic Python API

from mineru.backend.pipeline.pipeline_analyze import pipeline_analyze
from mineru.backend.vlm import vlm_analyze
from mineru.backend.hybrid import hybrid_analyze

Direct Python imports bypass the CLI/API layer entirely. This is useful for embedding MinerU into larger Python applications.

9.6 Output Formats

MinerU produces two output types:

The MakeMode enum controls which output format is generated.

10. Troubleshooting

Error: Protocol version mismatch

Cause: Client and server are running different versions of MinerU with incompatible API_PROTOCOL_VERSION values.

Solution: Ensure both mineru CLI client and mineru-api server are the same version:

pip install --upgrade mineru

Prevention: Pin MinerU version in your requirements file and upgrade client and server together.

Error: Timed out while polling task status

Cause: Async task exceeded TASK_RESULT_TIMEOUT_SECONDS (default: 3600 seconds / 1 hour). Common with very large PDFs or underpowered hardware.

Solution:

1. Check GPU utilization — the process may be stuck or OOM
2. Check server logs for errors during processing
3. For large documents, increase the timeout or use page range limiting (--start / --end)

Prevention: Set MINERU_API_MAX_CONCURRENT_REQUESTS to prevent overloading the server.

Error: HybridDependencyError

Cause: The hybrid backend requires both pipeline and VLM dependencies. One or both are missing.

Solution: Install the full dependency set:

pip install mineru[full]

Prevention: Use the pipeline backend if VLM dependencies are unavailable.

Error: CUDA not available / CUDA_NOT_AVAILABLE

Cause: PyTorch cannot find CUDA drivers or GPU hardware.

Solution:

1. Verify NVIDIA drivers: nvidia-smi
2. Verify PyTorch CUDA: python -c "import torch; print(torch.cuda.is_available())"
3. For CPU-only operation: export MINERU_DEVICE_MODE=cpu

Prevention: Use Docker images with pre-configured CUDA support.

Error: Empty PDF / EmptyData

Cause: Input PDF contains no extractable pages or content.

Solution: Verify the PDF is not corrupt and contains actual content. Try opening in a PDF viewer.

Error: Unsupported file suffix

Cause: Input file has an extension not in the supported set (PDF, DOCX, PPTX, XLSX, common image formats).

Solution: Rename the file with the correct extension or convert to a supported format.

Error: Health check failure on startup

Cause: API server failed to become healthy within MINERU_LOCAL_API_STARTUP_TIMEOUT_SECONDS (default: 300 seconds). Usually caused by slow model downloads or loading.

Solution:

# Increase startup timeout
export MINERU_LOCAL_API_STARTUP_TIMEOUT_SECONDS=600

# Pre-download models before starting server
download-models -s huggingface

Prevention: Always run download-models before first server start.

Error: Upstream unavailable/rejected (Router)

Cause: Router cannot reach any upstream API server, or all upstreams are rejecting requests (overloaded).

Solution:

1. Check upstream server health: curl http://upstream:8000/health
2. Check network connectivity between router and upstreams
3. Verify --upstream-url values are correct

Prevention: Monitor upstream health and scale horizontally when load increases.

Note

For issues related to specific document types (Arabic text ordering, image segmentation anomalies, table extraction quality), see the GitHub Issues tracker. Known issues include #2551 (Arabic PDF parsing order), #4008 (image segmentation), and #4207 (table extraction).

11. Quick Reference

Environment Variables Cheat Sheet

# Essential production settings
export MINERU_DEVICE_MODE=cuda
export MINERU_LOG_LEVEL=INFO
export MINERU_API_OUTPUT_ROOT=/data/mineru/output
export MINERU_API_MAX_CONCURRENT_REQUESTS=4
export MINERU_MODEL_SOURCE=huggingface

# Performance tuning
export MINERU_PDF_RENDER_THREADS=4
export MINERU_PDF_RENDER_TIMEOUT=30
export MINERU_VIRTUAL_VRAM_SIZE=8192
export MINERU_PROCESSING_WINDOW_SIZE=10

# Feature flags
export MINERU_FORMULA_ENABLE=true
export MINERU_TABLE_ENABLE=true
export MINERU_TABLE_MERGE_ENABLE=true
export MINERU_FORMULA_CH_SUPPORT=false

# Router settings
export MINERU_ROUTER_LOCAL_GPUS=0,1,2,3
export MINERU_ROUTER_WORKER_HOST=0.0.0.0

Port Reference

Backend Selection Guide

Docker Profiles

docker compose --profile api up -d        # API server
docker compose --profile router up -d     # Load balancer
docker compose --profile gradio up -d     # Web UI
docker compose --profile openai-server up -d  # VLM server