Add prompt mode presets and remove test script

Changes:
- Added PROMPT_MODES dict with 5 presets: document, image, free, figure, describe
- Added --prompt-mode argument (default: document)
- Custom --prompt still supported (overrides prompt-mode)
- Updated help text and examples to show prompt modes
- Removed deepseek-ocr-vllm-test.py (no longer needed after successful testing)

Prompt modes from DeepSeek-OCR GitHub:
- document: Convert document to markdown with grounding (default)
- image: OCR any image with grounding
- free: Free OCR without layout preservation
- figure: Parse figures from documents
- describe: Generate detailed image descriptions

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

DeepSeek-OCR

@@ -0,0 +1 @@
+Subproject commit 8cf003d38821fa1b19c73da3bd1b0dc262ea8136

deepseek-ocr-vllm.py

@@ -70,6 +70,15 @@ RESOLUTION_MODES = {
     },  # Dynamic resolution
 }
 
+# Prompt mode presets (from DeepSeek-OCR GitHub)
+PROMPT_MODES = {
+    "document": "<image>\n<|grounding|>Convert the document to markdown.",
+    "image": "<image>\n<|grounding|>OCR this image.",
+    "free": "<image>\nFree OCR.",
+    "figure": "<image>\nParse the figure.",
+    "describe": "<image>\nDescribe this image in detail.",
+}
+
 
 def check_cuda_availability():
     """Check if CUDA is available and exit if not."""
