v1.12.0

Dockerfile_minicpm45v_cpu

@@ -14,7 +14,7 @@ ENV OLLAMA_ORIGINS="*"
 ENV CUDA_VISIBLE_DEVICES=""
 
 # Copy and setup entrypoint
-COPY image_support_files/docker-entrypoint.sh /usr/local/bin/docker-entrypoint.sh
+COPY image_support_files/minicpm45v_entrypoint.sh /usr/local/bin/docker-entrypoint.sh
 RUN chmod +x /usr/local/bin/docker-entrypoint.sh
 
 # Expose Ollama API port

Dockerfile_minicpm45v_gpu

@@ -12,7 +12,7 @@ ENV OLLAMA_HOST="0.0.0.0"
 ENV OLLAMA_ORIGINS="*"
 
 # Copy and setup entrypoint
-COPY image_support_files/docker-entrypoint.sh /usr/local/bin/docker-entrypoint.sh
+COPY image_support_files/minicpm45v_entrypoint.sh /usr/local/bin/docker-entrypoint.sh
 RUN chmod +x /usr/local/bin/docker-entrypoint.sh
 
 # Expose Ollama API port

Dockerfile_paddleocr

@@ -1,49 +0,0 @@
-# PaddleOCR GPU Variant
-# OCR processing with NVIDIA GPU support using PaddlePaddle
-FROM paddlepaddle/paddle:2.6.2-gpu-cuda11.7-cudnn8.4-trt8.4
-
-LABEL maintainer="Task Venture Capital GmbH <hello@task.vc>"
-LABEL description="PaddleOCR PP-OCRv4 - GPU optimized"
-LABEL org.opencontainers.image.source="https://code.foss.global/host.today/ht-docker-ai"
-
-# Environment configuration
-ENV OCR_LANGUAGE="en"
-ENV SERVER_PORT="5000"
-ENV SERVER_HOST="0.0.0.0"
-ENV PYTHONUNBUFFERED=1
-
-# Set working directory
-WORKDIR /app
-
-# Install system dependencies
-RUN apt-get update && apt-get install -y --no-install-recommends \
-    libgl1-mesa-glx \
-    libglib2.0-0 \
-    curl \
-    && rm -rf /var/lib/apt/lists/*
-
-# Install Python dependencies (using stable paddleocr 2.x)
-RUN pip install --no-cache-dir \
-    paddleocr==2.8.1 \
-    fastapi \
-    uvicorn[standard] \
-    python-multipart \
-    opencv-python-headless \
-    pillow
-
-# Copy server files
-COPY image_support_files/paddleocr_server.py /app/paddleocr_server.py
-COPY image_support_files/paddleocr-entrypoint.sh /usr/local/bin/paddleocr-entrypoint.sh
-RUN chmod +x /usr/local/bin/paddleocr-entrypoint.sh
-
-# Note: OCR models will be downloaded on first run
-# This ensures compatibility across different GPU architectures
-
-# Expose API port
-EXPOSE 5000
-
-# Health check
-HEALTHCHECK --interval=30s --timeout=10s --start-period=60s --retries=3 \
-    CMD curl -f http://localhost:5000/health || exit 1
-
-ENTRYPOINT ["/usr/local/bin/paddleocr-entrypoint.sh"]

Dockerfile_paddleocr_cpu

@@ -1,53 +0,0 @@
-# PaddleOCR CPU Variant
-# OCR processing optimized for CPU-only inference
-FROM python:3.10-slim-bookworm
-
-LABEL maintainer="Task Venture Capital GmbH <hello@task.vc>"
-LABEL description="PaddleOCR PP-OCRv4 - CPU optimized"
-LABEL org.opencontainers.image.source="https://code.foss.global/host.today/ht-docker-ai"
-
-# Environment configuration for CPU-only mode
-ENV OCR_LANGUAGE="en"
-ENV SERVER_PORT="5000"
-ENV SERVER_HOST="0.0.0.0"
-ENV PYTHONUNBUFFERED=1
-# Disable GPU usage for CPU-only variant
-ENV CUDA_VISIBLE_DEVICES="-1"
-
-# Set working directory
-WORKDIR /app
-
-# Install system dependencies
-RUN apt-get update && apt-get install -y --no-install-recommends \
-    libgl1-mesa-glx \
-    libglib2.0-0 \
-    libgomp1 \
-    curl \
-    && rm -rf /var/lib/apt/lists/*
-
-# Install Python dependencies (CPU version of PaddlePaddle - using stable 2.x versions)
-RUN pip install --no-cache-dir \
-    paddlepaddle==2.6.2 \
-    paddleocr==2.8.1 \
-    fastapi \
-    uvicorn[standard] \
-    python-multipart \
-    opencv-python-headless \
-    pillow
-
-# Copy server files
-COPY image_support_files/paddleocr_server.py /app/paddleocr_server.py
-COPY image_support_files/paddleocr-entrypoint.sh /usr/local/bin/paddleocr-entrypoint.sh
-RUN chmod +x /usr/local/bin/paddleocr-entrypoint.sh
-
-# Note: OCR models will be downloaded on first run
-# This avoids build-time segfaults with certain CPU architectures
-
-# Expose API port
-EXPOSE 5000
-
-# Health check (longer start-period for CPU variant)
-HEALTHCHECK --interval=30s --timeout=10s --start-period=120s --retries=3 \
-    CMD curl -f http://localhost:5000/health || exit 1
-
-ENTRYPOINT ["/usr/local/bin/paddleocr-entrypoint.sh"]

Dockerfile_paddleocr_vl_cpu

@@ -0,0 +1,57 @@
+# PaddleOCR-VL CPU Variant
+# Vision-Language Model for document parsing using transformers (slower, no GPU required)
+FROM python:3.11-slim-bookworm
+
+LABEL maintainer="Task Venture Capital GmbH <hello@task.vc>"
+LABEL description="PaddleOCR-VL 0.9B CPU - Vision-Language Model for document parsing"
+LABEL org.opencontainers.image.source="https://code.foss.global/host.today/ht-docker-ai"
+
+# Environment configuration
+ENV PYTHONUNBUFFERED=1
+ENV HF_HOME=/root/.cache/huggingface
+ENV CUDA_VISIBLE_DEVICES=""
+ENV SERVER_PORT=8000
+ENV SERVER_HOST=0.0.0.0
+
+# Set working directory
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    libgl1-mesa-glx \
+    libglib2.0-0 \
+    libgomp1 \
+    curl \
+    git \
+    && rm -rf /var/lib/apt/lists/*
+
+# Install Python dependencies
+RUN pip install --no-cache-dir --upgrade pip && \
+    pip install --no-cache-dir \
+    torch==2.5.1 torchvision==0.20.1 --index-url https://download.pytorch.org/whl/cpu && \
+    pip install --no-cache-dir \
+    transformers \
+    accelerate \
+    safetensors \
+    pillow \
+    fastapi \
+    uvicorn[standard] \
+    python-multipart \
+    httpx \
+    protobuf \
+    sentencepiece \
+    einops
+
+# Copy server files
+COPY image_support_files/paddleocr_vl_server.py /app/paddleocr_vl_server.py
+COPY image_support_files/paddleocr_vl_entrypoint.sh /usr/local/bin/paddleocr-vl-cpu-entrypoint.sh
+RUN chmod +x /usr/local/bin/paddleocr-vl-cpu-entrypoint.sh
+
+# Expose API port
+EXPOSE 8000
+
+# Health check (longer start-period for CPU + model download)
+HEALTHCHECK --interval=30s --timeout=10s --start-period=600s --retries=3 \
+    CMD curl -f http://localhost:8000/health || exit 1
+
+ENTRYPOINT ["/usr/local/bin/paddleocr-vl-cpu-entrypoint.sh"]

Dockerfile_paddleocr_vl_full

@@ -0,0 +1,90 @@
+# PaddleOCR-VL Full Pipeline (PP-DocLayoutV2 + PaddleOCR-VL + Structured Output)
+# Self-contained GPU image with complete document parsing pipeline
+FROM nvidia/cuda:12.4.0-devel-ubuntu22.04
+
+LABEL maintainer="Task Venture Capital GmbH <hello@task.vc>"
+LABEL description="PaddleOCR-VL Full Pipeline - Layout Detection + VL Recognition + JSON/Markdown Output"
+LABEL org.opencontainers.image.source="https://code.foss.global/host.today/ht-docker-ai"
+
+# Environment configuration
+ENV DEBIAN_FRONTEND=noninteractive
+ENV PYTHONUNBUFFERED=1
+ENV HF_HOME=/root/.cache/huggingface
+ENV PADDLEOCR_HOME=/root/.paddleocr
+ENV SERVER_PORT=8000
+ENV SERVER_HOST=0.0.0.0
+ENV VLM_PORT=8080
+
+# Set working directory
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    python3.11 \
+    python3.11-venv \
+    python3.11-dev \
+    python3-pip \
+    libgl1-mesa-glx \
+    libglib2.0-0 \
+    libgomp1 \
+    libsm6 \
+    libxext6 \
+    libxrender1 \
+    curl \
+    git \
+    wget \
+    && rm -rf /var/lib/apt/lists/* \
+    && update-alternatives --install /usr/bin/python python /usr/bin/python3.11 1 \
+    && update-alternatives --install /usr/bin/python3 python3 /usr/bin/python3.11 1
+
+# Create and activate virtual environment
+RUN python -m venv /opt/venv
+ENV PATH="/opt/venv/bin:$PATH"
+
+# Upgrade pip
+RUN pip install --no-cache-dir --upgrade pip setuptools wheel
+
+# Install PaddlePaddle GPU (CUDA 12.x)
+RUN pip install --no-cache-dir \
+    paddlepaddle-gpu==3.2.1 \
+    --extra-index-url https://www.paddlepaddle.org.cn/packages/stable/cu126/
+
+# Install PaddleOCR with doc-parser (includes PP-DocLayoutV2)
+RUN pip install --no-cache-dir \
+    "paddleocr[doc-parser]" \
+    safetensors
+
+# Install PyTorch with CUDA support
+RUN pip install --no-cache-dir \
+    torch==2.5.1 \
+    torchvision \
+    --index-url https://download.pytorch.org/whl/cu124
+
+# Install transformers for PaddleOCR-VL inference (no vLLM - use local inference)
+# PaddleOCR-VL requires transformers>=4.55.0 for use_kernel_forward_from_hub
+RUN pip install --no-cache-dir \
+    transformers>=4.55.0 \
+    accelerate \
+    hf-kernels
+
+# Install our API server dependencies
+RUN pip install --no-cache-dir \
+    fastapi \
+    uvicorn[standard] \
+    python-multipart \
+    httpx \
+    pillow
+
+# Copy server files
+COPY image_support_files/paddleocr_vl_full_server.py /app/server.py
+COPY image_support_files/paddleocr_vl_full_entrypoint.sh /usr/local/bin/entrypoint.sh
+RUN chmod +x /usr/local/bin/entrypoint.sh
+
+# Expose ports (8000 = API, 8080 = internal VLM server)
+EXPOSE 8000
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=10s --start-period=600s --retries=3 \
+    CMD curl -f http://localhost:8000/health || exit 1
+
+ENTRYPOINT ["/usr/local/bin/entrypoint.sh"]

Dockerfile_paddleocr_vl_gpu

@@ -0,0 +1,71 @@
+# PaddleOCR-VL GPU Variant (Transformers-based, not vLLM)
+# Vision-Language Model for document parsing using transformers with CUDA
+FROM nvidia/cuda:12.4.0-runtime-ubuntu22.04
+
+LABEL maintainer="Task Venture Capital GmbH <hello@task.vc>"
+LABEL description="PaddleOCR-VL 0.9B GPU - Vision-Language Model using transformers"
+LABEL org.opencontainers.image.source="https://code.foss.global/host.today/ht-docker-ai"
+
+# Environment configuration
+ENV DEBIAN_FRONTEND=noninteractive
+ENV PYTHONUNBUFFERED=1
+ENV HF_HOME=/root/.cache/huggingface
+ENV SERVER_PORT=8000
+ENV SERVER_HOST=0.0.0.0
+
+# Set working directory
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    python3.11 \
+    python3.11-venv \
+    python3.11-dev \
+    python3-pip \
+    libgl1-mesa-glx \
+    libglib2.0-0 \
+    libgomp1 \
+    curl \
+    git \
+    && rm -rf /var/lib/apt/lists/* \
+    && update-alternatives --install /usr/bin/python python /usr/bin/python3.11 1 \
+    && update-alternatives --install /usr/bin/python3 python3 /usr/bin/python3.11 1
+
+# Create and activate virtual environment
+RUN python -m venv /opt/venv
+ENV PATH="/opt/venv/bin:$PATH"
+
+# Install PyTorch with CUDA support
+RUN pip install --no-cache-dir --upgrade pip && \
+    pip install --no-cache-dir \
+    torch==2.5.1 \
+    torchvision \
+    --index-url https://download.pytorch.org/whl/cu124
+
+# Install Python dependencies (transformers-based, not vLLM)
+RUN pip install --no-cache-dir \
+    transformers \
+    accelerate \
+    safetensors \
+    pillow \
+    fastapi \
+    uvicorn[standard] \
+    python-multipart \
+    httpx \
+    protobuf \
+    sentencepiece \
+    einops
+
+# Copy server files (same as CPU variant - it auto-detects CUDA)
+COPY image_support_files/paddleocr_vl_server.py /app/paddleocr_vl_server.py
+COPY image_support_files/paddleocr_vl_entrypoint.sh /usr/local/bin/paddleocr-vl-entrypoint.sh
+RUN chmod +x /usr/local/bin/paddleocr-vl-entrypoint.sh
+
+# Expose API port
+EXPOSE 8000
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=10s --start-period=300s --retries=3 \
+    CMD curl -f http://localhost:8000/health || exit 1
+
+ENTRYPOINT ["/usr/local/bin/paddleocr-vl-entrypoint.sh"]

Dockerfile_qwen3vl

@@ -0,0 +1,26 @@
+# Qwen3-VL-30B-A3B Vision Language Model
+# Q4_K_M quantization (~20GB model)
+#
+# Most powerful Qwen vision model:
+# - 256K context (expandable to 1M)
+# - Visual agent capabilities
+# - Code generation from images
+#
+# Build: docker build -f Dockerfile_qwen3vl -t qwen3vl .
+# Run:   docker run --gpus all -p 11434:11434 -v ht-ollama-models:/root/.ollama qwen3vl
+
+FROM ollama/ollama:latest
+
+# Pre-pull the model during build (optional - can also pull at runtime)
+# This makes the image larger but faster to start
+# RUN ollama serve & sleep 5 && ollama pull qwen3-vl:30b-a3b && pkill ollama
+
+# Expose Ollama API port
+EXPOSE 11434
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=10s --start-period=60s --retries=3 \
+  CMD curl -f http://localhost:11434/api/tags || exit 1
+
+# Start Ollama server
+CMD ["serve"]

build-images.sh

@@ -16,7 +16,7 @@ echo -e "${BLUE}Building ht-docker-ai images...${NC}"
 # Build GPU variant
 echo -e "${GREEN}Building MiniCPM-V 4.5 GPU variant...${NC}"
 docker build \
-    -f Dockerfile_minicpm45v \
+    -f Dockerfile_minicpm45v_gpu \
     -t ${REGISTRY}/${NAMESPACE}/${IMAGE_NAME}:minicpm45v \
     -t ${REGISTRY}/${NAMESPACE}/${IMAGE_NAME}:minicpm45v-gpu \
     -t ${REGISTRY}/${NAMESPACE}/${IMAGE_NAME}:latest \
@@ -29,19 +29,19 @@ docker build \
     -t ${REGISTRY}/${NAMESPACE}/${IMAGE_NAME}:minicpm45v-cpu \
     .
 
-# Build PaddleOCR GPU variant
+# Build PaddleOCR-VL GPU variant
-echo -e "${GREEN}Building PaddleOCR GPU variant...${NC}"
+echo -e "${GREEN}Building PaddleOCR-VL GPU variant...${NC}"
 docker build \
-    -f Dockerfile_paddleocr \
+    -f Dockerfile_paddleocr_vl_gpu \
-    -t ${REGISTRY}/${NAMESPACE}/${IMAGE_NAME}:paddleocr \
+    -t ${REGISTRY}/${NAMESPACE}/${IMAGE_NAME}:paddleocr-vl \
-    -t ${REGISTRY}/${NAMESPACE}/${IMAGE_NAME}:paddleocr-gpu \
+    -t ${REGISTRY}/${NAMESPACE}/${IMAGE_NAME}:paddleocr-vl-gpu \
     .
 
-# Build PaddleOCR CPU variant
+# Build PaddleOCR-VL CPU variant
-echo -e "${GREEN}Building PaddleOCR CPU variant...${NC}"
+echo -e "${GREEN}Building PaddleOCR-VL CPU variant...${NC}"
 docker build \
-    -f Dockerfile_paddleocr_cpu \
+    -f Dockerfile_paddleocr_vl_cpu \
-    -t ${REGISTRY}/${NAMESPACE}/${IMAGE_NAME}:paddleocr-cpu \
+    -t ${REGISTRY}/${NAMESPACE}/${IMAGE_NAME}:paddleocr-vl-cpu \
     .
 
 echo -e "${GREEN}All images built successfully!${NC}"
@@ -52,7 +52,7 @@ echo "  - ${REGISTRY}/${NAMESPACE}/${IMAGE_NAME}:minicpm45v (GPU)"
 echo "  - ${REGISTRY}/${NAMESPACE}/${IMAGE_NAME}:minicpm45v-cpu (CPU)"
 echo "  - ${REGISTRY}/${NAMESPACE}/${IMAGE_NAME}:latest (GPU)"
 echo ""
-echo "  PaddleOCR:"
+echo "  PaddleOCR-VL (Vision-Language Model):"
-echo "  - ${REGISTRY}/${NAMESPACE}/${IMAGE_NAME}:paddleocr (GPU)"
+echo "  - ${REGISTRY}/${NAMESPACE}/${IMAGE_NAME}:paddleocr-vl (GPU/vLLM)"
-echo "  - ${REGISTRY}/${NAMESPACE}/${IMAGE_NAME}:paddleocr-gpu (GPU)"
+echo "  - ${REGISTRY}/${NAMESPACE}/${IMAGE_NAME}:paddleocr-vl-gpu (GPU/vLLM)"
-echo "  - ${REGISTRY}/${NAMESPACE}/${IMAGE_NAME}:paddleocr-cpu (CPU)"
+echo "  - ${REGISTRY}/${NAMESPACE}/${IMAGE_NAME}:paddleocr-vl-cpu (CPU)"

changelog.md

@@ -1,5 +1,100 @@
 # Changelog
 
+## 2026-01-18 - 1.12.0 - feat(tests)
+switch vision tests to multi-query extraction (count then per-row/field queries) and add logging/summaries
+
+- Replace streaming + consensus pipeline with multi-query approach: count rows per page, then query each transaction/field individually (batched parallel queries).
+- Introduce unified helpers (queryVision / queryField / getTransaction / countTransactions) and simplify Ollama requests (stream:false, reduced num_predict, /no_think prompts).
+- Improve parsing and normalization for amounts (European formats), invoice numbers, dates and currency extraction.
+- Adjust model checks to look for generic 'minicpm' and update test names/messages; add pass/fail counters and a summary test output.
+- Remove previous consensus voting and streaming JSON accumulation logic, and add immediate per-transaction logging and batching.
+
+## 2026-01-18 - 1.11.0 - feat(vision)
+process pages separately and make Qwen3-VL vision extraction more robust; add per-page parsing, safer JSON handling, reduced token usage, and multi-query invoice extraction
+
+- Bank statements: split extraction into extractTransactionsFromPage and sequentially process pages to avoid thinking-token exhaustion
+- Bank statements: reduced num_predict from 8000 to 4000, send single image per request, added per-page logging and non-throwing handling for empty or non-JSON responses
+- Bank statements: catch JSON.parse errors and return empty array instead of throwing
+- Invoices: introduced queryField to request single values and perform multiple simple queries (reduces model thinking usage)
+- Invoices: reduced num_predict for invoice queries from 4000 to 500 and parse amounts robustly (handles European formats like 1.234,56)
+- Invoices: normalize currency to uppercase 3-letter code, return safe defaults (empty strings / 0) instead of nulls, and parse net/vat/total with fallbacks
+- General: simplified Ollama API error messages to avoid including response body content in thrown errors
+
+## 2026-01-18 - 1.10.1 - fix(tests)
+improve Qwen3-VL invoice extraction test by switching to non-stream API, adding model availability/pull checks, simplifying response parsing, and tightening model options
+
+- Replaced streaming reader logic with direct JSON parsing of the /api/chat response
+- Added ensureQwen3Vl() to check and pull the Qwen3-VL:8b model from Ollama
+- Switched to ensureMiniCpm() to verify Ollama service is running before model checks
+- Use /no_think prompt for direct JSON output and set temperature to 0.0 and num_predict to 512
+- Removed retry loop and streaming parsing; improved error messages to include response body
+- Updated logging and test setup messages for clarity
+
+## 2026-01-18 - 1.10.0 - feat(vision)
+add Qwen3-VL vision model support with Dockerfile and tests; improve invoice OCR conversion and prompts; simplify extraction flow by removing consensus voting
+
+- Add Dockerfile_qwen3vl to provide an Ollama-based image for Qwen3-VL and expose the Ollama API on port 11434
+- Introduce test/test.invoices.qwen3vl.ts and ensureQwen3Vl() helper to pull and test qwen3-vl:8b
+- Improve PDF->PNG conversion and prompt in ministral3 tests (higher DPI, max quality, sharpen) and increase num_predict from 512 to 1024
+- Simplify extraction pipeline: remove consensus voting, log single-pass results, and simplify OCR HTML sanitization/truncation logic
+
+## 2026-01-18 - 1.9.0 - feat(tests)
+add Ministral 3 vision tests and improve invoice extraction pipeline to use Ollama chat schema, sanitization, and multi-page support
+
+- Add new vision-based test suites for Ministral 3: test/test.invoices.ministral3.ts and test/test.bankstatements.ministral3.ts (model ministral-3:8b).
+- Introduce ensureMinistral3() helper to start/check Ollama/MiniCPM model in test/helpers/docker.ts.
+- Switch invoice extraction to use Ollama /api/chat with a JSON schema (format) and streaming support (reads message.content).
+- Improve HTML handling: sanitizeHtml() to remove OCR artifacts, concatenate multi-page HTML with page markers, and increase truncation limits.
+- Enhance response parsing: strip Markdown code fences, robustly locate JSON object boundaries, and provide clearer JSON parse errors.
+- Add PDF->PNG conversion (ImageMagick) and direct image-based extraction flow for vision model tests.
+
+## 2026-01-18 - 1.8.0 - feat(paddleocr-vl)
+add structured HTML output and table parsing for PaddleOCR-VL, update API, tests, and README
+
+- Add result_to_html(), parse_markdown_table(), and parse_paddleocr_table() to emit semantic HTML and convert OCR/markdown tables to proper <table> elements
+- Enhance result_to_markdown() with positional/type hints (header/footer/title/table/figure) to improve downstream LLM processing
+- Expose 'html' in supported formats and handle output_format='html' in parse endpoints and CLI flow
+- Update tests to request HTML output and extract invoice fields from structured HTML (test/test.invoices.paddleocr-vl.ts)
+- Refresh README with usage, new images/tags, architecture notes, and troubleshooting for the updated pipeline
+
+## 2026-01-17 - 1.7.1 - fix(docker)
+standardize Dockerfile and entrypoint filenames; add GPU-specific Dockerfiles and update build and test references
+
+- Added Dockerfile_minicpm45v_gpu and image_support_files/minicpm45v_entrypoint.sh; removed the old Dockerfile_minicpm45v and docker-entrypoint.sh
+- Renamed and simplified PaddleOCR entrypoint to image_support_files/paddleocr_vl_entrypoint.sh and updated CPU/GPU Dockerfile references
+- Updated build-images.sh to use *_gpu Dockerfiles and clarified PaddleOCR GPU build log
+- Updated test/helpers/docker.ts to point to Dockerfile_minicpm45v_gpu so tests build the GPU variant
+
+## 2026-01-17 - 1.7.0 - feat(tests)
+use Qwen2.5 (Ollama) for invoice extraction tests and add helpers for model management; normalize dates and coerce numeric fields
+
+- Added ensureOllamaModel and ensureQwen25 test helpers to pull/check Ollama models via localhost:11434
+- Updated invoices test to use qwen2.5:7b instead of MiniCPM and removed image payload from the text-only extraction step
+- Increased Markdown truncate limit from 8000 to 12000 and reduced model num_predict from 2048 to 512
+- Rewrote extraction prompt to require strict JSON output and added post-processing to parse/convert numeric fields
+- Added normalizeDate and improved compareInvoice to normalize dates and handle numeric formatting/tolerance
+- Updated test setup to ensure Qwen2.5 is available and adjusted logging/messages to reflect the Qwen2.5-based workflow
+
+## 2026-01-17 - 1.6.0 - feat(paddleocr-vl)
+add PaddleOCR-VL full pipeline Docker image and API server, plus integration tests and docker helpers
+
+- Add Dockerfile_paddleocr_vl_full and entrypoint script to build a GPU-enabled image with PP-DocLayoutV2 + PaddleOCR-VL and a FastAPI server
+- Introduce image_support_files/paddleocr_vl_full_server.py implementing the full pipeline API (/parse, OpenAI-compatible /v1/chat/completions) and a /formats endpoint
+- Improve image handling: decode_image supports data URLs, HTTP(S), raw base64 and file paths; add optimize_image_resolution to auto-scale images into the recommended 1080-2048px range
+- Add test helpers (test/helpers/docker.ts) to build/start/health-check Docker images and new ensurePaddleOcrVlFull workflow
+- Add comprehensive integration tests for bank statements and invoices (MiniCPM and PaddleOCR-VL variants) and update tests to ensure required containers are running before tests
+- Switch MiniCPM model references to 'minicpm-v:latest' and increase health/timeout expectations for the full pipeline
+
+## 2026-01-17 - 1.5.0 - feat(paddleocr-vl)
+add PaddleOCR-VL GPU Dockerfile, pin vllm, update CPU image deps, and improve entrypoint and tests
+
+- Add a new GPU Dockerfile for PaddleOCR-VL (transformers-based) with CUDA support, healthcheck, and entrypoint.
+- Pin vllm to 0.11.1 in Dockerfile_paddleocr_vl to use the first stable release with PaddleOCR-VL support.
+- Update CPU image: add torchvision==0.20.1 and extra Python deps (protobuf, sentencepiece, einops) required by the transformers-based server.
+- Rewrite paddleocr-vl-entrypoint.sh to build vllm args array, add MAX_MODEL_LEN and ENFORCE_EAGER env vars, include --limit-mm-per-prompt and optional --enforce-eager, and switch to exec vllm with constructed args.
+- Update tests to use the OpenAI-compatible PaddleOCR-VL chat completions API (/v1/chat/completions) with image+text message payload and model 'paddleocr-vl'.
+- Add @types/node to package.json dependencies and tidy devDependencies ordering.
+
 ## 2026-01-16 - 1.4.0 - feat(invoices)
 add hybrid OCR + vision invoice/document parsing with PaddleOCR, consensus voting, and prompt/test refactors
 

image_support_files/paddleocr-entrypoint.sh

@@ -1,25 +0,0 @@
-#!/bin/bash
-set -e
-
-# Configuration from environment
-OCR_LANGUAGE="${OCR_LANGUAGE:-en}"
-SERVER_PORT="${SERVER_PORT:-5000}"
-SERVER_HOST="${SERVER_HOST:-0.0.0.0}"
-
-echo "Starting PaddleOCR Server..."
-echo "  Language: ${OCR_LANGUAGE}"
-echo "  Host: ${SERVER_HOST}"
-echo "  Port: ${SERVER_PORT}"
-
-# Check GPU availability
-if [ "${CUDA_VISIBLE_DEVICES}" = "-1" ]; then
-    echo "  GPU: Disabled (CPU mode)"
-else
-    echo "  GPU: Enabled"
-fi
-
-# Start the FastAPI server with uvicorn
-exec python -m uvicorn paddleocr_server:app \
-    --host "${SERVER_HOST}" \
-    --port "${SERVER_PORT}" \
-    --workers 1

image_support_files/paddleocr_server.py

@@ -1,253 +0,0 @@
-#!/usr/bin/env python3
-"""
-PaddleOCR FastAPI Server
-Provides REST API for OCR operations using PaddleOCR
-"""
-
-import os
-import io
-import base64
-import logging
-from typing import Optional, List, Any
-
-from fastapi import FastAPI, File, UploadFile, Form, HTTPException
-from fastapi.responses import JSONResponse
-from pydantic import BaseModel
-import numpy as np
-from PIL import Image
-from paddleocr import PaddleOCR
-
-# Configure logging
-logging.basicConfig(
-    level=logging.INFO,
-    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
-)
-logger = logging.getLogger(__name__)
-
-# Environment configuration
-OCR_LANGUAGE = os.environ.get('OCR_LANGUAGE', 'en')
-# GPU is controlled via CUDA_VISIBLE_DEVICES environment variable
-USE_GPU = os.environ.get('CUDA_VISIBLE_DEVICES', '') != '-1'
-
-# Initialize FastAPI app
-app = FastAPI(
-    title="PaddleOCR Server",
-    description="REST API for OCR operations using PaddleOCR PP-OCRv4",
-    version="1.0.0"
-)
-
-# Global OCR instance
-ocr_instance: Optional[PaddleOCR] = None
-
-
-class OCRRequest(BaseModel):
-    """Request model for base64 image OCR"""
-    image: str
-    language: Optional[str] = None
-
-
-class BoundingBox(BaseModel):
-    """Bounding box for detected text"""
-    points: List[List[float]]
-
-
-class OCRResult(BaseModel):
-    """Single OCR detection result"""
-    text: str
-    confidence: float
-    box: List[List[float]]
-
-
-class OCRResponse(BaseModel):
-    """OCR response model"""
-    success: bool
-    results: List[OCRResult]
-    error: Optional[str] = None
-
-
-class HealthResponse(BaseModel):
-    """Health check response"""
-    status: str
-    model: str
-    language: str
-    gpu_enabled: bool
-
-
-def get_ocr(lang: Optional[str] = None) -> PaddleOCR:
-    """Get or initialize the OCR instance"""
-    global ocr_instance
-    use_lang = lang or OCR_LANGUAGE
-
-    # Return cached instance if same language
-    if ocr_instance is not None and lang is None:
-        return ocr_instance
-
-    logger.info(f"Initializing PaddleOCR with language={use_lang}, use_gpu={USE_GPU}")
-    new_ocr = PaddleOCR(
-        use_angle_cls=True,
-        lang=use_lang,
-        use_gpu=USE_GPU,
-        show_log=False
-    )
-
-    # Cache the default language instance
-    if lang is None:
-        ocr_instance = new_ocr
-
-    logger.info("PaddleOCR initialized successfully")
-    return new_ocr
-
-
-def decode_base64_image(base64_string: str) -> np.ndarray:
-    """Decode base64 string to numpy array"""
-    # Remove data URL prefix if present
-    if ',' in base64_string:
-        base64_string = base64_string.split(',')[1]
-
-    image_data = base64.b64decode(base64_string)
-    image = Image.open(io.BytesIO(image_data))
-
-    # Convert to RGB if necessary
-    if image.mode != 'RGB':
-        image = image.convert('RGB')
-
-    return np.array(image)
-
-
-def process_ocr_result(result: Any) -> List[OCRResult]:
-    """Process PaddleOCR result into structured format"""
-    results = []
-
-    if result is None or len(result) == 0:
-        return results
-
-    # PaddleOCR returns list of results per image
-    # Each result is a list of [box, (text, confidence)]
-    for line in result[0] if result[0] else []:
-        if line is None:
-            continue
-
-        box = line[0]  # [[x1,y1], [x2,y2], [x3,y3], [x4,y4]]
-        text_info = line[1]  # (text, confidence)
-
-        results.append(OCRResult(
-            text=text_info[0],
-            confidence=float(text_info[1]),
-            box=[[float(p[0]), float(p[1])] for p in box]
-        ))
-
-    return results
-
-
-@app.on_event("startup")
-async def startup_event():
-    """Pre-warm the OCR model on startup"""
-    logger.info("Pre-warming OCR model...")
-    try:
-        ocr = get_ocr()
-        # Create a small test image to warm up the model
-        test_image = np.zeros((100, 100, 3), dtype=np.uint8)
-        test_image.fill(255)  # White image
-        ocr.ocr(test_image, cls=True)
-        logger.info("OCR model pre-warmed successfully")
-    except Exception as e:
-        logger.error(f"Failed to pre-warm OCR model: {e}")
-
-
-@app.get("/health", response_model=HealthResponse)
-async def health_check():
-    """Health check endpoint"""
-    try:
-        # Ensure OCR is initialized
-        get_ocr()
-        return HealthResponse(
-            status="healthy",
-            model="PP-OCRv4",
-            language=OCR_LANGUAGE,
-            gpu_enabled=USE_GPU
-        )
-    except Exception as e:
-        logger.error(f"Health check failed: {e}")
-        raise HTTPException(status_code=503, detail=str(e))
-
-
-@app.post("/ocr", response_model=OCRResponse)
-async def ocr_base64(request: OCRRequest):
-    """
-    Perform OCR on a base64-encoded image
-
-    Args:
-        request: OCRRequest with base64 image and optional language
-
-    Returns:
-        OCRResponse with detected text, confidence scores, and bounding boxes
-    """
-    try:
-        # Decode image
-        image = decode_base64_image(request.image)
-
-        # Get OCR instance (use request language if provided)
-        if request.language and request.language != OCR_LANGUAGE:
-            ocr = get_ocr(request.language)
-        else:
-            ocr = get_ocr()
-
-        result = ocr.ocr(image, cls=True)
-
-        # Process results
-        results = process_ocr_result(result)
-
-        return OCRResponse(success=True, results=results)
-
-    except Exception as e:
-        logger.error(f"OCR processing failed: {e}")
-        return OCRResponse(success=False, results=[], error=str(e))
-
-
-@app.post("/ocr/upload", response_model=OCRResponse)
-async def ocr_upload(
-    img: UploadFile = File(...),
-    language: Optional[str] = Form(None)
-):
-    """
-    Perform OCR on an uploaded image file
-
-    Args:
-        img: Uploaded image file
-        language: Optional language code (default: env OCR_LANGUAGE)
-
-    Returns:
-        OCRResponse with detected text, confidence scores, and bounding boxes
-    """
-    try:
-        # Read image
-        contents = await img.read()
-        image = Image.open(io.BytesIO(contents))
-
-        # Convert to RGB if necessary
-        if image.mode != 'RGB':
-            image = image.convert('RGB')
-
-        image_array = np.array(image)
-
-        # Get OCR instance
-        if language and language != OCR_LANGUAGE:
-            ocr = get_ocr(language)
-        else:
-            ocr = get_ocr()
-
-        result = ocr.ocr(image_array, cls=True)
-
-        # Process results
-        results = process_ocr_result(result)
-
-        return OCRResponse(success=True, results=results)
-
-    except Exception as e:
-        logger.error(f"OCR processing failed: {e}")
-        return OCRResponse(success=False, results=[], error=str(e))
-
-
-if __name__ == "__main__":
-    import uvicorn
-    uvicorn.run(app, host="0.0.0.0", port=5000)

image_support_files/paddleocr_vl_entrypoint.sh

@@ -0,0 +1,19 @@
+#!/bin/bash
+set -e
+
+echo "==================================="
+echo "PaddleOCR-VL Server (CPU)"
+echo "==================================="
+
+HOST="${SERVER_HOST:-0.0.0.0}"
+PORT="${SERVER_PORT:-8000}"
+
+echo "Host: ${HOST}"
+echo "Port: ${PORT}"
+echo "Device: CPU (no GPU)"
+echo ""
+
+echo "Starting PaddleOCR-VL CPU server..."
+echo "==================================="
+
+exec python /app/paddleocr_vl_server.py

image_support_files/paddleocr_vl_full_entrypoint.sh

@@ -0,0 +1,12 @@
+#!/bin/bash
+set -e
+
+echo "Starting PaddleOCR-VL Full Pipeline Server (Transformers backend)..."
+
+# Environment
+SERVER_PORT=${SERVER_PORT:-8000}
+SERVER_HOST=${SERVER_HOST:-0.0.0.0}
+
+# Start our API server directly (no vLLM - uses local transformers inference)
+echo "Starting API server on port $SERVER_PORT..."
+exec python /app/server.py

image_support_files/paddleocr_vl_full_server.py

@@ -0,0 +1,636 @@
+#!/usr/bin/env python3
+"""
+PaddleOCR-VL Full Pipeline API Server (Transformers backend)
+
+Provides REST API for document parsing using:
+- PP-DocLayoutV2 for layout detection
+- PaddleOCR-VL (transformers) for recognition
+- Structured JSON/Markdown output
+"""
+
+import os
+import io
+import re
+import base64
+import logging
+import tempfile
+import time
+import json
+from typing import Optional, List, Union
+from pathlib import Path
+
+from fastapi import FastAPI, HTTPException, UploadFile, File, Form
+from fastapi.responses import JSONResponse
+from pydantic import BaseModel
+from PIL import Image
+import torch
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
+
+# Environment configuration
+SERVER_HOST = os.environ.get('SERVER_HOST', '0.0.0.0')
+SERVER_PORT = int(os.environ.get('SERVER_PORT', '8000'))
+MODEL_NAME = "PaddlePaddle/PaddleOCR-VL"
+
+# Device configuration
+DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
+logger.info(f"Using device: {DEVICE}")
+
+# Task prompts
+TASK_PROMPTS = {
+    "ocr": "OCR:",
+    "table": "Table Recognition:",
+    "formula": "Formula Recognition:",
+    "chart": "Chart Recognition:",
+}
+
+# Initialize FastAPI app
+app = FastAPI(
+    title="PaddleOCR-VL Full Pipeline Server",
+    description="Document parsing with PP-DocLayoutV2 + PaddleOCR-VL (transformers)",
+    version="1.0.0"
+)
+
+# Global model instances
+vl_model = None
+vl_processor = None
+layout_model = None
+
+
+def load_vl_model():
+    """Load the PaddleOCR-VL model for element recognition"""
+    global vl_model, vl_processor
+
+    if vl_model is not None:
+        return
+
+    logger.info(f"Loading PaddleOCR-VL model: {MODEL_NAME}")
+    from transformers import AutoModelForCausalLM, AutoProcessor
+
+    vl_processor = AutoProcessor.from_pretrained(MODEL_NAME, trust_remote_code=True)
+
+    if DEVICE == "cuda":
+        vl_model = AutoModelForCausalLM.from_pretrained(
+            MODEL_NAME,
+            trust_remote_code=True,
+            torch_dtype=torch.bfloat16,
+        ).to(DEVICE).eval()
+    else:
+        vl_model = AutoModelForCausalLM.from_pretrained(
+            MODEL_NAME,
+            trust_remote_code=True,
+            torch_dtype=torch.float32,
+            low_cpu_mem_usage=True,
+        ).eval()
+
+    logger.info("PaddleOCR-VL model loaded successfully")
+
+
+def load_layout_model():
+    """Load the LayoutDetection model for layout detection"""
+    global layout_model
+
+    if layout_model is not None:
+        return
+
+    try:
+        logger.info("Loading LayoutDetection model (PP-DocLayout_plus-L)...")
+        from paddleocr import LayoutDetection
+
+        layout_model = LayoutDetection()
+        logger.info("LayoutDetection model loaded successfully")
+    except Exception as e:
+        logger.warning(f"Could not load LayoutDetection: {e}")
+        logger.info("Falling back to VL-only mode (no layout detection)")
+
+
+def recognize_element(image: Image.Image, task: str = "ocr") -> str:
+    """Recognize a single element using PaddleOCR-VL"""
+    load_vl_model()
+
+    prompt = TASK_PROMPTS.get(task, TASK_PROMPTS["ocr"])
+
+    messages = [
+        {
+            "role": "user",
+            "content": [
+                {"type": "image", "image": image},
+                {"type": "text", "text": prompt},
+            ]
+        }
+    ]
+
+    inputs = vl_processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    )
+
+    if DEVICE == "cuda":
+        inputs = {k: v.to(DEVICE) for k, v in inputs.items()}
+
+    with torch.inference_mode():
+        outputs = vl_model.generate(
+            **inputs,
+            max_new_tokens=4096,
+            do_sample=False,
+            use_cache=True
+        )
+
+    response = vl_processor.batch_decode(outputs, skip_special_tokens=True)[0]
+
+    # Extract only the assistant's response content
+    # The response format is: "User: <prompt>\nAssistant: <content>"
+    # We want to extract just the content after "Assistant:"
+    if "Assistant:" in response:
+        parts = response.split("Assistant:")
+        if len(parts) > 1:
+            response = parts[-1].strip()
+    elif "assistant:" in response.lower():
+        # Case-insensitive fallback
+        import re
+        match = re.split(r'[Aa]ssistant:', response)
+        if len(match) > 1:
+            response = match[-1].strip()
+
+    return response
+
+
+def detect_layout(image: Image.Image) -> List[dict]:
+    """Detect layout regions in the image"""
+    load_layout_model()
+
+    if layout_model is None:
+        # No layout model - return a single region covering the whole image
+        return [{
+            "type": "text",
+            "bbox": [0, 0, image.width, image.height],
+            "score": 1.0
+        }]
+
+    # Save image to temp file
+    with tempfile.NamedTemporaryFile(suffix=".png", delete=False) as tmp:
+        image.save(tmp.name, "PNG")
+        tmp_path = tmp.name
+
+    try:
+        results = layout_model.predict(tmp_path)
+        regions = []
+
+        for res in results:
+            # LayoutDetection returns boxes in 'boxes' key
+            for box in res.get("boxes", []):
+                coord = box.get("coordinate", [0, 0, image.width, image.height])
+                # Convert numpy floats to regular floats
+                bbox = [float(c) for c in coord]
+                regions.append({
+                    "type": box.get("label", "text"),
+                    "bbox": bbox,
+                    "score": float(box.get("score", 1.0))
+                })
+
+        # Sort regions by vertical position (top to bottom)
+        regions.sort(key=lambda r: r["bbox"][1])
+
+        return regions if regions else [{
+            "type": "text",
+            "bbox": [0, 0, image.width, image.height],
+            "score": 1.0
+        }]
+
+    finally:
+        os.unlink(tmp_path)
+
+
+def process_document(image: Image.Image) -> dict:
+    """Process a document through the full pipeline"""
+    logger.info(f"Processing document: {image.size}")
+
+    # Step 1: Detect layout
+    regions = detect_layout(image)
+    logger.info(f"Detected {len(regions)} layout regions")
+
+    # Step 2: Recognize each region
+    blocks = []
+    for i, region in enumerate(regions):
+        region_type = region["type"].lower()
+        bbox = region["bbox"]
+
+        # Crop region from image
+        x1, y1, x2, y2 = [int(c) for c in bbox]
+        region_image = image.crop((x1, y1, x2, y2))
+
+        # Determine task based on region type
+        if "table" in region_type:
+            task = "table"
+        elif "formula" in region_type or "math" in region_type:
+            task = "formula"
+        elif "chart" in region_type or "figure" in region_type:
+            task = "chart"
+        else:
+            task = "ocr"
+
+        # Recognize the region
+        try:
+            content = recognize_element(region_image, task)
+            blocks.append({
+                "index": i,
+                "type": region_type,
+                "bbox": bbox,
+                "content": content,
+                "task": task
+            })
+            logger.info(f"  Region {i} ({region_type}): {len(content)} chars")
+        except Exception as e:
+            logger.error(f"  Region {i} error: {e}")
+            blocks.append({
+                "index": i,
+                "type": region_type,
+                "bbox": bbox,
+                "content": "",
+                "error": str(e)
+            })
+
+    return {"blocks": blocks, "image_size": list(image.size)}
+
+
+def result_to_markdown(result: dict) -> str:
+    """Convert result to Markdown format with structural hints for LLM processing.
+
+    Adds positional and type-based formatting to help downstream LLMs
+    understand document structure:
+    - Tables are marked with **[TABLE]** prefix
+    - Header zone content (top 15%) is bolded
+    - Footer zone content (bottom 15%) is separated with horizontal rule
+    - Titles are formatted as # headers
+    - Figures/charts are marked with *[Figure: ...]*
+    """
+    lines = []
+    image_height = result.get("image_size", [0, 1000])[1]
+
+    for block in result.get("blocks", []):
+        block_type = block.get("type", "text").lower()
+        content = block.get("content", "").strip()
+        bbox = block.get("bbox", [])
+
+        if not content:
+            continue
+
+        # Determine position zone (top 15%, middle, bottom 15%)
+        y_pos = bbox[1] if bbox and len(bbox) > 1 else 0
+        y_end = bbox[3] if bbox and len(bbox) > 3 else y_pos
+        is_header_zone = y_pos < image_height * 0.15
+        is_footer_zone = y_end > image_height * 0.85
+
+        # Format based on type and position
+        if "table" in block_type:
+            lines.append(f"\n**[TABLE]**\n{content}\n")
+        elif "title" in block_type:
+            lines.append(f"# {content}")
+        elif "formula" in block_type or "math" in block_type:
+            lines.append(f"\n$$\n{content}\n$$\n")
+        elif "figure" in block_type or "chart" in block_type:
+            lines.append(f"*[Figure: {content}]*")
+        elif is_header_zone:
+            lines.append(f"**{content}**")
+        elif is_footer_zone:
+            lines.append(f"---\n{content}")
+        else:
+            lines.append(content)
+
+    return "\n\n".join(lines)
+
+
+def parse_markdown_table(content: str) -> str:
+    """Convert table content to HTML table.
+
+    Handles:
+    - PaddleOCR-VL format: <fcel>cell<lcel>cell<nl> (detected by <fcel> tags)
+    - Pipe-delimited tables: | Header | Header |
+    - Separator rows: |---|---|
+    - Returns HTML <table> structure
+    """
+    content_stripped = content.strip()
+
+    # Check for PaddleOCR-VL table format (<fcel>, <lcel>, <ecel>, <nl>)
+    if '<fcel>' in content_stripped or '<nl>' in content_stripped:
+        return parse_paddleocr_table(content_stripped)
+
+    lines = content_stripped.split('\n')
+    if not lines:
+        return f'<pre>{content}</pre>'
+
+    # Check if it looks like a markdown table
+    if not any('|' in line for line in lines):
+        return f'<pre>{content}</pre>'
+
+    html_rows = []
+    is_header = True
+
+    for line in lines:
+        line = line.strip()
+        if not line or line.startswith('|') == False and '|' not in line:
+            continue
+
+        # Skip separator rows (|---|---|)
+        if re.match(r'^[\|\s\-:]+$', line):
+            is_header = False
+            continue
+
+        # Parse cells
+        cells = [c.strip() for c in line.split('|')]
+        cells = [c for c in cells if c]  # Remove empty from edges
+
+        if is_header:
+            row = '<tr>' + ''.join(f'<th>{c}</th>' for c in cells) + '</tr>'
+            html_rows.append(f'<thead>{row}</thead>')
+            is_header = False
+        else:
+            row = '<tr>' + ''.join(f'<td>{c}</td>' for c in cells) + '</tr>'
+            html_rows.append(row)
+
+    if html_rows:
+        # Wrap body rows in tbody
+        header = html_rows[0] if '<thead>' in html_rows[0] else ''
+        body_rows = [r for r in html_rows if '<thead>' not in r]
+        body = f'<tbody>{"".join(body_rows)}</tbody>' if body_rows else ''
+        return f'<table>{header}{body}</table>'
+
+    return f'<pre>{content}</pre>'
+
+
+def parse_paddleocr_table(content: str) -> str:
+    """Convert PaddleOCR-VL table format to HTML table.
+
+    PaddleOCR-VL uses:
+    - <fcel> = first cell in a row
+    - <lcel> = subsequent cells
+    - <ecel> = empty cell
+    - <nl> = row separator (newline)
+
+    Example input:
+    <fcel>Header1<lcel>Header2<nl><fcel>Value1<lcel>Value2<nl>
+    """
+    # Split into rows by <nl>
+    rows_raw = re.split(r'<nl>', content)
+    html_rows = []
+    is_first_row = True
+
+    for row_content in rows_raw:
+        row_content = row_content.strip()
+        if not row_content:
+            continue
+
+        # Extract cells: split by <fcel>, <lcel>, or <ecel>
+        # Each cell is the text between these markers
+        cells = []
+
+        # Pattern to match cell markers and capture content
+        # Content is everything between markers
+        parts = re.split(r'<fcel>|<lcel>|<ecel>', row_content)
+        for part in parts:
+            part = part.strip()
+            if part:
+                cells.append(part)
+
+        if not cells:
+            continue
+
+        # First row is header
+        if is_first_row:
+            row_html = '<tr>' + ''.join(f'<th>{c}</th>' for c in cells) + '</tr>'
+            html_rows.append(f'<thead>{row_html}</thead>')
+            is_first_row = False
+        else:
+            row_html = '<tr>' + ''.join(f'<td>{c}</td>' for c in cells) + '</tr>'
+            html_rows.append(row_html)
+
+    if html_rows:
+        header = html_rows[0] if '<thead>' in html_rows[0] else ''
+        body_rows = [r for r in html_rows if '<thead>' not in r]
+        body = f'<tbody>{"".join(body_rows)}</tbody>' if body_rows else ''
+        return f'<table>{header}{body}</table>'
+
+    return f'<pre>{content}</pre>'
+
+
+def result_to_html(result: dict) -> str:
+    """Convert result to semantic HTML for optimal LLM processing.
+
+    Uses semantic HTML5 tags with position metadata as data-* attributes.
+    Markdown tables are converted to proper HTML <table> tags for
+    unambiguous parsing by downstream LLMs.
+    """
+    parts = []
+    image_height = result.get("image_size", [0, 1000])[1]
+
+    parts.append('<!DOCTYPE html><html><body>')
+
+    for block in result.get("blocks", []):
+        block_type = block.get("type", "text").lower()
+        content = block.get("content", "").strip()
+        bbox = block.get("bbox", [])
+
+        if not content:
+            continue
+
+        # Position metadata
+        y_pos = bbox[1] / image_height if bbox and len(bbox) > 1 else 0
+        data_attrs = f'data-type="{block_type}" data-y="{y_pos:.2f}"'
+
+        # Format based on type
+        if "table" in block_type:
+            table_html = parse_markdown_table(content)
+            parts.append(f'<section {data_attrs} class="table-region">{table_html}</section>')
+        elif "title" in block_type:
+            parts.append(f'<h1 {data_attrs}>{content}</h1>')
+        elif "formula" in block_type or "math" in block_type:
+            parts.append(f'<div {data_attrs} class="formula"><code>{content}</code></div>')
+        elif "figure" in block_type or "chart" in block_type:
+            parts.append(f'<figure {data_attrs}><figcaption>{content}</figcaption></figure>')
+        elif y_pos < 0.15:
+            parts.append(f'<header {data_attrs}><strong>{content}</strong></header>')
+        elif y_pos > 0.85:
+            parts.append(f'<footer {data_attrs}>{content}</footer>')
+        else:
+            parts.append(f'<p {data_attrs}>{content}</p>')
+
+    parts.append('</body></html>')
+    return '\n'.join(parts)
+
+
+# Request/Response models
+class ParseRequest(BaseModel):
+    image: str  # base64 encoded image
+    output_format: Optional[str] = "json"
+
+
+class ParseResponse(BaseModel):
+    success: bool
+    format: str
+    result: Union[dict, str]
+    processing_time: float
+    error: Optional[str] = None
+
+
+def decode_image(image_source: str) -> Image.Image:
+    """Decode image from base64 or data URL"""
+    if image_source.startswith("data:"):
+        header, data = image_source.split(",", 1)
+        image_data = base64.b64decode(data)
+    else:
+        image_data = base64.b64decode(image_source)
+
+    return Image.open(io.BytesIO(image_data)).convert("RGB")
+
+
+@app.on_event("startup")
+async def startup_event():
+    """Pre-load models on startup"""
+    logger.info("Starting PaddleOCR-VL Full Pipeline Server...")
+    try:
+        load_vl_model()
+        load_layout_model()
+        logger.info("Models loaded successfully")
+    except Exception as e:
+        logger.error(f"Failed to pre-load models: {e}")
+
+
+@app.get("/health")
+async def health_check():
+    """Health check endpoint"""
+    return {
+        "status": "healthy" if vl_model is not None else "loading",
+        "service": "PaddleOCR-VL Full Pipeline (Transformers)",
+        "device": DEVICE,
+        "vl_model_loaded": vl_model is not None,
+        "layout_model_loaded": layout_model is not None
+    }
+
+
+@app.get("/formats")
+async def supported_formats():
+    """List supported output formats"""
+    return {
+        "output_formats": ["json", "markdown", "html"],
+        "image_formats": ["PNG", "JPEG", "WebP", "BMP", "GIF", "TIFF"],
+        "capabilities": [
+            "Layout detection (PP-DocLayoutV2)",
+            "Text recognition (OCR)",
+            "Table recognition",
+            "Formula recognition (LaTeX)",
+            "Chart recognition",
+            "Multi-language support (109 languages)"
+        ]
+    }
+
+
+@app.post("/parse", response_model=ParseResponse)
+async def parse_document_endpoint(request: ParseRequest):
+    """Parse a document image and return structured output"""
+    try:
+        start_time = time.time()
+
+        image = decode_image(request.image)
+        result = process_document(image)
+
+        if request.output_format == "markdown":
+            markdown = result_to_markdown(result)
+            output = {"markdown": markdown}
+        elif request.output_format == "html":
+            html = result_to_html(result)
+            output = {"html": html}
+        else:
+            output = result
+
+        elapsed = time.time() - start_time
+        logger.info(f"Processing complete in {elapsed:.2f}s")
+
+        return ParseResponse(
+            success=True,
+            format=request.output_format,
+            result=output,
+            processing_time=elapsed
+        )
+
+    except Exception as e:
+        logger.error(f"Error processing document: {e}", exc_info=True)
+        return ParseResponse(
+            success=False,
+            format=request.output_format,
+            result={},
+            processing_time=0,
+            error=str(e)
+        )
+
+
+@app.post("/v1/chat/completions")
+async def chat_completions(request: dict):
+    """OpenAI-compatible chat completions endpoint"""
+    try:
+        messages = request.get("messages", [])
+        output_format = request.get("output_format", "json")
+
+        # Find user message with image
+        image = None
+        for msg in reversed(messages):
+            if msg.get("role") == "user":
+                content = msg.get("content", [])
+                if isinstance(content, list):
+                    for item in content:
+                        if item.get("type") == "image_url":
+                            url = item.get("image_url", {}).get("url", "")
+                            image = decode_image(url)
+                            break
+                break
+
+        if image is None:
+            raise HTTPException(status_code=400, detail="No image provided")
+
+        start_time = time.time()
+        result = process_document(image)
+
+        if output_format == "markdown":
+            content = result_to_markdown(result)
+        elif output_format == "html":
+            content = result_to_html(result)
+        else:
+            content = json.dumps(result, ensure_ascii=False, indent=2)
+
+        elapsed = time.time() - start_time
+
+        return {
+            "id": f"chatcmpl-{int(time.time()*1000)}",
+            "object": "chat.completion",
+            "created": int(time.time()),
+            "model": "paddleocr-vl-full",
+            "choices": [{
+                "index": 0,
+                "message": {"role": "assistant", "content": content},
+                "finish_reason": "stop"
+            }],
+            "usage": {
+                "prompt_tokens": 100,
+                "completion_tokens": len(content) // 4,
+                "total_tokens": 100 + len(content) // 4
+            },
+            "processing_time": elapsed
+        }
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error in chat completions: {e}", exc_info=True)
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host=SERVER_HOST, port=SERVER_PORT)

image_support_files/paddleocr_vl_server.py

@@ -0,0 +1,465 @@
+#!/usr/bin/env python3
+"""
+PaddleOCR-VL FastAPI Server (CPU variant)
+Provides OpenAI-compatible REST API for document parsing using PaddleOCR-VL
+"""
+
+import os
+import io
+import base64
+import logging
+import time
+from typing import Optional, List, Any, Dict, Union
+
+from fastapi import FastAPI, HTTPException
+from fastapi.responses import JSONResponse
+from pydantic import BaseModel
+import torch
+from PIL import Image
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
+
+# Environment configuration
+SERVER_HOST = os.environ.get('SERVER_HOST', '0.0.0.0')
+SERVER_PORT = int(os.environ.get('SERVER_PORT', '8000'))
+MODEL_NAME = os.environ.get('MODEL_NAME', 'PaddlePaddle/PaddleOCR-VL')
+
+# Device configuration
+DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
+logger.info(f"Using device: {DEVICE}")
+
+# Task prompts for PaddleOCR-VL
+TASK_PROMPTS = {
+    "ocr": "OCR:",
+    "table": "Table Recognition:",
+    "formula": "Formula Recognition:",
+    "chart": "Chart Recognition:",
+}
+
+# Initialize FastAPI app
+app = FastAPI(
+    title="PaddleOCR-VL Server",
+    description="OpenAI-compatible REST API for document parsing using PaddleOCR-VL",
+    version="1.0.0"
+)
+
+# Global model instances
+model = None
+processor = None
+
+
+# Request/Response models (OpenAI-compatible)
+class ImageUrl(BaseModel):
+    url: str
+
+
+class ContentItem(BaseModel):
+    type: str
+    text: Optional[str] = None
+    image_url: Optional[ImageUrl] = None
+
+
+class Message(BaseModel):
+    role: str
+    content: Union[str, List[ContentItem]]
+
+
+class ChatCompletionRequest(BaseModel):
+    model: str = "paddleocr-vl"
+    messages: List[Message]
+    temperature: Optional[float] = 0.0
+    max_tokens: Optional[int] = 4096
+
+
+class Choice(BaseModel):
+    index: int
+    message: Message
+    finish_reason: str
+
+
+class Usage(BaseModel):
+    prompt_tokens: int
+    completion_tokens: int
+    total_tokens: int
+
+
+class ChatCompletionResponse(BaseModel):
+    id: str
+    object: str = "chat.completion"
+    created: int
+    model: str
+    choices: List[Choice]
+    usage: Usage
+
+
+class HealthResponse(BaseModel):
+    status: str
+    model: str
+    device: str
+
+
+def load_model():
+    """Load the PaddleOCR-VL model and processor"""
+    global model, processor
+
+    if model is not None:
+        return
+
+    logger.info(f"Loading PaddleOCR-VL model: {MODEL_NAME}")
+
+    from transformers import AutoModelForCausalLM, AutoProcessor
+
+    # Load processor
+    processor = AutoProcessor.from_pretrained(MODEL_NAME, trust_remote_code=True)
+
+    # Load model with appropriate settings for CPU/GPU
+    if DEVICE == "cuda":
+        model = AutoModelForCausalLM.from_pretrained(
+            MODEL_NAME,
+            trust_remote_code=True,
+            torch_dtype=torch.bfloat16,
+        ).to(DEVICE).eval()
+    else:
+        # CPU mode - use float32 for compatibility
+        model = AutoModelForCausalLM.from_pretrained(
+            MODEL_NAME,
+            trust_remote_code=True,
+            torch_dtype=torch.float32,
+            low_cpu_mem_usage=True,
+        ).eval()
+
+    logger.info("PaddleOCR-VL model loaded successfully")
+
+
+def optimize_image_resolution(image: Image.Image, max_size: int = 2048, min_size: int = 1080) -> Image.Image:
+    """
+    Optimize image resolution for PaddleOCR-VL.
+
+    Best results are achieved with images in the 1080p-2K range.
+    - Images larger than max_size are scaled down
+    - Very small images are scaled up to min_size
+    """
+    width, height = image.size
+    max_dim = max(width, height)
+    min_dim = min(width, height)
+
+    # Scale down if too large (4K+ images often miss text)
+    if max_dim > max_size:
+        scale = max_size / max_dim
+        new_width = int(width * scale)
+        new_height = int(height * scale)
+        logger.info(f"Scaling down image from {width}x{height} to {new_width}x{new_height}")
+        image = image.resize((new_width, new_height), Image.Resampling.LANCZOS)
+    # Scale up if too small
+    elif max_dim < min_size and min_dim < min_size:
+        scale = min_size / max_dim
+        new_width = int(width * scale)
+        new_height = int(height * scale)
+        logger.info(f"Scaling up image from {width}x{height} to {new_width}x{new_height}")
+        image = image.resize((new_width, new_height), Image.Resampling.LANCZOS)
+    else:
+        logger.info(f"Image size {width}x{height} is optimal, no scaling needed")
+
+    return image
+
+
+def decode_image(image_source: str, optimize: bool = True) -> Image.Image:
+    """
+    Decode image from various sources.
+
+    Supported formats:
+    - Base64 data URL: data:image/png;base64,... or data:image/jpeg;base64,...
+    - HTTP/HTTPS URL: https://example.com/image.png
+    - Raw base64 string
+    - Local file path
+
+    Supported image types: PNG, JPEG, WebP, BMP, GIF, TIFF
+    """
+    image = None
+
+    if image_source.startswith("data:"):
+        # Base64 encoded image with MIME type header
+        # Supports: data:image/png;base64,... data:image/jpeg;base64,... etc.
+        header, data = image_source.split(",", 1)
+        image_data = base64.b64decode(data)
+        image = Image.open(io.BytesIO(image_data)).convert("RGB")
+        logger.debug(f"Decoded base64 image with header: {header}")
+    elif image_source.startswith("http://") or image_source.startswith("https://"):
+        # URL - fetch image
+        import httpx
+        response = httpx.get(image_source, timeout=30.0)
+        response.raise_for_status()
+        image = Image.open(io.BytesIO(response.content)).convert("RGB")
+        logger.debug(f"Fetched image from URL: {image_source[:50]}...")
+    else:
+        # Assume it's a file path or raw base64
+        try:
+            image_data = base64.b64decode(image_source)
+            image = Image.open(io.BytesIO(image_data)).convert("RGB")
+            logger.debug("Decoded raw base64 image")
+        except:
+            # Try as file path
+            image = Image.open(image_source).convert("RGB")
+            logger.debug(f"Loaded image from file: {image_source}")
+
+    # Optimize resolution for best OCR results
+    if optimize:
+        image = optimize_image_resolution(image)
+
+    return image
+
+
+def extract_image_and_text(content: Union[str, List[ContentItem]]) -> tuple:
+    """Extract image and text prompt from message content"""
+    if isinstance(content, str):
+        return None, content
+
+    image = None
+    text = ""
+
+    for item in content:
+        if item.type == "image_url" and item.image_url:
+            image = decode_image(item.image_url.url)
+        elif item.type == "text" and item.text:
+            text = item.text
+
+    return image, text
+
+
+def generate_response(image: Image.Image, prompt: str, max_tokens: int = 4096) -> str:
+    """Generate response using PaddleOCR-VL"""
+    load_model()
+
+    messages = [
+        {
+            "role": "user",
+            "content": [
+                {"type": "image", "image": image},
+                {"type": "text", "text": prompt},
+            ]
+        }
+    ]
+
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    )
+
+    if DEVICE == "cuda":
+        inputs = {k: v.to(DEVICE) for k, v in inputs.items()}
+
+    with torch.inference_mode():
+        outputs = model.generate(
+            **inputs,
+            max_new_tokens=max_tokens,
+            do_sample=False,
+            use_cache=True
+        )
+
+    response = processor.batch_decode(outputs, skip_special_tokens=True)[0]
+
+    # Extract the assistant's response (after the prompt)
+    if "assistant" in response.lower():
+        parts = response.split("assistant")
+        if len(parts) > 1:
+            response = parts[-1].strip()
+
+    return response
+
+
+@app.on_event("startup")
+async def startup_event():
+    """Pre-load the model on startup"""
+    logger.info("Pre-loading PaddleOCR-VL model...")
+    try:
+        load_model()
+        logger.info("Model pre-loaded successfully")
+    except Exception as e:
+        logger.error(f"Failed to pre-load model: {e}")
+        # Don't fail startup - model will be loaded on first request
+
+
+@app.get("/health", response_model=HealthResponse)
+async def health_check():
+    """Health check endpoint"""
+    return HealthResponse(
+        status="healthy" if model is not None else "loading",
+        model=MODEL_NAME,
+        device=DEVICE
+    )
+
+
+@app.get("/formats")
+async def supported_formats():
+    """List supported image formats and input methods"""
+    return {
+        "image_formats": {
+            "supported": ["PNG", "JPEG", "WebP", "BMP", "GIF", "TIFF"],
+            "recommended": ["PNG", "JPEG"],
+            "mime_types": [
+                "image/png",
+                "image/jpeg",
+                "image/webp",
+                "image/bmp",
+                "image/gif",
+                "image/tiff"
+            ]
+        },
+        "input_methods": {
+            "base64_data_url": {
+                "description": "Base64 encoded image with MIME type header",
+                "example": "data:image/png;base64,iVBORw0KGgo..."
+            },
+            "http_url": {
+                "description": "Direct HTTP/HTTPS URL to image",
+                "example": "https://example.com/image.png"
+            },
+            "raw_base64": {
+                "description": "Raw base64 string without header",
+                "example": "iVBORw0KGgo..."
+            }
+        },
+        "resolution": {
+            "optimal_range": "1080p to 2K (1080-2048 pixels on longest side)",
+            "auto_scaling": True,
+            "note": "Images are automatically scaled to optimal range. 4K+ images are scaled down for better accuracy."
+        },
+        "task_prompts": TASK_PROMPTS
+    }
+
+
+@app.get("/v1/models")
+async def list_models():
+    """List available models (OpenAI-compatible)"""
+    return {
+        "object": "list",
+        "data": [
+            {
+                "id": "paddleocr-vl",
+                "object": "model",
+                "created": int(time.time()),
+                "owned_by": "paddlepaddle"
+            }
+        ]
+    }
+
+
+@app.post("/v1/chat/completions", response_model=ChatCompletionResponse)
+async def chat_completions(request: ChatCompletionRequest):
+    """
+    OpenAI-compatible chat completions endpoint for PaddleOCR-VL
+
+    Supports tasks:
+    - "OCR:" - Text recognition
+    - "Table Recognition:" - Table extraction
+    - "Formula Recognition:" - Formula extraction
+    - "Chart Recognition:" - Chart extraction
+    """
+    try:
+        # Get the last user message
+        user_message = None
+        for msg in reversed(request.messages):
+            if msg.role == "user":
+                user_message = msg
+                break
+
+        if not user_message:
+            raise HTTPException(status_code=400, detail="No user message found")
+
+        # Extract image and prompt
+        image, prompt = extract_image_and_text(user_message.content)
+
+        if image is None:
+            raise HTTPException(status_code=400, detail="No image provided in message")
+
+        # Default to OCR if no specific prompt
+        if not prompt or prompt.strip() == "":
+            prompt = "OCR:"
+
+        logger.info(f"Processing request with prompt: {prompt[:50]}...")
+
+        # Generate response
+        start_time = time.time()
+        response_text = generate_response(image, prompt, request.max_tokens or 4096)
+        elapsed = time.time() - start_time
+
+        logger.info(f"Generated response in {elapsed:.2f}s ({len(response_text)} chars)")
+
+        # Build OpenAI-compatible response
+        return ChatCompletionResponse(
+            id=f"chatcmpl-{int(time.time()*1000)}",
+            created=int(time.time()),
+            model=request.model,
+            choices=[
+                Choice(
+                    index=0,
+                    message=Message(role="assistant", content=response_text),
+                    finish_reason="stop"
+                )
+            ],
+            usage=Usage(
+                prompt_tokens=100,  # Approximate
+                completion_tokens=len(response_text) // 4,
+                total_tokens=100 + len(response_text) // 4
+            )
+        )
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error processing request: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+# Legacy endpoint for compatibility with old PaddleOCR API
+class LegacyOCRRequest(BaseModel):
+    image: str
+    task: Optional[str] = "ocr"
+
+
+class LegacyOCRResponse(BaseModel):
+    success: bool
+    result: str
+    task: str
+    error: Optional[str] = None
+
+
+@app.post("/ocr", response_model=LegacyOCRResponse)
+async def legacy_ocr(request: LegacyOCRRequest):
+    """
+    Legacy OCR endpoint for backwards compatibility
+
+    Tasks: ocr, table, formula, chart
+    """
+    try:
+        image = decode_image(request.image)
+        prompt = TASK_PROMPTS.get(request.task, TASK_PROMPTS["ocr"])
+
+        result = generate_response(image, prompt)
+
+        return LegacyOCRResponse(
+            success=True,
+            result=result,
+            task=request.task
+        )
+    except Exception as e:
+        logger.error(f"Legacy OCR error: {e}")
+        return LegacyOCRResponse(
+            success=False,
+            result="",
+            task=request.task,
+            error=str(e)
+        )
+
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host=SERVER_HOST, port=SERVER_PORT)

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@host.today/ht-docker-ai",
-  "version": "1.4.0",
+  "version": "1.12.0",
   "type": "module",
   "private": false,
   "description": "Docker images for AI vision-language models including MiniCPM-V 4.5",
@@ -13,8 +13,8 @@
     "test": "tstest test/ --verbose"
   },
   "devDependencies": {
-    "@git.zone/tstest": "^1.0.90",
+    "@git.zone/tsrun": "^1.3.3",
-    "@git.zone/tsrun": "^1.3.3"
+    "@git.zone/tstest": "^1.0.90"
   },
   "repository": {
     "type": "git",
@@ -28,5 +28,8 @@
     "minicpm",
     "ollama",
     "multimodal"
-  ]
+  ],
+  "dependencies": {
+    "@types/node": "^25.0.9"
+  }
 }

pnpm-lock.yaml

@@ -7,6 +7,10 @@ settings:
 importers:
 
   .:
+    dependencies:
+      '@types/node':
+        specifier: ^25.0.9
+        version: 25.0.9
     devDependencies:
       '@git.zone/tsrun':
         specifier: ^1.3.3

readme.hints.md

@@ -77,56 +77,73 @@ HEALTHCHECK --interval=30s --timeout=10s --start-period=60s --retries=3 \
 
 CPU variant has longer `start-period` (120s) due to slower startup.
 
-## PaddleOCR
+## PaddleOCR-VL (Recommended)
 
 ### Overview
 
-PaddleOCR is a standalone OCR service using PaddlePaddle's PP-OCRv4 model. It provides:
+PaddleOCR-VL is a 0.9B parameter Vision-Language Model specifically optimized for document parsing. It replaces the older PP-Structure approach with native VLM understanding.
 
-- Text detection and recognition
+**Key advantages over PP-Structure:**
-- Multi-language support
+- Native table understanding (no HTML parsing needed)
-- FastAPI REST API
+- 109 language support
-- GPU and CPU variants
+- Better handling of complex multi-row tables
+- Structured Markdown/JSON output
 
 ### Docker Images
 
 | Tag | Description |
 |-----|-------------|
-| `paddleocr` | GPU variant (default) |
+| `paddleocr-vl` | GPU variant using vLLM (recommended) |
-| `paddleocr-gpu` | GPU variant (alias) |
+| `paddleocr-vl-cpu` | CPU variant using transformers |
-| `paddleocr-cpu` | CPU-only variant |
 
-### API Endpoints
+### API Endpoints (OpenAI-compatible)
 
 | Endpoint | Method | Description |
 |----------|--------|-------------|
 | `/health` | GET | Health check with model info |
-| `/ocr` | POST | OCR with base64 image (JSON body) |
+| `/v1/models` | GET | List available models |
-| `/ocr/upload` | POST | OCR with file upload (multipart form) |
+| `/v1/chat/completions` | POST | OpenAI-compatible chat completions |
+| `/ocr` | POST | Legacy OCR endpoint |
 
 ### Request/Response Format
 
-**POST /ocr (JSON)**
+**POST /v1/chat/completions (OpenAI-compatible)**
 ```json
 {
-  "image": "<base64-encoded-image>",
+  "model": "paddleocr-vl",
-  "language": "en"  // optional
+  "messages": [
+    {
+      "role": "user",
+      "content": [
+        {"type": "image_url", "image_url": {"url": "data:image/png;base64,..."}},
+        {"type": "text", "text": "Table Recognition:"}
+      ]
+    }
+  ],
+  "temperature": 0.0,
+  "max_tokens": 8192
 }
 ```
 
-**POST /ocr/upload (multipart)**
+**Task Prompts:**
-- `img`: image file
+- `"OCR:"` - Text recognition
-- `language`: optional language code
+- `"Table Recognition:"` - Table extraction (returns markdown)
+- `"Formula Recognition:"` - Formula extraction
+- `"Chart Recognition:"` - Chart extraction
 
 **Response**
 ```json
 {
-  "success": true,
+  "id": "chatcmpl-...",
-  "results": [
+  "object": "chat.completion",
+  "choices": [
     {
-      "text": "Invoice #12345",
+      "index": 0,
-      "confidence": 0.98,
+      "message": {
-      "box": [[x1,y1], [x2,y2], [x3,y3], [x4,y4]]
+        "role": "assistant",
+        "content": "| Date | Description | Amount |\n|---|---|---|\n| 2021-06-01 | GITLAB INC | -119.96 |"
+      },
+      "finish_reason": "stop"
     }
   ]
 }
@@ -136,19 +153,16 @@ PaddleOCR is a standalone OCR service using PaddlePaddle's PP-OCRv4 model. It pr
 
 | Variable | Default | Description |
 |----------|---------|-------------|
-| `OCR_LANGUAGE` | `en` | Default language for OCR |
+| `MODEL_NAME` | `PaddlePaddle/PaddleOCR-VL` | Model to load |
-| `SERVER_PORT` | `5000` | Server port |
+| `HOST` | `0.0.0.0` | Server host |
-| `SERVER_HOST` | `0.0.0.0` | Server host |
+| `PORT` | `8000` | Server port |
-| `CUDA_VISIBLE_DEVICES` | (auto) | Set to `-1` for CPU-only |
+| `MAX_BATCHED_TOKENS` | `16384` | vLLM max batch tokens |
+| `GPU_MEMORY_UTILIZATION` | `0.9` | GPU memory usage (0-1) |
 
 ### Performance
 
-- **GPU**: ~1-3 seconds per page
+- **GPU (vLLM)**: ~2-5 seconds per page
-- **CPU**: ~10-30 seconds per page
+- **CPU**: ~30-60 seconds per page
-
-### Supported Languages
-
-Common language codes: `en` (English), `ch` (Chinese), `de` (German), `fr` (French), `es` (Spanish), `ja` (Japanese), `ko` (Korean)
 
 ---
 
@@ -193,6 +207,43 @@ npmci docker build
 npmci docker push code.foss.global
 ```
 
+## Multi-Pass Extraction Strategy
+
+The bank statement extraction uses a dual-VLM consensus approach:
+
+### Architecture: Dual-VLM Consensus
+
+| VLM | Model | Purpose |
+|-----|-------|---------|
+| **MiniCPM-V 4.5** | 8B params | Primary visual extraction |
+| **PaddleOCR-VL** | 0.9B params | Table-specialized extraction |
+
+### Extraction Strategy
+
+1. **Pass 1**: MiniCPM-V visual extraction (images → JSON)
+2. **Pass 2**: PaddleOCR-VL table recognition (images → markdown → JSON)
+3. **Consensus**: If Pass 1 == Pass 2 → Done (fast path)
+4. **Pass 3+**: MiniCPM-V visual if no consensus
+
+### Why Dual-VLM Works
+
+- **Different architectures**: Two independent models cross-check each other
+- **Specialized strengths**: PaddleOCR-VL optimized for tables, MiniCPM-V for general vision
+- **No structure loss**: Both VLMs see the original images directly
+- **Fast consensus**: Most documents complete in 2 passes when VLMs agree
+
+### Comparison vs Old PP-Structure Approach
+
+| Approach | Bank Statement Result | Issue |
+|----------|----------------------|-------|
+| MiniCPM-V Visual | 28 transactions ✓ | - |
+| PP-Structure HTML + Visual | 13 transactions ✗ | HTML merged rows incorrectly |
+| PaddleOCR-VL Table | 28 transactions ✓ | Native table understanding |
+
+**Key insight**: PP-Structure's HTML output loses structure for complex tables. PaddleOCR-VL's native VLM approach maintains table integrity.
+
+---
+
 ## Related Resources
 
 - [Ollama Documentation](https://ollama.ai/docs)

readme.md

@@ -1,23 +1,40 @@
-# @host.today/ht-docker-ai
+# @host.today/ht-docker-ai 🚀
 
-Docker images for AI vision-language models, starting with MiniCPM-V 4.5.
+Production-ready Docker images for state-of-the-art AI Vision-Language Models. Run powerful multimodal AI locally with GPU acceleration or CPU fallback—no cloud API keys required.
 
-## Overview
+## Issue Reporting and Security
 
-This project provides ready-to-use Docker containers for running state-of-the-art AI vision-language models. Built on Ollama for simplified model management and a consistent REST API.
+For reporting bugs, issues, or security vulnerabilities, please visit [community.foss.global/](https://community.foss.global/). This is the central community hub for all issue reporting. Developers who sign and comply with our contribution agreement and go through identification can also get a [code.foss.global/](https://code.foss.global/) account to submit Pull Requests directly.
 
-## Available Images
+## 🎯 What's Included
 
-| Tag | Description | Requirements |
+| Model | Parameters | Best For | API |
-|-----|-------------|--------------|
+|-------|-----------|----------|-----|
-| `minicpm45v` | MiniCPM-V 4.5 with GPU support | NVIDIA GPU, 9-18GB VRAM |
+| **MiniCPM-V 4.5** | 8B | General vision understanding, image analysis, multi-image | Ollama-compatible |
-| `minicpm45v-cpu` | MiniCPM-V 4.5 CPU-only | 8GB+ RAM |
+| **PaddleOCR-VL** | 0.9B | Document parsing, table extraction, OCR | OpenAI-compatible |
-| `latest` | Alias for `minicpm45v` | NVIDIA GPU |
 
-## Quick Start
+## 📦 Available Images
 
-### GPU (Recommended)
+```
+code.foss.global/host.today/ht-docker-ai:<tag>
+```
 
+| Tag | Model | Hardware | Port |
+|-----|-------|----------|------|
+| `minicpm45v` / `latest` | MiniCPM-V 4.5 | NVIDIA GPU (9-18GB VRAM) | 11434 |
+| `minicpm45v-cpu` | MiniCPM-V 4.5 | CPU only (8GB+ RAM) | 11434 |
+| `paddleocr-vl` / `paddleocr-vl-gpu` | PaddleOCR-VL | NVIDIA GPU | 8000 |
+| `paddleocr-vl-cpu` | PaddleOCR-VL | CPU only | 8000 |
+
+---
+
+## 🖼️ MiniCPM-V 4.5
+
+A GPT-4o level multimodal LLM from OpenBMB—handles image understanding, OCR, multi-image analysis, and visual reasoning across 30+ languages.
+
+### Quick Start
+
+**GPU (Recommended):**
 ```bash
 docker run -d \
   --name minicpm \
@@ -27,8 +44,7 @@ docker run -d \
   code.foss.global/host.today/ht-docker-ai:minicpm45v
 ```
 
-### CPU Only
+**CPU Only:**
-
 ```bash
 docker run -d \
   --name minicpm \
@@ -37,18 +53,16 @@ docker run -d \
   code.foss.global/host.today/ht-docker-ai:minicpm45v-cpu
 ```
 
-## API Usage
+> 💡 **Pro tip:** Mount the volume to persist downloaded models (~5GB). Without it, models re-download on every container start.
 
-The container exposes the Ollama API on port 11434.
+### API Examples
-
-### List Available Models
 
+**List models:**
 ```bash
 curl http://localhost:11434/api/tags
 ```
 
-### Generate Text from Image
+**Analyze an image:**
-
 ```bash
 curl http://localhost:11434/api/generate -d '{
   "model": "minicpm-v",
@@ -57,60 +71,128 @@ curl http://localhost:11434/api/generate -d '{
 }'
 ```
 
-### Chat with Vision
+**Chat with vision:**
-
 ```bash
 curl http://localhost:11434/api/chat -d '{
   "model": "minicpm-v",
-  "messages": [
+  "messages": [{
-    {
     "role": "user",
     "content": "Describe this image in detail",
     "images": ["<base64-encoded-image>"]
-    }
+  }]
-  ]
 }'
 ```
 
-## Environment Variables
+### Hardware Requirements
 
-| Variable | Default | Description |
+| Variant | VRAM/RAM | Notes |
-|----------|---------|-------------|
+|---------|----------|-------|
-| `MODEL_NAME` | `minicpm-v` | Model to pull on startup |
+| GPU (int4 quantized) | 9GB VRAM | Recommended for most use cases |
-| `OLLAMA_HOST` | `0.0.0.0` | Host address for API |
+| GPU (full precision) | 18GB VRAM | Maximum quality |
-| `OLLAMA_ORIGINS` | `*` | Allowed CORS origins |
+| CPU (GGUF) | 8GB+ RAM | Slower but accessible |
 
-## Hardware Requirements
+---
 
-### GPU Variant (`minicpm45v`)
+## 📄 PaddleOCR-VL
 
-- NVIDIA GPU with CUDA support
+A specialized 0.9B Vision-Language Model optimized for document parsing. Native support for tables, formulas, charts, and text extraction in 109 languages.
-- Minimum 9GB VRAM (int4 quantized)
-- Recommended 18GB VRAM (full precision)
-- NVIDIA Container Toolkit installed
 
-### CPU Variant (`minicpm45v-cpu`)
+### Quick Start
 
-- Minimum 8GB RAM
+**GPU:**
-- Recommended 16GB+ RAM for better performance
+```bash
-- No GPU required
+docker run -d \
+  --name paddleocr \
+  --gpus all \
+  -p 8000:8000 \
+  -v hf-cache:/root/.cache/huggingface \
+  code.foss.global/host.today/ht-docker-ai:paddleocr-vl
+```
 
-## Model Information
+**CPU:**
+```bash
+docker run -d \
+  --name paddleocr \
+  -p 8000:8000 \
+  -v hf-cache:/root/.cache/huggingface \
+  code.foss.global/host.today/ht-docker-ai:paddleocr-vl-cpu
+```
 
-**MiniCPM-V 4.5** is a GPT-4o level multimodal large language model developed by OpenBMB.
+### OpenAI-Compatible API
 
-- **Parameters**: 8B (Qwen3-8B + SigLIP2-400M)
+PaddleOCR-VL exposes a fully OpenAI-compatible `/v1/chat/completions` endpoint:
-- **Capabilities**: Image understanding, OCR, multi-image analysis
-- **Languages**: 30+ languages including English, Chinese, French, Spanish
 
-## Docker Compose Example
+```bash
+curl http://localhost:8000/v1/chat/completions \
+  -H "Content-Type: application/json" \
+  -d '{
+    "model": "paddleocr-vl",
+    "messages": [{
+      "role": "user",
+      "content": [
+        {"type": "image_url", "image_url": {"url": "data:image/png;base64,<base64>"}},
+        {"type": "text", "text": "Table Recognition:"}
+      ]
+    }],
+    "max_tokens": 8192
+  }'
+```
+
+### Task Prompts
+
+| Prompt | Output | Use Case |
+|--------|--------|----------|
+| `OCR:` | Plain text | General text extraction |
+| `Table Recognition:` | Markdown table | Invoices, bank statements, spreadsheets |
+| `Formula Recognition:` | LaTeX | Math equations, scientific notation |
+| `Chart Recognition:` | Description | Graphs and visualizations |
+
+### API Endpoints
+
+| Endpoint | Method | Description |
+|----------|--------|-------------|
+| `/health` | GET | Health check with model/device info |
+| `/formats` | GET | Supported image formats and input methods |
+| `/v1/models` | GET | List available models |
+| `/v1/chat/completions` | POST | OpenAI-compatible chat completions |
+| `/ocr` | POST | Legacy OCR endpoint |
+
+### Image Input Methods
+
+PaddleOCR-VL accepts images in multiple formats:
+
+```javascript
+// Base64 data URL
+"data:image/png;base64,iVBORw0KGgo..."
+
+// HTTP URL
+"https://example.com/document.png"
+
+// Raw base64
+"iVBORw0KGgo..."
+```
+
+**Supported formats:** PNG, JPEG, WebP, BMP, GIF, TIFF
+
+**Optimal resolution:** 1080p–2K. Images are automatically scaled for best results.
+
+### Performance
+
+| Mode | Speed per Page |
+|------|----------------|
+| GPU (CUDA) | 2–5 seconds |
+| CPU | 30–60 seconds |
+
+---
+
+## 🐳 Docker Compose
 
 ```yaml
 version: '3.8'
 services:
+  # General vision tasks
   minicpm:
     image: code.foss.global/host.today/ht-docker-ai:minicpm45v
-    container_name: minicpm
     ports:
       - "11434:11434"
     volumes:
@@ -124,11 +206,50 @@ services:
               capabilities: [gpu]
     restart: unless-stopped
 
+  # Document parsing / OCR
+  paddleocr:
+    image: code.foss.global/host.today/ht-docker-ai:paddleocr-vl
+    ports:
+      - "8000:8000"
+    volumes:
+      - hf-cache:/root/.cache/huggingface
+    deploy:
+      resources:
+        reservations:
+          devices:
+            - driver: nvidia
+              count: 1
+              capabilities: [gpu]
+    restart: unless-stopped
+
 volumes:
   ollama-data:
+  hf-cache:
 ```
 
-## Building Locally
+---
+
+## ⚙️ Environment Variables
+
+### MiniCPM-V 4.5
+
+| Variable | Default | Description |
+|----------|---------|-------------|
+| `MODEL_NAME` | `minicpm-v` | Ollama model to pull on startup |
+| `OLLAMA_HOST` | `0.0.0.0` | API bind address |
+| `OLLAMA_ORIGINS` | `*` | Allowed CORS origins |
+
+### PaddleOCR-VL
+
+| Variable | Default | Description |
+|----------|---------|-------------|
+| `MODEL_NAME` | `PaddlePaddle/PaddleOCR-VL` | HuggingFace model ID |
+| `SERVER_HOST` | `0.0.0.0` | API bind address |
+| `SERVER_PORT` | `8000` | API port |
+
+---
+
+## 🔧 Building from Source
 
 ```bash
 # Clone the repository
@@ -142,6 +263,77 @@ cd ht-docker-ai
 ./test-images.sh
 ```
 
-## License
+---
 
-MIT - Task Venture Capital GmbH
+## 🏗️ Architecture Notes
+
+### Dual-VLM Consensus Strategy
+
+For production document extraction, consider using both models together:
+
+1. **Pass 1:** MiniCPM-V visual extraction (images → JSON)
+2. **Pass 2:** PaddleOCR-VL table recognition (images → markdown → JSON)
+3. **Consensus:** If results match → Done (fast path)
+4. **Pass 3+:** Additional visual passes if needed
+
+This dual-VLM approach catches extraction errors that single models miss.
+
+### Why This Works
+
+- **Different architectures:** Two independent models cross-validate each other
+- **Specialized strengths:** PaddleOCR-VL excels at tables; MiniCPM-V handles general vision
+- **Native processing:** Both VLMs see original images—no intermediate HTML/structure loss
+
+---
+
+## 🔍 Troubleshooting
+
+### Model download hangs
+```bash
+docker logs -f <container-name>
+```
+Model downloads can take several minutes (~5GB for MiniCPM-V).
+
+### Out of memory
+- **GPU:** Use the CPU variant or upgrade VRAM
+- **CPU:** Increase container memory: `--memory=16g`
+
+### API not responding
+1. Check container health: `docker ps`
+2. Review logs: `docker logs <container>`
+3. Verify port: `curl localhost:11434/api/tags` or `curl localhost:8000/health`
+
+### Enable NVIDIA GPU support on host
+```bash
+# Install NVIDIA Container Toolkit
+curl -fsSL https://nvidia.github.io/libnvidia-container/gpgkey | sudo gpg --dearmor -o /usr/share/keyrings/nvidia-container-toolkit-keyring.gpg
+curl -s -L https://nvidia.github.io/libnvidia-container/stable/deb/nvidia-container-toolkit.list | \
+  sed 's#deb https://#deb [signed-by=/usr/share/keyrings/nvidia-container-toolkit-keyring.gpg] https://#g' | \
+  sudo tee /etc/apt/sources.list.d/nvidia-container-toolkit.list
+sudo apt-get update && sudo apt-get install -y nvidia-container-toolkit
+sudo nvidia-ctk runtime configure --runtime=docker
+sudo systemctl restart docker
+```
+
+---
+
+## License and Legal Information
+
+This repository contains open-source code licensed under the MIT License. A copy of the license can be found in the [LICENSE](./LICENSE) file.
+
+**Please note:** The MIT License does not grant permission to use the trade names, trademarks, service marks, or product names of the project, except as required for reasonable and customary use in describing the origin of the work and reproducing the content of the NOTICE file.
+
+### Trademarks
+
+This project is owned and maintained by Task Venture Capital GmbH. The names and logos associated with Task Venture Capital GmbH and any related products or services are trademarks of Task Venture Capital GmbH or third parties, and are not included within the scope of the MIT license granted herein.
+
+Use of these trademarks must comply with Task Venture Capital GmbH's Trademark Guidelines or the guidelines of the respective third-party owners, and any usage must be approved in writing. Third-party trademarks used herein are the property of their respective owners and used only in a descriptive manner, e.g. for an implementation of an API or similar.
+
+### Company Information
+
+Task Venture Capital GmbH
+Registered at District Court Bremen HRB 35230 HB, Germany
+
+For any legal inquiries or further information, please contact us via email at hello@task.vc.
+
+By using this repository, you acknowledge that you have read this section, agree to comply with its terms, and understand that the licensing of the code does not imply endorsement by Task Venture Capital GmbH of any derivative works.

test/helpers/docker.ts

@@ -0,0 +1,385 @@
+import { execSync } from 'child_process';
+
+// Project container names (only manage these)
+const PROJECT_CONTAINERS = [
+  'paddleocr-vl-test',
+  'paddleocr-vl-gpu-test',
+  'paddleocr-vl-cpu-test',
+  'paddleocr-vl-full-test',
+  'minicpm-test',
+];
+
+// Image configurations
+export interface IImageConfig {
+  name: string;
+  dockerfile: string;
+  buildContext: string;
+  containerName: string;
+  ports: string[];
+  volumes?: string[];
+  gpus?: boolean;
+  healthEndpoint?: string;
+  healthTimeout?: number;
+}
+
+export const IMAGES = {
+  paddleocrVlGpu: {
+    name: 'paddleocr-vl-gpu',
+    dockerfile: 'Dockerfile_paddleocr_vl_gpu',
+    buildContext: '.',
+    containerName: 'paddleocr-vl-test',
+    ports: ['8000:8000'],
+    volumes: ['ht-huggingface-cache:/root/.cache/huggingface'],
+    gpus: true,
+    healthEndpoint: 'http://localhost:8000/health',
+    healthTimeout: 300000, // 5 minutes for model loading
+  } as IImageConfig,
+
+  paddleocrVlCpu: {
+    name: 'paddleocr-vl-cpu',
+    dockerfile: 'Dockerfile_paddleocr_vl_cpu',
+    buildContext: '.',
+    containerName: 'paddleocr-vl-test',
+    ports: ['8000:8000'],
+    volumes: ['ht-huggingface-cache:/root/.cache/huggingface'],
+    gpus: false,
+    healthEndpoint: 'http://localhost:8000/health',
+    healthTimeout: 300000,
+  } as IImageConfig,
+
+  minicpm: {
+    name: 'minicpm45v',
+    dockerfile: 'Dockerfile_minicpm45v_gpu',
+    buildContext: '.',
+    containerName: 'minicpm-test',
+    ports: ['11434:11434'],
+    volumes: ['ht-ollama-models:/root/.ollama'],
+    gpus: true,
+    healthEndpoint: 'http://localhost:11434/api/tags',
+    healthTimeout: 120000,
+  } as IImageConfig,
+
+  // Full PaddleOCR-VL pipeline with PP-DocLayoutV2 + structured JSON output
+  paddleocrVlFull: {
+    name: 'paddleocr-vl-full',
+    dockerfile: 'Dockerfile_paddleocr_vl_full',
+    buildContext: '.',
+    containerName: 'paddleocr-vl-full-test',
+    ports: ['8000:8000'],
+    volumes: [
+      'ht-huggingface-cache:/root/.cache/huggingface',
+      'ht-paddleocr-cache:/root/.paddleocr',
+    ],
+    gpus: true,
+    healthEndpoint: 'http://localhost:8000/health',
+    healthTimeout: 600000, // 10 minutes for model loading (vLLM + PP-DocLayoutV2)
+  } as IImageConfig,
+};
+
+/**
+ * Execute a shell command and return output
+ */
+function exec(command: string, silent = false): string {
+  try {
+    return execSync(command, {
+      encoding: 'utf-8',
+      stdio: silent ? 'pipe' : 'inherit',
+    });
+  } catch (err: unknown) {
+    if (silent) return '';
+    throw err;
+  }
+}
+
+/**
+ * Check if a Docker image exists locally
+ */
+export function imageExists(imageName: string): boolean {
+  const result = exec(`docker images -q ${imageName}`, true);
+  return result.trim().length > 0;
+}
+
+/**
+ * Check if a container is running
+ */
+export function isContainerRunning(containerName: string): boolean {
+  const result = exec(`docker ps --filter "name=^${containerName}$" --format "{{.Names}}"`, true);
+  return result.trim() === containerName;
+}
+
+/**
+ * Check if a container exists (running or stopped)
+ */
+export function containerExists(containerName: string): boolean {
+  const result = exec(`docker ps -a --filter "name=^${containerName}$" --format "{{.Names}}"`, true);
+  return result.trim() === containerName;
+}
+
+/**
+ * Stop and remove a container
+ */
+export function removeContainer(containerName: string): void {
+  if (containerExists(containerName)) {
+    console.log(`[Docker] Removing container: ${containerName}`);
+    exec(`docker rm -f ${containerName}`, true);
+  }
+}
+
+/**
+ * Stop all project containers that conflict with the required one
+ */
+export function stopConflictingContainers(requiredContainer: string, requiredPort: string): void {
+  // Stop project containers using the same port
+  for (const container of PROJECT_CONTAINERS) {
+    if (container === requiredContainer) continue;
+
+    if (isContainerRunning(container)) {
+      // Check if this container uses the same port
+      const ports = exec(`docker port ${container} 2>/dev/null || true`, true);
+      if (ports.includes(requiredPort.split(':')[0])) {
+        console.log(`[Docker] Stopping conflicting container: ${container}`);
+        exec(`docker stop ${container}`, true);
+      }
+    }
+  }
+}
+
+/**
+ * Build a Docker image
+ */
+export function buildImage(config: IImageConfig): void {
+  console.log(`[Docker] Building image: ${config.name}`);
+  const cmd = `docker build --load -f ${config.dockerfile} -t ${config.name} ${config.buildContext}`;
+  exec(cmd);
+}
+
+/**
+ * Start a container from an image
+ */
+export function startContainer(config: IImageConfig): void {
+  // Remove existing container if it exists
+  removeContainer(config.containerName);
+
+  console.log(`[Docker] Starting container: ${config.containerName}`);
+
+  const portArgs = config.ports.map((p) => `-p ${p}`).join(' ');
+  const volumeArgs = config.volumes?.map((v) => `-v ${v}`).join(' ') || '';
+  const gpuArgs = config.gpus ? '--gpus all' : '';
+
+  const cmd = `docker run -d --name ${config.containerName} ${gpuArgs} ${portArgs} ${volumeArgs} ${config.name}`;
+  exec(cmd);
+}
+
+/**
+ * Wait for a container to become healthy
+ */
+export async function waitForHealth(
+  endpoint: string,
+  timeoutMs: number = 120000,
+  intervalMs: number = 5000
+): Promise<boolean> {
+  const startTime = Date.now();
+  console.log(`[Docker] Waiting for health: ${endpoint}`);
+
+  while (Date.now() - startTime < timeoutMs) {
+    try {
+      const response = await fetch(endpoint, {
+        method: 'GET',
+        signal: AbortSignal.timeout(5000),
+      });
+      if (response.ok) {
+        console.log(`[Docker] Service healthy!`);
+        return true;
+      }
+    } catch {
+      // Service not ready yet
+    }
+
+    const elapsed = Math.round((Date.now() - startTime) / 1000);
+    console.log(`[Docker] Waiting... (${elapsed}s)`);
+    await new Promise((resolve) => setTimeout(resolve, intervalMs));
+  }
+
+  console.log(`[Docker] Health check timeout after ${timeoutMs / 1000}s`);
+  return false;
+}
+
+/**
+ * Ensure a service is running and healthy
+ * - Builds image if missing
+ * - Stops conflicting project containers
+ * - Starts container if not running
+ * - Waits for health check
+ */
+export async function ensureService(config: IImageConfig): Promise<boolean> {
+  console.log(`\n[Docker] Ensuring service: ${config.name}`);
+
+  // Build image if it doesn't exist
+  if (!imageExists(config.name)) {
+    console.log(`[Docker] Image not found, building...`);
+    buildImage(config);
+  }
+
+  // Stop conflicting containers on the same port
+  const mainPort = config.ports[0];
+  stopConflictingContainers(config.containerName, mainPort);
+
+  // Start container if not running
+  if (!isContainerRunning(config.containerName)) {
+    startContainer(config);
+  } else {
+    console.log(`[Docker] Container already running: ${config.containerName}`);
+  }
+
+  // Wait for health
+  if (config.healthEndpoint) {
+    return waitForHealth(config.healthEndpoint, config.healthTimeout);
+  }
+
+  return true;
+}
+
+/**
+ * Ensure PaddleOCR-VL GPU service is running
+ */
+export async function ensurePaddleOcrVlGpu(): Promise<boolean> {
+  return ensureService(IMAGES.paddleocrVlGpu);
+}
+
+/**
+ * Ensure PaddleOCR-VL CPU service is running
+ */
+export async function ensurePaddleOcrVlCpu(): Promise<boolean> {
+  return ensureService(IMAGES.paddleocrVlCpu);
+}
+
+/**
+ * Ensure MiniCPM service is running
+ */
+export async function ensureMiniCpm(): Promise<boolean> {
+  return ensureService(IMAGES.minicpm);
+}
+
+/**
+ * Check if GPU is available
+ */
+export function isGpuAvailable(): boolean {
+  try {
+    const result = exec('nvidia-smi --query-gpu=name --format=csv,noheader 2>/dev/null', true);
+    return result.trim().length > 0;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Ensure PaddleOCR-VL service (auto-detect GPU/CPU)
+ */
+export async function ensurePaddleOcrVl(): Promise<boolean> {
+  if (isGpuAvailable()) {
+    console.log('[Docker] GPU detected, using GPU image');
+    return ensurePaddleOcrVlGpu();
+  } else {
+    console.log('[Docker] No GPU detected, using CPU image');
+    return ensurePaddleOcrVlCpu();
+  }
+}
+
+/**
+ * Ensure PaddleOCR-VL Full Pipeline service (PP-DocLayoutV2 + structured output)
+ * This is the recommended service for production use - outputs structured JSON/Markdown
+ */
+export async function ensurePaddleOcrVlFull(): Promise<boolean> {
+  if (!isGpuAvailable()) {
+    console.log('[Docker] WARNING: Full pipeline requires GPU, but none detected');
+  }
+  return ensureService(IMAGES.paddleocrVlFull);
+}
+
+/**
+ * Ensure an Ollama model is pulled and available
+ * Uses the MiniCPM container (which runs Ollama) to pull the model
+ */
+export async function ensureOllamaModel(modelName: string): Promise<boolean> {
+  const OLLAMA_URL = 'http://localhost:11434';
+
+  console.log(`\n[Ollama] Ensuring model: ${modelName}`);
+
+  // Check if model exists
+  try {
+    const response = await fetch(`${OLLAMA_URL}/api/tags`);
+    if (response.ok) {
+      const data = await response.json();
+      const models = data.models || [];
+      // Exact match required - don't match on prefix
+      const exists = models.some((m: { name: string }) => m.name === modelName);
+
+      if (exists) {
+        console.log(`[Ollama] Model already available: ${modelName}`);
+        return true;
+      }
+    }
+  } catch {
+    console.log(`[Ollama] Cannot check models, Ollama may not be running`);
+    return false;
+  }
+
+  // Pull the model
+  console.log(`[Ollama] Pulling model: ${modelName} (this may take a while)...`);
+  try {
+    const response = await fetch(`${OLLAMA_URL}/api/pull`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ name: modelName, stream: false }),
+    });
+
+    if (response.ok) {
+      console.log(`[Ollama] Model pulled successfully: ${modelName}`);
+      return true;
+    } else {
+      console.log(`[Ollama] Failed to pull model: ${response.status}`);
+      return false;
+    }
+  } catch (err) {
+    console.log(`[Ollama] Error pulling model: ${err}`);
+    return false;
+  }
+}
+
+/**
+ * Ensure Qwen2.5 7B model is available (for text-only JSON extraction)
+ */
+export async function ensureQwen25(): Promise<boolean> {
+  // First ensure the Ollama service (MiniCPM container) is running
+  const ollamaOk = await ensureMiniCpm();
+  if (!ollamaOk) return false;
+
+  // Then ensure the Qwen2.5 model is pulled
+  return ensureOllamaModel('qwen2.5:7b');
+}
+
+/**
+ * Ensure Ministral 3 8B model is available (for structured JSON extraction)
+ * Ministral 3 has native JSON output support and OCR-style document extraction
+ */
+export async function ensureMinistral3(): Promise<boolean> {
+  // First ensure the Ollama service (MiniCPM container) is running
+  const ollamaOk = await ensureMiniCpm();
+  if (!ollamaOk) return false;
+
+  // Then ensure the Ministral 3 8B model is pulled
+  return ensureOllamaModel('ministral-3:8b');
+}
+
+/**
+ * Ensure Qwen3-VL 8B model is available (vision-language model)
+ * Q4_K_M quantization (~5GB) - fits in 15GB VRAM with room to spare
+ */
+export async function ensureQwen3Vl(): Promise<boolean> {
+  // First ensure the Ollama service is running
+  const ollamaOk = await ensureMiniCpm();
+  if (!ollamaOk) return false;
+
+  // Then ensure Qwen3-VL 8B is pulled
+  return ensureOllamaModel('qwen3-vl:8b');
+}

