Sync from GitHub via hub-sync

README.md

@@ -117,6 +117,7 @@ _Sorted by model size:_
 | [`dots-mocr.py`](https://huggingface.co/datasets/uv-scripts/ocr/blob/main/dots-mocr.py) | [dots.mocr](https://huggingface.co/rednote-hilab/dots.mocr) | 3B | vLLM | 8 prompt modes incl. SVG generation, layout + bbox, 100+ languages |
 | [`nanonets-ocr2.py`](https://huggingface.co/datasets/uv-scripts/ocr/blob/main/nanonets-ocr2.py) | [Nanonets-OCR2-3B](https://huggingface.co/nanonets/Nanonets-OCR2-3B) | 3B | vLLM | Next-gen, Qwen2.5-VL base. **Pin `--image vllm/vllm-openai:v0.10.2`** (vLLM ≥0.11 breaks Qwen2.5-VL → all `!`) |
 | [`deepseek-ocr-vllm.py`](https://huggingface.co/datasets/uv-scripts/ocr/blob/main/deepseek-ocr-vllm.py) | [DeepSeek-OCR](https://huggingface.co/deepseek-ai/DeepSeek-OCR) | 4B | vLLM | 5 resolution + 5 prompt modes |
+| [`jina-ocr-v1.py`](https://huggingface.co/datasets/uv-scripts/ocr/blob/main/jina-ocr-v1.py) | [jina-ocr-v1](https://huggingface.co/jinaai/jina-ocr-v1) | 3.4B MoE (~570M active) | vLLM | DeepSeek-OCR fine-tune + FastMTP speculative decoding (`--spec 0` to disable) and an n-gram repetition stop. Card: 91.14 OmniDocBench v1.6, **83.4 olmOCR-Bench**. Offline vLLM only. **CC-BY-NC-4.0** |
 | [`deepseek-ocr.py`](https://huggingface.co/datasets/uv-scripts/ocr/blob/main/deepseek-ocr.py) | [DeepSeek-OCR](https://huggingface.co/deepseek-ai/DeepSeek-OCR) | 4B | Transformers | Same model, Transformers backend |
 | [`deepseek-ocr2-vllm.py`](https://huggingface.co/datasets/uv-scripts/ocr/blob/main/deepseek-ocr2-vllm.py) | [DeepSeek-OCR-2](https://huggingface.co/deepseek-ai/DeepSeek-OCR-2) | 3B | vLLM | Newer; needs nightly vLLM **+ the `vllm/vllm-openai` image** ([why](#if-a-vllm-script-crashes-at-startup-the-nvcc--nvrtc-error)) |
 | [`unlimited-ocr-vllm.py`](https://huggingface.co/datasets/uv-scripts/ocr/blob/main/unlimited-ocr-vllm.py) | [Unlimited-OCR](https://huggingface.co/baidu/Unlimited-OCR) | 3.3B | vLLM | DeepSeek-OCR-based; layout-grounded markdown (`--strip-grounding` for clean text). Single-image batch — needs Baidu's **dedicated `vllm/vllm-openai:unlimited-ocr` image** (`-cu129` on Hopper). Multi-page "long-horizon" parsing → serve it ([doc](serving-unlimited-ocr.md)); both engines do clean docs, **SGLang more robust** on hard scans. MIT |

jina-ocr-v1.py

@@ -0,0 +1,377 @@
+# /// script
+# requires-python = ">=3.11"
+# dependencies = [
+#     "datasets>=4.0.0",
+#     "huggingface-hub",
+#     "pillow",
+#     "vllm>=0.21",
+#     "tqdm",
+#     "toolz",
+#     "torch",
+# ]
+#
+# [tool.hf-jobs]
+# flavor = "a10g-small"
+# secrets = ["HF_TOKEN"]
+# env = { UV_TORCH_BACKEND = "auto" }
+# ///
+
+"""
+Convert document images to markdown using jina-ocr-v1 with vLLM (offline batch).
+
+jina-ocr-v1 (Jina AI, 2026-09) is a DeepSeek-OCR fine-tune: the DeepEncoder vision
+tower plus a 3B mixture-of-experts decoder with ~570M active parameters, and a
+FastMTP speculative-decoding head (one draft block reused for K=3 steps). The
+card reports 91.14 on OmniDocBench v1.6 and 83.4 on olmOCR-Bench. Licence:
+CC-BY-NC-4.0 (non-commercial).
+
+The model ships its own vLLM glue in the checkpoint (`deepseek_ocr_mtp.py`):
+architecture registration, the speculative config, and an n-gram repetition
+stop built on vLLM's own `repetition_detection`. This recipe follows the card's
+offline pattern exactly: put the snapshot on the import path, `register()`
+once, then `LLM(**vllm_llm_kwargs(...))` and `llm.chat(...)`.
+
+Run on HF Jobs (hardware and the HF_TOKEN secret come from the script's
+[tool.hf-jobs] header; `hf` CLI 1.32+):
+
+  hf jobs uv run https://huggingface.co/datasets/uv-scripts/ocr/raw/main/jina-ocr-v1.py \\
+      <input-dataset> <output-dataset>
+
+Notes:
+- `--spec 0` disables speculative decoding (A/B it: FastMTP is a latency trick
+  that helps most at low concurrency; at batch 16 the gain may be small).
+- `--no-repetition-stop` disables the card's n-gram stop.
+- Uses vLLM from PyPI on the default uv image; the first run spends a few
+  minutes installing it. `--image vllm/vllm-openai:<tag>` skips that.
+
+Model: jinaai/jina-ocr-v1
+"""
+
+import argparse
+import io
+import json
+import logging
+import os
+import sys
+from datetime import datetime
+from typing import Any, Dict, Union
+
+from datasets import load_dataset
+from huggingface_hub import DatasetCard, login, snapshot_download
+from PIL import Image
+from toolz import partition_all
+from tqdm.auto import tqdm
+
+# The default uv-script image has no nvcc; vLLM's FlashInfer sampler would JIT a
+# kernel and crash engine init. Greedy OCR does not need it. No-op on vllm images.
+os.environ.setdefault("VLLM_USE_FLASHINFER_SAMPLER", "0")
+# register() adds architectures to this process's ModelRegistry; the engine worker only
+# sees them if it is forked, not spawned. Nothing below initialises CUDA before LLM().
+os.environ.setdefault("VLLM_WORKER_MULTIPROC_METHOD", "fork")
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+MODEL_ID = "jinaai/jina-ocr-v1"
+SCRIPT_NAME = "jina-ocr-v1.py"
+SCRIPT_URL = f"https://huggingface.co/datasets/uv-scripts/ocr/raw/main/{SCRIPT_NAME}"
+
+
+def check_cuda_availability():
+    """GPU check WITHOUT initialising CUDA in this process.
+
+    torch.cuda.is_available() would initialise CUDA here, and vLLM then forces the
+    `spawn` start method for its engine worker. A spawned worker does not inherit the
+    ModelRegistry entries that register() adds in this process, so the custom
+    architecture is "not supported" in the worker (seen on the first smoke run).
+    nvidia-smi answers the same question with no CUDA context.
+    """
+    import shutil
+    import subprocess
+
+    if shutil.which("nvidia-smi") is None:
+        logger.error("nvidia-smi not found. This script requires a GPU.")
+        sys.exit(1)
+    try:
+        out = subprocess.run(["nvidia-smi", "--query-gpu=name", "--format=csv,noheader"],
+                             capture_output=True, text=True, timeout=30, check=True).stdout.strip()
+    except (subprocess.CalledProcessError, subprocess.TimeoutExpired) as e:
+        logger.error(f"nvidia-smi failed: {e}. This script requires a GPU.")
+        sys.exit(1)
+    logger.info(f"GPU: {out.splitlines()[0] if out else 'unknown'}")
+
+
+def ensure_output_columns_free(dataset, columns, overwrite=False):
+    """Fail fast if an output column would overwrite an existing input column."""
+    clash = [c for c in columns if c in dataset.column_names]
+    if not clash:
+        return dataset
+    if overwrite:
+        logger.warning(f"--overwrite: replacing existing column(s) {clash}")
+        return dataset.remove_columns(clash)
+    logger.error(f"Output column(s) {clash} already exist in the input dataset (columns: {dataset.column_names}).")
+    logger.error("Choose a different --output-column, or pass --overwrite to replace them.")
+    sys.exit(1)
+
+
+def to_pil(image: Union[Image.Image, Dict[str, Any], str]) -> Image.Image:
+    if isinstance(image, Image.Image):
+        return image
+    if isinstance(image, dict) and "bytes" in image:
+        return Image.open(io.BytesIO(image["bytes"]))
+    if isinstance(image, str):
+        return Image.open(image)
+    raise ValueError(f"Unsupported image type: {type(image)}")
+
+
+def load_model_glue(revision: str | None):
+    """Download the checkpoint and import its vLLM helpers.
+
+    vLLM v1 starts its engine core as a *spawned* process, which does not inherit
+    sys.path edits, so the snapshot directory also goes into PYTHONPATH before LLM()
+    is created. The architecture override points at `deepseek_ocr_mtp`, which the
+    worker must be able to import.
+    """
+    snapshot = snapshot_download(MODEL_ID, revision=revision)
+    os.environ["PYTHONPATH"] = snapshot + os.pathsep + os.environ.get("PYTHONPATH", "")
+    sys.path.insert(0, snapshot)
+    import deepseek_ocr_mtp  # noqa: E402  (lives in the checkpoint)
+
+    return snapshot, deepseek_ocr_mtp
+
+
+def create_dataset_card(
+    source_dataset: str,
+    num_samples: int,
+    processing_time: str,
+    batch_size: int,
+    max_model_len: int,
+    max_tokens: int,
+    spec: int,
+    repetition_stop: bool,
+    image_column: str,
+    output_column: str,
+    split: str,
+    image_count_per_sec: float,
+) -> str:
+    on_jobs = os.environ.get("JOB_ID") is not None
+    hw = os.environ.get("ACCELERATOR") or ""
+    origin = (
+        "Produced on [Hugging Face Jobs](https://huggingface.co/docs/huggingface_hub/guides/jobs)"
+        + (f" (`{hw}`)" if hw else "")
+    ) if on_jobs else "Generated"
+    tags = ["ocr", "document-processing", "jina-ocr", "markdown", "uv-script", "generated"]
+    if on_jobs:
+        tags.append("hf-jobs")
+    tag_lines = "\n".join(f"- {t}" for t in tags)
+
+    return f"""---
+tags:
+{tag_lines}
+---
+
+# Document OCR using jina-ocr-v1
+
+Markdown OCR of the images in [{source_dataset}](https://huggingface.co/datasets/{source_dataset})
+using [{MODEL_ID}](https://huggingface.co/{MODEL_ID}) (DeepSeek-OCR fine-tune, ~570M active parameters,
+FastMTP speculative decoding). The model is released under CC-BY-NC-4.0; check that licence before
+reusing these outputs commercially.
+
+## Processing Details
+
+- **Source Dataset**: [{source_dataset}](https://huggingface.co/datasets/{source_dataset})
+- **Model**: [{MODEL_ID}](https://huggingface.co/{MODEL_ID})
+- **Number of Samples**: {num_samples:,}
+- **Processing Time**: {processing_time} (~{image_count_per_sec:.2f} images/second including model load)
+- **Processing Date**: {datetime.now().strftime("%Y-%m-%d %H:%M UTC")}
+
+### Configuration
+
+- **Image Column**: `{image_column}`
+- **Output Column**: `{output_column}`
+- **Dataset Split**: `{split}`
+- **Batch Size**: {batch_size}
+- **Max Model Length**: {max_model_len:,} tokens
+- **Max Output Tokens**: {max_tokens:,}
+- **Speculative decoding (FastMTP draft depth)**: {spec}
+- **N-gram repetition stop**: {"on" if repetition_stop else "off"}
+
+## Dataset Structure
+
+All original columns plus:
+- `{output_column}`: the extracted text as markdown (HTML tables, LaTeX math)
+- `inference_info`: JSON list tracking the OCR models applied to this dataset
+
+## Reproduction
+
+{origin} with the [`{SCRIPT_NAME}`]({SCRIPT_URL}) recipe from [uv-scripts](https://huggingface.co/uv-scripts). Run it yourself:
+
+```bash
+hf jobs uv run {SCRIPT_URL} \\
+    {source_dataset} \\
+    <output-dataset> \\
+    --image-column {image_column} \\
+    --batch-size {batch_size} \\
+    --spec {spec}
+```
+"""
+
+
+def main():
+    ap = argparse.ArgumentParser(description="jina-ocr-v1 batch OCR with vLLM (offline)")
+    ap.add_argument("input_dataset")
+    ap.add_argument("output_dataset")
+    ap.add_argument("--image-column", default="image")
+    ap.add_argument("--output-column", default="markdown")
+    ap.add_argument("--overwrite", action="store_true", help="Replace an existing output column")
+    ap.add_argument("--split", default="train")
+    ap.add_argument("--input-config", default=None, help="Config (subset) name of the input dataset")
+    ap.add_argument("--config", default=None, help="Config name for the output dataset")
+    ap.add_argument("--max-samples", type=int, default=None)
+    ap.add_argument("--shuffle", action="store_true")
+    ap.add_argument("--seed", type=int, default=42)
+    ap.add_argument("--batch-size", type=int, default=16)
+    ap.add_argument("--max-tokens", type=int, default=4096)
+    ap.add_argument("--max-model-len", type=int, default=8192)
+    ap.add_argument("--gpu-memory-utilization", type=float, default=0.85)
+    ap.add_argument("--spec", type=int, default=3, help="FastMTP draft depth K; 0 disables speculative decoding")
+    ap.add_argument("--no-repetition-stop", action="store_true", help="Disable the card's n-gram repetition stop")
+    ap.add_argument("--prompt", default=None, help="Override the model's default OCR prompt")
+    ap.add_argument("--revision", default=None, help="Model revision to pin")
+    ap.add_argument("--private", action="store_true")
+    ap.add_argument("--create-pr", action="store_true")
+    ap.add_argument("--hf-token", default=None)
+    ap.add_argument("--verbose", action="store_true", help="Log resolved package versions after the run")
+    args = ap.parse_args()
+
+    check_cuda_availability()
+    start_time = datetime.now()
+
+    hf_token = args.hf_token or os.environ.get("HF_TOKEN")
+    if hf_token:
+        login(token=hf_token)
+
+    logger.info(f"Loading dataset: {args.input_dataset}")
+    dataset = load_dataset(args.input_dataset, name=args.input_config, split=args.split)
+    if args.image_column not in dataset.column_names:
+        raise ValueError(f"Column '{args.image_column}' not found. Available: {dataset.column_names}")
+    dataset = ensure_output_columns_free(dataset, [args.output_column], overwrite=args.overwrite)
+    if args.shuffle:
+        dataset = dataset.shuffle(seed=args.seed)
+    if args.max_samples:
+        dataset = dataset.select(range(min(args.max_samples, len(dataset))))
+        logger.info(f"Limited to {len(dataset)} samples")
+
+    # --- model: the checkpoint's own vLLM glue, in the card's order ---------------
+    snapshot, glue = load_model_glue(args.revision)
+    from vllm import LLM
+
+    glue.register()
+    llm_kwargs = glue.vllm_llm_kwargs(
+        snapshot, num_speculative_tokens=args.spec, mtp_heads=1, mtp_recursive=True,
+    )
+    llm_kwargs.setdefault("max_model_len", args.max_model_len)
+    llm_kwargs.setdefault("gpu_memory_utilization", args.gpu_memory_utilization)
+    llm_kwargs.setdefault("enable_prefix_caching", False)
+    llm_kwargs.setdefault("mm_processor_cache_gb", 0)
+    llm_kwargs.setdefault("limit_mm_per_prompt", {"image": 1})
+    logger.info(f"Initializing vLLM with {MODEL_ID} (spec={args.spec}); this can take a few minutes")
+    llm = LLM(**llm_kwargs)
+
+    sampling_kwargs = {"max_tokens": args.max_tokens}
+    if args.no_repetition_stop:
+        sampling_kwargs["repetition_detection"] = None
+    sampling_params = glue.vllm_sampling_params(**sampling_kwargs)
+    prompt = args.prompt or glue.DEFAULT_OCR_PROMPT
+    logger.info(f"Prompt: {prompt}")
+
+    # --- inference ------------------------------------------------------------------
+    all_markdown = []
+    n_batches = (len(dataset) + args.batch_size - 1) // args.batch_size
+    for batch_indices in tqdm(partition_all(args.batch_size, range(len(dataset))), total=n_batches, desc="jina-ocr-v1"):
+        batch_indices = list(batch_indices)
+        batch_images = [dataset[i][args.image_column] for i in batch_indices]
+        try:
+            messages = []
+            for img in batch_images:
+                pil_img = to_pil(img).convert("RGB")
+                messages.append([{"role": "user", "content": [
+                    {"type": "image_pil", "image_pil": pil_img},
+                    {"type": "text", "text": prompt},
+                ]}])
+            outputs = llm.chat(messages, sampling_params=sampling_params, use_tqdm=False)
+            for output in outputs:
+                all_markdown.append(output.outputs[0].text.strip())
+        except Exception as e:
+            logger.error(f"Error processing batch: {e}")
+            all_markdown.extend(["[OCR FAILED]"] * len(batch_images))
+
+    if args.spec > 0:
+        glue.log_spec_stats(llm)
+
+    processing_duration = datetime.now() - start_time
+    processing_time_str = f"{processing_duration.total_seconds() / 60:.1f} min"
+    images_per_sec = len(dataset) / max(1.0, processing_duration.total_seconds())
+
+    # --- output dataset ---------------------------------------------------------------
+    dataset = dataset.add_column(args.output_column, all_markdown)
+    inference_entry = {
+        "model_id": MODEL_ID,
+        "model_name": "jina-ocr-v1",
+        "column_name": args.output_column,
+        "timestamp": datetime.now().isoformat(),
+        "prompt": "custom" if args.prompt else "default",
+        "batch_size": args.batch_size,
+        "max_tokens": args.max_tokens,
+        "max_model_len": args.max_model_len,
+        "speculative_tokens": args.spec,
+        "repetition_stop": not args.no_repetition_stop,
+        "script": SCRIPT_NAME,
+        "script_url": SCRIPT_URL,
+    }
+    if "inference_info" in dataset.column_names:
+        def update_inference_info(example):
+            try:
+                existing = json.loads(example["inference_info"]) if example["inference_info"] else []
+            except (json.JSONDecodeError, TypeError):
+                existing = []
+            existing.append(inference_entry)
+            return {"inference_info": json.dumps(existing)}
+        dataset = dataset.map(update_inference_info)
+    else:
+        dataset = dataset.add_column("inference_info", [json.dumps([inference_entry])] * len(dataset))
+
+    logger.info(f"Pushing to {args.output_dataset}")
+    dataset.push_to_hub(
+        args.output_dataset,
+        private=args.private,
+        token=hf_token,
+        **({"config_name": args.config} if args.config else {}),
+        create_pr=args.create_pr,
+        commit_message=f"Add {MODEL_ID} OCR results ({len(dataset)} samples)" + (f" [{args.config}]" if args.config else ""),
+    )
+    card = DatasetCard(create_dataset_card(
+        source_dataset=args.input_dataset, num_samples=len(dataset), processing_time=processing_time_str,
+        batch_size=args.batch_size, max_model_len=args.max_model_len, max_tokens=args.max_tokens,
+        spec=args.spec, repetition_stop=not args.no_repetition_stop, image_column=args.image_column,
+        output_column=args.output_column, split=args.split, image_count_per_sec=images_per_sec,
+    ))
+    card.push_to_hub(args.output_dataset, token=hf_token)
+    logger.info(f"Dataset available at: https://huggingface.co/datasets/{args.output_dataset}")
+    logger.info(f"Processing time: {processing_time_str}")
+
+    failed = sum(1 for m in all_markdown if m == "[OCR FAILED]")
+    if failed:
+        logger.warning(f"{failed} of {len(all_markdown)} rows are [OCR FAILED] (a whole batch fails together in offline mode)")
+
+    if args.verbose:
+        import importlib.metadata
+        for pkg in ["vllm", "transformers", "torch", "datasets", "pillow"]:
+            try:
+                logger.info(f"{pkg}=={importlib.metadata.version(pkg)}")
+            except importlib.metadata.PackageNotFoundError:
+                logger.info(f"{pkg}: not installed")
+
+
+if __name__ == "__main__":
+    main()

models.json

@@ -26,7 +26,10 @@
     "task": "ocr",
     "output": "plain text",
     "license": "apache-2.0",
-    "languages": { "evidence": "count-claim", "count": 48 }
+    "languages": {
+      "evidence": "count-claim",
+      "count": 48
+    }
   },
   "falcon-ocr.py": {
     "model_id": "tiiuae/Falcon-OCR",
@@ -35,7 +38,9 @@
     "task": "ocr",
     "output": "markdown",
     "license": "apache-2.0",
-    "languages": { "evidence": "not-stated" }
+    "languages": {
+      "evidence": "not-stated"
+    }
   },
   "smoldocling-ocr.py": {
     "model_id": "ds4sd/SmolDocling-256M-preview",
@@ -43,7 +48,9 @@
     "backend": "transformers",
     "task": "ocr",
     "output": "DocTags",
-    "languages": { "evidence": "english-only" }
+    "languages": {
+      "evidence": "english-only"
+    }
   },
   "surya-ocr.py": {
     "model_id": "datalab-to/surya-ocr-2",
@@ -69,7 +76,16 @@
     "languages": {
       "evidence": "named-list",
       "count": 8,
-      "named": ["zh", "en", "fr", "es", "ru", "de", "ja", "ko"],
+      "named": [
+        "zh",
+        "en",
+        "fr",
+        "es",
+        "ru",
+        "de",
+        "ja",
+        "ko"
+      ],
       "notes": "Declared in card metadata only; no per-language evidence in the card body."
     }
   },
@@ -116,7 +132,9 @@
     "task": "ocr",
     "output": "markdown + LaTeX + HTML tables",
     "license": "apache-2.0",
-    "languages": { "evidence": "not-stated" }
+    "languages": {
+      "evidence": "not-stated"
+    }
   },
   "ovis-ocr2-server.py": {
     "model_id": "ATH-MaaS/OvisOCR2",
@@ -127,7 +145,9 @@
     "output": "markdown + LaTeX + HTML tables",
     "license": "apache-2.0",
     "notes": "Server-mode sibling of ovis-ocr2.py: ~1.7x its inference throughput, per-request failure isolation. See SERVING.md.",
-    "languages": { "evidence": "not-stated" }
+    "languages": {
+      "evidence": "not-stated"
+    }
   },
   "ovis-ocr2-saturate.py": {
     "model_id": "ATH-MaaS/OvisOCR2",
@@ -138,7 +158,9 @@
     "output": "markdown + LaTeX + HTML tables",
     "license": "apache-2.0",
     "notes": "saturate companion of ovis-ocr2-server.py: same model/prompt/sampling/post-processing; the driver half (adaptive concurrency, retries, resumable parquet output, durable error rows) is the saturate library. SERVING dict at the top of the script is the machine-readable tuning prior.",
-    "languages": { "evidence": "not-stated" }
+    "languages": {
+      "evidence": "not-stated"
+    }
   },
   "lighton-ocr.py": {
     "model_id": "lightonai/LightOnOCR-1B-1025",
@@ -149,7 +171,17 @@
     "languages": {
       "evidence": "named-list",
       "count": 9,
-      "named": ["en", "fr", "de", "es", "it", "nl", "pt", "sv", "da"],
+      "named": [
+        "en",
+        "fr",
+        "de",
+        "es",
+        "it",
+        "nl",
+        "pt",
+        "sv",
+        "da"
+      ],
       "notes": "Explicitly European / Latin-alphabet focused."
     }
   },
@@ -162,7 +194,19 @@
     "languages": {
       "evidence": "named-list",
       "count": 11,
-      "named": ["en", "fr", "de", "es", "it", "nl", "pt", "sv", "da", "zh", "ja"],
+      "named": [
+        "en",
+        "fr",
+        "de",
+        "es",
+        "it",
+        "nl",
+        "pt",
+        "sv",
+        "da",
+        "zh",
+        "ja"
+      ],
       "notes": "Adds zh/ja over v1; declared, not benchmarked per language."
     }
   },
@@ -177,7 +221,19 @@
     "languages": {
       "evidence": "named-list",
       "count": 11,
-      "named": ["en", "fr", "de", "es", "it", "nl", "pt", "sv", "da", "zh", "ja"],
+      "named": [
+        "en",
+        "fr",
+        "de",
+        "es",
+        "it",
+        "nl",
+        "pt",
+        "sv",
+        "da",
+        "zh",
+        "ja"
+      ],
       "notes": "Adds zh/ja over v1; declared, not benchmarked per language."
     }
   },
@@ -192,7 +248,19 @@
     "languages": {
       "evidence": "named-list",
       "count": 11,
-      "named": ["en", "fr", "de", "es", "it", "nl", "pt", "sv", "da", "zh", "ja"],
+      "named": [
+        "en",
+        "fr",
+        "de",
+        "es",
+        "it",
+        "nl",
+        "pt",
+        "sv",
+        "da",
+        "zh",
+        "ja"
+      ],
       "notes": "Adds zh/ja over v1; declared, not benchmarked per language."
     }
   },
@@ -204,7 +272,9 @@
     "task": "ocr",
     "output": "markdown",
     "license": "Hunyuan Community License (excludes EU/UK/KR)",
-    "languages": { "evidence": "multilingual-unspecified" }
+    "languages": {
+      "evidence": "multilingual-unspecified"
+    }
   },
   "hunyuan-ocr-1.5.py": {
     "model_id": "tencent/HunyuanOCR",
@@ -237,7 +307,9 @@
     "task": "ocr",
     "output": "markdown",
     "license": "apache-2.0",
-    "languages": { "evidence": "not-stated" }
+    "languages": {
+      "evidence": "not-stated"
+    }
   },
   "abot-ocr.py": {
     "model_id": "acvlab/ABot-OCR",
@@ -246,7 +318,9 @@
     "image": "vllm/vllm-openai",
     "task": "ocr",
     "output": "markdown (text, LaTeX, HTML tables)",
-    "languages": { "evidence": "not-stated" }
+    "languages": {
+      "evidence": "not-stated"
+    }
   },
   "nanonets-ocr.py": {
     "model_id": "nanonets/Nanonets-OCR-s",
@@ -254,7 +328,9 @@
     "backend": "vllm",
     "task": "ocr",
     "output": "markdown (LaTeX, tables, forms)",
-    "languages": { "evidence": "english-only" }
+    "languages": {
+      "evidence": "english-only"
+    }
   },
   "dots-mocr.py": {
     "model_id": "rednote-hilab/dots.mocr",
@@ -262,7 +338,9 @@
     "backend": "vllm",
     "task": "ocr | 8 prompt modes incl. SVG, layout + bbox",
     "output": "markdown",
-    "languages": { "evidence": "multilingual-unspecified" }
+    "languages": {
+      "evidence": "multilingual-unspecified"
+    }
   },
   "nanonets-ocr2.py": {
     "model_id": "nanonets/Nanonets-OCR2-3B",
@@ -274,7 +352,19 @@
     "languages": {
       "evidence": "named-list",
       "count": "11 named + 'many more'",
-      "named": ["en", "zh", "fr", "es", "pt", "de", "it", "ru", "ja", "ko", "ar"],
+      "named": [
+        "en",
+        "zh",
+        "fr",
+        "es",
+        "pt",
+        "de",
+        "it",
+        "ru",
+        "ja",
+        "ko",
+        "ar"
+      ],
       "notes": "Only card claiming multilingual handwriting; list illustrative, no per-language benchmark."
     }
   },
@@ -285,7 +375,23 @@
     "task": "ocr | 5 resolution + 5 prompt modes",
     "output": "markdown",
     "license": "mit",
-    "languages": { "evidence": "multilingual-unspecified" }
+    "languages": {
+      "evidence": "multilingual-unspecified"
+    }
+  },
+  "jina-ocr-v1.py": {
+    "model_id": "jinaai/jina-ocr-v1",
+    "model_name": "jina-ocr-v1",
+    "params": "3.4B (MoE, ~570M active)",
+    "backend": "vllm",
+    "task": "ocr",
+    "output": "markdown",
+    "license": "cc-by-nc-4.0",
+    "notes": "DeepSeek-OCR fine-tune with a FastMTP speculative-decoding head; offline vLLM only (the checkpoint's register() must run in-process, no vllm serve path yet). Card: 91.14 OmniDocBench v1.6, 83.4 olmOCR-Bench.",
+    "languages": {
+      "evidence": "multilingual-unspecified",
+      "notes": "Card metadata says multilingual; no per-language list or evidence in the card body."
+    }
   },
   "deepseek-ocr.py": {
     "model_id": "deepseek-ai/DeepSeek-OCR",
@@ -294,7 +400,9 @@
     "task": "ocr",
     "output": "markdown",
     "license": "mit",
-    "languages": { "evidence": "multilingual-unspecified" }
+    "languages": {
+      "evidence": "multilingual-unspecified"
+    }
   },
   "deepseek-ocr2-vllm.py": {
     "model_id": "deepseek-ai/DeepSeek-OCR-2",
@@ -304,7 +412,9 @@
     "task": "ocr",
     "output": "markdown",
     "license": "apache-2.0",
-    "languages": { "evidence": "multilingual-unspecified" }
+    "languages": {
+      "evidence": "multilingual-unspecified"
+    }
   },
   "unlimited-ocr-vllm.py": {
     "model_id": "baidu/Unlimited-OCR",
@@ -314,7 +424,9 @@
     "task": "ocr (layout-grounded markdown; single-image batch)",
     "output": "markdown",
     "license": "mit",
-    "languages": { "evidence": "multilingual-unspecified" }
+    "languages": {
+      "evidence": "multilingual-unspecified"
+    }
   },
   "nuextract3.py": {
     "model_id": "numind/NuExtract3",
@@ -323,7 +435,9 @@
     "image": "vllm/vllm-openai",
     "task": "ocr | schema-guided extraction",
     "output": "markdown or JSON",
-    "languages": { "evidence": "multilingual-unspecified" }
+    "languages": {
+      "evidence": "multilingual-unspecified"
+    }
   },
   "qianfan-ocr.py": {
     "model_id": "baidu/Qianfan-OCR",
@@ -343,7 +457,9 @@
     "backend": "vllm",
     "task": "ocr",
     "output": "markdown",
-    "languages": { "evidence": "english-only" }
+    "languages": {
+      "evidence": "english-only"
+    }
   },
   "rolm-ocr.py": {
     "model_id": "reducto/RolmOCR",
@@ -351,7 +467,9 @@
     "backend": "vllm",
     "task": "ocr",
     "output": "plain text",
-    "languages": { "evidence": "not-stated" }
+    "languages": {
+      "evidence": "not-stated"
+    }
   },
   "numarkdown-ocr.py": {
     "model_id": "numind/NuMarkdown-8B-Thinking",
@@ -359,7 +477,9 @@
     "backend": "vllm",
     "task": "ocr (reasoning)",
     "output": "markdown",
-    "languages": { "evidence": "not-stated" }
+    "languages": {
+      "evidence": "not-stated"
+    }
   },
   "lfm2-vl-extract.py": {
     "model_id": "LiquidAI/LFM2.5-VL-1.6B-Extract",
@@ -383,7 +503,17 @@
     "languages": {
       "evidence": "named-list",
       "count": 9,
-      "named": ["en", "ar", "zh", "fr", "de", "ja", "ko", "pt", "es"],
+      "named": [
+        "en",
+        "ar",
+        "zh",
+        "fr",
+        "de",
+        "ja",
+        "ko",
+        "pt",
+        "es"
+      ],
       "notes": "Text-only model (not OCR). Card prose names 9 incl. Portuguese; card YAML lists 8 (pt missing)."
     }
   },