@@ -250,7 +259,8 @@ def main(
     max_model_len: int = 8192,
     max_tokens: int = 8192,
     gpu_memory_utilization: float = 0.8,
-    prompt: str = "<image>\n<|grounding|>Convert the document to markdown.",
+    prompt_mode: str = "document",
+    prompt: str = None,
     hf_token: str = None,
     split: str = "train",
     max_samples: int = None,
@@ -305,6 +315,21 @@ def main(
         f"image_size={final_image_size}, crop_mode={final_crop_mode}"
     )
 
+    # Determine prompt
+    if prompt is not None:
+        final_prompt = prompt
+        logger.info(f"Using custom prompt")
+    elif prompt_mode in PROMPT_MODES:
+        final_prompt = PROMPT_MODES[prompt_mode]
+        logger.info(f"Using prompt mode: {prompt_mode}")
+    else:
+        raise ValueError(
+            f"Invalid prompt mode '{prompt_mode}'. "
+            f"Use one of {list(PROMPT_MODES.keys())} or specify --prompt"
+        )
+
+    logger.info(f"Prompt: {final_prompt}")
+
     # Load dataset
     logger.info(f"Loading dataset: {input_dataset}")
     dataset = load_dataset(input_dataset, split=split)
@@ -362,7 +387,7 @@ def main(
 
         try:
             # Create messages for batch
-            batch_messages = [make_ocr_message(img, prompt) for img in batch_images]
+            batch_messages = [make_ocr_message(img, final_prompt) for img in batch_images]
 
             # Process with vLLM
             outputs = llm.chat(batch_messages, sampling_params)
@@ -411,7 +436,8 @@ def main(
         "base_size": final_base_size,
         "image_size": final_image_size,
         "crop_mode": final_crop_mode,
-        "prompt": prompt,
+        "prompt": final_prompt,
+        "prompt_mode": prompt_mode if prompt is None else "custom",
         "batch_size": batch_size,
         "max_tokens": max_tokens,
         "gpu_memory_utilization": gpu_memory_utilization,
@@ -486,14 +512,18 @@ if __name__ == "__main__":
         )
         print("\n3. Fast processing (Tiny - 512×512):")
         print("   uv run deepseek-ocr-vllm.py quick-test output --resolution-mode tiny")
-        print("\n4. Process a subset for testing:")
+        print("\n4. Parse figures from documents:")
+        print("   uv run deepseek-ocr-vllm.py scientific-papers figures --prompt-mode figure")
+        print("\n5. Free OCR without layout:")
+        print("   uv run deepseek-ocr-vllm.py images text --prompt-mode free")
+        print("\n6. Process a subset for testing:")
         print(
             "   uv run deepseek-ocr-vllm.py large-dataset test-output --max-samples 10"
         )
-        print("\n5. Custom resolution:")
+        print("\n7. Custom resolution:")
         print("   uv run deepseek-ocr-vllm.py dataset output \\")
         print("       --base-size 1024 --image-size 640 --crop-mode")
-        print("\n6. Running on HF Jobs:")
+        print("\n8. Running on HF Jobs:")
         print("   hf jobs uv run --flavor l4x1 \\")
         print("     -s HF_TOKEN \\")
         print("     -e UV_TORCH_BACKEND=auto \\")
@@ -517,6 +547,13 @@ Resolution Modes:
   large     1280×1280 pixels, maximum quality (400 vision tokens)
   gundam    Dynamic multi-tile processing (adaptive)
 
+Prompt Modes:
+  document  Convert document to markdown with grounding (default)
+  image     OCR any image with grounding
+  free      Free OCR without layout preservation
+  figure    Parse figures from documents
+  describe  Generate detailed image descriptions
+
 Examples:
   # Basic usage with default Gundam mode
   uv run deepseek-ocr-vllm.py my-images-dataset ocr-results
@@ -527,6 +564,15 @@ Examples:
   # Fast processing for testing
   uv run deepseek-ocr-vllm.py dataset output --resolution-mode tiny --max-samples 100
 
+  # Parse figures from a document dataset
+  uv run deepseek-ocr-vllm.py scientific-papers figures --prompt-mode figure
+
+  # Free OCR without layout (fastest)
+  uv run deepseek-ocr-vllm.py images text --prompt-mode free
+
+  # Custom prompt for specific task
+  uv run deepseek-ocr-vllm.py dataset output --prompt "<image>\nExtract all table data."
+
   # Custom resolution settings
   uv run deepseek-ocr-vllm.py dataset output --base-size 1024 --image-size 640 --crop-mode
 
@@ -592,10 +638,15 @@ Examples:
         default=0.8,
         help="GPU memory utilization (default: 0.8)",
     )
+    parser.add_argument(
+        "--prompt-mode",
+        default="document",
+        choices=list(PROMPT_MODES.keys()),
+        help="Prompt mode preset (default: document). Use --prompt for custom prompts.",
+    )
     parser.add_argument(
         "--prompt",
-        default="<image>\n<|grounding|>Convert the document to markdown.",
-        help="Prompt for OCR (default: grounding markdown conversion)",
+        help="Custom OCR prompt (overrides --prompt-mode)",
     )
     parser.add_argument("--hf-token", help="Hugging Face API token")
     parser.add_argument(
@@ -636,6 +687,7 @@ Examples:
         max_model_len=args.max_model_len,
         max_tokens=args.max_tokens,
         gpu_memory_utilization=args.gpu_memory_utilization,
+        prompt_mode=args.prompt_mode,
         prompt=args.prompt,
         hf_token=args.hf_token,
         split=args.split,

numarkdown-ocr.py

@@ -25,6 +25,8 @@ Features:
 - Mathematical formula recognition
 - Clean markdown output generation
 - Optional thinking trace inclusion
+- Multi-GPU support with automatic detection
+- Optimized token budget for reasoning models
 """
 
 import argparse
@@ -39,6 +41,7 @@ from typing import Any, Dict, List, Union, Optional, Tuple
 from datetime import datetime
 
 import torch
+from torch import cuda
 from datasets import load_dataset
 from huggingface_hub import DatasetCard, HfApi, login
 from PIL import Image
@@ -50,14 +53,20 @@ logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
 
-def check_cuda_availability():
-    """Check if CUDA is available and exit if not."""
-    if not torch.cuda.is_available():
+def check_gpu_availability() -> int:
+    """Check if CUDA is available and return the number of GPUs."""
+    if not cuda.is_available():
         logger.error("CUDA is not available. This script requires a GPU.")
-        logger.error("Please run on a machine with a CUDA-capable GPU.")
+        logger.error("Please run on a machine with NVIDIA GPU or use HF Jobs with GPU flavor.")
         sys.exit(1)
-    else:
-        logger.info(f"CUDA is available. GPU: {torch.cuda.get_device_name(0)}")
+    
+    num_gpus = cuda.device_count()
+    for i in range(num_gpus):
+        gpu_name = cuda.get_device_name(i)
+        gpu_memory = cuda.get_device_properties(i).total_memory / 1024**3
+        logger.info(f"GPU {i}: {gpu_name} with {gpu_memory:.1f} GB memory")
+    
+    return num_gpus
 
 
 def validate_and_resize_image(
@@ -167,6 +176,7 @@ def create_dataset_card(
     max_tokens: int,
     gpu_memory_utilization: float,
     include_thinking: bool,
+    tensor_parallel_size: int,
     image_column: str = "image",
     split: str = "train",
 ) -> str:
@@ -206,6 +216,7 @@ This dataset contains markdown-formatted OCR results from images in [{source_dat
 - **Max Model Length**: {max_model_len:,} tokens
 - **Max Output Tokens**: {max_tokens:,}
 - **GPU Memory Utilization**: {gpu_memory_utilization:.1%}
+- **Tensor Parallel Size**: {tensor_parallel_size} GPU(s)
 - **Thinking Traces**: {"Included" if include_thinking else "Excluded (only final answers)"}
 
 ## Model Information
@@ -271,7 +282,7 @@ uv run https://huggingface.co/datasets/uv-scripts/ocr/raw/main/numarkdown-ocr.py
 ## Performance
 
 - **Processing Speed**: ~{num_samples / (float(processing_time.split()[0]) * 60):.1f} images/second
-- **GPU Configuration**: vLLM with {gpu_memory_utilization:.0%} GPU memory utilization
+- **GPU Configuration**: {tensor_parallel_size} GPU(s) with {gpu_memory_utilization:.0%} memory utilization
 - **Model Size**: 8.29B parameters
 
 Generated with 🤖 [UV Scripts](https://huggingface.co/uv-scripts)
@@ -285,8 +296,9 @@ def main(
     batch_size: int = 16,
     model: str = "numind/NuMarkdown-8B-Thinking",
     max_model_len: int = 16384,
-    max_tokens: int = 8192,
+    max_tokens: int = 16384,
     gpu_memory_utilization: float = 0.9,
+    tensor_parallel_size: Optional[int] = None,
     hf_token: str = None,
     split: str = "train",
     max_samples: int = None,
@@ -297,10 +309,27 @@ def main(
     temperature: float = 0.0,
     custom_prompt: Optional[str] = None,
 ):
-    """Process images from HF dataset through NuMarkdown model."""
+    """Process images from HF dataset through NuMarkdown model.
     
-    # Check CUDA availability first
-    check_cuda_availability()
+    The max_tokens parameter controls the total token budget for both
+    thinking and answer phases. For complex documents with extensive
+    reasoning, the default of 16384 tokens provides ample room for both
+    the thinking process and the final markdown output.
+    """
+    
+    # GPU check and configuration
+    num_gpus = check_gpu_availability()
+    if tensor_parallel_size is None:
+        tensor_parallel_size = num_gpus
+        logger.info(
+            f"Auto-detected {num_gpus} GPU(s), using tensor_parallel_size={tensor_parallel_size}"
+        )
+    else:
+        logger.info(f"Using specified tensor_parallel_size={tensor_parallel_size}")
+        if tensor_parallel_size > num_gpus:
+            logger.warning(
+                f"Requested {tensor_parallel_size} GPUs but only {num_gpus} available"
+            )
     
     # Track processing start time
     start_time = datetime.now()
@@ -335,11 +364,13 @@ def main(
     
     # Initialize vLLM with trust_remote_code for NuMarkdown
     logger.info(f"Initializing vLLM with model: {model}")
+    logger.info(f"Using {tensor_parallel_size} GPU(s) for inference")
     llm = LLM(
         model=model,
         trust_remote_code=True,  # Required for NuMarkdown
         max_model_len=max_model_len,
         gpu_memory_utilization=gpu_memory_utilization,
+        tensor_parallel_size=tensor_parallel_size,
         limit_mm_per_prompt={"image": 1},
     )
     
@@ -452,6 +483,7 @@ def main(
         max_tokens=max_tokens,
         gpu_memory_utilization=gpu_memory_utilization,
         include_thinking=include_thinking,
+        tensor_parallel_size=tensor_parallel_size,
         image_column=image_column,
         split=split,
     )
@@ -502,15 +534,17 @@ if __name__ == "__main__":
         print("\n3. With custom settings:")
         print("   uv run numarkdown-ocr.py scientific-papers extracted-text \\")
         print("       --batch-size 8 \\")
-        print("       --max-tokens 8192 \\")
+        print("       --max-tokens 16384 \\")
         print("       --gpu-memory-utilization 0.9")
         print("\n4. Process a subset for testing:")
         print("   uv run numarkdown-ocr.py large-dataset test-output --max-samples 10")
         print("\n5. Custom prompt for specific needs:")
         print("   uv run numarkdown-ocr.py invoices invoice-data \\")
         print('       --custom-prompt "Extract all invoice details including line items"')
-        print("\n6. Running on HF Jobs:")
-        print("   hf jobs uv run --flavor l4x1 \\")
+        print("\n6. Multi-GPU processing:")
+        print("   uv run numarkdown-ocr.py large-docs processed-docs --tensor-parallel-size 2")
+        print("\n7. Running on HF Jobs:")
+        print("   hf jobs uv run --flavor a100x2 \\")
         print('     -e HF_TOKEN=$(python3 -c "from huggingface_hub import get_token; print(get_token())") \\')
         print("     https://huggingface.co/datasets/uv-scripts/ocr/raw/main/numarkdown-ocr.py \\")
         print("       your-document-dataset \\")
@@ -536,6 +570,9 @@ Examples:
   # Custom prompt for specific extraction
   uv run numarkdown-ocr.py forms form-data --custom-prompt "Extract all form fields and values"
   
+  # Multi-GPU for large datasets
+  uv run numarkdown-ocr.py large-dataset processed --tensor-parallel-size 4
+  
   # Random sample from dataset
   uv run numarkdown-ocr.py ordered-dataset random-sample --max-samples 50 --shuffle
         """,
@@ -568,14 +605,19 @@ Examples:
     parser.add_argument(
         "--max-tokens",
         type=int,
-        default=8192,
-        help="Maximum tokens to generate (default: 8192)",
+        default=16384,
+        help="Maximum tokens to generate including thinking tokens (default: 16384)",
     )
     parser.add_argument(
         "--gpu-memory-utilization",
         type=float,
         default=0.9,
-        help="GPU memory utilization (default: 0.9)",
+        help="GPU memory utilization per GPU (default: 0.9)",
+    )
+    parser.add_argument(
+        "--tensor-parallel-size",
+        type=int,
+        help="Number of GPUs to use (default: auto-detect all available)",
     )
     parser.add_argument("--hf-token", help="Hugging Face API token")
     parser.add_argument(
@@ -628,6 +670,7 @@ Examples:
         max_model_len=args.max_model_len,
         max_tokens=args.max_tokens,
         gpu_memory_utilization=args.gpu_memory_utilization,
+        tensor_parallel_size=args.tensor_parallel_size,
         hf_token=args.hf_token,
         split=args.split,
         max_samples=args.max_samples,

smoldocling-ocr.py

@@ -0,0 +1,580 @@
+# /// script
+# requires-python = ">=3.11"
+# dependencies = [
+#     "datasets",
+#     "huggingface-hub[hf_transfer]",
+#     "pillow",
+#     "vllm",
+#     "tqdm",
+#     "toolz",
+#     "torch",  # Added for CUDA check
+#     "docling-core",  # For DocTags conversion
+# ]
+#
+# ///
+
+"""
+Extract structured documents using SmolDocling-256M with vLLM.
+
+This script processes images through the SmolDocling model to extract
+structured document content with DocTags format, ideal for documents
+with code, formulas, tables, and complex layouts.
+
+Features:
+- Ultra-compact 256M parameter model
+- DocTags format for efficient representation
+- Code block recognition with indentation
+- Mathematical formula detection
+- Table and chart extraction
+- Layout preservation with bounding boxes
+"""
+
+import argparse
+import base64
+import io
+import json
+import logging
+import os
+import re
+import sys
+from typing import Any, Dict, List, Union
+from datetime import datetime
+
+import torch
+from datasets import load_dataset
+from docling_core.types.doc import DoclingDocument
+from docling_core.types.doc.document import DocTagsDocument
+from huggingface_hub import DatasetCard, login
+from PIL import Image
+from toolz import partition_all
+from tqdm.auto import tqdm
+from vllm import LLM, SamplingParams
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+def check_cuda_availability():
+    """Check if CUDA is available and exit if not."""
+    if not torch.cuda.is_available():
+        logger.error("CUDA is not available. This script requires a GPU.")
+        logger.error("Please run on a machine with a CUDA-capable GPU.")
+        sys.exit(1)
+    else:
+        logger.info(f"CUDA is available. GPU: {torch.cuda.get_device_name(0)}")
+
+
+def prepare_llm_input(
+    image: Union[Image.Image, Dict[str, Any], str],
+    prompt_text: str = "Convert page to Docling.",
+) -> Dict:
+    """Prepare input for vLLM processing."""
+    # Convert to PIL Image if needed
+    if isinstance(image, Image.Image):
+        pil_img = image.convert("RGB")
+    elif isinstance(image, dict) and "bytes" in image:
+        pil_img = Image.open(io.BytesIO(image["bytes"])).convert("RGB")
+    elif isinstance(image, str):
+        pil_img = Image.open(image).convert("RGB")
+    else:
+        raise ValueError(f"Unsupported image type: {type(image)}")
+
+    # Create chat template - exact format from the example
+    chat_template = (
+        f"<|im_start|>User:<image>{prompt_text}<end_of_utterance>\nAssistant:"
+    )
+
+    # Return in the format expected by vLLM generate
+    return {"prompt": chat_template, "multi_modal_data": {"image": pil_img}}
+
+
+def convert_doctags_to_markdown(doctags_output: str) -> str:
+    """Convert DocTags output to markdown format."""
+    # For now, just return the raw output as-is
+    # We'll focus on getting the basic vLLM inference working first
+    return doctags_output.strip()
+
+
+def create_dataset_card(
+    source_dataset: str,
+    model: str,
+    num_samples: int,
+    processing_time: str,
+    output_column: str,
+    output_format: str,
+    batch_size: int,
+    max_model_len: int,
+    max_tokens: int,
+    gpu_memory_utilization: float,
+    image_column: str = "image",
+    split: str = "train",
+) -> str:
+    """Create a dataset card documenting the OCR process."""
+    model_name = model.split("/")[-1]
+
+    return f"""---
+tags:
+- ocr
+- document-processing
+- smoldocling
+- doctags
+- structured-extraction
+- uv-script
+- generated
+---
+
+# Document Processing using {model_name}
+
+This dataset contains structured document extraction from images in [{source_dataset}](https://huggingface.co/datasets/{source_dataset}) using SmolDocling.
+
+## Processing Details
+
+- **Source Dataset**: [{source_dataset}](https://huggingface.co/datasets/{source_dataset})
+- **Model**: [{model}](https://huggingface.co/{model})
+- **Number of Samples**: {num_samples:,}
+- **Processing Time**: {processing_time}
+- **Processing Date**: {datetime.now().strftime("%Y-%m-%d %H:%M UTC")}
+
+### Configuration
+
+- **Image Column**: `{image_column}`
+- **Output Column**: `{output_column}`
+- **Output Format**: {output_format}
+- **Dataset Split**: `{split}`
+- **Batch Size**: {batch_size}
+- **Max Model Length**: {max_model_len:,} tokens
+- **Max Output Tokens**: {max_tokens:,}
+- **GPU Memory Utilization**: {gpu_memory_utilization:.1%}
+
+## Model Information
+
+SmolDocling-256M is an ultra-compact multimodal model that excels at:
+- 💻 **Code Recognition** - Detects and formats code blocks with proper indentation
+- 🔢 **Formula Recognition** - Identifies and processes mathematical expressions
+- 📊 **Tables & Charts** - Extracts structured data from tables and charts
+- 📐 **Layout Preservation** - Maintains document structure with bounding boxes
+- 🏷️ **DocTags Format** - Efficient minimal representation for documents
+- ⚡ **Fast Inference** - Only 256M parameters for quick processing
+
+## Dataset Structure
+
+The dataset contains all original columns plus:
+- `{output_column}`: The extracted {"DocTags JSON" if output_format == "doctags" else "markdown"} from each image
+- `inference_info`: JSON list tracking all OCR models applied to this dataset
+
+## Usage
+
+```python
+from datasets import load_dataset
+import json
+{"from docling_core.types.doc import DoclingDocument" if output_format == "doctags" else ""}
+{"from docling_core.types.doc.document import DocTagsDocument" if output_format == "doctags" else ""}
+
+# Load the dataset
+dataset = load_dataset("{{output_dataset_id}}", split="{split}")
+
+# Access the extracted content
+for example in dataset:
+    {"# Parse DocTags and convert to desired format" if output_format == "doctags" else ""}
+    {f"doc_tags = DocTagsDocument.model_validate_json(example['{output_column}'])" if output_format == "doctags" else f"print(example['{output_column}'])"}
+    {"doc = DoclingDocument.from_doctags(doc_tags)" if output_format == "doctags" else ""}
+    {"print(doc.export(format='md').text)  # Or 'html', 'json'" if output_format == "doctags" else ""}
+    break
+
+# View all OCR models applied to this dataset
+inference_info = json.loads(dataset[0]["inference_info"])
+for info in inference_info:
+    print(f"Column: {{info['column_name']}} - Model: {{info['model_id']}}")
+```
+
+## Reproduction
+
+This dataset was generated using the [uv-scripts/ocr](https://huggingface.co/datasets/uv-scripts/ocr) SmolDocling script:
+
+```bash
+uv run https://huggingface.co/datasets/uv-scripts/ocr/raw/main/smoldocling-ocr.py \\
+    {source_dataset} \\
+    <output-dataset> \\
+    --image-column {image_column} \\
+    --output-format {output_format} \\
+    --batch-size {batch_size} \\
+    --max-model-len {max_model_len} \\
+    --max-tokens {max_tokens} \\
+    --gpu-memory-utilization {gpu_memory_utilization}
+```
+
+## Performance
+
+- **Processing Speed**: ~{num_samples / (float(processing_time.split()[0]) * 60):.1f} images/second
+- **Model Size**: 256M parameters (ultra-compact)
+- **GPU Configuration**: vLLM with {gpu_memory_utilization:.0%} GPU memory utilization
+
+Generated with 🤖 [UV Scripts](https://huggingface.co/uv-scripts)
+"""
+
+
+def main(
+    input_dataset: str,
+    output_dataset: str,
+    image_column: str = "image",
+    batch_size: int = 32,
+    model: str = "ds4sd/SmolDocling-256M-preview",
+    max_model_len: int = 8192,
+    max_tokens: int = 8192,
+    gpu_memory_utilization: float = 0.8,
+    hf_token: str = None,
+    split: str = "train",
+    max_samples: int = None,
+    private: bool = False,
+    output_column: str = None,
+    output_format: str = "markdown",
+    shuffle: bool = False,
+    seed: int = 42,
+    prompt: str = "Convert page to Docling.",
+):
+    """Process images from HF dataset through SmolDocling model."""
+
+    # Check CUDA availability first
+    check_cuda_availability()
+
+    # Track processing start time
+    start_time = datetime.now()
+
+    # Enable HF_TRANSFER for faster downloads
+    os.environ["HF_HUB_ENABLE_HF_TRANSFER"] = "1"
+
+    # Login to HF if token provided
+    HF_TOKEN = hf_token or os.environ.get("HF_TOKEN")
+    if HF_TOKEN:
+        login(token=HF_TOKEN)
+
+    # Load dataset
+    logger.info(f"Loading dataset: {input_dataset}")
+    dataset = load_dataset(input_dataset, split=split)
+
+    # Set output column name dynamically if not provided
+    if output_column is None:
+        # Extract model name from path (e.g., "ds4sd/SmolDocling-256M-preview" -> "smoldocling")
+        model_name = model.split("/")[-1].split("-")[0].lower()
+        output_column = f"{model_name}_text"
+        logger.info(f"Using dynamic output column name: {output_column}")
+
+    # Validate image column
+    if image_column not in dataset.column_names:
+        raise ValueError(
+            f"Column '{image_column}' not found. Available: {dataset.column_names}"
+        )
+
+    # Validate output format
+    if output_format not in ["markdown", "doctags"]:
+        raise ValueError(
+            f"Invalid output format '{output_format}'. Must be 'markdown' or 'doctags'"
+        )
+
+    # Shuffle if requested
+    if shuffle:
+        logger.info(f"Shuffling dataset with seed {seed}")
+        dataset = dataset.shuffle(seed=seed)
+
+    # Limit samples if requested
+    if max_samples:
+        dataset = dataset.select(range(min(max_samples, len(dataset))))
+        logger.info(f"Limited to {len(dataset)} samples")
+
+    # Initialize vLLM
+    logger.info(f"Initializing vLLM with model: {model}")
+    llm = LLM(
+        model=model,
+        trust_remote_code=True,
+        max_model_len=max_model_len,
+        gpu_memory_utilization=gpu_memory_utilization,
+        limit_mm_per_prompt={"image": 1},
+    )
+
+    sampling_params = SamplingParams(
+        temperature=0.0,  # Deterministic for OCR
+        max_tokens=max_tokens,
+    )
+
+    # Process images in batches
+    all_output = []
+
+    logger.info(f"Processing {len(dataset)} images in batches of {batch_size}")
+    logger.info(f"Output format: {output_format}")
+
+    # Process in batches to avoid memory issues
+    for batch_indices in tqdm(
+        partition_all(batch_size, range(len(dataset))),
+        total=(len(dataset) + batch_size - 1) // batch_size,
+        desc="OCR processing",
+    ):
+        batch_indices = list(batch_indices)
+        batch_images = [dataset[i][image_column] for i in batch_indices]
+
+        try:
+            # Prepare inputs for batch
+            batch_inputs = [prepare_llm_input(img, prompt) for img in batch_images]
+
+            # Process with vLLM using generate
+            outputs = llm.generate(batch_inputs, sampling_params=sampling_params)
+
+            # Extract text from outputs
+            for i, output in enumerate(outputs):
+                raw_output = output.outputs[0].text.strip()
+
+                # Convert to markdown if requested
+                if output_format == "markdown":
+                    processed_output = convert_doctags_to_markdown(raw_output)
+                else:
+                    processed_output = raw_output
+
+                all_output.append(processed_output)
+
+        except Exception as e:
+            logger.error(f"Error processing batch: {e}")
+            # Add error placeholders for failed batch
+            all_output.extend(["[OCR FAILED]"] * len(batch_images))
+
+    # Add output column to dataset
+    logger.info(f"Adding {output_column} column to dataset")
+    dataset = dataset.add_column(output_column, all_output)
+
+    # Handle inference_info tracking
+    logger.info("Updating inference_info...")
+
+    # Check for existing inference_info
+    if "inference_info" in dataset.column_names:
+        # Parse existing info from first row (all rows have same info)
+        try:
+            existing_info = json.loads(dataset[0]["inference_info"])
+            if not isinstance(existing_info, list):
+                existing_info = [existing_info]  # Convert old format to list
+        except (json.JSONDecodeError, TypeError):
+            existing_info = []
+        # Remove old column to update it
+        dataset = dataset.remove_columns(["inference_info"])
+    else:
+        existing_info = []
+
+    # Add new inference info
+    new_info = {
+        "column_name": output_column,
+        "model_id": model,
+        "processing_date": datetime.now().isoformat(),
+        "batch_size": batch_size,
+        "max_tokens": max_tokens,
+        "gpu_memory_utilization": gpu_memory_utilization,
+        "max_model_len": max_model_len,
+        "output_format": output_format,
+        "prompt": prompt,
+        "script": "smoldocling-ocr.py",
+        "script_version": "1.0.0",
+        "script_url": "https://huggingface.co/datasets/uv-scripts/ocr/raw/main/smoldocling-ocr.py",
+    }
+    existing_info.append(new_info)
+
+    # Add updated inference_info column
+    info_json = json.dumps(existing_info, ensure_ascii=False)
+    dataset = dataset.add_column("inference_info", [info_json] * len(dataset))
+
+    # Push to hub
+    logger.info(f"Pushing to {output_dataset}")
+    dataset.push_to_hub(output_dataset, private=private, token=HF_TOKEN)
+
+    # Calculate processing time
+    end_time = datetime.now()
+    processing_duration = end_time - start_time
+    processing_time = f"{processing_duration.total_seconds() / 60:.1f} minutes"
+
+    # Create and push dataset card
+    logger.info("Creating dataset card...")
+    card_content = create_dataset_card(
+        source_dataset=input_dataset,
+        model=model,
+        num_samples=len(dataset),
+        processing_time=processing_time,
+        output_column=output_column,
+        output_format=output_format,
+        batch_size=batch_size,
+        max_model_len=max_model_len,
+        max_tokens=max_tokens,
+        gpu_memory_utilization=gpu_memory_utilization,
+        image_column=image_column,
+        split=split,
+    )
+
+    card = DatasetCard(card_content)
+    card.push_to_hub(output_dataset, token=HF_TOKEN)
+    logger.info("✅ Dataset card created and pushed!")
+
+    logger.info("✅ OCR conversion complete!")
+    logger.info(
+        f"Dataset available at: https://huggingface.co/datasets/{output_dataset}"
+    )
+
+
+if __name__ == "__main__":
+    # Show example usage if no arguments
+    if len(sys.argv) == 1:
+        print("=" * 80)
+        print("SmolDocling Ultra-Compact Document Processing")
+        print("=" * 80)
+        print("\nThis script extracts structured document content using")
+        print("the SmolDocling-256M model with vLLM acceleration.")
+        print("\nFeatures:")
+        print("- Ultra-compact 256M parameter model")
+        print("- DocTags format for efficient representation")
+        print("- Code block recognition with indentation")
+        print("- Mathematical formula detection")
+        print("- Table and chart extraction")
+        print("- Layout preservation with bounding boxes")
+        print("\nExample usage:")
+        print("\n1. Basic document conversion to markdown:")
+        print("   uv run smoldocling-ocr.py document-images extracted-docs")
+        print("\n2. Extract with DocTags format:")
+        print("   uv run smoldocling-ocr.py scientific-papers doc-analysis \\")
+        print("       --output-format doctags")
+        print("\n3. Custom settings:")
+        print("   uv run smoldocling-ocr.py code-docs structured-output \\")
+        print("       --image-column page \\")
+        print("       --batch-size 64 \\")
+        print("       --gpu-memory-utilization 0.9")
+        print("\n4. Process a subset for testing:")
+        print("   uv run smoldocling-ocr.py large-dataset test-output --max-samples 10")
+        print("\n5. Random sample from ordered dataset:")
+        print(
+            "   uv run smoldocling-ocr.py ordered-dataset random-test --max-samples 50 --shuffle"
+        )
+        print("\n6. Running on HF Jobs:")
+        print("   hf jobs uv run --flavor l4x1 \\")
+        print(
+            '     -e HF_TOKEN=$(python3 -c "from huggingface_hub import get_token; print(get_token())") \\'
+        )
+        print(
+            "     https://huggingface.co/datasets/uv-scripts/ocr/raw/main/smoldocling-ocr.py \\"
+        )
+        print("       your-document-dataset \\")
+        print("       your-structured-output")
+        print("\n" + "=" * 80)
+        print("\nFor full help, run: uv run smoldocling-ocr.py --help")
+        sys.exit(0)
+
+    parser = argparse.ArgumentParser(
+        description="Extract structured documents using SmolDocling",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  # Basic usage
+  uv run smoldocling-ocr.py my-images-dataset structured-output
+
+  # With DocTags format output
+  uv run smoldocling-ocr.py documents doc-analysis --output-format doctags
+
+  # Process subset for testing
+  uv run smoldocling-ocr.py large-dataset test-output --max-samples 100
+
+  # Random sample of 100 images
+  uv run smoldocling-ocr.py ordered-dataset random-sample --max-samples 100 --shuffle
+
+  # Custom output column name (default: smoldocling_text)
+  uv run smoldocling-ocr.py images texts --output-column extracted_content
+        """,
+    )
+
+    parser.add_argument("input_dataset", help="Input dataset ID from Hugging Face Hub")
+    parser.add_argument("output_dataset", help="Output dataset ID for Hugging Face Hub")
+    parser.add_argument(
+        "--image-column",
+        default="image",
+        help="Column containing images (default: image)",
+    )
+    parser.add_argument(
+        "--batch-size",
+        type=int,
+        default=32,
+        help="Batch size for processing (default: 32)",
+    )
+    parser.add_argument(
+        "--model",
+        default="ds4sd/SmolDocling-256M-preview",
+        help="Model to use (default: ds4sd/SmolDocling-256M-preview)",
+    )
+    parser.add_argument(
+        "--max-model-len",
+        type=int,
+        default=8192,
+        help="Maximum model context length (default: 8192)",
+    )
+    parser.add_argument(
+        "--max-tokens",
+        type=int,
+        default=8192,
+        help="Maximum tokens to generate (default: 8192)",
+    )
+    parser.add_argument(
+        "--gpu-memory-utilization",
+        type=float,
+        default=0.8,
+        help="GPU memory utilization (default: 0.8)",
+    )
+    parser.add_argument("--hf-token", help="Hugging Face API token")
+    parser.add_argument(
+        "--split", default="train", help="Dataset split to use (default: train)"
+    )
+    parser.add_argument(
+        "--max-samples",
+        type=int,
+        help="Maximum number of samples to process (for testing)",
+    )
+    parser.add_argument(
+        "--private", action="store_true", help="Make output dataset private"
+    )
+    parser.add_argument(
+        "--output-column",
+        default=None,
+        help="Name of the output column for extracted text (default: auto-generated from model name)",
+    )
+    parser.add_argument(
+        "--output-format",
+        default="markdown",
+        choices=["markdown", "doctags"],
+        help="Output format: 'markdown' or 'doctags' (default: markdown)",
+    )
+    parser.add_argument(
+        "--shuffle",
+        action="store_true",
+        help="Shuffle the dataset before processing (useful for random sampling)",
+    )
+    parser.add_argument(
+        "--seed",
+        type=int,
+        default=42,
+        help="Random seed for shuffling (default: 42)",
+    )
+    parser.add_argument(
+        "--prompt",
+        default="Convert page to Docling.",
+        help="Custom prompt for the model (default: 'Convert page to Docling.')",
+    )
+
+    args = parser.parse_args()
+
+    main(
+        input_dataset=args.input_dataset,
+        output_dataset=args.output_dataset,
+        image_column=args.image_column,
+        batch_size=args.batch_size,
+        model=args.model,
+        max_model_len=args.max_model_len,
+        max_tokens=args.max_tokens,
+        gpu_memory_utilization=args.gpu_memory_utilization,
+        hf_token=args.hf_token,
+        split=args.split,
+        max_samples=args.max_samples,
+        private=args.private,
+        output_column=args.output_column,
+        output_format=args.output_format,
+        shuffle=args.shuffle,
+        seed=args.seed,
+        prompt=args.prompt,
+    )