test/test.bankstatements.combined.ts

@@ -1,15 +1,27 @@
+/**
+ * Bank statement extraction test using MiniCPM-V (visual) + PaddleOCR-VL (table recognition)
+ *
+ * This is the combined/dual-VLM approach that uses both models for consensus:
+ *   - MiniCPM-V for visual extraction
+ *   - PaddleOCR-VL for table recognition
+ */
 import { tap, expect } from '@git.zone/tstest/tapbundle';
 import * as fs from 'fs';
 import * as path from 'path';
 import { execSync } from 'child_process';
 import * as os from 'os';
+import { ensurePaddleOcrVl, ensureMiniCpm } from './helpers/docker.js';
 
+// Service URLs
 const OLLAMA_URL = 'http://localhost:11434';
-const MODEL = 'openbmb/minicpm-v4.5:q8_0';
+const PADDLEOCR_VL_URL = 'http://localhost:8000';
-const PADDLEOCR_URL = 'http://localhost:5000';
 
-// Prompt for visual extraction (with images)
+// Models
-const VISUAL_EXTRACT_PROMPT = `/nothink
+const MINICPM_MODEL = 'minicpm-v:latest';
+const PADDLEOCR_VL_MODEL = 'paddleocr-vl';
+
+// Prompt for MiniCPM-V visual extraction
+const MINICPM_EXTRACT_PROMPT = `/nothink
 You are a bank statement parser. Extract EVERY transaction from the table.
 
 Read the Amount column carefully:
