Instructions to use openbmb/MiniCPM-OCR-Jev-AWQ with libraries, inference providers, notebooks, and local apps. Follow these links to get started.

Libraries

How to use openbmb/MiniCPM-OCR-Jev-AWQ with Transformers:

# Use a pipeline as a high-level helper
from transformers import pipeline

pipe = pipeline("image-text-to-text", model="openbmb/MiniCPM-OCR-Jev-AWQ")
messages = [
    {
        "role": "user",
        "content": [
            {"type": "image", "url": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/p-blog/candy.JPG"},
            {"type": "text", "text": "What animal is on the candy?"}
        ]
    },
]
pipe(text=messages)

# pip install -U transformers accelerate
# Load model directly
from transformers import AutoProcessor, AutoModelForSequenceClassification

processor = AutoProcessor.from_pretrained("openbmb/MiniCPM-OCR-Jev-AWQ")
model = AutoModelForSequenceClassification.from_pretrained("openbmb/MiniCPM-OCR-Jev-AWQ", device_map="auto")
messages = [
    {
        "role": "user",
        "content": [
            {"type": "image", "url": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/p-blog/candy.JPG"},
            {"type": "text", "text": "What animal is on the candy?"}
        ]
    },
]
inputs = processor.apply_chat_template(
	messages,
	add_generation_prompt=True,
	tokenize=True,
	return_dict=True,
	return_tensors="pt",
).to(model.device)

outputs = model.generate(**inputs, max_new_tokens=256)
print(processor.decode(outputs[0][inputs["input_ids"].shape[-1]:]))

Notebooks
Google Colab
Kaggle
Local Apps Settings

vLLM

How to use openbmb/MiniCPM-OCR-Jev-AWQ with vLLM:

Install from pip and serve model

# Install vLLM from pip:
pip install vllm
# Start the vLLM server:
vllm serve "openbmb/MiniCPM-OCR-Jev-AWQ"
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:8000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "openbmb/MiniCPM-OCR-Jev-AWQ",
		"messages": [
			{
				"role": "user",
				"content": [
					{
						"type": "text",
						"text": "Describe this image in one sentence."
					},
					{
						"type": "image_url",
						"image_url": {
							"url": "https://cdn.britannica.com/61/93061-050-99147DCE/Statue-of-Liberty-Island-New-York-Bay.jpg"
						}
					}
				]
			}
		]
	}'

Use Docker

docker model run hf.co/openbmb/MiniCPM-OCR-Jev-AWQ

SGLang

How to use openbmb/MiniCPM-OCR-Jev-AWQ with SGLang:

Install from pip and serve model

# Install SGLang from pip:
pip install sglang
# Start the SGLang server:
python3 -m sglang.launch_server \
    --model-path "openbmb/MiniCPM-OCR-Jev-AWQ" \
    --host 0.0.0.0 \
    --port 30000
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:30000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "openbmb/MiniCPM-OCR-Jev-AWQ",
		"messages": [
			{
				"role": "user",
				"content": [
					{
						"type": "text",
						"text": "Describe this image in one sentence."
					},
					{
						"type": "image_url",
						"image_url": {
							"url": "https://cdn.britannica.com/61/93061-050-99147DCE/Statue-of-Liberty-Island-New-York-Bay.jpg"
						}
					}
				]
			}
		]
	}'

Use Docker images

docker run --gpus all \
    --shm-size 32g \
    -p 30000:30000 \
    -v ~/.cache/huggingface:/root/.cache/huggingface \
    --env "HF_TOKEN=<secret>" \
    --ipc=host \
    lmsysorg/sglang:latest \
    python3 -m sglang.launch_server \
        --model-path "openbmb/MiniCPM-OCR-Jev-AWQ" \
        --host 0.0.0.0 \
        --port 30000
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:30000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "openbmb/MiniCPM-OCR-Jev-AWQ",
		"messages": [
			{
				"role": "user",
				"content": [
					{
						"type": "text",
						"text": "Describe this image in one sentence."
					},
					{
						"type": "image_url",
						"image_url": {
							"url": "https://cdn.britannica.com/61/93061-050-99147DCE/Statue-of-Liberty-Island-New-York-Bay.jpg"
						}
					}
				]
			}
		]
	}'

Docker Model Runner
How to use openbmb/MiniCPM-OCR-Jev-AWQ with Docker Model Runner:
```
docker model run hf.co/openbmb/MiniCPM-OCR-Jev-AWQ
```

GitHub · Usage

This repository hosts the AWQ W4A16 quantized version of MiniCPM-OCR Jev. For the original BF16 weights and the base model card, see openbmb/MiniCPM-OCR-Jev. Everything below describes the model itself; see Quantization for what changed. MiniCPM-OCR Jev (2B) is an OCR quality-assessment model for text, formula, and table regions. Given a region image and a candidate OCR result, it returns a score from 0 to 1 — higher means the candidate is more likely correct.

MiniCPM-OCR Jev

MiniCPM-OCR Jev is a 2B OCR quality-assessment model for text, formula, and table regions. Given a region image and a candidate OCR result, it returns a score from 0 to 1 — higher means the candidate is more likely correct. Use it to auto-accept reliable regions, route the rest to human review, or pick the best result among several OCR models.

🛡️ A small model that beats larger ones: at only 2B parameters, decision AUROC (×100) on JevOCRBench is 93.6, above JEV-35B-A3B (90.1) and close to Qwen3.5-397B-A17B (93.8).
🧩 Stable generalization: on parses from MiniCPM-OCR 1.0, GLM-OCR, PaddleOCR-VL-1.6, and Xiaomi-OCR-0, AUROC (×100) stays in 91.9–93.4.