@@ -394,7 +524,9 @@
     "task": "schema-guided extraction (image or multi-page PDF -> JSON)",
     "output": "JSON",
     "license": "modified OpenRAIL-M",
-    "languages": { "evidence": "not-stated" }
+    "languages": {
+      "evidence": "not-stated"
+    }
   },
   "pp-doclayout.py": {
     "model_id": "PaddlePaddle/PP-DocLayout-L",
@@ -402,11 +534,31 @@
     "backend": "paddleocr",
     "task": "layout detection (no text extraction)",
     "output": "bounding boxes + region classes",
-    "languages": { "evidence": "not-applicable" }
+    "languages": {
+      "evidence": "not-applicable"
+    }
+  },
+  "glm-ocr-v2.py": {
+    "variant_of": "glm-ocr.py",
+    "notes": "Adds checkpoint/resume for very large jobs."
+  },
+  "glm-ocr-bucket.py": {
+    "variant_of": "glm-ocr.py",
+    "notes": "Reads images/PDFs from a mounted bucket, writes one .md per page."
+  },
+  "falcon-ocr-bucket.py": {
+    "variant_of": "falcon-ocr.py",
+    "notes": "Reads images/PDFs from a mounted bucket, writes one .md per page."
   },
-  "glm-ocr-v2.py": { "variant_of": "glm-ocr.py", "notes": "Adds checkpoint/resume for very large jobs." },
-  "glm-ocr-bucket.py": { "variant_of": "glm-ocr.py", "notes": "Reads images/PDFs from a mounted bucket, writes one .md per page." },
-  "falcon-ocr-bucket.py": { "variant_of": "falcon-ocr.py", "notes": "Reads images/PDFs from a mounted bucket, writes one .md per page." },
-  "surya-ocr-bucket.py": { "variant_of": "surya-ocr.py", "notes": "Bucket-to-bucket structured OCR (--io-mode mount|copy), resumable." },
-  "ocr-vllm-judge.py": { "model_id": "configurable", "task": "pairwise OCR-quality judging (VLM-as-judge)", "languages": { "evidence": "not-applicable" } }
+  "surya-ocr-bucket.py": {
+    "variant_of": "surya-ocr.py",
+    "notes": "Bucket-to-bucket structured OCR (--io-mode mount|copy), resumable."
+  },
+  "ocr-vllm-judge.py": {
+    "model_id": "configurable",
+    "task": "pairwise OCR-quality judging (VLM-as-judge)",
+    "languages": {
+      "evidence": "not-applicable"
+    }
+  }
 }