@@ -21,9 +33,12 @@ For each row output: {"date":"YYYY-MM-DD","counterparty":"NAME","amount":-21.47}
 
 Do not skip any rows. Return ONLY the JSON array, no explanation.`;
 
-// Prompt for OCR-only extraction (no images)
+// Prompt for PaddleOCR-VL table extraction
-const OCR_EXTRACT_PROMPT = `/nothink
+const PADDLEOCR_VL_TABLE_PROMPT = `Table Recognition:`;
-You are a bank statement parser. Extract EVERY transaction from the OCR text below.
+
+// Post-processing prompt to convert PaddleOCR-VL output to JSON
+const PADDLEOCR_VL_CONVERT_PROMPT = `/nothink
+Convert the following bank statement table data to JSON.
 
 Read the Amount values carefully:
 - "- 21,47 €" means DEBIT, output as: -21.47
@@ -32,48 +47,12 @@ Read the Amount values carefully:
 
 For each transaction output: {"date":"YYYY-MM-DD","counterparty":"NAME","amount":-21.47}
 
-Do not skip any transactions. Return ONLY the JSON array, no explanation.`;
+Return ONLY the JSON array, no explanation.
 
-/**
+Table data:
- * Build prompt for OCR-only extraction (no images)
- */
-function buildOcrOnlyPrompt(ocrText: string): string {
-  // Limit OCR text to prevent context overflow
-  const maxOcrLength = 12000;
-  const truncatedOcr = ocrText.length > maxOcrLength
-    ? ocrText.substring(0, maxOcrLength) + '\n... (truncated)'
-    : ocrText;
-
-  return `${OCR_EXTRACT_PROMPT}
-
-OCR text from bank statement:
 ---
-${truncatedOcr}
+{TABLE_DATA}
 ---`;
-}
-
-/**
- * Extract OCR text from an image using PaddleOCR
- */
-async function extractOcrText(imageBase64: string): Promise<string> {
-  try {
-    const response = await fetch(`${PADDLEOCR_URL}/ocr`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ image: imageBase64 }),
-    });
-
-    if (!response.ok) return '';
-
-    const data = await response.json();
-    if (data.success && data.results) {
-      return data.results.map((r: { text: string }) => r.text).join('\n');
-    }
-  } catch {
-    // PaddleOCR unavailable
-  }
-  return '';
-}
 
 interface ITransaction {
   date: string;
@@ -94,7 +73,7 @@ function convertPdfToImages(pdfPath: string): string[] {
       { stdio: 'pipe' }
     );
 
-    const files = fs.readdirSync(tempDir).filter((f) => f.endsWith('.png')).sort();
+    const files = fs.readdirSync(tempDir).filter((f: string) => f.endsWith('.png')).sort();
     const images: string[] = [];
 
     for (const file of files) {
@@ -110,12 +89,12 @@ function convertPdfToImages(pdfPath: string): string[] {
 }
 
 /**
- * Visual extraction pass (with images)
+ * Extract using MiniCPM-V via Ollama
  */
-async function extractVisual(images: string[], passLabel: string): Promise<ITransaction[]> {
+async function extractWithMiniCPM(images: string[], passLabel: string): Promise<ITransaction[]> {
   const payload = {
-    model: MODEL,
+    model: MINICPM_MODEL,
-    prompt: VISUAL_EXTRACT_PROMPT,
+    prompt: MINICPM_EXTRACT_PROMPT,
     images,
     stream: true,
     options: {
@@ -124,31 +103,6 @@ async function extractVisual(images: string[], passLabel: string): Promise<ITran
     },
   };
 
-  return doExtraction(payload, passLabel);
-}
-
-/**
- * OCR-only extraction pass (no images, just text)
- */
-async function extractFromOcr(ocrText: string, passLabel: string): Promise<ITransaction[]> {
-  const payload = {
-    model: MODEL,
-    prompt: buildOcrOnlyPrompt(ocrText),
-    stream: true,
-    options: {
-      num_predict: 16384,
-      temperature: 0.1,
-    },
-  };
-
-  return doExtraction(payload, passLabel);
-}
-
-/**
- * Common extraction logic
- */
-async function doExtraction(payload: object, passLabel: string): Promise<ITransaction[]> {
-
   const response = await fetch(`${OLLAMA_URL}/api/generate`, {
     method: 'POST',
     headers: { 'Content-Type': 'application/json' },
@@ -168,7 +122,7 @@ async function doExtraction(payload: object, passLabel: string): Promise<ITransa
   let fullText = '';
   let lineBuffer = '';
 
-  console.log(`[${passLabel}] Extracting...`);
+  console.log(`[${passLabel}] Extracting with MiniCPM-V...`);
 
   while (true) {
     const { done, value } = await reader.read();
@@ -184,7 +138,6 @@ async function doExtraction(payload: object, passLabel: string): Promise<ITransa
           fullText += json.response;
           lineBuffer += json.response;
 
-          // Print complete lines
           if (lineBuffer.includes('\n')) {
             const parts = lineBuffer.split('\n');
             for (let i = 0; i < parts.length - 1; i++) {
@@ -214,6 +167,140 @@ async function doExtraction(payload: object, passLabel: string): Promise<ITransa
   return JSON.parse(fullText.substring(startIdx, endIdx));
 }
 
+/**
+ * Extract table using PaddleOCR-VL via OpenAI-compatible API
+ */
+async function extractTableWithPaddleOCRVL(imageBase64: string): Promise<string> {
+  const payload = {
+    model: PADDLEOCR_VL_MODEL,
+    messages: [
+      {
+        role: 'user',
+        content: [
+          {
+            type: 'image_url',
+            image_url: { url: `data:image/png;base64,${imageBase64}` },
+          },
+          {
+            type: 'text',
+            text: PADDLEOCR_VL_TABLE_PROMPT,
+          },
+        ],
+      },
+    ],
+    temperature: 0.0,
+    max_tokens: 8192,
+  };
+
+  const response = await fetch(`${PADDLEOCR_VL_URL}/v1/chat/completions`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(payload),
+  });
+
+  if (!response.ok) {
+    const text = await response.text();
+    throw new Error(`PaddleOCR-VL API error: ${response.status} - ${text}`);
+  }
+
+  const data = await response.json();
+  return data.choices?.[0]?.message?.content || '';
+}
+
+/**
+ * Convert PaddleOCR-VL table output to transactions using MiniCPM-V
+ */
+async function convertTableToTransactions(
+  tableData: string,
+  passLabel: string
+): Promise<ITransaction[]> {
+  const prompt = PADDLEOCR_VL_CONVERT_PROMPT.replace('{TABLE_DATA}', tableData);
+
+  const payload = {
+    model: MINICPM_MODEL,
+    prompt,
+    stream: true,
+    options: {
+      num_predict: 16384,
+      temperature: 0.1,
+    },
+  };
+
+  const response = await fetch(`${OLLAMA_URL}/api/generate`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(payload),
+  });
+
+  if (!response.ok) {
+    throw new Error(`Ollama API error: ${response.status}`);
+  }
+
+  const reader = response.body?.getReader();
+  if (!reader) {
+    throw new Error('No response body');
+  }
+
+  const decoder = new TextDecoder();
+  let fullText = '';
+
+  console.log(`[${passLabel}] Converting table data to JSON...`);
+
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+
+    const chunk = decoder.decode(value, { stream: true });
+    const lines = chunk.split('\n').filter((l) => l.trim());
+
+    for (const line of lines) {
+      try {
+        const json = JSON.parse(line);
+        if (json.response) {
+          fullText += json.response;
+        }
+      } catch {
+        // Skip invalid JSON lines
+      }
+    }
+  }
+
+  const startIdx = fullText.indexOf('[');
+  const endIdx = fullText.lastIndexOf(']') + 1;
+
+  if (startIdx < 0 || endIdx <= startIdx) {
+    throw new Error('No JSON array found in response');
+  }
+
+  return JSON.parse(fullText.substring(startIdx, endIdx));
+}
+
+/**
+ * Extract using PaddleOCR-VL (table recognition) + conversion
+ */
+async function extractWithPaddleOCRVL(
+  images: string[],
+  passLabel: string
+): Promise<ITransaction[]> {
+  console.log(`[${passLabel}] Extracting tables with PaddleOCR-VL...`);
+
+  // Extract table data from each page
+  const tableDataParts: string[] = [];
+  for (let i = 0; i < images.length; i++) {
+    console.log(`[${passLabel}] Processing page ${i + 1}/${images.length}...`);
+    const tableData = await extractTableWithPaddleOCRVL(images[i]);
+    if (tableData.trim()) {
+      tableDataParts.push(`--- Page ${i + 1} ---\n${tableData}`);
+    }
+  }
+
+  const combinedTableData = tableDataParts.join('\n\n');
+  console.log(`[${passLabel}] Got ${combinedTableData.length} chars of table data`);
+
+  // Convert to transactions
+  return convertTableToTransactions(combinedTableData, passLabel);
+}
+
 /**
  * Create a hash of transactions for comparison
  */
@@ -225,10 +312,31 @@ function hashTransactions(transactions: ITransaction[]): string {
 }
 
 /**
- * Extract with majority voting - run until 2 passes match
+ * Check if PaddleOCR-VL service is available
- * Strategy: Pass 1 = Visual (images), Pass 2 = OCR-only (text), Pass 3+ = Visual
  */
-async function extractWithConsensus(images: string[], maxPasses: number = 5): Promise<ITransaction[]> {
+async function isPaddleOCRVLAvailable(): Promise<boolean> {
+  try {
+    const response = await fetch(`${PADDLEOCR_VL_URL}/health`, {
+      method: 'GET',
+      signal: AbortSignal.timeout(5000),
+    });
+    return response.ok;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Extract with dual-VLM consensus
+ * Strategy:
+ *   Pass 1 = MiniCPM-V visual extraction
+ *   Pass 2 = PaddleOCR-VL table recognition (if available)
+ *   Pass 3+ = MiniCPM-V visual (fallback)
+ */
+async function extractWithConsensus(
+  images: string[],
+  maxPasses: number = 5
+): Promise<ITransaction[]> {
   const results: Array<{ transactions: ITransaction[]; hash: string }> = [];
   const hashCounts: Map<string, number> = new Map();
 
@@ -236,59 +344,48 @@ async function extractWithConsensus(images: string[], maxPasses: number = 5): Pr
     const hash = hashTransactions(transactions);
     results.push({ transactions, hash });
     hashCounts.set(hash, (hashCounts.get(hash) || 0) + 1);
-    console.log(`[${passLabel}] Got ${transactions.length} transactions (hash: ${hash.substring(0, 20)}...)`);
+    console.log(
+      `[${passLabel}] Got ${transactions.length} transactions (hash: ${hash.substring(0, 20)}...)`
+    );
     return hashCounts.get(hash)!;
   };
 
-  // Run Pass 1 (Visual) in parallel with OCR extraction
+  // Check if PaddleOCR-VL is available
-  let ocrText = '';
+  const paddleOCRVLAvailable = await isPaddleOCRVLAvailable();
-  const pass1Promise = extractVisual(images, 'Pass 1 Visual').catch((err) => ({ error: err }));
+  if (paddleOCRVLAvailable) {
-
+    console.log('[Setup] PaddleOCR-VL service available - using dual-VLM consensus');
-  // Extract OCR from all pages
-  const ocrPromise = (async () => {
-    const ocrTexts: string[] = [];
-    for (let i = 0; i < images.length; i++) {
-      const pageOcr = await extractOcrText(images[i]);
-      if (pageOcr) {
-        ocrTexts.push(`--- Page ${i + 1} ---\n${pageOcr}`);
-      }
-    }
-    ocrText = ocrTexts.join('\n\n');
-    if (ocrText) {
-      console.log(`[OCR] Extracted text from ${ocrTexts.length} page(s)`);
-    }
-    return ocrText;
-  })();
-
-  // Wait for Pass 1 and OCR to complete
-  const [pass1Result] = await Promise.all([pass1Promise, ocrPromise]);
-
-  // Process Pass 1 result
-  if ('error' in pass1Result) {
-    console.log(`[Pass 1] Error: ${(pass1Result as { error: unknown }).error}`);
   } else {
-    addResult(pass1Result as ITransaction[], 'Pass 1 Visual');
+    console.log('[Setup] PaddleOCR-VL not available - using MiniCPM-V only');
   }
 
-  // Pass 2: OCR-only (no images) - faster, different approach
+  // Pass 1: MiniCPM-V visual extraction
-  if (ocrText) {
   try {
-      const pass2Result = await extractFromOcr(ocrText, 'Pass 2 OCR-only');
+    const pass1Result = await extractWithMiniCPM(images, 'Pass 1 MiniCPM-V');
-      const count = addResult(pass2Result, 'Pass 2 OCR-only');
+    addResult(pass1Result, 'Pass 1 MiniCPM-V');
+  } catch (err) {
+    console.log(`[Pass 1] Error: ${err}`);
+  }
+
+  // Pass 2: PaddleOCR-VL table recognition (if available)
+  if (paddleOCRVLAvailable) {
+    try {
+      const pass2Result = await extractWithPaddleOCRVL(images, 'Pass 2 PaddleOCR-VL');
+      const count = addResult(pass2Result, 'Pass 2 PaddleOCR-VL');
       if (count >= 2) {
-        console.log(`[Consensus] Visual and OCR extractions match!`);
+        console.log('[Consensus] MiniCPM-V and PaddleOCR-VL extractions match!');
         return pass2Result;
       }
     } catch (err) {
-      console.log(`[Pass 2 OCR-only] Error: ${err}`);
+      console.log(`[Pass 2 PaddleOCR-VL] Error: ${err}`);
     }
   }
 
-  // Continue with visual passes 3+ if no consensus yet
+  // Pass 3+: Continue with MiniCPM-V visual passes
-  for (let pass = 3; pass <= maxPasses; pass++) {
+  const startPass = paddleOCRVLAvailable ? 3 : 2;
+  for (let pass = startPass; pass <= maxPasses; pass++) {
     try {
-      const transactions = await extractVisual(images, `Pass ${pass} Visual`);
+      const transactions = await extractWithMiniCPM(images, `Pass ${pass} MiniCPM-V`);
-      const count = addResult(transactions, `Pass ${pass} Visual`);
+      const count = addResult(transactions, `Pass ${pass} MiniCPM-V`);
 
       if (count >= 2) {
         console.log(`[Consensus] Reached after ${pass} passes`);
@@ -368,7 +465,7 @@ function findTestCases(): Array<{ name: string; pdfPath: string; jsonPath: strin
   }
 
   const files = fs.readdirSync(testDir);
-  const pdfFiles = files.filter((f) => f.endsWith('.pdf'));
+  const pdfFiles = files.filter((f: string) => f.endsWith('.pdf'));
   const testCases: Array<{ name: string; pdfPath: string; jsonPath: string }> = [];
 
   for (const pdf of pdfFiles) {
@@ -388,11 +485,18 @@ function findTestCases(): Array<{ name: string; pdfPath: string; jsonPath: strin
 
 // Tests
 
-tap.test('should connect to Ollama API', async () => {
+tap.test('setup: ensure Docker containers are running', async () => {
-  const response = await fetch(`${OLLAMA_URL}/api/tags`);
+  console.log('\n[Setup] Checking Docker containers...\n');
-  expect(response.ok).toBeTrue();
+
-  const data = await response.json();
+  // Ensure PaddleOCR-VL is running (auto-detects GPU/CPU)
-  expect(data.models).toBeArray();
+  const paddleOk = await ensurePaddleOcrVl();
+  expect(paddleOk).toBeTrue();
+
+  // Ensure MiniCPM is running
+  const minicpmOk = await ensureMiniCpm();
+  expect(minicpmOk).toBeTrue();
+
+  console.log('\n[Setup] All containers ready!\n');
 });
 
 tap.test('should have MiniCPM-V 4.5 model loaded', async () => {
@@ -402,6 +506,12 @@ tap.test('should have MiniCPM-V 4.5 model loaded', async () => {
   expect(modelNames.some((name: string) => name.includes('minicpm-v4.5'))).toBeTrue();
 });
 
+tap.test('should check PaddleOCR-VL availability', async () => {
+  const available = await isPaddleOCRVLAvailable();
+  console.log(`PaddleOCR-VL available: ${available}`);
+  expect(available).toBeTrue();
+});
+
 // Dynamic test for each PDF/JSON pair
 const testCases = findTestCases();
 for (const testCase of testCases) {
@@ -416,7 +526,7 @@ for (const testCase of testCases) {
     const images = convertPdfToImages(testCase.pdfPath);
     console.log(`Converted: ${images.length} pages\n`);
 
-    // Extract with consensus voting
+    // Extract with dual-VLM consensus
     const extracted = await extractWithConsensus(images);
     console.log(`\nFinal: ${extracted.length} transactions`);
 

test/test.bankstatements.minicpm.ts

@@ -0,0 +1,324 @@
+/**
+ * Bank statement extraction using MiniCPM-V (visual extraction)
+ *
+ * Multi-query approach with thinking DISABLED for speed:
+ * 1. First ask how many transactions on each page
+ * 2. Then query each transaction individually
+ * Single pass, no consensus voting.
+ */
+import { tap, expect } from '@git.zone/tstest/tapbundle';
+import * as fs from 'fs';
+import * as path from 'path';
+import { execSync } from 'child_process';
+import * as os from 'os';
+import { ensureMiniCpm } from './helpers/docker.js';
+
+const OLLAMA_URL = 'http://localhost:11434';
+const MODEL = 'minicpm-v:latest';
+
+interface ITransaction {
+  date: string;
+  counterparty: string;
+  amount: number;
+}
+
+/**
+ * Convert PDF to PNG images using ImageMagick
+ */
+function convertPdfToImages(pdfPath: string): string[] {
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pdf-convert-'));
+  const outputPattern = path.join(tempDir, 'page-%d.png');
+
+  try {
+    execSync(
+      `convert -density 300 -quality 100 "${pdfPath}" -background white -alpha remove "${outputPattern}"`,
+      { stdio: 'pipe' }
+    );
+
+    const files = fs.readdirSync(tempDir).filter((f: string) => f.endsWith('.png')).sort();
+    const images: string[] = [];
+
+    for (const file of files) {
+      const imagePath = path.join(tempDir, file);
+      const imageData = fs.readFileSync(imagePath);
+      images.push(imageData.toString('base64'));
+    }
+
+    return images;
+  } finally {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  }
+}
+
+/**
+ * Query MiniCPM-V with a prompt (thinking disabled for speed)
+ */
+async function queryVision(image: string, prompt: string): Promise<string> {
+  const response = await fetch(`${OLLAMA_URL}/api/generate`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({
+      model: MODEL,
+      prompt: `/no_think\n${prompt}`,
+      images: [image],
+      stream: false,
+      options: {
+        num_predict: 500,
+        temperature: 0.1,
+      },
+    }),
+  });
+
+  if (!response.ok) {
+    throw new Error(`Ollama API error: ${response.status}`);
+  }
+
+  const data = await response.json();
+  return (data.response || '').trim();
+}
+
+/**
+ * Count transactions on a page
+ */
+async function countTransactions(image: string, pageNum: number): Promise<number> {
+  const response = await queryVision(image,
+    `Count the transaction rows in this bank statement table.
+Each transaction has a date, description, and amount (debit or credit).
+Do not count headers or totals.
+How many transaction rows are there? Answer with just the number.`
+  );
+
+  console.log(`    [Page ${pageNum}] Count response: "${response}"`);
+  const match = response.match(/(\d+)/);
+  const count = match ? parseInt(match[1], 10) : 0;
+  console.log(`    [Page ${pageNum}] Parsed count: ${count}`);
+  return count;
+}
+
+/**
+ * Get a single transaction by index (logs immediately)
+ */
+async function getTransaction(image: string, index: number, pageNum: number): Promise<ITransaction | null> {
+  const response = await queryVision(image,
+    `Look at transaction row #${index} in the bank statement table (row 1 is the first transaction after the header).
+
+Extract:
+- DATE: in YYYY-MM-DD format
+- COUNTERPARTY: the description/name
+- AMOUNT: as a number (negative for debits like "- 21,47 €" = -21.47, positive for credits)
+
+Format your answer as: DATE|COUNTERPARTY|AMOUNT
+Example: 2024-01-15|Amazon|-25.99`
+  );
+
+  // Parse the response
+  const lines = response.split('\n').filter(l => l.includes('|'));
+  const line = lines[lines.length - 1] || response;
+  const parts = line.split('|').map(p => p.trim());
+
+  if (parts.length >= 3) {
+    // Parse amount - handle various formats
+    let amountStr = parts[2].replace(/[€$£\s]/g, '').replace('−', '-').replace('–', '-');
+    // European format: comma is decimal
+    if (amountStr.includes(',')) {
+      amountStr = amountStr.replace(/\./g, '').replace(',', '.');
+    }
+    const amount = parseFloat(amountStr) || 0;
+
+    const tx = {
+      date: parts[0],
+      counterparty: parts[1],
+      amount: amount,
+    };
+    // Log immediately as this transaction completes
+    console.log(`    [P${pageNum} Tx${index.toString().padStart(2, ' ')}] ${tx.date} | ${tx.counterparty.substring(0, 25).padEnd(25)} | ${tx.amount >= 0 ? '+' : ''}${tx.amount.toFixed(2)}`);
+    return tx;
+  }
+
+  // Log raw response on parse failure
+  console.log(`    [P${pageNum} Tx${index.toString().padStart(2, ' ')}] PARSE FAILED: "${response.replace(/\n/g, ' ').substring(0, 60)}..."`);
+  return null;
+}
+
+/**
+ * Extract transactions from a single page using multi-query approach
+ */
+async function extractTransactionsFromPage(image: string, pageNum: number): Promise<ITransaction[]> {
+  // Step 1: Count transactions
+  const count = await countTransactions(image, pageNum);
+
+  if (count === 0) {
+    return [];
+  }
+
+  // Step 2: Query each transaction (in batches to avoid overwhelming)
+  // Each transaction logs itself as it completes
+  const transactions: ITransaction[] = [];
+  const batchSize = 5;
+
+  for (let start = 1; start <= count; start += batchSize) {
+    const end = Math.min(start + batchSize - 1, count);
+    const indices = Array.from({ length: end - start + 1 }, (_, i) => start + i);
+
+    // Query batch in parallel - each logs as it completes
+    const results = await Promise.all(
+      indices.map(i => getTransaction(image, i, pageNum))
+    );
+
+    for (const tx of results) {
+      if (tx) {
+        transactions.push(tx);
+      }
+    }
+  }
+
+  console.log(`    [Page ${pageNum}] Complete: ${transactions.length}/${count} extracted`);
+  return transactions;
+}
+
+/**
+ * Extract all transactions from bank statement
+ */
+async function extractTransactions(images: string[]): Promise<ITransaction[]> {
+  console.log(`    [Vision] Processing ${images.length} page(s) with MiniCPM-V (multi-query, deep think)`);
+
+  const allTransactions: ITransaction[] = [];
+
+  for (let i = 0; i < images.length; i++) {
+    const pageTransactions = await extractTransactionsFromPage(images[i], i + 1);
+    allTransactions.push(...pageTransactions);
+  }
+
+  console.log(`    [Vision] Total: ${allTransactions.length} transactions`);
+  return allTransactions;
+}
+
+/**
+ * Compare extracted transactions against expected
+ */
+function compareTransactions(
+  extracted: ITransaction[],
+  expected: ITransaction[]
+): { matches: number; total: number; errors: string[] } {
+  const errors: string[] = [];
+  let matches = 0;
+
+  for (let i = 0; i < expected.length; i++) {
+    const exp = expected[i];
+    const ext = extracted[i];
+
+    if (!ext) {
+      errors.push(`Missing transaction ${i}: ${exp.date} ${exp.counterparty}`);
+      continue;
+    }
+
+    const dateMatch = ext.date === exp.date;
+    const amountMatch = Math.abs(ext.amount - exp.amount) < 0.01;
+
+    if (dateMatch && amountMatch) {
+      matches++;
+    } else {
+      errors.push(
+        `Mismatch at ${i}: expected ${exp.date}/${exp.amount}, got ${ext.date}/${ext.amount}`
+      );
+    }
+  }
+
+  if (extracted.length > expected.length) {
+    errors.push(`Extra transactions: ${extracted.length - expected.length}`);
+  }
+
+  return { matches, total: expected.length, errors };
+}
+
+/**
+ * Find all test cases (PDF + JSON pairs) in .nogit/
+ */
+function findTestCases(): Array<{ name: string; pdfPath: string; jsonPath: string }> {
+  const testDir = path.join(process.cwd(), '.nogit');
+  if (!fs.existsSync(testDir)) {
+    return [];
+  }
+
+  const files = fs.readdirSync(testDir);
+  const pdfFiles = files.filter((f: string) => f.endsWith('.pdf'));
+  const testCases: Array<{ name: string; pdfPath: string; jsonPath: string }> = [];
+
+  for (const pdf of pdfFiles) {
+    const baseName = pdf.replace('.pdf', '');
+    const jsonFile = `${baseName}.json`;
+    if (files.includes(jsonFile)) {
+      testCases.push({
+        name: baseName,
+        pdfPath: path.join(testDir, pdf),
+        jsonPath: path.join(testDir, jsonFile),
+      });
+    }
+  }
+
+  return testCases.sort((a, b) => a.name.localeCompare(b.name));
+}
+
+// Tests
+
+tap.test('setup: ensure Docker containers are running', async () => {
+  console.log('\n[Setup] Checking Docker containers...\n');
+  const minicpmOk = await ensureMiniCpm();
+  expect(minicpmOk).toBeTrue();
+  console.log('\n[Setup] All containers ready!\n');
+});
+
+tap.test('should have MiniCPM-V model loaded', async () => {
+  const response = await fetch(`${OLLAMA_URL}/api/tags`);
+  const data = await response.json();
+  const modelNames = data.models.map((m: { name: string }) => m.name);
+  expect(modelNames.some((name: string) => name.includes('minicpm'))).toBeTrue();
+});
+
+const testCases = findTestCases();
+console.log(`\nFound ${testCases.length} bank statement test cases (MiniCPM-V)\n`);
+
+let passedCount = 0;
+let failedCount = 0;
+
+for (const testCase of testCases) {
+  tap.test(`should extract: ${testCase.name}`, async () => {
+    const expected: ITransaction[] = JSON.parse(fs.readFileSync(testCase.jsonPath, 'utf-8'));
+    console.log(`\n=== ${testCase.name} ===`);
+    console.log(`Expected: ${expected.length} transactions`);
+
+    const images = convertPdfToImages(testCase.pdfPath);
+    console.log(`  Pages: ${images.length}`);
+
+    const extracted = await extractTransactions(images);
+    console.log(`  Extracted: ${extracted.length} transactions`);
+
+    const result = compareTransactions(extracted, expected);
+    const accuracy = result.total > 0 ? result.matches / result.total : 0;
+
+    if (accuracy >= 0.95 && extracted.length === expected.length) {
+      passedCount++;
+      console.log(`  Result: PASS (${result.matches}/${result.total})`);
+    } else {
+      failedCount++;
+      console.log(`  Result: FAIL (${result.matches}/${result.total})`);
+      result.errors.slice(0, 5).forEach((e) => console.log(`    - ${e}`));
+    }
+
+    expect(accuracy).toBeGreaterThan(0.95);
+    expect(extracted.length).toEqual(expected.length);
+  });
+}
+
+tap.test('summary', async () => {
+  const total = testCases.length;
+  console.log(`\n======================================================`);
+  console.log(`   Bank Statement Summary (MiniCPM-V)`);
+  console.log(`======================================================`);
+  console.log(`  Method:   Multi-query (no_think)`);
+  console.log(`  Passed:   ${passedCount}/${total}`);
+  console.log(`  Failed:   ${failedCount}/${total}`);
+  console.log(`======================================================\n`);
+});
+
+export default tap.start();

test/test.bankstatements.ministral3.ts

@@ -0,0 +1,348 @@
+/**
+ * Bank Statement extraction using Ministral 3 Vision (Direct)
+ *
+ * NO OCR pipeline needed - Ministral 3 has built-in vision encoder:
+ *   1. Convert PDF to images
+ *   2. Send images directly to Ministral 3 via Ollama
+ *   3. Extract transactions as structured JSON
+ */
+import { tap, expect } from '@git.zone/tstest/tapbundle';
+import * as fs from 'fs';
+import * as path from 'path';
+import { execSync } from 'child_process';
+import * as os from 'os';
+import { ensureMinistral3 } from './helpers/docker.js';
+
+const OLLAMA_URL = 'http://localhost:11434';
+const VISION_MODEL = 'ministral-3:8b';
+
+interface ITransaction {
+  date: string;
+  counterparty: string;
+  amount: number;
+}
+
+/**
+ * Convert PDF to PNG images using ImageMagick
+ */
+function convertPdfToImages(pdfPath: string): string[] {
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pdf-convert-'));
+  const outputPattern = path.join(tempDir, 'page-%d.png');
+
+  try {
+    execSync(
+      `convert -density 200 -quality 90 "${pdfPath}" -background white -alpha remove "${outputPattern}"`,
+      { stdio: 'pipe' }
+    );
+
+    const files = fs.readdirSync(tempDir).filter((f) => f.endsWith('.png')).sort();
+    const images: string[] = [];
+
+    for (const file of files) {
+      const imagePath = path.join(tempDir, file);
+      const imageData = fs.readFileSync(imagePath);
+      images.push(imageData.toString('base64'));
+    }
+
+    return images;
+  } finally {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  }
+}
+
+/**
+ * Extract transactions from a single page image using Ministral 3 Vision
+ */
+async function extractTransactionsFromPage(image: string, pageNum: number): Promise<ITransaction[]> {
+  console.log(`    [Vision] Processing page ${pageNum}`);
+
+  // JSON schema for array of transactions
+  const transactionSchema = {
+    type: 'array',
+    items: {
+      type: 'object',
+      properties: {
+        date: { type: 'string', description: 'Transaction date in YYYY-MM-DD format' },
+        counterparty: { type: 'string', description: 'Name of the other party' },
+        amount: { type: 'number', description: 'Amount (negative for debits, positive for credits)' },
+      },
+      required: ['date', 'counterparty', 'amount'],
+    },
+  };
+
+  const prompt = `Extract ALL bank transactions from this bank statement page.
+
+For each transaction, extract:
+- date: Transaction date in YYYY-MM-DD format
+- counterparty: The name/description of the other party (merchant, payee, etc.)
+- amount: The amount as a number (NEGATIVE for debits/expenses, POSITIVE for credits/income)
+
+Return a JSON array of transactions. If no transactions visible, return empty array [].
+Example: [{"date":"2021-06-01","counterparty":"AMAZON","amount":-50.00}]`;
+
+  const response = await fetch(`${OLLAMA_URL}/api/chat`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({
+      model: VISION_MODEL,
+      messages: [
+        {
+          role: 'user',
+          content: prompt,
+          images: [image],
+        },
+      ],
+      format: transactionSchema,
+      stream: true,
+      options: {
+        num_predict: 4096,  // Bank statements can have many transactions
+        temperature: 0.0,
+      },
+    }),
+  });
+
+  if (!response.ok) {
+    throw new Error(`Ollama API error: ${response.status}`);
+  }
+
+  const reader = response.body?.getReader();
+  if (!reader) {
+    throw new Error('No response body');
+  }
+
+  const decoder = new TextDecoder();
+  let fullText = '';
+
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+
+    const chunk = decoder.decode(value, { stream: true });
+    const lines = chunk.split('\n').filter((l) => l.trim());
+
+    for (const line of lines) {
+      try {
+        const json = JSON.parse(line);
+        if (json.message?.content) {
+          fullText += json.message.content;
+        }
+      } catch {
+        // Skip invalid JSON lines
+      }
+    }
+  }
+
+  // Parse JSON response
+  let jsonStr = fullText.trim();
+
+  if (jsonStr.startsWith('```json')) jsonStr = jsonStr.slice(7);
+  else if (jsonStr.startsWith('```')) jsonStr = jsonStr.slice(3);
+  if (jsonStr.endsWith('```')) jsonStr = jsonStr.slice(0, -3);
+  jsonStr = jsonStr.trim();
+
+  // Find array boundaries
+  const startIdx = jsonStr.indexOf('[');
+  const endIdx = jsonStr.lastIndexOf(']') + 1;
+
+  if (startIdx < 0 || endIdx <= startIdx) {
+    console.log(`    [Page ${pageNum}] No transactions found`);
+    return [];
+  }
+
+  try {
+    const parsed = JSON.parse(jsonStr.substring(startIdx, endIdx));
+    console.log(`    [Page ${pageNum}] Found ${parsed.length} transactions`);
+    return parsed.map((t: { date?: string; counterparty?: string; amount?: number }) => ({
+      date: t.date || '',
+      counterparty: t.counterparty || '',
+      amount: parseFloat(String(t.amount)) || 0,
+    }));
+  } catch (e) {
+    console.log(`    [Page ${pageNum}] Parse error: ${e}`);
+    return [];
+  }
+}
+
+/**
+ * Extract all transactions from all pages
+ */
+async function extractAllTransactions(images: string[]): Promise<ITransaction[]> {
+  const allTransactions: ITransaction[] = [];
+
+  for (let i = 0; i < images.length; i++) {
+    const pageTransactions = await extractTransactionsFromPage(images[i], i + 1);
+    allTransactions.push(...pageTransactions);
+  }
+
+  return allTransactions;
+}
+
+/**
+ * Normalize date to YYYY-MM-DD
+ */
+function normalizeDate(dateStr: string): string {
+  if (!dateStr) return '';
+  if (/^\d{4}-\d{2}-\d{2}$/.test(dateStr)) return dateStr;
+
+  // Handle DD/MM/YYYY or DD.MM.YYYY
+  const match = dateStr.match(/^(\d{1,2})[\/.](\d{1,2})[\/.](\d{4})$/);
+  if (match) {
+    return `${match[3]}-${match[2].padStart(2, '0')}-${match[1].padStart(2, '0')}`;
+  }
+
+  return dateStr;
+}
+
+/**
+ * Compare extracted transactions vs expected
+ */
+function compareTransactions(
+  extracted: ITransaction[],
+  expected: ITransaction[]
+): { matchRate: number; matched: number; missed: number; extra: number; errors: string[] } {
+  const errors: string[] = [];
+  let matched = 0;
+
+  // Normalize all dates
+  const normalizedExtracted = extracted.map((t) => ({
+    ...t,
+    date: normalizeDate(t.date),
+    counterparty: t.counterparty.toUpperCase().trim(),
+  }));
+
+  const normalizedExpected = expected.map((t) => ({
+    ...t,
+    date: normalizeDate(t.date),
+    counterparty: t.counterparty.toUpperCase().trim(),
+  }));
+
+  // Try to match each expected transaction
+  const matchedIndices = new Set<number>();
+
+  for (const exp of normalizedExpected) {
+    let found = false;
+
+    for (let i = 0; i < normalizedExtracted.length; i++) {
+      if (matchedIndices.has(i)) continue;
+
+      const ext = normalizedExtracted[i];
+
+      // Match by date + amount (counterparty names can vary)
+      if (ext.date === exp.date && Math.abs(ext.amount - exp.amount) < 0.02) {
+        matched++;
+        matchedIndices.add(i);
+        found = true;
+        break;
+      }
+    }
+
+    if (!found) {
+      errors.push(`Missing: ${exp.date} | ${exp.counterparty} | ${exp.amount}`);
+    }
+  }
+
+  const missed = expected.length - matched;
+  const extra = extracted.length - matched;
+  const matchRate = expected.length > 0 ? (matched / expected.length) * 100 : 0;
+
+  return { matchRate, matched, missed, extra, errors };
+}
+
+/**
+ * Find test cases (PDF + JSON pairs in .nogit/)
+ */
+function findTestCases(): Array<{ name: string; pdfPath: string; jsonPath: string }> {
+  const testDir = path.join(process.cwd(), '.nogit');
+  if (!fs.existsSync(testDir)) return [];
+
+  const files = fs.readdirSync(testDir);
+  const testCases: Array<{ name: string; pdfPath: string; jsonPath: string }> = [];
+
+  for (const pdf of files.filter((f) => f.endsWith('.pdf'))) {
+    const baseName = pdf.replace('.pdf', '');
+    const jsonFile = `${baseName}.json`;
+    if (files.includes(jsonFile)) {
+      // Skip invoice files - only bank statements
+      if (!baseName.includes('invoice')) {
+        testCases.push({
+          name: baseName,
+          pdfPath: path.join(testDir, pdf),
+          jsonPath: path.join(testDir, jsonFile),
+        });
+      }
+    }
+  }
+
+  return testCases.sort((a, b) => a.name.localeCompare(b.name));
+}
+
+// Tests
+
+tap.test('setup: ensure Ministral 3 is running', async () => {
+  console.log('\n[Setup] Checking Ministral 3...\n');
+  const ok = await ensureMinistral3();
+  expect(ok).toBeTrue();
+  console.log('\n[Setup] Ready!\n');
+});
+
+const testCases = findTestCases();
+console.log(`\nFound ${testCases.length} bank statement test cases (Ministral 3 Vision)\n`);
+
+let totalMatched = 0;
+let totalExpected = 0;
+const times: number[] = [];
+
+for (const testCase of testCases) {
+  tap.test(`should extract bank statement: ${testCase.name}`, async () => {
+    const expected: ITransaction[] = JSON.parse(fs.readFileSync(testCase.jsonPath, 'utf-8'));
+    console.log(`\n=== ${testCase.name} ===`);
+    console.log(`Expected: ${expected.length} transactions`);
+
+    const start = Date.now();
+    const images = convertPdfToImages(testCase.pdfPath);
+    console.log(`  Pages: ${images.length}`);
+
+    const extracted = await extractAllTransactions(images);
+    const elapsed = Date.now() - start;
+    times.push(elapsed);
+
+    console.log(`  Extracted: ${extracted.length} transactions`);
+
+    const result = compareTransactions(extracted, expected);
+    totalMatched += result.matched;
+    totalExpected += expected.length;
+
+    console.log(`  Match rate: ${result.matchRate.toFixed(1)}% (${result.matched}/${expected.length})`);
+    console.log(`  Missed: ${result.missed}, Extra: ${result.extra}`);
+    console.log(`  Time: ${(elapsed / 1000).toFixed(1)}s`);
+
+    if (result.errors.length > 0 && result.errors.length <= 5) {
+      result.errors.forEach((e) => console.log(`    - ${e}`));
+    } else if (result.errors.length > 5) {
+      console.log(`    (${result.errors.length} missing transactions)`);
+    }
+
+    // Consider it a pass if we match at least 70% of transactions
+    expect(result.matchRate).toBeGreaterThan(70);
+  });
+}
+
+tap.test('summary', async () => {
+  const overallMatchRate = totalExpected > 0 ? (totalMatched / totalExpected) * 100 : 0;
+  const totalTime = times.reduce((a, b) => a + b, 0) / 1000;
+  const avgTime = times.length > 0 ? totalTime / times.length : 0;
+
+  console.log(`\n======================================================`);
+  console.log(`   Bank Statement Extraction Summary (Ministral 3)`);
+  console.log(`======================================================`);
+  console.log(`  Method:      Ministral 3 8B Vision (Direct)`);
+  console.log(`  Statements:  ${testCases.length}`);
+  console.log(`  Matched:     ${totalMatched}/${totalExpected} transactions`);
+  console.log(`  Match rate:  ${overallMatchRate.toFixed(1)}%`);
+  console.log(`------------------------------------------------------`);
+  console.log(`  Total time:  ${totalTime.toFixed(1)}s`);
+  console.log(`  Avg per stmt: ${avgTime.toFixed(1)}s`);
+  console.log(`======================================================\n`);
+});
+
+export default tap.start();

test/test.bankstatements.paddleocr-vl.ts

@@ -0,0 +1,346 @@
+/**
+ * Bank statement extraction test using PaddleOCR-VL Full Pipeline
+ *
+ * This tests the complete PaddleOCR-VL pipeline for bank statements:
+ *   1. PP-DocLayoutV2 for layout detection
+ *   2. PaddleOCR-VL for recognition (tables with proper structure)
+ *   3. Structured Markdown output with tables
+ *   4. MiniCPM extracts transactions from structured tables
+ *
+ * The structured Markdown has properly formatted tables,
+ * making it much easier for MiniCPM to extract transaction data.
+ */
+import { tap, expect } from '@git.zone/tstest/tapbundle';
+import * as fs from 'fs';
+import * as path from 'path';
+import { execSync } from 'child_process';
+import * as os from 'os';
+import { ensurePaddleOcrVlFull, ensureMiniCpm } from './helpers/docker.js';
+
+const PADDLEOCR_VL_URL = 'http://localhost:8000';
+const OLLAMA_URL = 'http://localhost:11434';
+const MINICPM_MODEL = 'minicpm-v:latest';
+
+interface ITransaction {
+  date: string;
+  counterparty: string;
+  amount: number;
+}
+
+/**
+ * Convert PDF to PNG images using ImageMagick
+ */
+function convertPdfToImages(pdfPath: string): string[] {
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pdf-convert-'));
+  const outputPattern = path.join(tempDir, 'page-%d.png');
+
+  try {
+    execSync(
+      `convert -density 300 -quality 100 "${pdfPath}" -background white -alpha remove "${outputPattern}"`,
+      { stdio: 'pipe' }
+    );
+
+    const files = fs.readdirSync(tempDir).filter((f: string) => f.endsWith('.png')).sort();
+    const images: string[] = [];
+
+    for (const file of files) {
+      const imagePath = path.join(tempDir, file);
+      const imageData = fs.readFileSync(imagePath);
+      images.push(imageData.toString('base64'));
+    }
+
+    return images;
+  } finally {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  }
+}
+
+/**
+ * Parse document using PaddleOCR-VL Full Pipeline (returns structured Markdown)
+ */
+async function parseDocument(imageBase64: string): Promise<string> {
+  const response = await fetch(`${PADDLEOCR_VL_URL}/parse`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({
+      image: imageBase64,
+      output_format: 'markdown',
+    }),
+  });
+
+  if (!response.ok) {
+    const text = await response.text();
+    throw new Error(`PaddleOCR-VL API error: ${response.status} - ${text}`);
+  }
+
+  const data = await response.json();
+
+  if (!data.success) {
+    throw new Error(`PaddleOCR-VL error: ${data.error}`);
+  }
+
+  return data.result?.markdown || '';
+}
+
+/**
+ * Extract transactions from structured Markdown using MiniCPM
+ */
+async function extractTransactionsFromMarkdown(markdown: string): Promise<ITransaction[]> {
+  console.log(`    [Extract] Processing ${markdown.length} chars of Markdown`);
+
+  const prompt = `/nothink
+Convert this bank statement to a JSON array of transactions.
+
+Read the Amount values carefully:
+- "- 21,47 €" means DEBIT, output as: -21.47
+- "+ 1.000,00 €" means CREDIT, output as: 1000.00
+- European format: comma = decimal point, dot = thousands
+
+For each transaction output: {"date":"YYYY-MM-DD","counterparty":"NAME","amount":-21.47}
+
+Return ONLY the JSON array, no explanation.
+
+Document:
+${markdown}`;
+
+  const payload = {
+    model: MINICPM_MODEL,
+    prompt,
+    stream: true,
+    options: {
+      num_predict: 16384,
+      temperature: 0.1,
+    },
+  };
+
+  const response = await fetch(`${OLLAMA_URL}/api/generate`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(payload),
+  });
+
+  if (!response.ok) {
+    throw new Error(`Ollama API error: ${response.status}`);
+  }
+
+  const reader = response.body?.getReader();
+  if (!reader) {
+    throw new Error('No response body');
+  }
+
+  const decoder = new TextDecoder();
+  let fullText = '';
+
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+
+    const chunk = decoder.decode(value, { stream: true });
+    const lines = chunk.split('\n').filter((l) => l.trim());
+
+    for (const line of lines) {
+      try {
+        const json = JSON.parse(line);
+        if (json.response) {
+          fullText += json.response;
+        }
+      } catch {
+        // Skip invalid JSON lines
+      }
+    }
+  }
+
+  // Extract JSON array from response
+  const startIdx = fullText.indexOf('[');
+  const endIdx = fullText.lastIndexOf(']') + 1;
+
+  if (startIdx < 0 || endIdx <= startIdx) {
+    throw new Error(`No JSON array found in response: ${fullText.substring(0, 200)}`);
+  }
+
+  const jsonStr = fullText.substring(startIdx, endIdx);
+  return JSON.parse(jsonStr);
+}
+
+/**
+ * Extract transactions from all pages of a bank statement
+ */
+async function extractAllTransactions(images: string[]): Promise<ITransaction[]> {
+  const allTransactions: ITransaction[] = [];
+
+  for (let i = 0; i < images.length; i++) {
+    console.log(`  Processing page ${i + 1}/${images.length}...`);
+
+    // Parse with full pipeline
+    const markdown = await parseDocument(images[i]);
+    console.log(`    [Parse] Got ${markdown.split('\n').length} lines of Markdown`);
+
+    // Extract transactions
+    try {
+      const transactions = await extractTransactionsFromMarkdown(markdown);
+      console.log(`    [Extracted] ${transactions.length} transactions`);
+      allTransactions.push(...transactions);
+    } catch (err) {
+      console.log(`    [Error] ${err}`);
+    }
+  }
+
+  return allTransactions;
+}
+
+/**
+ * Compare transactions - find matching transaction in expected list
+ */
+function findMatchingTransaction(
+  tx: ITransaction,
+  expectedList: ITransaction[]
+): ITransaction | undefined {
+  return expectedList.find((exp) => {
+    const dateMatch = tx.date === exp.date;
+    const amountMatch = Math.abs(tx.amount - exp.amount) < 0.02;
+    const counterpartyMatch =
+      tx.counterparty?.toLowerCase().includes(exp.counterparty?.toLowerCase().slice(0, 10)) ||
+      exp.counterparty?.toLowerCase().includes(tx.counterparty?.toLowerCase().slice(0, 10));
+    return dateMatch && amountMatch && counterpartyMatch;
+  });
+}
+
+/**
+ * Calculate extraction accuracy
+ */
+function calculateAccuracy(
+  extracted: ITransaction[],
+  expected: ITransaction[]
+): { matched: number; total: number; accuracy: number } {
+  let matched = 0;
+  const usedExpected = new Set<number>();
+
+  for (const tx of extracted) {
+    for (let i = 0; i < expected.length; i++) {
+      if (usedExpected.has(i)) continue;
+
+      const exp = expected[i];
+      const dateMatch = tx.date === exp.date;
+      const amountMatch = Math.abs(tx.amount - exp.amount) < 0.02;
+
+      if (dateMatch && amountMatch) {
+        matched++;
+        usedExpected.add(i);
+        break;
+      }
+    }
+  }
+
+  return {
+    matched,
+    total: expected.length,
+    accuracy: expected.length > 0 ? (matched / expected.length) * 100 : 0,
+  };
+}
+
+/**
+ * Find all test cases (PDF + JSON pairs) in .nogit/bankstatements/
+ */
+function findTestCases(): Array<{ name: string; pdfPath: string; jsonPath: string }> {
+  const testDir = path.join(process.cwd(), '.nogit/bankstatements');
+  if (!fs.existsSync(testDir)) {
+    return [];
+  }
+
+  const files = fs.readdirSync(testDir);
+  const pdfFiles = files.filter((f) => f.endsWith('.pdf'));
+  const testCases: Array<{ name: string; pdfPath: string; jsonPath: string }> = [];
+
+  for (const pdf of pdfFiles) {
+    const baseName = pdf.replace('.pdf', '');
+    const jsonFile = `${baseName}.json`;
+    if (files.includes(jsonFile)) {
+      testCases.push({
+        name: baseName,
+        pdfPath: path.join(testDir, pdf),
+        jsonPath: path.join(testDir, jsonFile),
+      });
+    }
+  }
+
+  testCases.sort((a, b) => a.name.localeCompare(b.name));
+  return testCases;
+}
+
+// Tests
+
+tap.test('setup: ensure Docker containers are running', async () => {
+  console.log('\n[Setup] Checking Docker containers...\n');
+
+  // Ensure PaddleOCR-VL Full Pipeline is running
+  const paddleOk = await ensurePaddleOcrVlFull();
+  expect(paddleOk).toBeTrue();
+
+  // Ensure MiniCPM is running (for field extraction from Markdown)
+  const minicpmOk = await ensureMiniCpm();
+  expect(minicpmOk).toBeTrue();
+
+  console.log('\n[Setup] All containers ready!\n');
+});
+
+// Dynamic test for each PDF/JSON pair
+const testCases = findTestCases();
+console.log(`\nFound ${testCases.length} bank statement test cases (PaddleOCR-VL Full Pipeline)\n`);
+
+const results: Array<{ name: string; accuracy: number; matched: number; total: number }> = [];
+
+for (const testCase of testCases) {
+  tap.test(`should extract bank statement: ${testCase.name}`, async () => {
+    // Load expected data
+    const expected: ITransaction[] = JSON.parse(fs.readFileSync(testCase.jsonPath, 'utf-8'));
+    console.log(`\n=== ${testCase.name} ===`);
+    console.log(`Expected: ${expected.length} transactions`);
+
+    const startTime = Date.now();
+
+    // Convert PDF to images
+    const images = convertPdfToImages(testCase.pdfPath);
+    console.log(`  Pages: ${images.length}`);
+
+    // Extract all transactions
+    const extracted = await extractAllTransactions(images);
+
+    const endTime = Date.now();
+    const elapsedMs = endTime - startTime;
+
+    // Calculate accuracy
+    const accuracy = calculateAccuracy(extracted, expected);
+    results.push({
+      name: testCase.name,
+      accuracy: accuracy.accuracy,
+      matched: accuracy.matched,
+      total: accuracy.total,
+    });
+
+    console.log(`  Extracted: ${extracted.length} transactions`);
+    console.log(`  Matched: ${accuracy.matched}/${accuracy.total} (${accuracy.accuracy.toFixed(1)}%)`);
+    console.log(`  Time: ${(elapsedMs / 1000).toFixed(1)}s`);
+
+    // We expect at least 50% accuracy
+    expect(accuracy.accuracy).toBeGreaterThan(50);
+  });
+}
+
+tap.test('summary', async () => {
+  const totalStatements = results.length;
+  const avgAccuracy =
+    results.length > 0 ? results.reduce((a, b) => a + b.accuracy, 0) / results.length : 0;
+  const totalMatched = results.reduce((a, b) => a + b.matched, 0);
+  const totalExpected = results.reduce((a, b) => a + b.total, 0);
+
+  console.log(`\n======================================================`);
+  console.log(`  Bank Statement Extraction Summary (PaddleOCR-VL Full)`);
+  console.log(`======================================================`);
+  console.log(`  Method:      PaddleOCR-VL Full Pipeline -> MiniCPM`);
+  console.log(`  Statements:  ${totalStatements}`);
+  console.log(`  Transactions: ${totalMatched}/${totalExpected} matched`);
+  console.log(`  Avg accuracy: ${avgAccuracy.toFixed(1)}%`);
+  console.log(`======================================================\n`);
+});
+
+export default tap.start();

test/test.bankstatements.qwen3vl.ts

@@ -0,0 +1,345 @@
+/**
+ * Bank statement extraction using Qwen3-VL 8B Vision (Direct)
+ *
+ * Multi-query approach:
+ * 1. First ask how many transactions on each page
+ * 2. Then query each transaction individually
+ * Single pass, no consensus voting.
+ */
+import { tap, expect } from '@git.zone/tstest/tapbundle';
+import * as fs from 'fs';
+import * as path from 'path';
+import { execSync } from 'child_process';
+import * as os from 'os';
+import { ensureMiniCpm } from './helpers/docker.js';
+
+const OLLAMA_URL = 'http://localhost:11434';
+const VISION_MODEL = 'qwen3-vl:8b';
+
+interface ITransaction {
+  date: string;
+  counterparty: string;
+  amount: number;
+}
+
+/**
+ * Convert PDF to PNG images
+ */
+function convertPdfToImages(pdfPath: string): string[] {
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pdf-convert-'));
+  const outputPattern = path.join(tempDir, 'page-%d.png');
+
+  try {
+    execSync(
+      `convert -density 150 -quality 90 "${pdfPath}" -background white -alpha remove "${outputPattern}"`,
+      { stdio: 'pipe' }
+    );
+
+    const files = fs.readdirSync(tempDir).filter((f: string) => f.endsWith('.png')).sort();
+    const images: string[] = [];
+
+    for (const file of files) {
+      const imagePath = path.join(tempDir, file);
+      const imageData = fs.readFileSync(imagePath);
+      images.push(imageData.toString('base64'));
+    }
+
+    return images;
+  } finally {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  }
+}
+
+/**
+ * Query Qwen3-VL with a simple prompt
+ */
+async function queryVision(image: string, prompt: string): Promise<string> {
+  const response = await fetch(`${OLLAMA_URL}/api/chat`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({
+      model: VISION_MODEL,
+      messages: [{
+        role: 'user',
+        content: prompt,
+        images: [image],
+      }],
+      stream: false,
+      options: {
+        num_predict: 500,
+        temperature: 0.1,
+      },
+    }),
+  });
+
+  if (!response.ok) {
+    throw new Error(`Ollama API error: ${response.status}`);
+  }
+
+  const data = await response.json();
+  return (data.message?.content || '').trim();
+}
+
+/**
+ * Count transactions on a page
+ */
+async function countTransactions(image: string, pageNum: number): Promise<number> {
+  const response = await queryVision(image,
+    `How many transaction rows are in this bank statement table?
+Count only the data rows (with dates like "01.01.2024" and amounts like "- 50,00 €").
+Do NOT count the header row or summary/total rows.
+Answer with just the number, for example: 7`
+  );
+
+  console.log(`    [Page ${pageNum}] Count query response: "${response}"`);
+  const match = response.match(/(\d+)/);
+  const count = match ? parseInt(match[1], 10) : 0;
+  console.log(`    [Page ${pageNum}] Parsed count: ${count}`);
+  return count;
+}
+
+/**
+ * Get a single transaction by index (logs immediately when complete)
+ */
+async function getTransaction(image: string, index: number, pageNum: number): Promise<ITransaction | null> {
+  const response = await queryVision(image,
+    `This is a bank statement. Look at transaction row #${index} in the table (counting from top, excluding headers).
+
+Extract this transaction's details:
+- Date in YYYY-MM-DD format
+- Counterparty/description name
+- Amount as number (negative for debits like "- 21,47 €" = -21.47, positive for credits like "+ 100,00 €" = 100.00)
+
+Answer in format: DATE|COUNTERPARTY|AMOUNT
+Example: 2024-01-15|Amazon|−25.99`
+  );
+
+  // Parse the response
+  const lines = response.split('\n').filter(l => l.includes('|'));
+  const line = lines[lines.length - 1] || response;
+  const parts = line.split('|').map(p => p.trim());
+
+  if (parts.length >= 3) {
+    // Parse amount - handle various formats
+    let amountStr = parts[2].replace(/[€$£\s]/g, '').replace('−', '-').replace('–', '-');
+    // European format: comma is decimal
+    if (amountStr.includes(',')) {
+      amountStr = amountStr.replace(/\./g, '').replace(',', '.');
+    }
+    const amount = parseFloat(amountStr) || 0;
+
+    const tx = {
+      date: parts[0],
+      counterparty: parts[1],
+      amount: amount,
+    };
+    // Log immediately as this transaction completes
+    console.log(`    [P${pageNum} Tx${index.toString().padStart(2, ' ')}] ${tx.date} | ${tx.counterparty.substring(0, 25).padEnd(25)} | ${tx.amount >= 0 ? '+' : ''}${tx.amount.toFixed(2)}`);
+    return tx;
+  }
+
+  // Log raw response on parse failure
+  console.log(`    [P${pageNum} Tx${index.toString().padStart(2, ' ')}] PARSE FAILED: "${response.replace(/\n/g, ' ').substring(0, 60)}..."`);
+  return null;
+}
+
+/**
+ * Extract transactions from a single page using multi-query approach
+ */
+async function extractTransactionsFromPage(image: string, pageNum: number): Promise<ITransaction[]> {
+  // Step 1: Count transactions
+  const count = await countTransactions(image, pageNum);
+
+  if (count === 0) {
+    return [];
+  }
+
+  // Step 2: Query each transaction (in batches to avoid overwhelming)
+  // Each transaction logs itself as it completes
+  const transactions: ITransaction[] = [];
+  const batchSize = 5;
+
+  for (let start = 1; start <= count; start += batchSize) {
+    const end = Math.min(start + batchSize - 1, count);
+    const indices = Array.from({ length: end - start + 1 }, (_, i) => start + i);
+
+    // Query batch in parallel - each logs as it completes
+    const results = await Promise.all(
+      indices.map(i => getTransaction(image, i, pageNum))
+    );
+
+    for (const tx of results) {
+      if (tx) {
+        transactions.push(tx);
+      }
+    }
+  }
+
+  console.log(`    [Page ${pageNum}] Complete: ${transactions.length}/${count} extracted`);
+  return transactions;
+}
+
+/**
+ * Extract all transactions from bank statement
+ */
+async function extractTransactions(images: string[]): Promise<ITransaction[]> {
+  console.log(`    [Vision] Processing ${images.length} page(s) with Qwen3-VL (multi-query)`);
+
+  const allTransactions: ITransaction[] = [];
+
+  for (let i = 0; i < images.length; i++) {
+    const pageTransactions = await extractTransactionsFromPage(images[i], i + 1);
+    allTransactions.push(...pageTransactions);
+  }
+
+  console.log(`    [Vision] Total: ${allTransactions.length} transactions`);
+  return allTransactions;
+}
+
+/**
+ * Compare transactions
+ */
+function compareTransactions(
+  extracted: ITransaction[],
+  expected: ITransaction[]
+): { matches: number; total: number; errors: string[] } {
+  const errors: string[] = [];
+  let matches = 0;
+
+  for (let i = 0; i < expected.length; i++) {
+    const exp = expected[i];
+    const ext = extracted[i];
+
+    if (!ext) {
+      errors.push(`Missing transaction ${i}: ${exp.date} ${exp.counterparty}`);
+      continue;
+    }
+
+    const dateMatch = ext.date === exp.date;
+    const amountMatch = Math.abs(ext.amount - exp.amount) < 0.01;
+
+    if (dateMatch && amountMatch) {
+      matches++;
+    } else {
+      errors.push(`Mismatch at ${i}: expected ${exp.date}/${exp.amount}, got ${ext.date}/${ext.amount}`);
+    }
+  }
+
+  if (extracted.length > expected.length) {
+    errors.push(`Extra transactions: ${extracted.length - expected.length}`);
+  }
+
+  return { matches, total: expected.length, errors };
+}
+
+/**
+ * Find test cases in .nogit/
+ */
+function findTestCases(): Array<{ name: string; pdfPath: string; jsonPath: string }> {
+  const testDir = path.join(process.cwd(), '.nogit');
+  if (!fs.existsSync(testDir)) return [];
+
+  const files = fs.readdirSync(testDir);
+  const testCases: Array<{ name: string; pdfPath: string; jsonPath: string }> = [];
+
+  for (const pdf of files.filter((f: string) => f.endsWith('.pdf'))) {
+    const baseName = pdf.replace('.pdf', '');
+    const jsonFile = `${baseName}.json`;
+    if (files.includes(jsonFile)) {
+      testCases.push({
+        name: baseName,
+        pdfPath: path.join(testDir, pdf),
+        jsonPath: path.join(testDir, jsonFile),
+      });
+    }
+  }
+
+  return testCases.sort((a, b) => a.name.localeCompare(b.name));
+}
+
+/**
+ * Ensure Qwen3-VL model is available
+ */
+async function ensureQwen3Vl(): Promise<boolean> {
+  try {
+    const response = await fetch(`${OLLAMA_URL}/api/tags`);
+    if (response.ok) {
+      const data = await response.json();
+      const models = data.models || [];
+      if (models.some((m: { name: string }) => m.name === VISION_MODEL)) {
+        console.log(`[Ollama] Model available: ${VISION_MODEL}`);
+        return true;
+      }
+    }
+  } catch {
+    return false;
+  }
+
+  console.log(`[Ollama] Pulling ${VISION_MODEL}...`);
+  const pullResponse = await fetch(`${OLLAMA_URL}/api/pull`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ name: VISION_MODEL, stream: false }),
+  });
+
+  return pullResponse.ok;
+}
+
+// Tests
+
+tap.test('setup: ensure Qwen3-VL is running', async () => {
+  console.log('\n[Setup] Checking Qwen3-VL 8B...\n');
+  const ollamaOk = await ensureMiniCpm();
+  expect(ollamaOk).toBeTrue();
+  const visionOk = await ensureQwen3Vl();
+  expect(visionOk).toBeTrue();
+  console.log('\n[Setup] Ready!\n');
+});
+
+const testCases = findTestCases();
+console.log(`\nFound ${testCases.length} bank statement test cases (Qwen3-VL)\n`);
+
+let passedCount = 0;
+let failedCount = 0;
+
+for (const testCase of testCases) {
+  tap.test(`should extract: ${testCase.name}`, async () => {
+    const expected: ITransaction[] = JSON.parse(fs.readFileSync(testCase.jsonPath, 'utf-8'));
+    console.log(`\n=== ${testCase.name} ===`);
+    console.log(`Expected: ${expected.length} transactions`);
+
+    const images = convertPdfToImages(testCase.pdfPath);
+    console.log(`  Pages: ${images.length}`);
+
+    const extracted = await extractTransactions(images);
+    console.log(`  Extracted: ${extracted.length} transactions`);
+
+    const result = compareTransactions(extracted, expected);
+    const accuracy = result.total > 0 ? result.matches / result.total : 0;
+
+    if (accuracy >= 0.95 && extracted.length === expected.length) {
+      passedCount++;
+      console.log(`  Result: PASS (${result.matches}/${result.total})`);
+    } else {
+      failedCount++;
+      console.log(`  Result: FAIL (${result.matches}/${result.total})`);
+      result.errors.slice(0, 5).forEach((e) => console.log(`    - ${e}`));
+    }
+
+    expect(accuracy).toBeGreaterThan(0.95);
+    expect(extracted.length).toEqual(expected.length);
+  });
+}
+
+tap.test('summary', async () => {
+  const total = testCases.length;
+  console.log(`\n======================================================`);
+  console.log(`   Bank Statement Summary (Qwen3-VL Vision)`);
+  console.log(`======================================================`);
+  console.log(`  Method:   Multi-query (count then extract each)`);
+  console.log(`  Passed:   ${passedCount}/${total}`);
+  console.log(`  Failed:   ${failedCount}/${total}`);
+  console.log(`======================================================\n`);
+});
+
+export default tap.start();

test/test.invoices.combined.ts

@@ -1,12 +1,20 @@
+/**
+ * Invoice extraction test using MiniCPM-V (visual) + PaddleOCR-VL (OCR augmentation)
+ *
+ * This is the combined approach that uses both models for best accuracy:
+ *   - MiniCPM-V for visual understanding
+ *   - PaddleOCR-VL for OCR text to augment prompts
+ */
 import { tap, expect } from '@git.zone/tstest/tapbundle';
 import * as fs from 'fs';
 import * as path from 'path';
 import { execSync } from 'child_process';
 import * as os from 'os';
+import { ensurePaddleOcrVl, ensureMiniCpm } from './helpers/docker.js';
 
 const OLLAMA_URL = 'http://localhost:11434';
-const MODEL = 'openbmb/minicpm-v4.5:q8_0';
+const MODEL = 'minicpm-v:latest';
-const PADDLEOCR_URL = 'http://localhost:5000';
+const PADDLEOCR_VL_URL = 'http://localhost:8000';
 
 interface IInvoice {
   invoice_number: string;
@@ -19,24 +27,33 @@ interface IInvoice {
 }
 
 /**
- * Extract OCR text from an image using PaddleOCR
+ * Extract OCR text from an image using PaddleOCR-VL (OpenAI-compatible API)
  */
 async function extractOcrText(imageBase64: string): Promise<string> {
   try {
-    const response = await fetch(`${PADDLEOCR_URL}/ocr`, {
+    const response = await fetch(`${PADDLEOCR_VL_URL}/v1/chat/completions`, {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ image: imageBase64 }),
+      body: JSON.stringify({
+        model: 'paddleocr-vl',
+        messages: [{
+          role: 'user',
+          content: [
+            { type: 'image_url', image_url: { url: `data:image/png;base64,${imageBase64}` } },
+            { type: 'text', text: 'OCR:' }
+          ]
+        }],
+        temperature: 0.0,
+        max_tokens: 4096
+      }),
     });
 
     if (!response.ok) return '';
 
     const data = await response.json();
-    if (data.success && data.results) {
+    return data.choices?.[0]?.message?.content || '';
-      return data.results.map((r: { text: string }) => r.text).join('\n');
-    }
   } catch {
-    // PaddleOCR unavailable
+    // PaddleOCR-VL unavailable
   }
   return '';
 }
@@ -349,11 +366,18 @@ function findTestCases(): Array<{ name: string; pdfPath: string; jsonPath: strin
 
 // Tests
 
-tap.test('should connect to Ollama API', async () => {
+tap.test('setup: ensure Docker containers are running', async () => {
-  const response = await fetch(`${OLLAMA_URL}/api/tags`);
+  console.log('\n[Setup] Checking Docker containers...\n');
-  expect(response.ok).toBeTrue();
+
-  const data = await response.json();
+  // Ensure PaddleOCR-VL is running (auto-detects GPU/CPU)
-  expect(data.models).toBeArray();
+  const paddleOk = await ensurePaddleOcrVl();
+  expect(paddleOk).toBeTrue();
+
+  // Ensure MiniCPM is running
+  const minicpmOk = await ensureMiniCpm();
+  expect(minicpmOk).toBeTrue();
+
+  console.log('\n[Setup] All containers ready!\n');
 });
 
 tap.test('should have MiniCPM-V 4.5 model loaded', async () => {

test/test.invoices.minicpm.ts

@@ -0,0 +1,500 @@
+/**
+ * Invoice extraction test using MiniCPM-V only (visual extraction)
+ *
+ * Multi-query approach with thinking DISABLED for speed.
+ * Single pass, no consensus voting.
+ */
+import { tap, expect } from '@git.zone/tstest/tapbundle';
+import * as fs from 'fs';
+import * as path from 'path';
+import { execSync } from 'child_process';
+import * as os from 'os';
+import { ensureMiniCpm } from './helpers/docker.js';
+
+const OLLAMA_URL = 'http://localhost:11434';
+const MODEL = 'minicpm-v:latest';
+
+interface IInvoice {
+  invoice_number: string;
+  invoice_date: string;
+  vendor_name: string;
+  currency: string;
+  net_amount: number;
+  vat_amount: number;
+  total_amount: number;
+}
+
+/**
+ * Convert PDF to PNG images using ImageMagick
+ */
+function convertPdfToImages(pdfPath: string): string[] {
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pdf-convert-'));
+  const outputPattern = path.join(tempDir, 'page-%d.png');
+
+  try {
+    execSync(
+      `convert -density 200 -quality 90 "${pdfPath}" -background white -alpha remove "${outputPattern}"`,
+      { stdio: 'pipe' }
+    );
+
+    const files = fs.readdirSync(tempDir).filter((f) => f.endsWith('.png')).sort();
+    const images: string[] = [];
+
+    for (const file of files) {
+      const imagePath = path.join(tempDir, file);
+      const imageData = fs.readFileSync(imagePath);
+      images.push(imageData.toString('base64'));
+    }
+
+    return images;
+  } finally {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  }
+}
+
+/**
+ * Query MiniCPM-V for a single field (thinking disabled for speed)
+ */
+async function queryField(images: string[], question: string): Promise<string> {
+  const response = await fetch(`${OLLAMA_URL}/api/generate`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({
+      model: MODEL,
+      prompt: `/no_think\n${question}`,
+      images: images,
+      stream: false,
+      options: {
+        num_predict: 500,
+        temperature: 0.1,
+      },
+    }),
+  });
+
+  if (!response.ok) {
+    throw new Error(`Ollama API error: ${response.status}`);
+  }
+
+  const data = await response.json();
+  const content = (data.response || '').trim();
+
+  // Return full content (no thinking to filter)
+  return content;
+}
+
+/**
+ * Extract invoice data using multiple queries with validation
+ */
+async function extractInvoiceFromImages(images: string[]): Promise<IInvoice> {
+  console.log(`    [Vision] Processing ${images.length} page(s) with MiniCPM-V (multi-query + validation)`);
+
+  // Log each result as it comes in
+  const queryAndLog = async (name: string, question: string): Promise<string> => {
+    const result = await queryField(images, question);
+    console.log(`    [Query] ${name}: "${result}"`);
+    return result;
+  };
+
+  // STRATEGY 1: List-then-pick for invoice number (avoids confusion with VAT/customer IDs)
+  // Also ask for invoice number directly as backup
+  const [allNumbers, directInvoiceNum] = await Promise.all([
+    queryAndLog('All Numbers   ', `List ALL document numbers visible on this invoice.
+For each number, identify what type it is.
+Format: type:number, type:number
+Example: >>>invoice:R0014359508, vat:DE123456789, customer:K001234<<<`),
+    queryAndLog('Invoice # Dir ', `What is the INVOICE NUMBER (Rechnungsnummer)?
+NOT the VAT number (starts with DE/IE), NOT customer ID.
+Look for "Invoice No.", "Rechnungsnr.", "Invoice #", or "Facture".
+For Adobe: starts with IEE or R followed by digits.
+Return ONLY the number: >>>IEE2022006460244<<<`),
+  ]);
+
+  // STRATEGY 2: Query each field with >>> <<< delimiters
+  const [invoiceDate, invoiceDateAlt, vendor, currency, totalAmount, netAmount, vatAmount] = await Promise.all([
+    queryAndLog('Invoice Date  ', `Find the INVOICE DATE (when issued, NOT due date).
+Look for: "Invoice Date", "Rechnungsdatum", "Date", "Datum"
+Return ONLY the date in YYYY-MM-DD format: >>>2024-01-15<<<`),
+
+    // STRATEGY 3: Ask same question differently for verification
+    queryAndLog('Date Alt      ', `What date appears next to the invoice number at the top?
+Return ONLY YYYY-MM-DD format: >>>2024-01-15<<<`),
+
+    queryAndLog('Vendor        ', `What company ISSUED this invoice (seller, not buyer)?
+Look at letterhead/logo at top.
+Return ONLY the company name: >>>Adobe Inc.<<<`),
+
+    queryAndLog('Currency      ', `What currency symbol appears next to amounts? € $ or £?
+Return the 3-letter code: >>>EUR<<<`),
+
+    queryAndLog('Total Amount  ', `What is the FINAL TOTAL amount (including tax) the customer must pay?
+Look for "Total", "Grand Total", "Gesamtbetrag" at the bottom.
+Return ONLY the number (no symbol): >>>24.99<<<`),
+
+    queryAndLog('Net Amount    ', `What is the NET/subtotal amount BEFORE tax?
+Look for "Net", "Netto", "Subtotal".
+Return ONLY the number: >>>20.99<<<`),
+
+    queryAndLog('VAT Amount    ', `What is the VAT/tax amount?
+Look for "VAT", "MwSt", "USt", "Tax".
+Return ONLY the number: >>>4.00<<<`),
+  ]);
+
+  // Extract value from >>> <<< delimiters, or return original if not found
+  const extractDelimited = (s: string): string => {
+    const match = s.match(/>>>([^<]+)<<</);
+    return match ? match[1].trim() : s.trim();
+  };
+
+  // Parse amount from string (handles European format and prose)
+  const parseAmount = (s: string): number => {
+    if (!s) return 0;
+
+    // First try delimited format
+    const delimitedMatch = s.match(/>>>([^<]+)<<</);
+    if (delimitedMatch) {
+      const numMatch = delimitedMatch[1].match(/([\d.,]+)/);
+      if (numMatch) {
+        const numStr = numMatch[1];
+        const normalized = numStr.includes(',') && numStr.indexOf(',') > numStr.lastIndexOf('.')
+          ? numStr.replace(/\./g, '').replace(',', '.')
+          : numStr.replace(/,/g, '');
+        return parseFloat(normalized) || 0;
+      }
+    }
+
+    // Try to find amount patterns in prose: "24.99", "24,99", "€24.99", "24.99 EUR"
+    const amountPatterns = [
+      /(?:€|EUR|USD|GBP)\s*([\d.,]+)/i,           // €24.99 or EUR 24.99
+      /([\d.,]+)\s*(?:€|EUR|USD|GBP)/i,           // 24.99 EUR or 24.99€
+      /(?:is|amount|total)[:\s]+([\d.,]+)/i,      // "is 24.99" or "amount: 24.99"
+      /\b(\d{1,3}(?:[.,]\d{2,3})*(?:[.,]\d{2}))\b/, // General number pattern with decimals
+    ];
+
+    for (const pattern of amountPatterns) {
+      const match = s.match(pattern);
+      if (match) {
+        const numStr = match[1];
+        // European format: 1.234,56 → 1234.56
+        const normalized = numStr.includes(',') && numStr.indexOf(',') > numStr.lastIndexOf('.')
+          ? numStr.replace(/\./g, '').replace(',', '.')
+          : numStr.replace(/,/g, '');
+        const value = parseFloat(normalized);
+        if (value > 0) return value;
+      }
+    }
+
+    return 0;
+  };
+
+  // STRATEGY 1: Parse "all numbers" to find invoice number
+  const extractInvoiceFromList = (allNums: string): string | null => {
+    const delimited = extractDelimited(allNums);
+
+    // Find ALL "invoice:XXX" matches
+    const invoiceMatches = delimited.matchAll(/invoice[:\s]*([A-Z0-9-]+)/gi);
+    const candidates: string[] = [];
+    for (const match of invoiceMatches) {
+      const value = match[1];
+      // Filter out labels like "USt-IdNr", "INVOICE", short strings
+      if (value.length > 5 && /\d{4,}/.test(value) && !/^(ust|vat|tax|nr|id|no)/i.test(value)) {
+        candidates.push(value);
+      }
+    }
+    if (candidates.length > 0) return candidates[0];
+
+    // Look for "rechnungsnr:XXX" pattern
+    const rechnungMatch = delimited.match(/rechnung[snr]*[:\s]*([A-Z0-9-]{6,})/i);
+    if (rechnungMatch && /\d{4,}/.test(rechnungMatch[1])) return rechnungMatch[1];
+
+    // Look for patterns like IEE2022..., R001... (Adobe invoice number patterns)
+    const adobeMatch = delimited.match(/\b(IEE\d{10,})\b/i);
+    if (adobeMatch) return adobeMatch[1];
+    const rInvoiceMatch = delimited.match(/\b(R\d{8,})\b/i);
+    if (rInvoiceMatch) return rInvoiceMatch[1];
+
+    return null;
+  };
+
+  // Fallback invoice number extraction
+  const extractInvoiceNumber = (s: string): string => {
+    const delimited = extractDelimited(s);
+    if (delimited !== s.trim()) return delimited;
+
+    let clean = s.replace(/\*\*/g, '').replace(/`/g, '');
+    const patterns = [
+      /\b([A-Z]{2,3}\d{10,})\b/i,
+      /\b([A-Z]\d{8,})\b/i,
+      /\b(INV[-\s]?\d{4}[-\s]?\d+)\b/i,
+      /\b(\d{7,})\b/,
+    ];
+    for (const pattern of patterns) {
+      const match = clean.match(pattern);
+      if (match) return match[1];
+    }
+    return clean.replace(/[^A-Z0-9-]/gi, '').trim() || clean.trim();
+  };
+
+  // Extract date with fallback
+  const extractDate = (s: string): string => {
+    const delimited = extractDelimited(s);
+    if (/^\d{4}-\d{2}-\d{2}$/.test(delimited)) return delimited;
+
+    let clean = s.replace(/\*\*/g, '').replace(/`/g, '');
+    const isoMatch = clean.match(/(\d{4}-\d{2}-\d{2})/);
+    if (isoMatch) return isoMatch[1];
+    const dmmyMatch = clean.match(/(\d{1,2})[-\/]([A-Z]{3})[-\/](\d{4})/i);
+    if (dmmyMatch) {
+      const monthMap: Record<string, string> = {
+        JAN: '01', FEB: '02', MAR: '03', APR: '04', MAY: '05', JUN: '06',
+        JUL: '07', AUG: '08', SEP: '09', OCT: '10', NOV: '11', DEC: '12',
+      };
+      return `${dmmyMatch[3]}-${monthMap[dmmyMatch[2].toUpperCase()] || '01'}-${dmmyMatch[1].padStart(2, '0')}`;
+    }
+    const dmyMatch = clean.match(/(\d{1,2})[\/.](\d{1,2})[\/.](\d{4})/);
+    if (dmyMatch) {
+      return `${dmyMatch[3]}-${dmyMatch[2].padStart(2, '0')}-${dmyMatch[1].padStart(2, '0')}`;
+    }
+    return '';
+  };
+
+  // Extract currency
+  const extractCurrency = (s: string): string => {
+    const delimited = extractDelimited(s);
+    if (['EUR', 'USD', 'GBP'].includes(delimited.toUpperCase())) return delimited.toUpperCase();
+    const upper = s.toUpperCase();
+    if (upper.includes('EUR') || upper.includes('€')) return 'EUR';
+    if (upper.includes('USD') || upper.includes('$')) return 'USD';
+    if (upper.includes('GBP') || upper.includes('£')) return 'GBP';
+    return 'EUR';
+  };
+
+  // Extract vendor
+  const extractVendor = (s: string): string => {
+    const delimited = extractDelimited(s);
+    if (delimited !== s.trim()) return delimited;
+    let clean = s.replace(/\*\*/g, '').replace(/`/g, '').trim();
+    if (clean.length < 50) return clean.replace(/[."]+$/, '').trim();
+    const companyMatch = clean.match(/([A-Z][A-Za-z0-9\s&]+(?:Ltd|Limited|GmbH|Inc|BV|AG|SE|LLC|Co|Corp)[.]?)/i);
+    if (companyMatch) return companyMatch[1].trim();
+    return clean;
+  };
+
+  // STRATEGY 1: Get invoice number - try multiple approaches
+  // 1. From list with type labels
+  // 2. From direct query
+  // 3. From pattern matching
+  const fromList = extractInvoiceFromList(allNumbers);
+  const fromDirect = extractInvoiceNumber(directInvoiceNum);
+  const fromFallback = extractInvoiceNumber(allNumbers);
+
+  // Prefer direct query if it has digits, otherwise use list
+  const invoiceNumber = (fromDirect && /\d{6,}/.test(fromDirect)) ? fromDirect :
+                        (fromList && /\d{4,}/.test(fromList)) ? fromList :
+                        fromDirect || fromList || fromFallback;
+  console.log(`    [Parsed] Invoice Number: "${invoiceNumber}" (list: ${fromList}, direct: ${fromDirect})`);
+
+  // STRATEGY 3: Compare two date responses, pick the valid one
+  const date1 = extractDate(invoiceDate);
+  const date2 = extractDate(invoiceDateAlt);
+  const finalDate = date1 || date2;
+  if (date1 && date2 && date1 !== date2) {
+    console.log(`    [Validate] Date mismatch: "${date1}" vs "${date2}" - using first`);
+  }
+
+  // Parse amounts
+  let total = parseAmount(totalAmount);
+  let net = parseAmount(netAmount);
+  let vat = parseAmount(vatAmount);
+
+  // STRATEGY 4: Cross-field validation for amounts
+  // If amounts seem wrong (e.g., 1690 instead of 1.69), try to fix
+  if (total > 10000 && net < 100) {
+    console.log(`    [Validate] Total ${total} seems too high vs net ${net}, dividing by 100`);
+    total = total / 100;
+  }
+  if (net > 10000 && total < 100) {
+    console.log(`    [Validate] Net ${net} seems too high vs total ${total}, dividing by 100`);
+    net = net / 100;
+  }
+
+  // Check if Net + VAT ≈ Total
+  if (net > 0 && vat >= 0 && total > 0) {
+    const calculated = net + vat;
+    if (Math.abs(calculated - total) > 1) {
+      console.log(`    [Validate] Math check: ${net} + ${vat} = ${calculated} ≠ ${total}`);
+    }
+  }
+
+  return {
+    invoice_number: invoiceNumber,
+    invoice_date: finalDate,
+    vendor_name: extractVendor(vendor),
+    currency: extractCurrency(currency),
+    net_amount: net,
+    vat_amount: vat,
+    total_amount: total,
+  };
+}
+
+/**
+ * Normalize date to YYYY-MM-DD
+ */
+function normalizeDate(dateStr: string | null): string {
+  if (!dateStr) return '';
+  if (/^\d{4}-\d{2}-\d{2}$/.test(dateStr)) return dateStr;
+
+  const monthMap: Record<string, string> = {
+    JAN: '01', FEB: '02', MAR: '03', APR: '04', MAY: '05', JUN: '06',
+    JUL: '07', AUG: '08', SEP: '09', OCT: '10', NOV: '11', DEC: '12',
+  };
+
+  let match = dateStr.match(/^(\d{1,2})-([A-Z]{3})-(\d{4})$/i);
+  if (match) {
+    return `${match[3]}-${monthMap[match[2].toUpperCase()] || '01'}-${match[1].padStart(2, '0')}`;
+  }
+
+  match = dateStr.match(/^(\d{1,2})[\/.](\d{1,2})[\/.](\d{4})$/);
+  if (match) {
+    return `${match[3]}-${match[2].padStart(2, '0')}-${match[1].padStart(2, '0')}`;
+  }
+
+  return dateStr;
+}
+
+/**
+ * Compare extracted invoice against expected
+ */
+function compareInvoice(
+  extracted: IInvoice,
+  expected: IInvoice
+): { match: boolean; errors: string[] } {
+  const errors: string[] = [];
+
+  // Compare invoice number (normalize by removing spaces and case)
+  const extNum = extracted.invoice_number?.replace(/\s/g, '').toLowerCase() || '';
+  const expNum = expected.invoice_number?.replace(/\s/g, '').toLowerCase() || '';
+  if (extNum !== expNum) {
+    errors.push(`invoice_number: expected "${expected.invoice_number}", got "${extracted.invoice_number}"`);
+  }
+
+  // Compare date
+  if (normalizeDate(extracted.invoice_date) !== normalizeDate(expected.invoice_date)) {
+    errors.push(`invoice_date: expected "${expected.invoice_date}", got "${extracted.invoice_date}"`);
+  }
+
+  // Compare total amount (with tolerance)
+  if (Math.abs(extracted.total_amount - expected.total_amount) > 0.02) {
+    errors.push(`total_amount: expected ${expected.total_amount}, got ${extracted.total_amount}`);
+  }
+
+  // Compare currency
+  if (extracted.currency?.toUpperCase() !== expected.currency?.toUpperCase()) {
+    errors.push(`currency: expected "${expected.currency}", got "${extracted.currency}"`);
+  }
+
+  return { match: errors.length === 0, errors };
+}
+
+/**
+ * Find all test cases (PDF + JSON pairs) in .nogit/invoices/
+ */
+function findTestCases(): Array<{ name: string; pdfPath: string; jsonPath: string }> {
+  const testDir = path.join(process.cwd(), '.nogit/invoices');
+  if (!fs.existsSync(testDir)) {
+    return [];
+  }
+
+  const files = fs.readdirSync(testDir);
+  const pdfFiles = files.filter((f) => f.endsWith('.pdf'));
+  const testCases: Array<{ name: string; pdfPath: string; jsonPath: string }> = [];
+
+  for (const pdf of pdfFiles) {
+    const baseName = pdf.replace('.pdf', '');
+    const jsonFile = `${baseName}.json`;
+    if (files.includes(jsonFile)) {
+      testCases.push({
+        name: baseName,
+        pdfPath: path.join(testDir, pdf),
+        jsonPath: path.join(testDir, jsonFile),
+      });
+    }
+  }
+
+  testCases.sort((a, b) => a.name.localeCompare(b.name));
+  return testCases;
+}
+
+// Tests
+
+tap.test('setup: ensure Docker containers are running', async () => {
+  console.log('\n[Setup] Checking Docker containers...\n');
+  const minicpmOk = await ensureMiniCpm();
+  expect(minicpmOk).toBeTrue();
+  console.log('\n[Setup] All containers ready!\n');
+});
+
+tap.test('should have MiniCPM-V model loaded', async () => {
+  const response = await fetch(`${OLLAMA_URL}/api/tags`);
+  const data = await response.json();
+  const modelNames = data.models.map((m: { name: string }) => m.name);
+  expect(modelNames.some((name: string) => name.includes('minicpm'))).toBeTrue();
+});
+
+const testCases = findTestCases();
+console.log(`\nFound ${testCases.length} invoice test cases (MiniCPM-V)\n`);
+
+let passedCount = 0;
+let failedCount = 0;
+const processingTimes: number[] = [];
+
+for (const testCase of testCases) {
+  tap.test(`should extract invoice: ${testCase.name}`, async () => {
+    const expected: IInvoice = JSON.parse(fs.readFileSync(testCase.jsonPath, 'utf-8'));
+    console.log(`\n=== ${testCase.name} ===`);
+    console.log(`Expected: ${expected.invoice_number} | ${expected.invoice_date} | ${expected.total_amount} ${expected.currency}`);
+
+    const startTime = Date.now();
+    const images = convertPdfToImages(testCase.pdfPath);
+    console.log(`  Pages: ${images.length}`);
+
+    const extracted = await extractInvoiceFromImages(images);
+    console.log(`  Extracted: ${extracted.invoice_number} | ${extracted.invoice_date} | ${extracted.total_amount} ${extracted.currency}`);
+
+    const elapsedMs = Date.now() - startTime;
+    processingTimes.push(elapsedMs);
+
+    const result = compareInvoice(extracted, expected);
+
+    if (result.match) {
+      passedCount++;
+      console.log(`  Result: MATCH (${(elapsedMs / 1000).toFixed(1)}s)`);
+    } else {
+      failedCount++;
+      console.log(`  Result: MISMATCH (${(elapsedMs / 1000).toFixed(1)}s)`);
+      result.errors.forEach((e) => console.log(`    - ${e}`));
+    }
+
+    expect(result.match).toBeTrue();
+  });
+}
+
+tap.test('summary', async () => {
+  const totalInvoices = testCases.length;
+  const accuracy = totalInvoices > 0 ? (passedCount / totalInvoices) * 100 : 0;
+  const totalTimeMs = processingTimes.reduce((a, b) => a + b, 0);
+  const avgTimeSec = processingTimes.length > 0 ? totalTimeMs / processingTimes.length / 1000 : 0;
+
+  console.log(`\n========================================`);
+  console.log(`   Invoice Extraction Summary (MiniCPM)`);
+  console.log(`========================================`);
+  console.log(`  Method:    Multi-query (no_think)`);
+  console.log(`  Passed:    ${passedCount}/${totalInvoices}`);
+  console.log(`  Failed:    ${failedCount}/${totalInvoices}`);
+  console.log(`  Accuracy:  ${accuracy.toFixed(1)}%`);
+  console.log(`----------------------------------------`);
+  console.log(`  Total time:   ${(totalTimeMs / 1000).toFixed(1)}s`);
+  console.log(`  Avg per inv:  ${avgTimeSec.toFixed(1)}s`);
+  console.log(`========================================\n`);
+});
+
+export default tap.start();

test/test.invoices.ministral3.ts

@@ -0,0 +1,334 @@
+/**
+ * Invoice extraction using Ministral 3 Vision (Direct)
+ *
+ * NO PaddleOCR needed - Ministral 3 has built-in vision encoder:
+ *   1. Convert PDF to images
+ *   2. Send images directly to Ministral 3 via Ollama
+ *   3. Extract structured JSON with native schema support
+ *
+ * This is the simplest possible pipeline.
+ */
+import { tap, expect } from '@git.zone/tstest/tapbundle';
+import * as fs from 'fs';
+import * as path from 'path';
+import { execSync } from 'child_process';
+import * as os from 'os';
+import { ensureMinistral3 } from './helpers/docker.js';
+
+const OLLAMA_URL = 'http://localhost:11434';
+const VISION_MODEL = 'ministral-3:8b';
+
+interface IInvoice {
+  invoice_number: string;
+  invoice_date: string;
+  vendor_name: string;
+  currency: string;
+  net_amount: number;
+  vat_amount: number;
+  total_amount: number;
+}
+
+/**
+ * Convert PDF to PNG images using ImageMagick
+ */
+function convertPdfToImages(pdfPath: string): string[] {
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pdf-convert-'));
+  const outputPattern = path.join(tempDir, 'page-%d.png');
+
+  try {
+    // High quality conversion: 300 DPI, max quality, sharpen for better OCR
+    execSync(
+      `convert -density 300 -quality 100 "${pdfPath}" -background white -alpha remove -sharpen 0x1 "${outputPattern}"`,
+      { stdio: 'pipe' }
+    );
+
+    const files = fs.readdirSync(tempDir).filter((f) => f.endsWith('.png')).sort();
+    const images: string[] = [];
+
+    for (const file of files) {
+      const imagePath = path.join(tempDir, file);
+      const imageData = fs.readFileSync(imagePath);
+      images.push(imageData.toString('base64'));
+    }
+
+    return images;
+  } finally {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  }
+}
+
+/**
+ * Extract invoice data directly from images using Ministral 3 Vision
+ */
+async function extractInvoiceFromImages(images: string[]): Promise<IInvoice> {
+  console.log(`    [Vision] Processing ${images.length} page(s) with Ministral 3`);
+
+  // JSON schema for structured output
+  const invoiceSchema = {
+    type: 'object',
+    properties: {
+      invoice_number: { type: 'string' },
+      invoice_date: { type: 'string' },
+      vendor_name: { type: 'string' },
+      currency: { type: 'string' },
+      net_amount: { type: 'number' },
+      vat_amount: { type: 'number' },
+      total_amount: { type: 'number' },
+    },
+    required: ['invoice_number', 'invoice_date', 'vendor_name', 'currency', 'net_amount', 'vat_amount', 'total_amount'],
+  };
+
+  const prompt = `You are an expert invoice data extraction system. Carefully analyze this invoice document and extract the following fields with high precision.
+
+INVOICE NUMBER:
+- Look for labels: "Invoice No", "Invoice #", "Invoice Number", "Rechnung Nr", "Rechnungsnummer", "Document No", "Bill No", "Reference"
+- Usually alphanumeric, often starts with letters (e.g., R0014359508, INV-2024-001)
+- Located near the top of the invoice
+
+INVOICE DATE:
+- Look for labels: "Invoice Date", "Date", "Datum", "Rechnungsdatum", "Issue Date", "Bill Date"
+- Convert ANY date format to YYYY-MM-DD (e.g., 14/10/2021 → 2021-10-14, Oct 14, 2021 → 2021-10-14)
+- Usually near the invoice number
+
+VENDOR NAME:
+- The company ISSUING the invoice (not the recipient)
+- Found in letterhead, logo area, or header - typically the largest/most prominent company name
+- Examples: "Hetzner Online GmbH", "Adobe Inc", "DigitalOcean LLC"
+
+CURRENCY:
+- Detect from symbols: € = EUR, $ = USD, £ = GBP
+- Or from text: "EUR", "USD", "GBP"
+- Default to EUR if unclear
+
+AMOUNTS (Critical - read carefully!):
+- total_amount: The FINAL amount due/payable - look for "Total", "Grand Total", "Amount Due", "Balance Due", "Gesamtbetrag", "Endbetrag"
+- net_amount: Subtotal BEFORE tax - look for "Subtotal", "Net", "Netto", "excl. VAT"
+- vat_amount: Tax amount - look for "VAT", "Tax", "MwSt", "USt", "19%", "20%"
+- For multi-page invoices: the FINAL totals are usually on the LAST page
+
+Return ONLY valid JSON with the extracted values.`;
+
+  const response = await fetch(`${OLLAMA_URL}/api/chat`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({
+      model: VISION_MODEL,
+      messages: [
+        {
+          role: 'user',
+          content: prompt,
+          images: images,  // Send all page images
+        },
+      ],
+      format: invoiceSchema,
+      stream: true,
+      options: {
+        num_predict: 1024,
+        temperature: 0.0,
+      },
+    }),
+  });
+
+  if (!response.ok) {
+    throw new Error(`Ollama API error: ${response.status}`);
+  }
+
+  const reader = response.body?.getReader();
+  if (!reader) {
+    throw new Error('No response body');
+  }
+
+  const decoder = new TextDecoder();
+  let fullText = '';
+
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+
+    const chunk = decoder.decode(value, { stream: true });
+    const lines = chunk.split('\n').filter((l) => l.trim());
+
+    for (const line of lines) {
+      try {
+        const json = JSON.parse(line);
+        if (json.message?.content) {
+          fullText += json.message.content;
+        }
+      } catch {
+        // Skip invalid JSON lines
+      }
+    }
+  }
+
+  // Parse JSON response
+  let jsonStr = fullText.trim();
+
+  if (jsonStr.startsWith('```json')) jsonStr = jsonStr.slice(7);
+  else if (jsonStr.startsWith('```')) jsonStr = jsonStr.slice(3);
+  if (jsonStr.endsWith('```')) jsonStr = jsonStr.slice(0, -3);
+  jsonStr = jsonStr.trim();
+
+  const startIdx = jsonStr.indexOf('{');
+  const endIdx = jsonStr.lastIndexOf('}') + 1;
+
+  if (startIdx < 0 || endIdx <= startIdx) {
+    throw new Error(`No JSON found: ${fullText.substring(0, 200)}`);
+  }
+
+  const parsed = JSON.parse(jsonStr.substring(startIdx, endIdx));
+
+  return {
+    invoice_number: parsed.invoice_number || null,
+    invoice_date: parsed.invoice_date || null,
+    vendor_name: parsed.vendor_name || null,
+    currency: parsed.currency || 'EUR',
+    net_amount: parseFloat(parsed.net_amount) || 0,
+    vat_amount: parseFloat(parsed.vat_amount) || 0,
+    total_amount: parseFloat(parsed.total_amount) || 0,
+  };
+}
+
+
+/**
+ * Normalize date to YYYY-MM-DD
+ */
+function normalizeDate(dateStr: string | null): string {
+  if (!dateStr) return '';
+  if (/^\d{4}-\d{2}-\d{2}$/.test(dateStr)) return dateStr;
+
+  const monthMap: Record<string, string> = {
+    JAN: '01', FEB: '02', MAR: '03', APR: '04', MAY: '05', JUN: '06',
+    JUL: '07', AUG: '08', SEP: '09', OCT: '10', NOV: '11', DEC: '12',
+  };
+
+  let match = dateStr.match(/^(\d{1,2})-([A-Z]{3})-(\d{4})$/i);
+  if (match) {
+    return `${match[3]}-${monthMap[match[2].toUpperCase()] || '01'}-${match[1].padStart(2, '0')}`;
+  }
+
+  match = dateStr.match(/^(\d{1,2})[\/.](\d{1,2})[\/.](\d{4})$/);
+  if (match) {
+    return `${match[3]}-${match[2].padStart(2, '0')}-${match[1].padStart(2, '0')}`;
+  }
+
+  return dateStr;
+}
+
+/**
+ * Compare extracted vs expected
+ */
+function compareInvoice(extracted: IInvoice, expected: IInvoice): { match: boolean; errors: string[] } {
+  const errors: string[] = [];
+
+  const extNum = extracted.invoice_number?.replace(/\s/g, '').toLowerCase() || '';
+  const expNum = expected.invoice_number?.replace(/\s/g, '').toLowerCase() || '';
+  if (extNum !== expNum) {
+    errors.push(`invoice_number: expected "${expected.invoice_number}", got "${extracted.invoice_number}"`);
+  }
+
+  if (normalizeDate(extracted.invoice_date) !== normalizeDate(expected.invoice_date)) {
+    errors.push(`invoice_date: expected "${expected.invoice_date}", got "${extracted.invoice_date}"`);
+  }
+
+  if (Math.abs(extracted.total_amount - expected.total_amount) > 0.02) {
+    errors.push(`total_amount: expected ${expected.total_amount}, got ${extracted.total_amount}`);
+  }
+
+  if (extracted.currency?.toUpperCase() !== expected.currency?.toUpperCase()) {
+    errors.push(`currency: expected "${expected.currency}", got "${extracted.currency}"`);
+  }
+
+  return { match: errors.length === 0, errors };
+}
+
+/**
+ * Find test cases
+ */
+function findTestCases(): Array<{ name: string; pdfPath: string; jsonPath: string }> {
+  const testDir = path.join(process.cwd(), '.nogit/invoices');
+  if (!fs.existsSync(testDir)) return [];
+
+  const files = fs.readdirSync(testDir);
+  const testCases: Array<{ name: string; pdfPath: string; jsonPath: string }> = [];
+
+  for (const pdf of files.filter((f) => f.endsWith('.pdf'))) {
+    const baseName = pdf.replace('.pdf', '');
+    const jsonFile = `${baseName}.json`;
+    if (files.includes(jsonFile)) {
+      testCases.push({
+        name: baseName,
+        pdfPath: path.join(testDir, pdf),
+        jsonPath: path.join(testDir, jsonFile),
+      });
+    }
+  }
+
+  return testCases.sort((a, b) => a.name.localeCompare(b.name));
+}
+
+// Tests
+
+tap.test('setup: ensure Ministral 3 is running', async () => {
+  console.log('\n[Setup] Checking Ministral 3...\n');
+  const ok = await ensureMinistral3();
+  expect(ok).toBeTrue();
+  console.log('\n[Setup] Ready!\n');
+});
+
+const testCases = findTestCases();
+console.log(`\nFound ${testCases.length} invoice test cases (Ministral 3 Vision Direct)\n`);
+
+let passedCount = 0;
+let failedCount = 0;
+const times: number[] = [];
+
+for (const testCase of testCases) {
+  tap.test(`should extract invoice: ${testCase.name}`, async () => {
+    const expected: IInvoice = JSON.parse(fs.readFileSync(testCase.jsonPath, 'utf-8'));
+    console.log(`\n=== ${testCase.name} ===`);
+    console.log(`Expected: ${expected.invoice_number} | ${expected.invoice_date} | ${expected.total_amount} ${expected.currency}`);
+
+    const start = Date.now();
+    const images = convertPdfToImages(testCase.pdfPath);
+    console.log(`  Pages: ${images.length}`);
+
+    const extracted = await extractInvoiceFromImages(images);
+    console.log(`  Extracted: ${extracted.invoice_number} | ${extracted.invoice_date} | ${extracted.total_amount} ${extracted.currency}`);
+    const elapsed = Date.now() - start;
+    times.push(elapsed);
+
+    const result = compareInvoice(extracted, expected);
+
+    if (result.match) {
+      passedCount++;
+      console.log(`  Result: MATCH (${(elapsed / 1000).toFixed(1)}s)`);
+    } else {
+      failedCount++;
+      console.log(`  Result: MISMATCH (${(elapsed / 1000).toFixed(1)}s)`);
+      result.errors.forEach((e) => console.log(`    - ${e}`));
+    }
+
+    expect(result.match).toBeTrue();
+  });
+}
+
+tap.test('summary', async () => {
+  const total = testCases.length;
+  const accuracy = total > 0 ? (passedCount / total) * 100 : 0;
+  const totalTime = times.reduce((a, b) => a + b, 0) / 1000;
+  const avgTime = times.length > 0 ? totalTime / times.length : 0;
+
+  console.log(`\n======================================================`);
+  console.log(`   Invoice Extraction Summary (Ministral 3 Vision)`);
+  console.log(`======================================================`);
+  console.log(`  Method:    Ministral 3 8B Vision (Direct)`);
+  console.log(`  Passed:    ${passedCount}/${total}`);
+  console.log(`  Failed:    ${failedCount}/${total}`);
+  console.log(`  Accuracy:  ${accuracy.toFixed(1)}%`);
+  console.log(`------------------------------------------------------`);
+  console.log(`  Total time:   ${totalTime.toFixed(1)}s`);
+  console.log(`  Avg per inv:  ${avgTime.toFixed(1)}s`);
+  console.log(`======================================================\n`);
+});
+
+export default tap.start();

test/test.invoices.paddleocr-vl.ts

@@ -0,0 +1,490 @@
+/**
+ * Invoice extraction test using PaddleOCR-VL Full Pipeline
+ *
+ * This tests the complete PaddleOCR-VL pipeline:
+ *   1. PP-DocLayoutV2 for layout detection
+ *   2. PaddleOCR-VL for recognition
+ *   3. Structured HTML output (semantic tags with proper tables)
+ *   4. Qwen2.5 extracts invoice fields from structured HTML
+ *
+ * HTML output is used instead of Markdown because:
+ * - <table> tags are unambiguous (no parser variations)
+ * - LLMs are heavily trained on web/HTML data
+ * - Semantic tags (header, footer, section) provide clear structure
+ */
+import { tap, expect } from '@git.zone/tstest/tapbundle';
+import * as fs from 'fs';
+import * as path from 'path';
+import { execSync } from 'child_process';
+import * as os from 'os';
+import { ensurePaddleOcrVlFull, ensureQwen25 } from './helpers/docker.js';
+
+const PADDLEOCR_VL_URL = 'http://localhost:8000';
+const OLLAMA_URL = 'http://localhost:11434';
+// Use Qwen2.5 for text-only JSON extraction (not MiniCPM which is vision-focused)
+const TEXT_MODEL = 'qwen2.5:7b';
+
+interface IInvoice {
+  invoice_number: string;
+  invoice_date: string;
+  vendor_name: string;
+  currency: string;
+  net_amount: number;
+  vat_amount: number;
+  total_amount: number;
+}
+
+/**
+ * Convert PDF to PNG images using ImageMagick
+ */
+function convertPdfToImages(pdfPath: string): string[] {
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pdf-convert-'));
+  const outputPattern = path.join(tempDir, 'page-%d.png');
+
+  try {
+    execSync(
+      `convert -density 200 -quality 90 "${pdfPath}" -background white -alpha remove "${outputPattern}"`,
+      { stdio: 'pipe' }
+    );
+
+    const files = fs.readdirSync(tempDir).filter((f) => f.endsWith('.png')).sort();
+    const images: string[] = [];
+
+    for (const file of files) {
+      const imagePath = path.join(tempDir, file);
+      const imageData = fs.readFileSync(imagePath);
+      images.push(imageData.toString('base64'));
+    }
+
+    return images;
+  } finally {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  }
+}
+
+/**
+ * Parse document using PaddleOCR-VL Full Pipeline (returns structured HTML)
+ */
+async function parseDocument(imageBase64: string): Promise<string> {
+  const response = await fetch(`${PADDLEOCR_VL_URL}/parse`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({
+      image: imageBase64,
+      output_format: 'html',
+    }),
+  });
+
+  if (!response.ok) {
+    const text = await response.text();
+    throw new Error(`PaddleOCR-VL API error: ${response.status} - ${text}`);
+  }
+
+  const data = await response.json();
+
+  if (!data.success) {
+    throw new Error(`PaddleOCR-VL error: ${data.error}`);
+  }
+
+  return data.result?.html || '';
+}
+
+/**
+ * Extract invoice fields using simple direct prompt
+ * The OCR output has clearly labeled fields - just ask the LLM to read them
+ */
+async function extractInvoiceFromHtml(html: string): Promise<IInvoice> {
+  // OCR output is already good - just truncate if too long
+  const truncated = html.length > 32000 ? html.slice(0, 32000) : html;
+  console.log(`    [Extract] ${truncated.length} chars of HTML`);
+
+  // JSON schema for structured output
+  const invoiceSchema = {
+    type: 'object',
+    properties: {
+      invoice_number: { type: 'string' },
+      invoice_date: { type: 'string' },
+      vendor_name: { type: 'string' },
+      currency: { type: 'string' },
+      net_amount: { type: 'number' },
+      vat_amount: { type: 'number' },
+      total_amount: { type: 'number' },
+    },
+    required: ['invoice_number', 'invoice_date', 'vendor_name', 'currency', 'net_amount', 'vat_amount', 'total_amount'],
+  };
+
+  // Simple, direct prompt - the OCR output already has labeled fields
+  const systemPrompt = `You read invoice HTML and extract labeled fields. Return JSON only.`;
+
+  const userPrompt = `Extract from this invoice HTML:
+- invoice_number: Find "Invoice no.", "Invoice #", "Invoice", "Rechnung", "Document No" and extract the value
+- invoice_date: Find "Invoice date", "Date", "Datum" and convert to YYYY-MM-DD format
+- vendor_name: The company name issuing the invoice (in header/letterhead)
+- currency: EUR, USD, or GBP (look for € $ £ symbols or text)
+- total_amount: Find "Total", "Grand Total", "Amount Due", "Gesamtbetrag" - the FINAL total amount
+- net_amount: Amount before VAT/tax (Subtotal, Net)
+- vat_amount: VAT/tax amount
+
+HTML:
+${truncated}
+
+Return ONLY valid JSON: {"invoice_number":"...", "invoice_date":"YYYY-MM-DD", "vendor_name":"...", "currency":"EUR", "net_amount":0, "vat_amount":0, "total_amount":0}`;
+
+  const response = await fetch(`${OLLAMA_URL}/api/chat`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({
+      model: TEXT_MODEL,
+      messages: [
+        { role: 'system', content: systemPrompt },
+        { role: 'user', content: userPrompt },
+      ],
+      format: invoiceSchema,
+      stream: true,
+      options: { num_predict: 512, temperature: 0.0 },
+    }),
+  });
+
+  if (!response.ok) {
+    throw new Error(`Ollama API error: ${response.status}`);
+  }
+
+  const reader = response.body?.getReader();
+  if (!reader) {
+    throw new Error('No response body');
+  }
+
+  const decoder = new TextDecoder();
+  let fullText = '';
+
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+
+    const chunk = decoder.decode(value, { stream: true });
+    const lines = chunk.split('\n').filter((l) => l.trim());
+
+    for (const line of lines) {
+      try {
+        const json = JSON.parse(line);
+        if (json.message?.content) {
+          fullText += json.message.content;
+        } else if (json.response) {
+          fullText += json.response;
+        }
+      } catch {
+        // Skip invalid JSON lines
+      }
+    }
+  }
+
+  // Extract JSON from response
+  let jsonStr = fullText.trim();
+
+  // Remove markdown code block if present
+  if (jsonStr.startsWith('```json')) {
+    jsonStr = jsonStr.slice(7);
+  } else if (jsonStr.startsWith('```')) {
+    jsonStr = jsonStr.slice(3);
+  }
+  if (jsonStr.endsWith('```')) {
+    jsonStr = jsonStr.slice(0, -3);
+  }
+  jsonStr = jsonStr.trim();
+
+  // Find JSON object boundaries
+  const startIdx = jsonStr.indexOf('{');
+  const endIdx = jsonStr.lastIndexOf('}') + 1;
+
+  if (startIdx < 0 || endIdx <= startIdx) {
+    throw new Error(`No JSON object found in response: ${fullText.substring(0, 200)}`);
+  }
+
+  jsonStr = jsonStr.substring(startIdx, endIdx);
+
+  let parsed;
+  try {
+    parsed = JSON.parse(jsonStr);
+  } catch (e) {
+    throw new Error(`Invalid JSON: ${jsonStr.substring(0, 200)}`);
+  }
+
+  // Normalize response to expected format
+  return {
+    invoice_number: parsed.invoice_number || null,
+    invoice_date: parsed.invoice_date || null,
+    vendor_name: parsed.vendor_name || null,
+    currency: parsed.currency || 'EUR',
+    net_amount: parseFloat(parsed.net_amount) || 0,
+    vat_amount: parseFloat(parsed.vat_amount) || 0,
+    total_amount: parseFloat(parsed.total_amount) || 0,
+  };
+}
+
+/**
+ * Single extraction pass: Parse with PaddleOCR-VL Full, extract with Qwen2.5 (text-only)
+ * Processes ALL pages and concatenates HTML for multi-page invoice support
+ */
+async function extractOnce(images: string[], passNum: number): Promise<IInvoice> {
+  // Parse ALL pages and concatenate HTML with page markers
+  const htmlParts: string[] = [];
+
+  for (let i = 0; i < images.length; i++) {
+    const pageHtml = await parseDocument(images[i]);
+    // Add page marker for context
+    htmlParts.push(`<!-- Page ${i + 1} -->\n${pageHtml}`);
+  }
+
+  const fullHtml = htmlParts.join('\n\n');
+  console.log(`    [Parse] Got ${fullHtml.split('\n').length} lines from ${images.length} page(s)`);
+
+  // Extract invoice fields from HTML using text-only model (no images)
+  return extractInvoiceFromHtml(fullHtml);
+}
+
+/**
+ * Create a hash of invoice for comparison (using key fields)
+ */
+function hashInvoice(invoice: IInvoice): string {
+  // Ensure total_amount is a number
+  const amount = typeof invoice.total_amount === 'number'
+    ? invoice.total_amount.toFixed(2)
+    : String(invoice.total_amount || 0);
+  return `${invoice.invoice_number}|${invoice.invoice_date}|${amount}`;
+}
+
+/**
+ * Extract with consensus voting
+ */
+async function extractWithConsensus(images: string[], invoiceName: string, maxPasses: number = 5): Promise<IInvoice> {
+  const results: Array<{ invoice: IInvoice; hash: string }> = [];
+  const hashCounts: Map<string, number> = new Map();
+
+  const addResult = (invoice: IInvoice, passLabel: string): number => {
+    const hash = hashInvoice(invoice);
+    results.push({ invoice, hash });
+    hashCounts.set(hash, (hashCounts.get(hash) || 0) + 1);
+    console.log(`  [${passLabel}] ${invoice.invoice_number} | ${invoice.invoice_date} | ${invoice.total_amount} ${invoice.currency}`);
+    return hashCounts.get(hash)!;
+  };
+
+  for (let pass = 1; pass <= maxPasses; pass++) {
+    try {
+      const invoice = await extractOnce(images, pass);
+      const count = addResult(invoice, `Pass ${pass}`);
+
+      if (count >= 2) {
+        console.log(`  [Consensus] Reached after ${pass} passes`);
+        return invoice;
+      }
+    } catch (err) {
+      console.log(`  [Pass ${pass}] Error: ${err}`);
+    }
+  }
+
+  // No consensus reached - return the most common result
+  let bestHash = '';
+  let bestCount = 0;
+  for (const [hash, count] of hashCounts) {
+    if (count > bestCount) {
+      bestCount = count;
+      bestHash = hash;
+    }
+  }
+
+  if (!bestHash) {
+    throw new Error(`No valid results for ${invoiceName}`);
+  }
+
+  const best = results.find((r) => r.hash === bestHash)!;
+  console.log(`  [No consensus] Using most common result (${bestCount}/${maxPasses} passes)`);
+  return best.invoice;
+}
+
+/**
+ * Normalize date to YYYY-MM-DD format
+ */
+function normalizeDate(dateStr: string | null): string {
+  if (!dateStr) return '';
+
+  // Already in correct format
+  if (/^\d{4}-\d{2}-\d{2}$/.test(dateStr)) {
+    return dateStr;
+  }
+
+  // Handle DD-MMM-YYYY format (e.g., "28-JUN-2022")
+  const monthMap: Record<string, string> = {
+    JAN: '01', FEB: '02', MAR: '03', APR: '04', MAY: '05', JUN: '06',
+    JUL: '07', AUG: '08', SEP: '09', OCT: '10', NOV: '11', DEC: '12',
+  };
+
+  const match = dateStr.match(/^(\d{1,2})-([A-Z]{3})-(\d{4})$/i);
+  if (match) {
+    const day = match[1].padStart(2, '0');
+    const month = monthMap[match[2].toUpperCase()] || '01';
+    const year = match[3];
+    return `${year}-${month}-${day}`;
+  }
+
+  // Handle DD/MM/YYYY or DD.MM.YYYY
+  const match2 = dateStr.match(/^(\d{1,2})[\/.](\d{1,2})[\/.](\d{4})$/);
+  if (match2) {
+    const day = match2[1].padStart(2, '0');
+    const month = match2[2].padStart(2, '0');
+    const year = match2[3];
+    return `${year}-${month}-${day}`;
+  }
+
+  return dateStr;
+}
+
+/**
+ * Compare extracted invoice against expected
+ */
+function compareInvoice(
+  extracted: IInvoice,
+  expected: IInvoice
+): { match: boolean; errors: string[] } {
+  const errors: string[] = [];
+
+  // Compare invoice number (normalize by removing spaces and case)
+  const extNum = extracted.invoice_number?.replace(/\s/g, '').toLowerCase() || '';
+  const expNum = expected.invoice_number?.replace(/\s/g, '').toLowerCase() || '';
+  if (extNum !== expNum) {
+    errors.push(`invoice_number: expected "${expected.invoice_number}", got "${extracted.invoice_number}"`);
+  }
+
+  // Compare date (normalize format first)
+  const extDate = normalizeDate(extracted.invoice_date);
+  const expDate = normalizeDate(expected.invoice_date);
+  if (extDate !== expDate) {
+    errors.push(`invoice_date: expected "${expected.invoice_date}", got "${extracted.invoice_date}"`);
+  }
+
+  // Compare total amount (with tolerance)
+  if (Math.abs(extracted.total_amount - expected.total_amount) > 0.02) {
+    errors.push(`total_amount: expected ${expected.total_amount}, got ${extracted.total_amount}`);
+  }
+
+  // Compare currency
+  if (extracted.currency?.toUpperCase() !== expected.currency?.toUpperCase()) {
+    errors.push(`currency: expected "${expected.currency}", got "${extracted.currency}"`);
+  }
+
+  return { match: errors.length === 0, errors };
+}
+
+/**
+ * Find all test cases (PDF + JSON pairs) in .nogit/invoices/
+ */
+function findTestCases(): Array<{ name: string; pdfPath: string; jsonPath: string }> {
+  const testDir = path.join(process.cwd(), '.nogit/invoices');
+  if (!fs.existsSync(testDir)) {
+    return [];
+  }
+
+  const files = fs.readdirSync(testDir);
+  const pdfFiles = files.filter((f) => f.endsWith('.pdf'));
+  const testCases: Array<{ name: string; pdfPath: string; jsonPath: string }> = [];
+
+  for (const pdf of pdfFiles) {
+    const baseName = pdf.replace('.pdf', '');
+    const jsonFile = `${baseName}.json`;
+    if (files.includes(jsonFile)) {
+      testCases.push({
+        name: baseName,
+        pdfPath: path.join(testDir, pdf),
+        jsonPath: path.join(testDir, jsonFile),
+      });
+    }
+  }
+
+  // Sort alphabetically
+  testCases.sort((a, b) => a.name.localeCompare(b.name));
+
+  return testCases;
+}
+
+// Tests
+
+tap.test('setup: ensure Docker containers are running', async () => {
+  console.log('\n[Setup] Checking Docker containers...\n');
+
+  // Ensure PaddleOCR-VL Full Pipeline is running
+  const paddleOk = await ensurePaddleOcrVlFull();
+  expect(paddleOk).toBeTrue();
+
+  // Ensure Qwen2.5 is available (for text-only JSON extraction)
+  const qwenOk = await ensureQwen25();
+  expect(qwenOk).toBeTrue();
+
+  console.log('\n[Setup] All containers ready!\n');
+});
+
+// Dynamic test for each PDF/JSON pair
+const testCases = findTestCases();
+console.log(`\nFound ${testCases.length} invoice test cases (PaddleOCR-VL Full Pipeline)\n`);
+
+let passedCount = 0;
+let failedCount = 0;
+const processingTimes: number[] = [];
+
+for (const testCase of testCases) {
+  tap.test(`should extract invoice: ${testCase.name}`, async () => {
+    // Load expected data
+    const expected: IInvoice = JSON.parse(fs.readFileSync(testCase.jsonPath, 'utf-8'));
+    console.log(`\n=== ${testCase.name} ===`);
+    console.log(`Expected: ${expected.invoice_number} | ${expected.invoice_date} | ${expected.total_amount} ${expected.currency}`);
+
+    const startTime = Date.now();
+
+    // Convert PDF to images
+    const images = convertPdfToImages(testCase.pdfPath);
+    console.log(`  Pages: ${images.length}`);
+
+    // Extract with consensus voting (PaddleOCR-VL Full -> MiniCPM)
+    const extracted = await extractWithConsensus(images, testCase.name);
+
+    const endTime = Date.now();
+    const elapsedMs = endTime - startTime;
+    processingTimes.push(elapsedMs);
+
+    // Compare results
+    const result = compareInvoice(extracted, expected);
+
+    if (result.match) {
+      passedCount++;
+      console.log(`  Result: MATCH (${(elapsedMs / 1000).toFixed(1)}s)`);
+    } else {
+      failedCount++;
+      console.log(`  Result: MISMATCH (${(elapsedMs / 1000).toFixed(1)}s)`);
+      result.errors.forEach((e) => console.log(`    - ${e}`));
+    }
+
+    // Assert match
+    expect(result.match).toBeTrue();
+  });
+}
+
+tap.test('summary', async () => {
+  const totalInvoices = testCases.length;
+  const accuracy = totalInvoices > 0 ? (passedCount / totalInvoices) * 100 : 0;
+  const totalTimeMs = processingTimes.reduce((a, b) => a + b, 0);
+  const avgTimeMs = processingTimes.length > 0 ? totalTimeMs / processingTimes.length : 0;
+  const avgTimeSec = avgTimeMs / 1000;
+  const totalTimeSec = totalTimeMs / 1000;
+
+  console.log(`\n======================================================`);
+  console.log(`   Invoice Extraction Summary (PaddleOCR-VL Full)`);
+  console.log(`======================================================`);
+  console.log(`  Method:    PaddleOCR-VL Full Pipeline (HTML) -> Qwen2.5 (text-only)`);
+  console.log(`  Passed:    ${passedCount}/${totalInvoices}`);
+  console.log(`  Failed:    ${failedCount}/${totalInvoices}`);
+  console.log(`  Accuracy:  ${accuracy.toFixed(1)}%`);
+  console.log(`------------------------------------------------------`);
+  console.log(`  Total time:   ${totalTimeSec.toFixed(1)}s`);
+  console.log(`  Avg per inv:  ${avgTimeSec.toFixed(1)}s`);
+  console.log(`======================================================\n`);
+});
+
+export default tap.start();

test/test.invoices.qwen3vl.ts

@@ -0,0 +1,351 @@
+/**
+ * Invoice extraction using Qwen3-VL 8B Vision (Direct)
+ *
+ * Multi-query approach: 5 parallel simple queries to avoid token exhaustion.
+ * Single pass, no consensus voting.
+ */
+import { tap, expect } from '@git.zone/tstest/tapbundle';
+import * as fs from 'fs';
+import * as path from 'path';
+import { execSync } from 'child_process';
+import * as os from 'os';
+import { ensureMiniCpm } from './helpers/docker.js';
+
+const OLLAMA_URL = 'http://localhost:11434';
+const VISION_MODEL = 'qwen3-vl:8b';
+
+interface IInvoice {
+  invoice_number: string;
+  invoice_date: string;
+  vendor_name: string;
+  currency: string;
+  net_amount: number;
+  vat_amount: number;
+  total_amount: number;
+}
+
+/**
+ * Convert PDF to PNG images using ImageMagick
+ */
+function convertPdfToImages(pdfPath: string): string[] {
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pdf-convert-'));
+  const outputPattern = path.join(tempDir, 'page-%d.png');
+
+  try {
+    // 150 DPI is sufficient for invoice extraction, reduces context size
+    execSync(
+      `convert -density 150 -quality 90 "${pdfPath}" -background white -alpha remove "${outputPattern}"`,
+      { stdio: 'pipe' }
+    );
+
+    const files = fs.readdirSync(tempDir).filter((f) => f.endsWith('.png')).sort();
+    const images: string[] = [];
+
+    for (const file of files) {
+      const imagePath = path.join(tempDir, file);
+      const imageData = fs.readFileSync(imagePath);
+      images.push(imageData.toString('base64'));
+    }
+
+    return images;
+  } finally {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  }
+}
+
+/**
+ * Query Qwen3-VL for a single field
+ * Uses simple prompts to minimize thinking tokens
+ */
+async function queryField(images: string[], question: string): Promise<string> {
+  const response = await fetch(`${OLLAMA_URL}/api/chat`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({
+      model: VISION_MODEL,
+      messages: [{
+        role: 'user',
+        content: `${question} Reply with just the value, nothing else.`,
+        images: images,
+      }],
+      stream: false,
+      options: {
+        num_predict: 500,
+        temperature: 0.1,
+      },
+    }),
+  });
+
+  if (!response.ok) {
+    throw new Error(`Ollama API error: ${response.status}`);
+  }
+
+  const data = await response.json();
+  return (data.message?.content || '').trim();
+}
+
+/**
+ * Extract invoice data using multiple simple queries
+ * Each query asks for 1-2 fields to minimize thinking tokens
+ * (Qwen3's thinking mode uses all tokens on complex prompts)
+ */
+async function extractInvoiceFromImages(images: string[]): Promise<IInvoice> {
+  console.log(`    [Vision] Processing ${images.length} page(s) with Qwen3-VL (multi-query)`);
+
+  // Query each field separately to avoid excessive thinking tokens
+  // Use explicit questions to avoid confusion between similar fields
+  // Log each result as it comes in (not waiting for all to complete)
+  const queryAndLog = async (name: string, question: string): Promise<string> => {
+    const result = await queryField(images, question);
+    console.log(`    [Query] ${name}: "${result}"`);
+    return result;
+  };
+
+  const [invoiceNum, invoiceDate, vendor, currency, totalAmount, netAmount, vatAmount] = await Promise.all([
+    queryAndLog('Invoice Number', 'What is the INVOICE NUMBER (not VAT number, not customer ID)? Look for "Invoice No", "Invoice #", "Rechnung Nr", "Facture". Just the number/code.'),
+    queryAndLog('Invoice Date  ', 'What is the INVOICE DATE (not due date, not delivery date)? The date the invoice was issued. Format: YYYY-MM-DD'),
+    queryAndLog('Vendor        ', 'What company ISSUED this invoice (the seller/vendor, not the buyer)? Look at the letterhead or "From" section.'),
+    queryAndLog('Currency      ', 'What CURRENCY is used? Look for € (EUR), $ (USD), or £ (GBP). Answer with 3-letter code: EUR, USD, or GBP'),
+    queryAndLog('Total Amount  ', 'What is the TOTAL AMOUNT INCLUDING TAX (the final amount to pay, with VAT/tax included)? Just the number, e.g. 24.99'),
+    queryAndLog('Net Amount    ', 'What is the NET AMOUNT (subtotal before VAT/tax)? Just the number, e.g. 20.99'),
+    queryAndLog('VAT Amount    ', 'What is the VAT/TAX AMOUNT? Just the number, e.g. 4.00'),
+  ]);
+
+  // Parse amount from string (handles European format)
+  const parseAmount = (s: string): number => {
+    if (!s) return 0;
+    // Extract number from the response
+    const match = s.match(/([\d.,]+)/);
+    if (!match) return 0;
+    const numStr = match[1];
+    // Handle European format: 1.234,56 → 1234.56
+    const normalized = numStr.includes(',') && numStr.indexOf(',') > numStr.lastIndexOf('.')
+      ? numStr.replace(/\./g, '').replace(',', '.')
+      : numStr.replace(/,/g, '');
+    return parseFloat(normalized) || 0;
+  };
+
+  // Extract invoice number from potentially verbose response
+  const extractInvoiceNumber = (s: string): string => {
+    let clean = s.replace(/\*\*/g, '').replace(/`/g, '').trim();
+    // Look for common invoice number patterns
+    const patterns = [
+      /\b([A-Z]{2,3}\d{10,})\b/i,           // IEE2022006460244
+      /\b([A-Z]\d{8,})\b/i,                  // R0014359508
+      /\b(INV[-\s]?\d{4}[-\s]?\d+)\b/i,     // INV-2024-001
+      /\b(\d{7,})\b/,                        // 1579087430
+    ];
+    for (const pattern of patterns) {
+      const match = clean.match(pattern);
+      if (match) return match[1];
+    }
+    return clean.replace(/[^A-Z0-9-]/gi, '').trim() || clean;
+  };
+
+  // Extract date (YYYY-MM-DD) from response
+  const extractDate = (s: string): string => {
+    let clean = s.replace(/\*\*/g, '').replace(/`/g, '').trim();
+    const isoMatch = clean.match(/(\d{4}-\d{2}-\d{2})/);
+    if (isoMatch) return isoMatch[1];
+    return clean.replace(/[^\d-]/g, '').trim();
+  };
+
+  // Extract currency
+  const extractCurrency = (s: string): string => {
+    const upper = s.toUpperCase();
+    if (upper.includes('EUR') || upper.includes('€')) return 'EUR';
+    if (upper.includes('USD') || upper.includes('$')) return 'USD';
+    if (upper.includes('GBP') || upper.includes('£')) return 'GBP';
+    return 'EUR';
+  };
+
+  return {
+    invoice_number: extractInvoiceNumber(invoiceNum),
+    invoice_date: extractDate(invoiceDate),
+    vendor_name: vendor.replace(/\*\*/g, '').replace(/`/g, '').trim() || '',
+    currency: extractCurrency(currency),
+    net_amount: parseAmount(netAmount),
+    vat_amount: parseAmount(vatAmount),
+    total_amount: parseAmount(totalAmount),
+  };
+}
+
+/**
+ * Normalize date to YYYY-MM-DD
+ */
+function normalizeDate(dateStr: string | null): string {
+  if (!dateStr) return '';
+  if (/^\d{4}-\d{2}-\d{2}$/.test(dateStr)) return dateStr;
+
+  const monthMap: Record<string, string> = {
+    JAN: '01', FEB: '02', MAR: '03', APR: '04', MAY: '05', JUN: '06',
+    JUL: '07', AUG: '08', SEP: '09', OCT: '10', NOV: '11', DEC: '12',
+  };
+
+  let match = dateStr.match(/^(\d{1,2})-([A-Z]{3})-(\d{4})$/i);
+  if (match) {
+    return `${match[3]}-${monthMap[match[2].toUpperCase()] || '01'}-${match[1].padStart(2, '0')}`;
+  }
+
+  match = dateStr.match(/^(\d{1,2})[\/.](\d{1,2})[\/.](\d{4})$/);
+  if (match) {
+    return `${match[3]}-${match[2].padStart(2, '0')}-${match[1].padStart(2, '0')}`;
+  }
+
+  return dateStr;
+}
+
+/**
+ * Compare extracted vs expected
+ */
+function compareInvoice(extracted: IInvoice, expected: IInvoice): { match: boolean; errors: string[] } {
+  const errors: string[] = [];
+
+  const extNum = extracted.invoice_number?.replace(/\s/g, '').toLowerCase() || '';
+  const expNum = expected.invoice_number?.replace(/\s/g, '').toLowerCase() || '';
+  if (extNum !== expNum) {
+    errors.push(`invoice_number: expected "${expected.invoice_number}", got "${extracted.invoice_number}"`);
+  }
+
+  if (normalizeDate(extracted.invoice_date) !== normalizeDate(expected.invoice_date)) {
+    errors.push(`invoice_date: expected "${expected.invoice_date}", got "${extracted.invoice_date}"`);
+  }
+
+  if (Math.abs(extracted.total_amount - expected.total_amount) > 0.02) {
+    errors.push(`total_amount: expected ${expected.total_amount}, got ${extracted.total_amount}`);
+  }
+
+  if (extracted.currency?.toUpperCase() !== expected.currency?.toUpperCase()) {
+    errors.push(`currency: expected "${expected.currency}", got "${extracted.currency}"`);
+  }
+
+  return { match: errors.length === 0, errors };
+}
+
+/**
+ * Find test cases
+ */
+function findTestCases(): Array<{ name: string; pdfPath: string; jsonPath: string }> {
+  const testDir = path.join(process.cwd(), '.nogit/invoices');
+  if (!fs.existsSync(testDir)) return [];
+
+  const files = fs.readdirSync(testDir);
+  const testCases: Array<{ name: string; pdfPath: string; jsonPath: string }> = [];
+
+  for (const pdf of files.filter((f) => f.endsWith('.pdf'))) {
+    const baseName = pdf.replace('.pdf', '');
+    const jsonFile = `${baseName}.json`;
+    if (files.includes(jsonFile)) {
+      testCases.push({
+        name: baseName,
+        pdfPath: path.join(testDir, pdf),
+        jsonPath: path.join(testDir, jsonFile),
+      });
+    }
+  }
+
+  return testCases.sort((a, b) => a.name.localeCompare(b.name));
+}
+
+/**
+ * Ensure Qwen3-VL 8B model is available
+ */
+async function ensureQwen3Vl(): Promise<boolean> {
+  try {
+    const response = await fetch(`${OLLAMA_URL}/api/tags`);
+    if (response.ok) {
+      const data = await response.json();
+      const models = data.models || [];
+      if (models.some((m: { name: string }) => m.name === VISION_MODEL)) {
+        console.log(`[Ollama] Model already available: ${VISION_MODEL}`);
+        return true;
+      }
+    }
+  } catch {
+    console.log('[Ollama] Cannot check models');
+    return false;
+  }
+
+  console.log(`[Ollama] Pulling model: ${VISION_MODEL}...`);
+  const pullResponse = await fetch(`${OLLAMA_URL}/api/pull`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ name: VISION_MODEL, stream: false }),
+  });
+
+  return pullResponse.ok;
+}
+
+// Tests
+
+tap.test('setup: ensure Qwen3-VL is running', async () => {
+  console.log('\n[Setup] Checking Qwen3-VL 8B...\n');
+
+  // Ensure Ollama service is running
+  const ollamaOk = await ensureMiniCpm();
+  expect(ollamaOk).toBeTrue();
+
+  // Ensure Qwen3-VL 8B model
+  const visionOk = await ensureQwen3Vl();
+  expect(visionOk).toBeTrue();
+
+  console.log('\n[Setup] Ready!\n');
+});
+
+const testCases = findTestCases();
+console.log(`\nFound ${testCases.length} invoice test cases (Qwen3-VL Vision)\n`);
+
+let passedCount = 0;
+let failedCount = 0;
+const times: number[] = [];
+
+for (const testCase of testCases) {
+  tap.test(`should extract invoice: ${testCase.name}`, async () => {
+    const expected: IInvoice = JSON.parse(fs.readFileSync(testCase.jsonPath, 'utf-8'));
+    console.log(`\n=== ${testCase.name} ===`);
+    console.log(`Expected: ${expected.invoice_number} | ${expected.invoice_date} | ${expected.total_amount} ${expected.currency}`);
+
+    const start = Date.now();
+    const images = convertPdfToImages(testCase.pdfPath);
+    console.log(`  Pages: ${images.length}`);
+
+    const extracted = await extractInvoiceFromImages(images);
+    console.log(`  Extracted: ${extracted.invoice_number} | ${extracted.invoice_date} | ${extracted.total_amount} ${extracted.currency}`);
+    const elapsed = Date.now() - start;
+    times.push(elapsed);
+
+    const result = compareInvoice(extracted, expected);
+
+    if (result.match) {
+      passedCount++;
+      console.log(`  Result: MATCH (${(elapsed / 1000).toFixed(1)}s)`);
+    } else {
+      failedCount++;
+      console.log(`  Result: MISMATCH (${(elapsed / 1000).toFixed(1)}s)`);
+      result.errors.forEach((e) => console.log(`    - ${e}`));
+    }
+
+    expect(result.match).toBeTrue();
+  });
+}
+
+tap.test('summary', async () => {
+  const total = testCases.length;
+  const accuracy = total > 0 ? (passedCount / total) * 100 : 0;
+  const totalTime = times.reduce((a, b) => a + b, 0) / 1000;
+  const avgTime = times.length > 0 ? totalTime / times.length : 0;
+
+  console.log(`\n======================================================`);
+  console.log(`   Invoice Extraction Summary (Qwen3-VL Vision)`);
+  console.log(`======================================================`);
+  console.log(`  Method:    Multi-query (single pass)`);
+  console.log(`  Passed:    ${passedCount}/${total}`);
+  console.log(`  Failed:    ${failedCount}/${total}`);
+  console.log(`  Accuracy:  ${accuracy.toFixed(1)}%`);
+  console.log(`------------------------------------------------------`);
+  console.log(`  Total time:   ${totalTime.toFixed(1)}s`);
+  console.log(`  Avg per inv:  ${avgTime.toFixed(1)}s`);
+  console.log(`======================================================\n`);
+});
+
+export default tap.start();

test/test.paddleocr.ts

@@ -1,258 +0,0 @@
-import { tap, expect } from '@git.zone/tstest/tapbundle';
-import * as fs from 'fs';
-import * as path from 'path';
-import { execSync } from 'child_process';
-import * as os from 'os';
-
-const PADDLEOCR_URL = 'http://localhost:5000';
-
-interface IOCRResult {
-  text: string;
-  confidence: number;
-  box: number[][];
-}
-
-interface IOCRResponse {
-  success: boolean;
-  results: IOCRResult[];
-  error?: string;
-}
-
-interface IHealthResponse {
-  status: string;
-  model: string;
-  language: string;
-  gpu_enabled: boolean;
-}
-
-/**
- * Convert PDF first page to PNG using ImageMagick
- */
-function convertPdfToImage(pdfPath: string): string {
-  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pdf-convert-'));
-  const outputPath = path.join(tempDir, 'page.png');
-
-  try {
-    execSync(
-      `convert -density 200 -quality 90 "${pdfPath}[0]" -background white -alpha remove "${outputPath}"`,
-      { stdio: 'pipe' }
-    );
-
-    const imageData = fs.readFileSync(outputPath);
-    return imageData.toString('base64');
-  } finally {
-    fs.rmSync(tempDir, { recursive: true, force: true });
-  }
-}
-
-/**
- * Create a simple test image with text using ImageMagick
- */
-function createTestImage(text: string): string {
-  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'test-image-'));
-  const outputPath = path.join(tempDir, 'test.png');
-
-  try {
-    execSync(
-      `convert -size 400x100 xc:white -font DejaVu-Sans -pointsize 24 -fill black -gravity center -annotate 0 "${text}" "${outputPath}"`,
-      { stdio: 'pipe' }
-    );
-
-    const imageData = fs.readFileSync(outputPath);
-    return imageData.toString('base64');
-  } finally {
-    fs.rmSync(tempDir, { recursive: true, force: true });
-  }
-}
-
-// Health check test
-tap.test('should respond to health check', async () => {
-  const response = await fetch(`${PADDLEOCR_URL}/health`);
-  expect(response.ok).toBeTrue();
-
-  const data: IHealthResponse = await response.json();
-  expect(data.status).toEqual('healthy');
-  expect(data.model).toEqual('PP-OCRv4');
-  expect(data.language).toBeTypeofString();
-  expect(data.gpu_enabled).toBeTypeofBoolean();
-
-  console.log(`PaddleOCR Status: ${data.status}`);
-  console.log(`  Model: ${data.model}`);
-  console.log(`  Language: ${data.language}`);
-  console.log(`  GPU Enabled: ${data.gpu_enabled}`);
-});
-
-// Base64 OCR test
-tap.test('should perform OCR on base64 image', async () => {
-  // Create a test image with known text
-  const testText = 'Hello World 12345';
-  console.log(`Creating test image with text: "${testText}"`);
-
-  const imageBase64 = createTestImage(testText);
-
-  const response = await fetch(`${PADDLEOCR_URL}/ocr`, {
-    method: 'POST',
-    headers: { 'Content-Type': 'application/json' },
-    body: JSON.stringify({ image: imageBase64 }),
-  });
-
-  expect(response.ok).toBeTrue();
-
-  const data: IOCRResponse = await response.json();
-  expect(data.success).toBeTrue();
-  expect(data.results).toBeArray();
-
-  const extractedText = data.results.map((r) => r.text).join(' ');
-  console.log(`Extracted text: "${extractedText}"`);
-
-  // Check that we got some text back
-  expect(data.results.length).toBeGreaterThan(0);
-
-  // Check that at least some of the expected text was found
-  const normalizedExtracted = extractedText.toLowerCase().replace(/\s+/g, '');
-  const normalizedExpected = testText.toLowerCase().replace(/\s+/g, '');
-  const hasPartialMatch =
-    normalizedExtracted.includes('hello') ||
-    normalizedExtracted.includes('world') ||
-    normalizedExtracted.includes('12345');
-
-  expect(hasPartialMatch).toBeTrue();
-});
-
-// File upload OCR test
-tap.test('should perform OCR via file upload', async () => {
-  const testText = 'Invoice Number 98765';
-  console.log(`Creating test image with text: "${testText}"`);
-
-  const imageBase64 = createTestImage(testText);
-  const imageBuffer = Buffer.from(imageBase64, 'base64');
-
-  const formData = new FormData();
-  const blob = new Blob([imageBuffer], { type: 'image/png' });
-  formData.append('img', blob, 'test.png');
-
-  const response = await fetch(`${PADDLEOCR_URL}/ocr/upload`, {
-    method: 'POST',
-    body: formData,
-  });
-
-  expect(response.ok).toBeTrue();
-
-  const data: IOCRResponse = await response.json();
-  expect(data.success).toBeTrue();
-  expect(data.results).toBeArray();
-
-  const extractedText = data.results.map((r) => r.text).join(' ');
-  console.log(`Extracted text: "${extractedText}"`);
-
-  // Check that we got some text back
-  expect(data.results.length).toBeGreaterThan(0);
-});
-
-// OCR result structure test
-tap.test('should return proper OCR result structure', async () => {
-  const testText = 'Test 123';
-  const imageBase64 = createTestImage(testText);
-
-  const response = await fetch(`${PADDLEOCR_URL}/ocr`, {
-    method: 'POST',
-    headers: { 'Content-Type': 'application/json' },
-    body: JSON.stringify({ image: imageBase64 }),
-  });
-
-  const data: IOCRResponse = await response.json();
-
-  if (data.results.length > 0) {
-    const result = data.results[0];
-
-    // Check result has required fields
-    expect(result.text).toBeTypeofString();
-    expect(result.confidence).toBeTypeofNumber();
-    expect(result.box).toBeArray();
-
-    // Check bounding box structure (4 points, each with x,y)
-    expect(result.box.length).toEqual(4);
-    for (const point of result.box) {
-      expect(point.length).toEqual(2);
-      expect(point[0]).toBeTypeofNumber();
-      expect(point[1]).toBeTypeofNumber();
-    }
-
-    // Confidence should be between 0 and 1
-    expect(result.confidence).toBeGreaterThan(0);
-    expect(result.confidence).toBeLessThanOrEqual(1);
-
-    console.log(`Result structure valid:`);
-    console.log(`  Text: "${result.text}"`);
-    console.log(`  Confidence: ${(result.confidence * 100).toFixed(1)}%`);
-    console.log(`  Box: ${JSON.stringify(result.box)}`);
-  }
-});
-
-// Test with actual invoice if available
-const invoiceDir = path.join(process.cwd(), '.nogit/invoices');
-if (fs.existsSync(invoiceDir)) {
-  const pdfFiles = fs.readdirSync(invoiceDir).filter((f) => f.endsWith('.pdf'));
-
-  if (pdfFiles.length > 0) {
-    const testPdf = pdfFiles[0];
-    tap.test(`should extract text from invoice: ${testPdf}`, async () => {
-      const pdfPath = path.join(invoiceDir, testPdf);
-      console.log(`Converting ${testPdf} to image...`);
-
-      const imageBase64 = convertPdfToImage(pdfPath);
-      console.log(`Image size: ${(imageBase64.length / 1024).toFixed(1)} KB`);
-
-      const startTime = Date.now();
-
-      const response = await fetch(`${PADDLEOCR_URL}/ocr`, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ image: imageBase64 }),
-      });
-
-      const endTime = Date.now();
-      const elapsedMs = endTime - startTime;
-
-      expect(response.ok).toBeTrue();
-
-      const data: IOCRResponse = await response.json();
-      expect(data.success).toBeTrue();
-
-      console.log(`OCR completed in ${(elapsedMs / 1000).toFixed(2)}s`);
-      console.log(`Found ${data.results.length} text regions`);
-
-      // Print first 10 results
-      const preview = data.results.slice(0, 10);
-      console.log(`\nFirst ${preview.length} results:`);
-      for (const result of preview) {
-        console.log(`  [${(result.confidence * 100).toFixed(0)}%] ${result.text}`);
-      }
-
-      if (data.results.length > 10) {
-        console.log(`  ... and ${data.results.length - 10} more`);
-      }
-
-      // Should find text in an invoice
-      expect(data.results.length).toBeGreaterThan(5);
-    });
-  }
-}
-
-// Error handling test
-tap.test('should handle invalid base64 gracefully', async () => {
-  const response = await fetch(`${PADDLEOCR_URL}/ocr`, {
-    method: 'POST',
-    headers: { 'Content-Type': 'application/json' },
-    body: JSON.stringify({ image: 'not-valid-base64!!!' }),
-  });
-
-  const data: IOCRResponse = await response.json();
-
-  // Should return success: false with error message
-  expect(data.success).toBeFalse();
-  expect(data.error).toBeTypeofString();
-  console.log(`Error handling works: ${data.error}`);
-});
-
-export default tap.start();