Architecture

Trained from Qwen3.5-2B. The vision encoder and language backbone are retained, and the language-model output head lm_head is replaced with a binary classification head that learns whether a candidate is correct.

Item	Description
Assessment unit	One text / formula / table region plus its candidate OCR result
Original region image	The crop from the document
Candidate content	OCR text and an image rendered from that text
Output	Score in 0–1; higher = more likely correct

When calling the cloud API, the Docker image, or the SDK service with a built-in renderer, supply the original region image, the candidate text, and the region category (text / formula / table) — the service renders internally. A service without a renderer requires you to supply the rendered image as well.

Evaluation Results

The table below reports overall and per-category AUROC (×100) on JevOCRBench. Higher values indicate better discrimination between correct and incorrect parsing results.

Overall, text, formula, and table AUROC on JevOCRBench, highlighting MiniCPM-OCR Jev.

Discrimination across OCR models

OCR model	MiniCPM-OCR 1.0	GLM-OCR	PaddleOCR-VL-1.6	Xiaomi-OCR-0
AUROC (×100)	92.7	91.9	93.4	93.1

Same 200 samples drawn at random from JevOCRBench; four models parse them independently, every candidate is hand-labelled, then scored by MiniCPM-OCR Jev. Maximum gap 1.5 points.

Automatic screening to reduce human review

Score the parsed result for each region and choose a threshold using samples from your application. Results above the threshold proceed automatically; the rest go to human review. A higher threshold typically reduces the number of results that pass automatically, so monitor both the accuracy of automatically accepted results and the volume of human review.

Accuracy versus review-free rate for legal documents, financial receipts, and complex documents.

Selecting across models to improve parsing quality

Use the same layout segmentation to have several OCR models parse each region. MiniCPM-OCR Jev scores the candidates for the same region, selects the highest-scoring candidate, and combines the selected results in reading order. If all candidates fall below the application threshold, the region can still be sent for human review.

Parsing-quality gains from MiniCPM-OCR Jev scoring for MiniCPM-OCR 1.0, Xiaomi OCR, and PaddleOCR-VL 1.6.

Candidates for the same region must share the crop and content boundaries. Jev selects among existing candidates, so quality is bounded by their coverage and correctness.

Examples

The figure below compares the original image with candidates 1 and 2, showing how MiniCPM-OCR Jev scores text, formula, and table candidates.

Three examples for text, formulas, and tables: original, candidate 1 and candidate 2, with MiniCPM-OCR Jev scores.

Quick start

Deployment	Guide
Cloud API	Single-candidate scoring, best-of-N, batched best-of-N (stub — being written)
Docker / local SDK	Environment, rendering options, service startup
vLLM backend	Service configuration with and without a renderer
SGLang	Deployment guide
llama.cpp	GGUF deployment guide
Ollama	Deployment guide
FlagOS (multi-chip)	Deployment guide

When a service has a built-in renderer (cloud API, Docker, SDK), check verdict before using the score — only scored means model scoring actually ran. Fixed values returned for precheck, rendering, or forward-pass failures must not be read as low model scores.

Pipeline integration

Keep page/region ids, original region images, region categories, and candidate text while parsing.
Submit image + category + candidate text (renderer service), or image + rendered image (renderer-less service).
Check status, associate scores with candidates, apply your threshold, and compare candidates within each region when several models are in play.
Emit selected results in the original reading order and keep pending regions for reviewers.

Use score for one candidate, score_best for best-of-N within a block, and score_best_batch across blocks — see the API documentation (stub for now; until it lands use the vLLM deploy guide for Jev).

Fine-tuning

ms-swift guide: data format, binary classification head configuration, training commands, and JevOCRBench evaluation.

Quantization

Field	Value
Format	`compressed-tensors`, `pack-quantized`
Weight bits	4
Group size	128
Activations	BF16 (W4A16)
Tool	llm-compressor
Recipe	`recipe.yaml` (kept in this repository)

Weight footprint drops from about 4.43 GB (BF16) to about 2.41 GB.

File	Notes
`model.safetensors`	4-bit quantized weights
`config.json`	base config + `quantization_config`
`recipe.yaml`	quantization recipe (AWQ/GPTQ modifiers, layer mappings)
tokenizer / chat template / processor configs	tokenizer and processor configs

The service name and request format are the same as the base model:

vllm serve openbmb/MiniCPM-OCR-Jev-AWQ \
  --served-model-name MiniCPM-OCR-Jev \
  --trust-remote-code

Related checkpoints

Format	Hugging Face	ModelScope
BF16 (original) (this repo)	🤗	ModelScope
GGUF (llama.cpp)	🤗	ModelScope
AWQ W4A16	🤗	ModelScope
GPTQ W4A16	🤗	ModelScope

Jev works on candidates from any parser. The companion parser is MiniCPM-OCR 1.0.

FAQ

Installation, model downloads, GPU memory, input formats, and unexpected outputs: FAQ.

License

Model weights, code, and documentation are released under the Apache License 2.0.

Downloads last month: 756

Safetensors

Model size

2B params

Tensor type

I32

BF16

Model tree for openbmb/MiniCPM-OCR-Jev-AWQ

Base model

Qwen/Qwen3.5-2B-Base

Finetuned

Qwen/Qwen3.5-2B

Finetuned

openbmb/MiniCPM-OCR-Jev

Quantized

(4)

this model

Collection including openbmb/MiniCPM-OCR-Jev-AWQ

MiniCPM-OCR

Collection

Fast, accurate OCR with correctness assessment. • 10 items • Updated 5 days ago • 18