deploy: update HF Space

.dockerignore

@@ -0,0 +1,59 @@
+# Ignore development artifacts
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+.Python
+*.so
+*.dylib
+*.log
+.venv/
+venv/
+ENV/
+env/
+.git/
+.gitignore
+.gitlab-ci.yml
+*.md
+!README.md
+.pytest_cache/
+*.swp
+*.swo
+*~
+.DS_Store
+
+# Ignore data directories (too large for Docker context)
+data/
+!data/prompt_templates/
+!data/visual_element_prefabs/
+
+# Ignore build artifacts
+*.egg-info/
+dist/
+build/
+*.whl
+
+# Ignore handwriting service (separate deployment)
+handwriting_service/
+
+# Ignore WordStylist (not needed for API)
+WordStylist/
+
+# Ignore scripts (not needed for API runtime)
+scripts/
+
+# Ignore documentation and deployment files
+ARCHITECTURE.md
+DEPLOYMENT.md
+*.sh
+!start.sh
+!start_worker.sh
+docker-compose.yml
+railway.json
+railway_setup_vars.sh
+
+# Keep only essential code
+!docgenie/
+!api/
+!setup.py
+!pyproject.toml

.gitattributes

@@ -0,0 +1,7 @@
+*.webp filter=lfs diff=lfs merge=lfs -text
+*.ico filter=lfs diff=lfs merge=lfs -text
+*.png filter=lfs diff=lfs merge=lfs -text
+*.jpg filter=lfs diff=lfs merge=lfs -text
+*.jpeg filter=lfs diff=lfs merge=lfs -text
+*.gif filter=lfs diff=lfs merge=lfs -text
+*.svg filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,172 @@
+# Project
+data/clusters/
+data/embeddings/
+data/temp/
+wandb/
+data/models/
+data/webapp_cache/
+data/analyzation/
+data/cherrypicks/
+data/hw_imgs/
+/data/seed-images/*
+/docgenie/playground/test.py
+/docgenie/playground/handwritten_text/doc_vqa_handwriting_text_images
+/docgenie/playground/handwritten_text/handwriting_raw_tokens
+/docgenie/playground/handwritten_text/temp
+data/datasets
+data/models
+data/cluster_plots
+data/syn_dataset_statistics_plots
+data/gt_embeddings
+data/wandb_downloads
+data/wandb_project_csvs
+data/folders.txt
+cache
+runs
+visualizations
+.venv
+**/**.__pycache__
+/docgenie/playground/handwritten_text/doc_vqa_handwriting_text_images
+/docgenie/playground/handwritten_text/temp
+data/datasets
+data/models
+
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+*.log
+
+# Virtual environments
+venv/
+env/
+ENV/
+.venv
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+.DS_Store
+
+# Jupyter Notebook
+.ipynb_checkpoints
+*.ipynb_checkpoints/
+
+# Model artifacts - download separately
+inference/
+inference_new/
+inference_hf/
+model/experiments/hf_conditional_latent/cached_vae/
+*.zip
+
+
+# Datasets - download separately
+docvqa-handwritten-sizes4/
+syn_docvqa/
+iam_dataset/
+iam_dataset_processed/
+iam_dataset_processed_partial/
+docvqa-test/
+docvqa-viselems/
+docvqa-viselems2/
+temp/
+generations/
+
+# Generated outputs
+output/
+
+# Backup files
+*.bak
+*.backup
+*.tmp
+
+# Testing
+.pytest_cache/
+.coverage
+htmlcov/
+
+# OS
+./data/clusters_old/
+Thumbs.db
+
+
+# Training
+training/
+vae_evaluation/
+
+
+# Logs and checkpoints
+*.pt
+# But allow the inference model for handwriting service
+!handwriting_service/WordStylist/models/ema_ckpt.pt
+*.ckpt
+*.pth
+*.safetensors
+
+.env
+
+# Playwright
+node_modules/
+/test-results/
+/playwright-report/
+/blob-report/
+/playwright/.cache/
+/playwright/.auth/
+
+
+!data/models/
+!data/models/handwriting/
+!data/models/handwriting/char_vocab.json
+!data/models/handwriting/config.yaml
+!data/models/handwriting/writer_id_map.json
+!data/models/handwriting/cached_vae/config.json
+data/models/.locks*
+data/models/baseline
+data/models/legacy
+data/models/models*
+data/models/pretrained
+test_run.py
+test_vlm.ipynb
+test.ipynb
+test2.ipynb
+test3.py
+test4.py
+test5.py
+test6.py
+data/results
+data/results_old/
+data/tmp/
+docgenie/playground/extract_02_eval_metrics_from_wandb.py
+docgenie/playground/extract_metrics_from_wandb.py
+data/cached_subsets
+data/mixed_datasets
+data/results_backup_v1
+data/results_v1
+data/old-results/
+data/embeddings
+data/mixed_datasets
+data/results_backup_v1
+sync_datasets.sh
+data/results_latest
+data/results_latest copy

.gitlab-ci.yml

@@ -0,0 +1,16 @@
+# You can override the included template(s) by including variable overrides
+# SAST customization: https://docs.gitlab.com/ee/user/application_security/sast/#customizing-the-sast-settings
+# Secret Detection customization: https://docs.gitlab.com/user/application_security/secret_detection/pipeline/configure
+# Dependency Scanning customization: https://docs.gitlab.com/ee/user/application_security/dependency_scanning/#customizing-the-dependency-scanning-settings
+# Container Scanning customization: https://docs.gitlab.com/ee/user/application_security/container_scanning/#customizing-the-container-scanning-settings
+# Note that environment variables can be set in several places
+# See https://docs.gitlab.com/ee/ci/variables/#cicd-variable-precedence
+stages:
+- test
+- secret-detection
+variables:
+  SECRET_DETECTION_ENABLED: 'true'
+secret_detection:
+  stage: secret-detection
+include:
+- template: Security/Secret-Detection.gitlab-ci.yml

.python-version

@@ -0,0 +1 @@
+3.11.12

API_FLOW_DOCUMENTATION.md

@@ -0,0 +1,1024 @@
+# Complete API Flow Documentation
+
+## Overview
+The DocGenie API provides three endpoints for synthetic document generation, implementing a 19-stage pipeline that transforms seed images and prompts into complete datasets with OCR, ground truth, and optional handwriting/visual elements.
+
+**Base URL**: `http://localhost:8000` (development) or Railway deployment  
+**Documentation**: `/docs` (FastAPI auto-generated Swagger UI)
+
+---
+
+## API Endpoints
+
+### 1. `/generate` - Legacy JSON Response (POST)
+**Purpose**: Generate documents and return complete JSON metadata  
+**Response**: JSON with HTML, PDF (base64), bounding boxes, optional handwriting/visual elements  
+**Use Case**: Testing, development, full metadata inspection  
+**Pipeline Stages**: 1-19 (configurable via parameters)
+
+### 2. `/generate/pdf` - Sync PDF+Dataset ZIP (POST)
+**Purpose**: Generate documents and return ZIP file with all artifacts  
+**Response**: ZIP file containing:
+- `*.pdf` - Generated document PDFs
+- `*_final.pdf` - PDFs with handwriting/visual elements (if enabled)
+- `*.msgpack` - Dataset format (if export enabled)
+- `metadata.json` - Complete generation metadata
+- `handwriting/` - Individual handwriting images
+- `visual_elements/` - Individual visual element images
+
+**Use Case**: Production dataset generation, batch processing  
+**Pipeline Stages**: 1-19 (all features available)
+
+### 3. `/generate/async` - Async Batch Processing (POST)
+**Purpose**: Queue large batch jobs via background worker (Redis Queue)  
+**Response**: Task ID for status polling  
+**Status Check**: `GET /generate/async/status/{task_id}`  
+**Result Download**: `GET /generate/async/result/{task_id}` (returns ZIP)  
+**Use Case**: Large-scale dataset generation (100+ documents)  
+**Pipeline Stages**: 1-19 (via worker.py)
+
+---
+
+## Request Parameters
+
+```python
+class GenerateDocumentRequest:
+    seed_images: List[HttpUrl]              # 1-8 seed images from web URLs
+    prompt_params: PromptParameters          # Generation configuration
+    
+class PromptParameters:
+    # Core Parameters
+    language: str = "english"                # Document language
+    doc_type: str = "invoice"                # Document type (invoice, receipt, form, etc.)
+    gt_type: str = "qa"                      # Ground truth format (qa, kie)
+    gt_format: str = "json"                  # GT encoding (json, annotation)
+    num_solutions: int = 1                   # Documents per seed set
+    
+    # Feature Toggles (Stages 07-19)
+    enable_handwriting: bool = False         # Stage 07-09, 12
+    handwriting_ratio: float = 0.2           # Probabilistic filter (0.0-1.0)
+    enable_visual_elements: bool = False     # Stage 08, 10, 13
+    visual_element_types: List[str] = []     # Filter types: logo, photo, figure, barcode, etc.
+    enable_ocr: bool = True                  # Stage 15
+    enable_bbox_normalization: bool = True   # Stage 16
+    enable_gt_verification: bool = False     # Stage 17
+    enable_analysis: bool = False            # Stage 18
+    enable_debug_visualization: bool = False # Stage 19
+    enable_dataset_export: bool = False      # Stage 19 (msgpack format)
+    dataset_export_format: str = "msgpack"   # Currently only msgpack supported
+    
+    # Reproducibility
+    seed: Optional[int] = None               # Random seed (null = random, int = reproducible)
+```
+
+---
+
+## Pipeline Architecture: The 19 Stages
+
+The API implements all 19 stages of the original batch pipeline in `docgenie/generation/`. Each stage is mapped to corresponding functions in `api/utils.py`.
+
+### **Phase 1: Core Pipeline (Stages 01-06)**
+Generate base documents from seed images and LLM prompts.
+
+#### **Stage 01: Seed Selection & Download**
+- **Original**: `pipeline_01_select_seeds.py`
+- **API**: `download_seed_images()` in `api/utils.py:117-161`
+- **Process**:
+  1. Accept user-provided seed image URLs (1-8 images)
+  2. Download with retry logic (3 attempts, exponential backoff)
+  3. Handle transient HTTP errors (502, 503, 504, 429)
+  4. Convert to base64 for LLM input
+- **Error Handling**: Retry with 2s, 4s, 8s delays; raise HTTPException on failure
+
+#### **Stage 02: Prompt LLM**
+- **Original**: `pipeline_02_prompt_llm.py`
+- **API**: `call_claude_api_direct()` in `api/utils.py:550-600`
+- **Process**:
+  1. Load prompt template: `data/prompt_templates/ClaudeRefined12/seed-based-json.txt`
+  2. Build prompt with parameters: language, doc_type, gt_type, num_solutions
+  3. Call Claude API (Anthropic Messages API v1)
+     - Model: `claude-3-5-sonnet-20241022` (configurable)
+     - Max tokens: 16,000
+     - Temperature: 1.0
+     - Vision: Send base64-encoded seed images
+  4. Receive HTML documents with embedded ground truth
+- **LLM Output Format**: Multiple `<!DOCTYPE html>...</html>` blocks with:
+  - CSS styling with page dimensions
+  - HTML elements with semantic classes
+  - Handwriting markers: `class="handwritten author1"` (author1, author2, etc.)
+  - Visual element placeholders: `data-placeholder="logo"`, `data-content="company-logo"`
+  - Ground truth: `<script id="GT">{...json...}</script>`
+
+#### **Stage 03: Process Response & Extract HTML**
+- **Original**: `pipeline_03_process_response.py`
+- **API**: `extract_html_documents_from_response()` in `api/utils.py:605-635`
+- **Process**:
+  1. Parse LLM response for `<!DOCTYPE html>...</html>` blocks (regex)
+  2. Prettify HTML with BeautifulSoup
+  3. Validate HTML structure
+  4. Extract ground truth JSON from `<script id="GT">` tag
+  5. Remove GT script tag, clean HTML for rendering
+- **Validation**: Check for required elements, CSS, proper structure
+
+#### **Stage 04: Render PDF & Extract Geometries**
+- **Original**: `pipeline_04_render_pdf_and_extract_geos.py`
+- **API**: `render_html_to_pdf()` in `api/utils.py:650-740`
+- **Process**:
+  1. Launch Playwright browser (Chromium)
+  2. Set page dimensions from CSS `@page` rule
+  3. Render HTML to PDF via `page.pdf()`
+  4. Extract element geometries:
+     - Handwriting elements: `.handwritten` class → `{rect, text, classes, selectorTypes: ["handwriting"]}`
+     - Visual elements: `[data-placeholder]` attribute → `{rect, dataPlaceholder, dataContent, selectorTypes: ["visual_element"]}`
+  5. Save PDF and geometries JSON
+- **Output**: 
+  - PDF at 72 DPI (PyMuPDF standard)
+  - Geometries at 96 DPI (browser rendering)
+  - Dimensions in mm
+
+#### **Stage 05: Extract Bounding Boxes**
+- **Original**: `pipeline_05_extract_bboxes_from_pdf.py`
+- **API**: `extract_bboxes_from_rendered_pdf()` in `api/utils.py:750-825`
+- **Process**:
+  1. Open PDF with PyMuPDF (fitz)
+  2. Extract text at word level: `page.get_text("words")`
+  3. Structure bboxes as:
+     ```python
+     {
+         "text": "word",
+         "x0": float,  # left
+         "y0": float,  # top
+         "x1": float,  # right (x2)
+         "y1": float,  # bottom (y2)
+         "block_no": int,
+         "line_no": int,
+         "word_no": int
+     }
+     ```
+  4. Filter whitespace-only text
+  5. Convert to OCRBox objects for processing
+- **Coordinate System**: PDF points (72 DPI), origin top-left
+
+#### **Stage 06: Validation**
+- **Original**: `pipeline_06_validation.py` (implicit)
+- **API**: `validate_html_structure()`, `validate_pdf()`, `validate_bboxes()` in `api/utils.py:830-890`
+- **Checks**:
+  - HTML: Required DOCTYPE, head, body, CSS
+  - PDF: File readable, page count = 1, has text
+  - Bboxes: Minimum count (configurable), valid coordinates
+
+---
+
+### **Phase 2: Feature Synthesis (Stages 07-13)**
+Add handwriting and visual elements to base documents.
+
+#### **Stage 07: Extract Handwriting Definitions**
+- **Original**: `pipeline_07_extract_handwriting.py`
+- **API**: `process_stage3_complete()` section in `api/utils.py:1150-1235`
+- **Process**:
+  1. Filter geometries: `"handwriting" in geo['selectorTypes']`
+  2. Parse classes: Extract `author1`, `author2`, etc. from `class="handwritten author1"`
+  3. **Probabilistic filtering** (handwriting_ratio):
+     ```python
+     if random.random() > handwriting_ratio:
+         continue  # Skip this element
+     ```
+     - `ratio=0.0`: No handwriting (0%)
+     - `ratio=0.5`: ~50% of marked elements
+     - `ratio=1.0`: All marked elements (100%)
+  4. Match geometries to word bboxes:
+     - Convert browser coords (96 DPI) to PDF coords (72 DPI): `scale = 72/96 = 0.75`
+     - Find consecutive word bboxes matching geometry text
+     - Check bboxes are within geometry rect (threshold: 0.7)
+     - Track taken bbox indices to avoid duplicates
+  5. Build handwriting region definitions:
+     ```python
+     {
+         "id": "hw0",
+         "text": "Patient Name",
+         "author_id": "author1",
+         "is_signature": False,
+         "rect": {x, y, width, height},  # in points
+         "bboxes": ["0_0_0 Patient 10.0 20.0 50.0 35.0", ...]
+     }
+     ```
+- **Reproducibility**: Use `seed + i` for each region to maintain order consistency
+
+#### **Stage 08: Extract Visual Element Definitions**
+- **Original**: `pipeline_08_extract_visual_element_definitions.py`
+- **API**: `process_stage3_complete()` section in `api/utils.py:1237-1275`
+- **Process**:
+  1. Filter geometries: `"visual_element" in geo['selectorTypes']`
+  2. Parse attributes:
+     - `data-placeholder`: Element type (logo, photo, figure, chart, barcode, etc.)
+     - `data-content`: Semantic description (e.g., "company-logo", "product-photo")
+  3. Normalize types using synonyms:
+     - "chart" → "figure"
+     - "image" → "photo"
+  4. Filter by `visual_element_types` parameter (if specified)
+  5. Convert coordinates: pixels (96 DPI) → mm
+  6. Extract rotation from CSS `transform: rotate(Xdeg)`
+  7. Build visual element definitions:
+     ```python
+     {
+         "id": "ve0",
+         "type": "logo",  # normalized
+         "content": "company-logo",
+         "rect": {x, y, width, height},  # in mm
+         "rotation": 0  # degrees
+     }
+     ```
+
+#### **Stage 09: Create Handwriting Images**
+- **Original**: `pipeline_09_create_handwriting_images.py`
+- **API**: `call_handwriting_service_batch()` in `api/utils.py:785-920`
+- **Handwriting Service**: RunPod serverless endpoint hosting WordStylist diffusion model
+- **Service Implementation**: `handwriting_service/handler.py`, `handwriting_service/inference.py`
+
+**🔄 Handwriting Service Integration Details:**
+
+##### **Service Architecture**
+- **Platform**: RunPod Serverless (GPU: NVIDIA A4000, Cost: ~$0.00025/s active)
+- **Model**: WordStylist (Diffusion-based handwriting synthesis)
+  - Architecture: UNet with conditional style embeddings
+  - Input: Text (A-Z, a-z only, no spaces), Writer style ID (0-656)
+  - Output: PNG image with transparent background
+  - Inference time: ~18s per text on A4000
+  - Weights: `handwriting_service/WordStylist/models/`
+- **Endpoints**:
+  - `/run` (async): Queue job, return ID, poll `/status/{id}` (10MB limit)
+  - `/runsync` (sync): Wait for completion, return result (20MB limit, used by API)
+
+##### **Batch Processing (Cost Optimization)**
+The API uses TRUE batch processing to minimize RunPod activation overhead:
+
+```python
+# ✅ NEW: Batch all texts in ONE request
+runpod_request = {
+    "input": {
+        "texts": [
+            {"text": "Hello", "author_id": 42, "hw_id": "hw0_b0_l0_w0"},
+            {"text": "World", "author_id": 42, "hw_id": "hw0_b0_l0_w1"},
+            # ... 10-100 texts
+        ],
+        "apply_blur": True
+    }
+}
+# Result: 1 worker activation × (N × 18s) = ~40-60% cost savings
+```
+
+**Cost Comparison for 10 texts:**
+- ❌ OLD (parallel): 10 workers × 18s = 180 worker-seconds + 10× activation fee
+- ✅ NEW (batched): 1 worker × 190s = 190 worker-seconds + 1× activation fee
+
+##### **API Processing Flow**
+1. **Group by region and line**: Split handwriting regions into word-level requests
+   ```python
+   # Text: "Patient Name" → 2 word-level generations
+   texts_to_generate = [
+       {"text": "Patient", "author_id": 42, "hw_id": "hw0_b0_l0_w0"},
+       {"text": "Name", "author_id": 42, "hw_id": "hw0_b0_l0_w1"}
+   ]
+   ```
+
+2. **Map author IDs to numeric styles**:
+   ```python
+   # "author1" → WRITER_STYLES[1] = 42 (deterministic)
+   # "author2" → WRITER_STYLES[2] = 137
+   # 657 total writer styles available
+   ```
+
+3. **Sanitize text** (WordStylist constraint):
+   ```python
+   # Only A-Z, a-z allowed (no spaces, numbers, punctuation)
+   "Hello123!" → "Hello"
+   "first-name" → "firstname"
+   ```
+
+4. **Send batch request** to RunPod `/runsync` endpoint:
+   ```python
+   POST https://api.runpod.ai/v2/{endpoint_id}/runsync
+   Authorization: Bearer {RUNPOD_API_KEY}
+   Content-Type: application/json
+   
+   {
+       "input": {
+           "texts": [...],
+           "apply_blur": True  # Gaussian blur for realism
+       }
+   }
+   ```
+
+5. **Handle async responses**:
+   - If `status: "IN_PROGRESS"`: Poll `/status/{job_id}` every 5-10s (max 30 polls)
+   - If `status: "COMPLETED"`: Extract `output.images[]`
+   - If `status: "FAILED"`: Raise exception (stops entire generation)
+
+6. **Response format**:
+   ```python
+   {
+       "status": "COMPLETED",
+       "output": {
+           "images": [
+               {
+                   "image_base64": "iVBORw0KGgoAAAANSU...",
+                   "width": 200,
+                   "height": 64,
+                   "text": "Patient",
+                   "author_id": 42,
+                   "hw_id": "hw0_b0_l0_w0"
+               },
+               ...
+           ],
+           "total_generated": 2
+       }
+   }
+   ```
+
+7. **Store generated images**: Map `hw_id → image_base64` for insertion
+
+##### **Error Handling**
+- **Retry logic**: 3 attempts with exponential backoff (matching seed download)
+- **Timeouts**: Dynamic based on batch size: `20s × num_texts + 30s buffer`
+- **Failure behavior**: **RAISE EXCEPTION** (since session fix)
+  - ❌ OLD: Silent continue → Documents without handwriting
+  - ✅ NEW: Raise exception → Generation fails when user requested handwriting
+
+##### **Service Code Structure**
+**`handwriting_service/handler.py`** (RunPod handler):
+```python
+# Initialize model ONCE at module level (not per request)
+generator = HandwritingGenerator(
+    model_dir="WordStylist",
+    checkpoint_path="WordStylist/models",
+    device="cuda"
+)
+
+def handler(job):
+    """RunPod entry point - supports both /run and /runsync"""
+    texts = job["input"]["texts"]  # Batch input
+    results = generator.generate_batch(
+        texts=[t["text"] for t in texts],
+        author_ids=[t["author_id"] for t in texts],
+        num_inference_steps=50,
+        temperature=1.0,
+        apply_blur=True
+    )
+    return {"images": results, "total_generated": len(results)}
+```
+
+**`handwriting_service/inference.py`** (WordStylist wrapper):
+```python
+class HandwritingGenerator:
+    def generate_batch(self, texts, author_ids, ...):
+        results = []
+        for text, author_id in zip(texts, author_ids):
+            # Load model checkpoint
+            unet = Unet(...)
+            unet.load_state_dict(checkpoint)
+            
+            # Prepare style condition
+            style_id_tensor = torch.tensor([author_id])
+            
+            # Diffusion reverse process (50 steps)
+            img = self.sample(unet, style_id_tensor, text_length=len(text))
+            
+            # Post-process: crop, resize, apply blur
+            img_pil = postprocess_image(img)
+            if apply_blur:
+                img_pil = img_pil.filter(ImageFilter.GaussianBlur(1.2))
+            
+            # Encode to base64
+            img_base64 = encode_pil_to_base64(img_pil)
+            results.append({
+                "image_base64": img_base64,
+                "width": img_pil.width,
+                "height": img_pil.height
+            })
+        
+        return results
+```
+
+#### **Stage 10: Create Visual Element Images**
+- **Original**: `pipeline_10_create_visual_elements.py`
+- **API**: `generate_visual_element_images()` in `api/utils.py:925-1020`
+- **Process**:
+  1. Load prefab images from `data/visual_element_prefabs/{type}/`:
+     - `logo/`: Company logos (50+ SVGs)
+     - `photo/`: Stock photos (100+ JPGs)
+     - `figure/`: Charts, graphs (30+ PNGs)
+     - `barcode/`: Generated barcodes
+     - `qr_code/`, `stamp/`, `signature/`, `checkbox/`, etc.
+  2. **Random selection** (seed-based if provided):
+     ```python
+     if seed is not None:
+         random.seed(seed)
+     prefab_path = random.choice(list(prefab_dir.glob("*")))
+     ```
+  3. **Special handling**:
+     - **Barcode**: Generate on-the-fly using `python-barcode` library
+       ```python
+       # Generate random EAN-13 barcode (12 digits + checksum)
+       barcode_num = random.randint(100000000000, 999999999999)
+       barcode = EAN13(str(barcode_num), writer=ImageWriter())
+       ```
+     - **QR Code**: Generate using `qrcode` library
+     - **Checkbox**: Render checked/unchecked SVG
+  4. Load and convert to base64:
+     ```python
+     with open(prefab_path, 'rb') as f:
+         img_bytes = f.read()
+         img_base64 = base64.b64encode(img_bytes).decode('utf-8')
+     ```
+  5. Return mapping: `ve_id → image_base64`
+
+#### **Stage 11: Make Text Transparent (Implicit)**
+- **Original**: `pipeline_11_make_text_transparent.py`
+- **API**: Implemented as "whiteout" in `process_stage3_complete()` at `api/utils.py:1415-1427`
+- **Process**:
+  ```python
+  # Draw white rectangles over original text to hide it
+  for hw_region in handwriting_regions:
+      for bbox_str in hw_region['bboxes']:
+          bbox = parse_bbox(bbox_str)
+          rect = fitz.Rect(bbox.x0, bbox.y0, bbox.x2, bbox.y2)
+          page.draw_rect(rect, color=(1,1,1), fill=(1,1,1))  # White fill
+  ```
+- **Why not transparent?**: PyMuPDF doesn't support making existing text transparent, so we use white rectangles instead (same visual result)
+
+#### **Stage 12: Insert Handwriting Images**
+- **Original**: `pipeline_12_insert_handwriting_images.py`
+- **API**: `process_stage3_complete()` section in `api/utils.py:1429-1520`
+- **Process**:
+  1. **Position calculation**:
+     ```python
+     # Get word bbox from PDF extraction
+     bbox_w = bbox.x2 - bbox.x0  # Width in points
+     bbox_h = bbox.y2 - bbox.y0  # Height in points
+     
+     # Resize handwriting image with aspect ratio
+     scale = min(bbox_w / img_width, bbox_h / img_height)
+     new_w = int(img_width * scale * SCALE_UP_FACTOR)  # 3x upscale
+     new_h = int(img_height * scale * SCALE_UP_FACTOR)
+     
+     # Add random offsets for natural variation
+     offset_x = random.randint(-MAX_OFFSET_LEFT, MAX_OFFSET_RIGHT) + FIXED_OFFSET
+     offset_y = random.randint(-MAX_OFFSET_UP, MAX_OFFSET_DOWN)
+     
+     # Position at bbox coordinates
+     x0 = bbox.x0 + offset_x
+     y0 = bbox.y0 + offset_y - y_padding
+     ```
+  
+  2. **Insert into PDF**:
+     ```python
+     img_resized = img.resize((new_w, new_h), Image.LANCZOS).convert("RGBA")
+     img_bytes = pil_to_bytes(img_resized)
+     rect = fitz.Rect(x0, y0, x0 + bbox_w, y0 + bbox_h)
+     page.insert_image(rect, stream=img_bytes)
+     ```
+  
+  3. Save intermediate PDF: `{doc_id}_with_handwriting.pdf`
+
+#### **Stage 13: Insert Visual Elements**
+- **Original**: `pipeline_13_insert_visual_elements.py`
+- **API**: `process_stage3_complete()` section in `api/utils.py:1523-1625`
+- **Process**:
+  1. Convert mm → points: `mm_to_pt = 72 / 25.4`
+  2. Resize with aspect ratio preservation (same as handwriting)
+  3. Center image on white background (maintains bbox size)
+  4. Insert into PDF at geometry coordinates
+  5. Save final PDF: `{doc_id}_final.pdf` (includes both handwriting + visual elements)
+
+---
+
+### **Phase 3: Image Finalization & OCR (Stages 14-15)**
+Convert final PDF to high-resolution image and extract OCR data.
+
+#### **Stage 14: Render Image**
+- **Original**: `pipeline_14_render_image.py`
+- **API**: `process_stage4_ocr()` in `api/utils.py:1899-1940`
+- **Process**:
+  ```python
+  # Render PDF page to high-res PNG
+  page = fitz.open(pdf_path)[0]
+  pix = page.get_pixmap(matrix=fitz.Matrix(3, 3))  # 3x scale = ~220 DPI
+  img_bytes = pix.tobytes("png")
+  img_base64 = base64.b64encode(img_bytes).decode('utf-8')
+  ```
+- **Output**: Base64-encoded PNG at 220 DPI (configurable via scale factor)
+
+#### **Stage 15: Perform OCR**
+- **Original**: `pipeline_15_perform_ocr.py`
+- **API**: `run_paddle_ocr()` in `api/utils.py:1950-2080`
+- **OCR Engine**: PaddleOCR v4 (multilingual)
+  - Models: `PP-OCRv4` detection + recognition
+  - Languages: Supports 80+ languages
+  - Accuracy: State-of-the-art open-source OCR
+- **Process**:
+  1. Render PDF to image via `pdf2image` at specified DPI (default: 300)
+  2. Initialize PaddleOCR with language parameter
+  3. Run detection + recognition:
+     ```python
+     ocr = PaddleOCR(lang=language, use_gpu=True)
+     results = ocr.ocr(img_array, cls=True)
+     ```
+  4. Parse results into word-level bboxes:
+     ```python
+     {
+         "text": "word",
+         "bbox": {
+             "x0": float,
+             "y0": float,
+             "x1": float,  # right
+             "y1": float   # bottom
+         },
+         "confidence": 0.95
+     }
+     ```
+- **Output**: Dictionary with `words` list, image dimensions, OCR engine info
+
+---
+
+### **Phase 4: Dataset Packaging (Stages 16-19)**
+Normalize, verify, analyze, and export final dataset.
+
+#### **Stage 16: Normalize Bboxes**
+- **Original**: `pipeline_16_normalize_bboxes.py`
+- **API**: `normalize_bboxes()` in `api/utils.py:2100-2180`
+- **Process**:
+  1. Convert absolute pixel coordinates → normalized [0, 1] range:
+     ```python
+     norm_bbox = [
+         bbox['x0'] / img_width,
+         bbox['y0'] / img_height,
+         bbox['x1'] / img_width,
+         bbox['y1'] / img_height
+     ]
+     ```
+  2. Clip to [0, 1]: `[max(0, min(1, x)) for x in norm_bbox]`
+  3. Create word-level and segment-level bboxes
+- **Output**: List of `{text, bbox: [x0, y0, x1, y1]}` where bbox is normalized
+
+#### **Stage 17: Ground Truth Verification**
+- **Original**: `pipeline_17_gt_preparation_verification.py`
+- **API**: `verify_ground_truth()` in `api/utils.py:2185-2250`
+- **Checks**:
+  - GT structure: Valid JSON, required fields
+  - Text matching: GT text exists in OCR output
+  - Bbox coverage: GT answers have corresponding bboxes
+- **Output**: Verification report with pass/fail status
+
+#### **Stage 18: Analyze**
+- **Original**: `pipeline_18_analyze.py`
+- **API**: `analyze_document()` in `api/utils.py:2255-2320`
+- **Metrics**:
+  - Word count, character count
+  - Average word length
+  - Handwriting regions count, coverage %
+  - Visual elements count by type
+  - OCR confidence statistics (mean, min, max)
+- **Output**: Analysis dictionary with computed metrics
+
+#### **Stage 19: Create Debug Data & Export**
+- **Original**: `pipeline_19_create_debug_data.py`
+- **API**: `export_to_msgpack()` in `api/utils.py:2350-2520`
+- **Debug Visualization**:
+  - Draw bboxes on image with different colors:
+    - Green: Word bboxes
+    - Red: Handwriting regions
+    - Blue: Visual elements
+    - Yellow: Ground truth target regions
+  - Save annotated image
+- **Dataset Export (msgpack)**:
+  ```python
+  dataset_entry = {
+      "image": img_bytes,  # PNG bytes
+      "words": ["hello", "world"],
+      "word_bboxes": [[0.1, 0.2, 0.15, 0.25], ...],  # Normalized
+      "segment_bboxes": [...],
+      "ground_truth": {"question": "answer"},
+      "metadata": {
+          "document_id": "...",
+          "has_handwriting": True,
+          "num_visual_elements": 3
+      }
+  }
+  msgpack.dump(dataset_entry, f)
+  ```
+- **Output**: `.msgpack` file compatible with PyTorch DataLoader
+
+---
+
+## Pipeline Verification: API vs Original Implementation
+
+### ✅ **Stage-by-Stage Mapping**
+
+| Stage | Original File | API Function | Status |
+|-------|--------------|--------------|--------|
+| 01 | `pipeline_01_select_seeds.py` | `download_seed_images()` | ✅ Mapped (with retry logic) |
+| 02 | `pipeline_02_prompt_llm.py` | `call_claude_api_direct()` | ✅ Mapped (uses Messages API) |
+| 03 | `pipeline_03_process_response.py` | `extract_html_documents_from_response()` | ✅ Mapped |
+| 04 | `pipeline_04_render_pdf_and_extract_geos.py` | `render_html_to_pdf()` | ✅ Mapped (Playwright) |
+| 05 | `pipeline_05_extract_bboxes_from_pdf.py` | `extract_bboxes_from_rendered_pdf()` | ✅ Mapped |
+| 06 | `pipeline_06_validation.py` | `validate_html_structure()`, `validate_pdf()` | ✅ Mapped |
+| 07 | `pipeline_07_extract_handwriting.py` | `process_stage3_complete()` section | ✅ Mapped (with ratio filter) |
+| 08 | `pipeline_08_extract_visual_element_definitions.py` | `process_stage3_complete()` section | ✅ Mapped |
+| 09 | `pipeline_09_create_handwriting_images.py` | `call_handwriting_service_batch()` | ✅ Mapped (RunPod integration) |
+| 10 | `pipeline_10_create_visual_elements.py` | `generate_visual_element_images()` | ✅ Mapped |
+| 11 | `pipeline_11_make_text_transparent.py` | `process_stage3_complete()` (whiteout) | ✅ Mapped (white rectangles) |
+| 12 | `pipeline_12_insert_handwriting_images.py` | `process_stage3_complete()` section | ✅ Mapped |
+| 13 | `pipeline_13_insert_visual_elements.py` | `process_stage3_complete()` section | ✅ Mapped |
+| 14 | `pipeline_14_render_image.py` | `process_stage4_ocr()` | ✅ Mapped |
+| 15 | `pipeline_15_perform_ocr.py` | `run_paddle_ocr()` | ✅ Mapped |
+| 16 | `pipeline_16_normalize_bboxes.py` | `normalize_bboxes()` | ✅ Mapped |
+| 17 | `pipeline_17_gt_preparation_verification.py` | `verify_ground_truth()` | ✅ Mapped |
+| 18 | `pipeline_18_analyze.py` | `analyze_document()` | ✅ Mapped |
+| 19 | `pipeline_19_create_debug_data.py` | `export_to_msgpack()` | ✅ Mapped |
+
+### 📊 **Key Differences: API vs Batch Pipeline**
+
+#### **Processing Model**
+- **Original**: Batch processing with file-based state management
+  - Input: CSV of seed selections, prompt parameters in JSON
+  - Output: Folder structure with intermediate files
+  - State: JSON logs per document + message
+  - Resumability: Can restart from any stage
+
+- **API**: Request/response with in-memory processing
+  - Input: JSON request with seed URLs
+  - Output: JSON response or ZIP file
+  - State: Ephemeral (temporary directories)
+  - Resumability: None (single-shot generation)
+
+#### **Handwriting Generation**
+- **Original**: Local GPU with WordStylist model loaded in-process
+  - Location: `docgenie/generation/handwriting_diffusion/`
+  - Execution: `generate_handwriting_diffusion_raw.py`
+  - Cost: Free (local GPU)
+
+- **API**: Remote RunPod serverless endpoint
+  - Location: `handwriting_service/` (deployed separately)
+  - Execution: HTTP POST to RunPod API
+  - Cost: ~$0.00025/s GPU time (pay-per-use)
+  - Benefit: No local GPU required, scales automatically
+
+#### **Seed Selection**
+- **Original**: Pre-crawled dataset with systematic selection
+  - Seeds stored in: `data/datasets/base_v2/`
+  - Selection: Clustering algorithm → balanced subset
+  - Tracking: CSV manifest with seed IDs
+
+- **API**: User-provided URLs
+  - Seeds: Any publicly accessible image URL
+  - Selection: User chooses 1-8 images per request
+  - Tracking: URLs stored in request metadata
+
+#### **Prompt Templates**
+- **Original**: Multiple template versions in folders
+  - Path: `data/prompt_templates/{version}/seed-based-json.txt`
+  - Versioning: ClaudeRefined1 → ClaudeRefined12
+  - Selection: Configurable per dataset
+
+- **API**: Fixed template (latest version)
+  - Path: `data/prompt_templates/ClaudeRefined12/seed-based-json.txt`
+  - Hardcoded in: `api/main.py:171`
+  - **Future improvement**: Make template selectable via API parameter
+
+---
+
+## Complete Request Flow Example
+
+### Example Request (Sync Endpoint)
+```bash
+POST /generate/pdf HTTP/1.1
+Content-Type: application/json
+
+{
+  "seed_images": [
+    "https://example.com/seed1.jpg",
+    "https://example.com/seed2.jpg"
+  ],
+  "prompt_params": {
+    "language": "english",
+    "doc_type": "medical_form",
+    "gt_type": "kie",
+    "gt_format": "json",
+    "num_solutions": 2,
+    "enable_handwriting": true,
+    "handwriting_ratio": 0.3,
+    "enable_visual_elements": true,
+    "visual_element_types": ["logo", "signature"],
+    "enable_ocr": true,
+    "enable_dataset_export": true,
+    "seed": 42
+  }
+}
+```
+
+### Processing Flow (Stages Executed)
+
+**Phase 1: Core Document Generation (30-60s)**
+1. ✅ Download 2 seed images with retry → `[img1_b64, img2_b64]`
+2. ✅ Load prompt template → Build prompt for medical_form + KIE
+3. ✅ Call Claude API → LLM generates 2 HTML documents (~25s)
+4. ✅ Extract HTML + ground truth → 2 clean HTML files with GT JSON
+5. ✅ Render each HTML to PDF via Playwright → 2 PDFs + geometries
+6. ✅ Extract word bboxes from PDFs → ~200-500 words per document
+
+**Phase 2: Feature Synthesis (120-180s if handwriting enabled)**
+7. ✅ Parse geometries for handwriting markers
+   - Found: 12 elements with `class="handwritten"`
+   - Filtered by ratio: 12 × 0.3 = ~4 elements selected (probabilistic)
+   - Matched to word bboxes: 4 regions with 15 total words
+8. ✅ Parse geometries for visual elements
+   - Found: 3 elements (`data-placeholder="logo"`, `"signature"`, `"logo"`)
+   - Filtered by types: Keep logo + signature, remove others
+   - Result: 2 visual element definitions
+9. ✅ Generate handwriting images via RunPod
+   - **Batch request**: 15 words in ONE API call
+   - Map author IDs: `author1 → style 42`, `author2 → style 137`
+   - RunPod processing: 1 worker × (15 × 18s) = ~270s
+   - Result: 15 PNG images (base64-encoded)
+10. ✅ Generate visual element images
+    - Logo: Random selection from `data/visual_element_prefabs/logo/` (seed=42)
+    - Signature: Generate on-the-fly using signature prefab
+    - Result: 2 PNG images
+11. ✅ Whiteout original text: Draw white rectangles over 15 word positions
+12. ✅ Insert handwriting: Place 15 generated images at word bboxes with offsets
+    - Save: `doc1_with_handwriting.pdf`, `doc2_with_handwriting.pdf`
+13. ✅ Insert visual elements: Place logo + signature at geometry coords
+    - Save: `doc1_final.pdf`, `doc2_final.pdf`
+
+**Phase 3: Image + OCR (5-10s)**
+14. ✅ Render each final PDF to 220 DPI image → 2 PNG files (base64)
+15. ✅ Run PaddleOCR on each image
+    - Doc1: Detected 187 words, avg confidence 0.91
+    - Doc2: Detected 203 words, avg confidence 0.94
+
+**Phase 4: Dataset Packaging (2-5s)**
+16. ✅ Normalize OCR bboxes: Convert pixels → [0,1] range
+17. ✅ Verify ground truth: Check GT fields match OCR output (enabled=false, skipped)
+18. ✅ Analyze documents: Compute metrics (enabled=false, skipped)
+19. ✅ Export to msgpack:
+    - Doc1: Pack image + words + normalized bboxes + GT → `doc1.msgpack`
+    - Doc2: Pack image + words + normalized bboxes + GT → `doc2.msgpack`
+
+**Final Output: ZIP File Contents**
+```
+dataset.zip
+├── doc1_uuid_0.pdf               # Original rendered PDF
+├── doc1_uuid_0_final.pdf         # PDF with handwriting + visual elements
+├── doc1_uuid_0.msgpack           # Dataset format
+├── doc2_uuid_1.pdf
+├── doc2_uuid_1_final.pdf
+├── doc2_uuid_1.msgpack
+├── metadata.json                 # Complete generation metadata
+└── handwriting/
+    ├── hw0_b0_l0_w0.png          # Individual handwriting images
+    ├── hw0_b0_l0_w1.png
+    └── ... (13 more)
+```
+
+### Response (JSON Metadata)
+```json
+{
+  "task_id": "uuid-here",
+  "status": "completed",
+  "num_documents": 2,
+  "processing_time_seconds": 305.7,
+  "stages_completed": [
+    "seed_download", "llm_prompt", "html_extraction",
+    "pdf_render", "bbox_extraction", "handwriting_extraction",
+    "visual_element_extraction", "handwriting_generation",
+    "visual_element_generation", "handwriting_insertion",
+    "visual_element_insertion", "image_render", "ocr",
+    "bbox_normalization", "dataset_export"
+  ],
+  "documents": [
+    {
+      "document_id": "doc1_uuid_0",
+      "ground_truth": {"patient_name": "John Doe", "date": "2024-01-15"},
+      "num_words": 187,
+      "num_handwriting_regions": 2,
+      "num_visual_elements": 2,
+      "ocr_confidence_avg": 0.91
+    },
+    {
+      "document_id": "doc2_uuid_1",
+      "ground_truth": {"patient_name": "Jane Smith", "date": "2024-01-16"},
+      "num_words": 203,
+      "num_handwriting_regions": 2,
+      "num_visual_elements": 2,
+      "ocr_confidence_avg": 0.94
+    }
+  ],
+  "download_url": "/download/dataset_uuid.zip"
+}
+```
+
+---
+
+## Configuration & Environment
+
+### Required Environment Variables
+```bash
+# LLM API
+ANTHROPIC_API_KEY=sk-ant-...              # Claude API key
+CLAUDE_MODEL=claude-3-5-sonnet-20241022   # Default model
+
+# Handwriting Service (RunPod)
+HANDWRITING_SERVICE_ENABLED=true
+HANDWRITING_SERVICE_URL=https://api.runpod.ai/v2/{endpoint_id}/runsync
+RUNPOD_API_KEY=...                        # RunPod API key
+HANDWRITING_APPLY_BLUR=true               # Gaussian blur for realism
+HANDWRITING_SERVICE_MAX_RETRIES=3
+HANDWRITING_SERVICE_TIMEOUT=600           # 10 minutes for large batches
+
+# OCR Configuration
+OCR_DPI=300                               # Image resolution for OCR
+OCR_LANGUAGE=en                           # PaddleOCR language code
+
+# File Paths
+PROMPT_TEMPLATES_DIR=/path/to/data/prompt_templates
+VISUAL_ELEMENT_PREFABS_DIR=/path/to/data/visual_element_prefabs
+```
+
+### Docker Deployment (Railway)
+```dockerfile
+# Dockerfile (api service)
+FROM python:3.11-slim
+RUN apt-get update && apt-get install -y \
+    chromium chromium-driver \  # Playwright dependencies
+    libgl1 libglib2.0-0 \      # PaddleOCR dependencies
+    && rm -rf /var/lib/apt/lists/*
+
+COPY api/ /app/api
+COPY docgenie/ /app/docgenie
+COPY data/ /app/data
+WORKDIR /app/api
+RUN pip install -r requirements.txt
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]
+```
+
+**Handwriting service**: See `handwriting_service/Dockerfile` (deployed separately to RunPod)
+
+---
+
+## Performance & Costs
+
+### Timing Breakdown (Single Document)
+| Stage | Time | Notes |
+|-------|------|-------|
+| Seed download | 0.5-2s | Depends on image size + network |
+| LLM prompt | 20-40s | Claude API latency |
+| PDF render | 1-3s | Playwright initialization |
+| Handwriting (10 words) | 180s | RunPod: 1 worker × (10×18s) |
+| Visual elements | 0.5-1s | Local file selection |
+| OCR | 3-5s | PaddleOCR inference |
+| Dataset export | 0.5-1s | msgpack serialization |
+| **TOTAL (no handwriting)** | **25-50s** |
+| **TOTAL (with handwriting)** | **200-230s** | Batched |
+
+### Cost Breakdown (Per Document)
+| Component | Cost | Notes |
+|-----------|------|-------|
+| Claude API | $0.015-0.03 | ~5K input + 16K output tokens |
+| RunPod GPU (10 words) | $0.045 | 180s × $0.00025/s |
+| Storage | Negligible | Temporary files deleted |
+| **TOTAL (no handwriting)** | **$0.015-0.03** |
+| **TOTAL (with handwriting)** | **$0.06-0.08** |
+
+**Optimization**: Batch multiple documents in ONE RunPod call to share worker activation overhead.
+
+---
+
+## Error Handling & Reliability
+
+### Retry Mechanisms
+1. **Seed image download**: 3 attempts, exponential backoff (2s, 4s, 8s)
+2. **Handwriting service**: 3 attempts, status polling up to 30 times
+3. **LLM API**: Built-in Anthropic SDK retries (rate limits, 529 errors)
+
+### Failure Modes
+| Error Type | Behavior | User Impact |
+|------------|----------|-------------|
+| Seed download failure | Raise HTTP 400 | Request rejected immediately |
+| LLM API error | Raise HTTP 500 | No charge, can retry |
+| Handwriting service failure | **Raise exception** (NEW) | Generation fails, prevents invalid outputs |
+| OCR failure | Log warning, continue | Document generated without OCR data |
+| PDF render failure | Raise HTTP 500 | Request fails, no partial results |
+
+### Session Fixes Applied
+- ✅ **Handwriting service failure now raises exception** (previously silent)
+- ✅ **Seed parameter defaults to null** (previously 0)
+- ✅ **Seed image download retry logic** (handles 503 timeout errors)
+- ✅ **API docs show correct examples** (seed: null, not 0)
+
+---
+
+## Future Enhancements
+
+### Short-term
+1. **Configurable prompt templates** via API parameter
+2. **Async endpoint progress tracking** (websocket or polling)
+3. **Batch ZIP download** with multiple documents in one archive
+4. **Cost estimation** before generation (preview mode)
+
+### Long-term
+1. **Custom visual element upload** (user-provided logos, signatures)
+2. **Multi-page document support** (currently single-page only)
+3. **Additional export formats** (COCO, YOLO, HuggingFace Datasets)
+4. **Fine-tuning handwriting styles** (train on user's handwriting samples)
+5. **LLM caching** (reduce cost for similar prompts)
+
+---
+
+## Troubleshooting
+
+### Common Issues
+
+**Q: "Handwriting service not called, but enable_handwriting=true"**
+- Check: LLM output contains `class="handwritten"` in HTML
+- Check: `handwriting_ratio` > 0 (default 0.2)
+- Check: `HANDWRITING_SERVICE_ENABLED=true` in environment
+- Debug: Look for "🔍 DEBUG - Handwriting Service Check" in logs
+
+**Q: "RunPod job stuck IN_PROGRESS"**
+- Cause: Large batch timing out
+- Solution: Increase `HANDWRITING_SERVICE_TIMEOUT` (default 600s)
+- Or: Reduce batch size by lowering `handwriting_ratio`
+
+**Q: "503 first byte timeout" on seed download**
+- Cause: CDN/storage provider temporary unavailability
+- Solution: Retry logic automatically handles this (3 attempts)
+- If persists: Use different image hosting (imgur, cloudinary)
+
+**Q: "Seed parameter still shows 0 in API docs"**
+- Fixed: Added `examples=[None, 42]` to Field definition
+- Clear browser cache if seeing old docs
+
+---
+
+## Testing
+
+### Unit Tests
+```bash
+# Test individual stages
+pytest api/tests/test_utils.py::test_download_seed_images
+pytest api/tests/test_utils.py::test_handwriting_service_batch
+```
+
+### Integration Tests
+```bash
+# Test sync endpoint (included in repo)
+python api/test_sync_pdf_api.py
+
+# Test async endpoint
+python api/test_async_api.py
+```
+
+### Manual Testing via Docs UI
+1. Navigate to `http://localhost:8000/docs`
+2. Expand `/generate/pdf` endpoint
+3. Click "Try it out"
+4. Paste example request JSON
+5. Click "Execute"
+6. Download resulting ZIP file
+
+### Example Test Request (Minimal)
+```json
+{
+  "seed_images": [
+    "https://i.imgur.com/example.jpg"
+  ],
+  "prompt_params": {
+    "language": "english",
+    "doc_type": "invoice",
+    "num_solutions": 1,
+    "enable_handwriting": false,
+    "enable_visual_elements": false,
+    "enable_ocr": true,
+    "enable_dataset_export": true
+  }
+}
+```
+
+---
+
+## Conclusion
+
+The DocGenie API successfully implements all 19 stages of the original batch pipeline in a request/response model suitable for real-time generation. Key architectural differences:
+
+1. **Handwriting generation**: Offloaded to RunPod serverless (cost-efficient batching)
+2. **Seed selection**: User-provided URLs instead of pre-crawled dataset
+3. **State management**: Ephemeral in-memory processing vs file-based
+4. **Scalability**: Horizontal scaling via FastAPI workers + async processing
+
+The API maintains feature parity with the batch pipeline while providing a simpler interface for integration with external systems (web apps, mobile apps, data pipelines).
+
+**Total Processing Time**: 25-50s (no handwriting) or 200-230s (with handwriting)  
+**Cost Per Document**: $0.015-0.08 depending on features  
+**Output Formats**: PDF, PNG, msgpack, ZIP archive
+
+For questions or issues, see `api/README.md` or `TESTING.md`.

ARCHITECTURE.md

@@ -0,0 +1,278 @@
+# 🏗️ DocGenie Architecture & Dependency Resolution
+
+## 📦 Package Structure
+
+```
+docgenie/                          ← Root monorepo
+├── docgenie/                      ← Core package (importable)
+│   ├── __init__.py               
+│   ├── generation/               ← Used by API
+│   │   ├── pipeline_01/
+│   │   │   └── claude_batching.py  ← ClaudeBatchedClient
+│   │   ├── pipeline_03/
+│   │   ├── pipeline_04/
+│   │   └── utils/
+│   ├── evaluation/
+│   └── utils/
+│
+├── api/                          ← API Service (imports docgenie.*)
+│   ├── main.py                   from docgenie import ENV
+│   ├── worker.py                 from docgenie.generation.pipeline_01...
+│   ├── utils.py                  from docgenie.generation...
+│   └── requirements.txt          Extra: Redis, Supabase, Google
+│
+├── handwriting_service/          ← GPU Service (NO docgenie imports!)
+│   ├── main.py                   ✓ Self-contained
+│   ├── inference.py              ✓ No external deps
+│   └── models.py
+│
+└── WordStylist/                  ← Model code (used by handwriting)
+```
+
+## 🔗 Dependency Graph
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│                     API Service                              │
+│  ┌──────────────────────────────────────────────────────┐   │
+│  │ api/main.py                                          │   │
+│  │ ↓ imports                                             │   │
+│  │ api/utils.py (call_claude_api_direct)               │   │
+│  └──────────────────────────────────────────────────────┘   │
+│                                                              │
+│  ┌──────────────────────────────────────────────────────┐   │
+│  │ api/worker.py                                        │   │
+│  │ ↓ imports                                             │   │
+│  │ from docgenie.generation.pipeline_01.claude_batching │   │
+│  │ from docgenie.generation.constants                   │   │
+│  │ from docgenie.generation.pipeline_03_process_response│   │
+│  │ from docgenie.generation.pipeline_04_render_pdf...   │   │
+│  │ from docgenie import ENV                             │   │
+│  └──────────────────────────────────────────────────────┘   │
+│                           ↓                                  │
+│                    REQUIRES                                  │
+│  ┌──────────────────────────────────────────────────────┐   │
+│  │          docgenie/ package                           │   │
+│  │          (entire generation module)                   │   │
+│  └──────────────────────────────────────────────────────┘   │
+└─────────────────────────────────────────────────────────────┘
+
+┌─────────────────────────────────────────────────────────────┐
+│              Handwriting Service                             │
+│  ┌──────────────────────────────────────────────────────┐   │
+│  │ handwriting_service/main.py                          │   │
+│  │ ↓ imports                                             │   │
+│  │ from handwriting_service.inference import ...        │   │
+│  │ from handwriting_service.models import ...           │   │
+│  └──────────────────────────────────────────────────────┘   │
+│                           ↓                                  │
+│                    REQUIRES                                  │
+│  ┌────────────────────────���─────────────────────────────┐   │
+│  │          WordStylist/ model                          │   │
+│  │          (diffusion model code)                       │   │
+│  └──────────────────────────────────────────────────────┘   │
+│                                                              │
+│  ✓ NO docgenie imports - completely independent!            │
+└─────────────────────────────────────────────────────────────┘
+```
+
+## 🐳 Docker Build Strategy
+
+### ❌ What Doesn't Work
+
+```dockerfile
+# ❌ WRONG: Can't copy just api/ folder
+FROM python:3.11
+COPY api/ /app/api/              # Missing docgenie package!
+RUN pip install -r requirements.txt
+CMD ["uvicorn", "main:app"]     # ImportError: No module named 'docgenie'
+```
+
+### ✅ What Works
+
+```dockerfile
+# ✅ CORRECT: Copy entire monorepo
+FROM python:3.11
+WORKDIR /app
+
+# Copy everything
+COPY . .
+
+# Install docgenie as package
+RUN pip install -e .             # Makes docgenie.* importable
+
+# Install API requirements
+RUN pip install -r api/requirements.txt
+
+WORKDIR /app/api
+CMD ["uvicorn", "main:app"]     # ✓ docgenie imports work!
+```
+
+## 🚢 Deployment Strategy Comparison
+
+### Option 1: Separate Deployments (❌ Won't Work)
+
+```
+API Deployment:
+├── api/ folder only
+└── ❌ Missing docgenie package → ImportError
+
+Handwriting Deployment:
+├── handwriting_service/ folder
+└── WordStylist/
+```
+
+**Problem:** API can't find docgenie imports!
+
+### Option 2: Monorepo Deployment (✅ Works)
+
+```
+API Deployment:
+├── docgenie/ package (core)
+├── api/ service (imports docgenie)
+├── setup.py
+└── requirements.txt
+
+Handwriting Deployment:
+├── handwriting_service/
+└── WordStylist/
+```
+
+**Solution:** Deploy entire repo for API, standalone for handwriting!
+
+## 📁 File Structure in Containers
+
+### API Container (Railway/EC2)
+```
+/app/
+├── docgenie/              ← Installed as Python package
+│   ├── __init__.py
+│   ├── generation/
+│   └── utils/
+├── api/                   ← Working directory
+│   ├── main.py
+│   ├── worker.py
+│   └── utils.py
+├── setup.py
+└── pyproject.toml
+
+Python can import:
+✓ from docgenie.generation.pipeline_01 import ...
+✓ from docgenie import ENV
+```
+
+### Handwriting Container (RunPod)
+```
+/app/
+├── handwriting_service/
+│   ├── main.py           ← No docgenie imports!
+│   ├── inference.py
+│   └── models.py
+└── WordStylist/          ← Model code
+    ├── ldm/
+    └── wordstylist_inference.py
+
+Python can import:
+✓ from handwriting_service.inference import ...
+✓ No docgenie dependencies needed!
+```
+
+## 🎯 Import Resolution Flow
+
+### API Service Import Chain
+
+1. **FastAPI starts:**
+   ```python
+   uvicorn main:app
+   ```
+
+2. **main.py imports utils:**
+   ```python
+   from api.utils import call_claude_api_direct
+   ```
+
+3. **utils.py imports docgenie:**
+   ```python
+   from docgenie.generation.pipeline_01.claude_batching import ClaudeBatchedClient
+   ```
+
+4. **Python looks for docgenie:**
+   - Checks sys.path
+   - Finds `/app` (where `pip install -e .` installed it)
+   - Loads `docgenie/__init__.py`
+   - ✓ Import succeeds!
+
+### Handwriting Service Import Chain
+
+1. **FastAPI starts:**
+   ```python
+   uvicorn main:app
+   ```
+
+2. **main.py imports local modules:**
+   ```python
+   from handwriting_service.inference import HandwritingGenerator
+   ```
+
+3. **inference.py imports WordStylist:**
+   ```python
+   sys.path.insert(0, str(Path(__file__).parent.parent / "WordStylist"))
+   from ldm.models.diffusion.ddpm import LatentDiffusion
+   ```
+
+4. **Python loads local modules:**
+   - No external package dependencies
+   - ✓ Completely self-contained!
+
+## 🔍 Verifying Imports
+
+### Test API Imports
+```bash
+# Inside API container
+python3 -c "from docgenie.generation.pipeline_01.claude_batching import ClaudeBatchedClient; print('✓ Import works!')"
+```
+
+### Test Handwriting Imports
+```bash
+# Inside handwriting container
+python3 -c "from handwriting_service.inference import HandwritingGenerator; print('✓ Import works!')"
+```
+
+## 💡 Key Insights
+
+1. **API needs monorepo:** Must deploy entire `docgenie/` folder structure
+2. **Handwriting is independent:** Can deploy just `handwriting_service/` + `WordStylist/`
+3. **Docker layer caching:** Install docgenie package first, then API requirements
+4. **Working directory matters:** Set WORKDIR to /app/api for API service
+5. **Python package installation:** `pip install -e .` makes docgenie importable globally
+
+## 📊 Deployment Size Comparison
+
+| Deployment | Size | Contents |
+|------------|------|----------|
+| API (Railway) | ~2GB | Python 3.11 + docgenie + API deps + Playwright |
+| Worker (Railway) | ~2GB | Same as API (shares image) |
+| Handwriting (RunPod) | ~8GB | CUDA 11.8 + PyTorch + Diffusers + WordStylist |
+
+**Total:** ~12GB (but cached independently)
+
+## ✅ Checklist for Successful Deployment
+
+- [ ] Dockerfile copies **entire monorepo** for API
+- [ ] `pip install -e .` runs before API requirements
+- [ ] WORKDIR set to /app/api for runtime
+- [ ] Handwriting Dockerfile copies only handwriting_service/ + WordStylist/
+- [ ] .dockerignore excludes data/ folders (too large)
+- [ ] Environment variables set in Railway/EC2
+- [ ] Redis URL points to Upstash
+- [ ] HANDWRITING_SERVICE_URL points to RunPod endpoint
+
+## 🎉 Result
+
+```
+✓ API can import from docgenie package
+✓ Worker can use ClaudeBatchedClient
+✓ Handwriting service runs independently
+✓ All services communicate via HTTP
+✓ No more ImportError!
+```

DEPLOYMENT.md

@@ -0,0 +1,875 @@
+# 🚀 DocGenie Deployment Guide
+
+Complete guide for deploying DocGenie API + Handwriting Service to production with all interdependencies resolved.
+
+## 📊 System Architecture
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│                         Client                               │
+└────────────────────┬────────────────────────────────────────┘
+                     │
+                     ▼
+┌─────────────────────────────────────────────────────────────┐
+│                    Railway (CPU)                             │
+│  ┌──────────────────────────────────────────────────────┐   │
+│  │  DocGenie API (Port 8000)                           │   │
+│  │  - FastAPI server                                     │   │
+│  │  - Imports: docgenie.generation.*                     │   │
+│  │  - Endpoints: /generate, /generate/pdf, /generate/async│  │
+│  └──────────────┬───────────────────────────────────────┘   │
+│                 │                                            │
+│  ┌──────────────▼───────────────────────────────────────┐   │
+│  │  Background Worker                                    │   │
+│  │  - RQ worker (Redis Queue)                           │   │
+│  │  - ClaudeBatchedClient (50% cost savings)            │   │
+│  │  - Imports: docgenie.generation.*                     │   │
+│  └──────────────┬───────────────────────────────────────┘   │
+└─────────────────┼────────────────────────────────────────────┘
+                  │
+        ┌─────────┴──────────┬──────────────┐
+        │                    │              │
+        ▼                    ▼              ▼
+┌───────────────┐  ┌──────────────────┐  ┌──────────────┐
+│ Redis (Upstash)│  │ Supabase         │  │ Google Drive │
+│ - Job queue    │  │ - PostgreSQL     │  │ - File storage│
+│ - Free tier    │  │ - Document DB    │  │ - OAuth 2.0  │
+└───────────────┘  └──────────────────┘  └──────────────┘
+        │
+        ▼
+┌─────────────────────────────────────────────────────────────┐
+│             RunPod Serverless (GPU)                          │
+│  ┌──────────────────────────────────────────────────────┐   │
+│  │  Handwriting Service (Port 8080)                     │   │
+│  │  - WordStylist diffusion model                        │   │
+│  │  - PyTorch + CUDA 11.8                                │   │
+│  │  - NO docgenie imports (standalone)                   │   │
+│  └──────────────────────────────────────────────────────┘   │
+└─────────────────────────────────────────────────────────────┘
+```
+
+## 🔗 Dependency Resolution
+
+### ✅ Problem: API imports from docgenie package
+**Solution:** Deploy entire monorepo, install as package with `pip install -e .`
+
+**API Service imports:**
+```python
+# api/worker.py
+from docgenie.generation.pipeline_01.claude_batching import ClaudeBatchedClient
+from docgenie import ENV
+
+# api/utils.py
+from docgenie.generation.constants import BS_PARSER, HANDWRITING_CLASS_NAME
+from docgenie.generation.pipeline_01.claude_batching import create_message
+from docgenie.generation.pipeline_03_process_response import process_response
+from docgenie.generation.pipeline_04_render_pdf_and_extract_geos import render_pdf
+```
+
+**Dockerfile solution:**
+```dockerfile
+# Copy entire monorepo
+COPY . .
+
+# Install as editable package
+RUN pip install -e .
+
+# Install API requirements
+RUN pip install -r api/requirements.txt
+```
+
+### ✅ Handwriting Service is Independent
+**No docgenie imports!** Can be deployed standalone.
+
+```python
+# handwriting_service/main.py - NO docgenie imports
+from handwriting_service.inference import HandwritingGenerator
+from handwriting_service.models import HandwritingRequest
+```
+
+## 📦 Pre-Deployment Checklist
+
+### 1. Environment Variables
+Create `api/.env` with all required variables:
+
+```bash
+# Claude API
+ANTHROPIC_API_KEY=sk-ant-xxxxx
+
+# Redis (will be replaced with Upstash URL)
+REDIS_URL=redis://localhost:6379
+
+# Handwriting Service
+HANDWRITING_SERVICE_URL=http://localhost:8080
+
+# Supabase
+SUPABASE_URL=https://xxxxx.supabase.co
+SUPABASE_KEY=eyJxxxxx
+
+# Google Drive (for token refresh only)
+# The frontend handles OAuth and sends tokens in API requests
+# These credentials are only needed to refresh expired tokens during long jobs
+GOOGLE_CLIENT_ID=xxxxx.apps.googleusercontent.com
+GOOGLE_CLIENT_SECRET=GOCSPX-xxxxx
+GOOGLE_DRIVE_FOLDER_NAME=DocGenie Documents
+```
+
+### 2. Test Locally First
+```bash
+# Terminal 1: Start Redis
+docker run -p 6379:6379 redis:7-alpine
+
+# Terminal 2: Start Handwriting Service
+cd handwriting_service
+DEVICE=cpu uvicorn main:app --port 8080
+
+# Terminal 3: Start API
+cd api
+source ../.venv/bin/activate
+uvicorn main:app --reload --port 8000
+
+# Terminal 4: Start Worker
+cd api
+source ../.venv/bin/activate
+python worker.py
+```
+
+Test endpoints:
+```bash
+# Health check
+curl http://localhost:8000/health
+
+# Async generation (uses batched API)
+curl -X POST http://localhost:8000/generate/async \
+  -H "Content-Type: application/json" \
+  -d '{"template_name": "DocGenie", "num_pages": 2}'
+```
+
+## 🚢 Deployment Steps
+
+### Option A: Railway + RunPod (RECOMMENDED - $10/month)
+
+#### Step 1: Deploy Redis to Upstash (FREE)
+
+1. Go to https://upstash.com
+2. Create account → New Redis Database
+3. Copy the `UPSTASH_REDIS_REST_URL` (looks like: `redis://default:xxxxx@xxxxx.upstash.io:6379`)
+
+#### Step 2: Deploy Handwriting Service to RunPod
+
+**Option A: Build from Git Repository (RECOMMENDED - No Docker Hub needed!)**
+
+This builds directly on RunPod's servers, avoiding the need to upload 10GB over your internet.
+
+1. **Prepare and push code to Git:**
+```bash
+cd /media/ahad-hassan/Volume_E/FYP/FYP/docgenie
+
+# First, prepare optimized WordStylist (removes 432MB of unnecessary files)
+cd handwriting_service
+./prepare_build.sh
+cd ..
+
+# Now commit the optimized WordStylist
+git add handwriting_service/
+git status  # Verify WordStylist is included (should show WordStylist/models/ema_ckpt.pt, etc.)
+git commit -m "Add handwriting service with optimized WordStylist"
+git push origin main
+```
+
+2. **Deploy to RunPod:**
+   - Go to https://runpod.io → Serverless → New Endpoint
+   - Click "Build from Git" (not Docker Image)
+   - Settings:
+     - Name: `docgenie-handwriting`
+     - Git URL: `https://github.com/Ahadhassan-2003/FYP.git`
+     - Git Branch: `main`
+     - Docker Build Context: `docgenie/handwriting_service`
+     - Dockerfile Path: `Dockerfile`
+     - GPU: RTX 4090 or A40
+     - Container Disk: 15GB
+     - Max Workers: 1
+     - Idle Timeout: 5 seconds
+     - Exposed Port: 8080
+   - Environment Variables:
+     ```
+     DEVICE=cuda
+     PYTHONUNBUFFERED=1
+     ```
+   - Build Args (prepare WordStylist):
+     ```
+     PREPARE_WORDSTYLIST=true
+     ```
+   - Click "Deploy"
+
+RunPod will clone your repo and build the image on their fast servers!
+
+**Option B: Pre-built Docker Image (if Git unavailable)**
+
+<details>
+<summary>Click to expand Docker Hub method</summary>
+
+```bash
+cd handwriting_service
+
+# Prepare optimized build (removes 432MB)
+./prepare_build.sh
+
+# Login to Docker Hub
+docker login
+
+# Build image
+docker buildx build --platform linux/amd64 \
+  -t yourusername/docgenie-handwriting:latest \
+  --build-arg BUILDKIT_INLINE_CACHE=1 \
+  .
+
+# Push to Docker Hub (may take 20-30 minutes for 10GB)
+docker push yourusername/docgenie-handwriting:latest
+```
+
+Then deploy on RunPod:
+   - Go to https://runpod.io → Serverless → New Endpoint
+   - Docker Image: `yourusername/docgenie-handwriting:latest`
+   - GPU: RTX 4090 or A40
+   - Port: 8080
+   - Environment Variables: `DEVICE=cuda`
+
+</details>
+docker push ahadhassan/docgenie-handwriting:v2
+3. **Get endpoint URL:**
+   - Copy the URL (looks like: `https://api.runpod.ai/v2/xxxxx/runsync`)
+   - This is your `HANDWRITING_SERVICE_URL`
+
+#### Step 3: Deploy API to Railway
+
+1. **Install Railway CLI:**
+```bash
+# Install Railway CLI
+npm i -g @railway/cli
+
+# Or use curl
+bash <(curl -fsSL cli.new) railway
+```
+
+2. **Initialize Railway project:**
+```bash
+cd /media/ahad-hassan/Volume_E/FYP/FYP/docgenie
+
+# Login to Railway
+railway login
+
+# Create new project
+railway init
+
+# Link to project (creates railway.json)
+railway link
+```
+
+3. **Set environment variables:**
+```bash
+# Set all environment variables from api/.env
+railway variables set ANTHROPIC_API_KEY=sk-ant-xxxxx
+railway variables set REDIS_URL=redis://default:xxxxx@xxxxx.upstash.io:6379
+railway variables set HANDWRITING_SERVICE_URL=https://api.runpod.ai/v2/xxxxx/runsync
+railway variables set SUPABASE_URL=https://xxxxx.supabase.co
+railway variables set SUPABASE_KEY=eyJxxxxx
+
+# Google OAuth (for token refresh only - frontend provides tokens in requests)
+railway variables set GOOGLE_CLIENT_ID=xxxxx.apps.googleusercontent.com
+railway variables set GOOGLE_CLIENT_SECRET=GOCSPX-xxxxx
+railway variables set GOOGLE_DRIVE_FOLDER_NAME="DocGenie Documents"
+```
+
+**Note:** Google access/refresh tokens are NOT environment variables! The frontend authenticates with Google OAuth, then passes `google_drive_token` and `google_drive_refresh_token` in the API request body. See [API request schema](api/schemas.py#L108-L114).
+
+4. **Deploy API + Worker:**
+```bash
+# Railway will detect Dockerfile and deploy automatically
+railway up
+
+# Or connect to GitHub and deploy from there
+railway connect
+```
+
+5. **Option 1: Separate Worker Service (For Production Scale):**
+   
+   *Note: Only needed if processing 50+ concurrent jobs. For most use cases, Option 2 (combined) is sufficient.*
+   
+   **Method A: Connect to Same GitHub Repo (Recommended)**
+   - Go to Railway dashboard → Your project → **New Service**
+   - Click **"GitHub Repo"** → Select your repo
+   - Name: `docgenie-worker`
+   - **Settings** → **Deploy**:
+     - Builder: `DOCKERFILE`
+     - Dockerfile Path: `Dockerfile`
+     - Root Directory: `/` (same as API)
+     - **Custom Start Command**:
+       ```bash
+       rq worker --url $REDIS_URL
+       ```
+   - **Variables**: Add all environment variables (same as API service)
+   - **Deploy**
+   
+   **Method B: Use Same Docker Image as API**
+   - Railway dashboard → New Service → **Empty Service**
+   - Name: `docgenie-worker`
+   - **Settings** → **Source**: Link to API service's image
+   - **Custom Start Command**: `rq worker --url $REDIS_URL`
+   - **Variables**: Copy from API service
+   - **Deploy**
+
+6. **Option 2: Combined API + Worker (Recommended for Getting Started):**
+   
+   Update `railway.json` to run both in one service:
+   ```json
+   {
+     "deploy": {
+       "startCommand": "uvicorn api.main:app --host 0.0.0.0 --port $PORT & rq worker --url $REDIS_URL & wait"
+     }
+   }
+   ```
+   
+   Then push:
+   ```bash
+   git add railway.json
+   git commit -m "feat: Run API and worker in combined service"
+   git push
+   ```
+   
+   **Benefits:**
+   - ✅ Single service ($5/month instead of $10/month)
+   - ✅ Simpler logs and monitoring
+   - ✅ Automatic scaling together
+   - ✅ Good for 90% of use cases
+
+7. **Get API URL:**
+   - Railway dashboard → API service → Settings → Domains
+   - Generate domain (e.g., `docgenie-api.up.railway.app`)
+
+#### Step 4: Update Frontend
+
+Update your frontend API URL to Railway domain:
+```javascript
+const API_URL = 'https://docgenie-api.up.railway.app';
+```
+
+### Option B: AWS EC2 + RunPod (For Production)
+
+#### Prerequisites
+- AWS account with EC2 access
+- Domain name (optional, for SSL)
+
+#### Step 1: Launch EC2 Instance
+
+```bash
+# Launch t3.medium instance
+aws ec2 run-instances \
+  --image-id ami-0c55b159cbfafe1f0 \
+  --instance-type t3.medium \
+  --key-name your-key-pair \
+  --security-group-ids sg-xxxxx \
+  --subnet-id subnet-xxxxx
+```
+
+**Security Group Rules:**
+- Port 22 (SSH) - Your IP only
+- Port 80 (HTTP) - 0.0.0.0/0
+- Port 443 (HTTPS) - 0.0.0.0/0
+- Port 8000 (API) - 0.0.0.0/0
+
+#### Step 2: Setup EC2
+
+```bash
+# SSH into instance
+ssh -i your-key.pem ubuntu@your-ec2-ip
+
+# Update system
+sudo apt update && sudo apt upgrade -y
+
+# Install Docker
+curl -fsSL https://get.docker.com -o get-docker.sh
+sudo sh get-docker.sh
+sudo usermod -aG docker ubuntu
+
+# Install Docker Compose
+sudo apt install docker-compose-plugin -y
+
+# Install Git
+sudo apt install git -y
+
+# Clone repository
+git clone https://gitlab.cs.hs-rm.de/diss_lamott/docgenie.git
+cd docgenie
+```
+
+#### Step 3: Configure Environment
+
+```bash
+# Create .env file
+cd api
+nano .env
+
+# Paste all environment variables
+# Save: Ctrl+X, Y, Enter
+
+# Update REDIS_URL to use Upstash
+# Update HANDWRITING_SERVICE_URL to RunPod endpoint
+```
+
+#### Step 4: Deploy with Docker Compose
+
+```bash
+cd /home/ubuntu/docgenie
+
+# Start services (API + Worker + Redis)
+docker-compose up -d api worker redis
+
+# Check logs
+docker-compose logs -f api
+docker-compose logs -f worker
+```
+
+#### Step 5: Setup Nginx Reverse Proxy
+
+```bash
+# Install Nginx
+sudo apt install nginx -y
+
+# Create config
+sudo nano /etc/nginx/sites-available/docgenie
+
+# Paste configuration:
+```
+
+```nginx
+server {
+    listen 80;
+    server_name your-domain.com;  # Or use EC2 IP
+
+    location / {
+        proxy_pass http://localhost:8000;
+        proxy_http_version 1.1;
+        proxy_set_header Upgrade $http_upgrade;
+        proxy_set_header Connection 'upgrade';
+        proxy_set_header Host $host;
+        proxy_cache_bypass $http_upgrade;
+        proxy_set_header X-Real-IP $remote_addr;
+        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+        proxy_set_header X-Forwarded-Proto $scheme;
+        
+        # Increase timeout for long-running requests
+        proxy_read_timeout 300s;
+        proxy_connect_timeout 75s;
+    }
+}
+```
+
+```bash
+# Enable site
+sudo ln -s /etc/nginx/sites-available/docgenie /etc/nginx/sites-enabled/
+sudo nginx -t
+sudo systemctl restart nginx
+
+# Optional: Setup SSL with Let's Encrypt
+sudo apt install certbot python3-certbot-nginx -y
+sudo certbot --nginx -d your-domain.com
+```
+
+#### Step 6: Setup Systemd Service (Auto-restart)
+
+```bash
+# Create service file
+sudo nano /etc/systemd/system/docgenie.service
+```
+
+```ini
+[Unit]
+Description=DocGenie API
+After=docker.service
+Requires=docker.service
+
+[Service]
+Type=oneshot
+RemainAfterExit=yes
+WorkingDirectory=/home/ubuntu/docgenie
+ExecStart=/usr/bin/docker-compose up -d api worker redis
+ExecStop=/usr/bin/docker-compose down
+User=ubuntu
+
+[Install]
+WantedBy=multi-user.target
+```
+
+```bash
+# Enable service
+sudo systemctl daemon-reload
+sudo systemctl enable docgenie
+sudo systemctl start docgenie
+
+# Check status
+sudo systemctl status docgenie
+```
+
+## 🧪 Testing Production Deployment
+
+### 1. Health Check
+```bash
+curl https://your-domain.com/health
+```
+
+### 2. Sync Generation (Fast)
+```bash
+curl -X POST https://your-domain.com/generate \
+  -H "Content-Type: application/json" \
+  -d '{
+    "template_name": "DocGenie",
+    "num_pages": 1
+  }'
+```
+
+### 3. Async Generation (Batched, Cheap)
+```bash
+# Start async job
+RESPONSE=$(curl -X POST https://your-domain.com/generate/async \
+  -H "Content-Type: application/json" \
+  -d '{
+    "template_name": "DocGenie",
+    "num_pages": 2
+  }')
+
+REQUEST_ID=$(echo $RESPONSE | jq -r '.request_id')
+echo "Request ID: $REQUEST_ID"
+
+# Poll status
+while true; do
+  STATUS=$(curl -s https://your-domain.com/jobs/$REQUEST_ID/status | jq -r '.status')
+  echo "Status: $STATUS"
+  if [ "$STATUS" = "completed" ] || [ "$STATUS" = "failed" ]; then
+    break
+  fi
+  sleep 10
+done
+
+# Get result
+curl https://your-domain.com/jobs/$REQUEST_ID/status | jq
+```
+
+## 📊 Cost Breakdown
+
+### Railway + RunPod (Recommended)
+| Service | Cost | Notes |
+|---------|------|-------|
+| Railway (API + Worker) | $5-10/month | Includes 500 hours |
+| Upstash Redis | FREE | 10K requests/day |
+| RunPod Serverless GPU | $0.20/hr | Only charged when active |
+| Supabase | FREE | 500MB database |
+| **Total** | **~$10-15/month** | + $0.20/hr GPU usage |
+
+### EC2 + RunPod
+| Service | Cost | Notes |
+|---------|------|-------|
+| EC2 t3.medium | $30/month | 2 vCPU, 4GB RAM |
+| Upstash Redis | FREE | External Redis |
+| RunPod Serverless GPU | $0.20/hr | Only when needed |
+| Supabase | FREE | External DB |
+| **Total** | **~$30/month** | + $0.20/hr GPU usage |
+
+### EC2 + Dedicated GPU (Production)
+| Service | Cost | Notes |
+|---------|------|-------|
+| EC2 g4dn.xlarge | $150/month | 4 vCPU, 16GB RAM, T4 GPU |
+| Supabase | FREE | External DB |
+| **Total** | **~$150/month** | All-in-one solution |
+
+## 🔧 Maintenance
+
+### Update Deployment
+
+**Railway:**
+```bash
+# Push to main branch (auto-deploy)
+git push origin main
+
+# Or manual deploy
+railway up
+```
+
+**EC2:**
+```bash
+ssh ubuntu@your-ec2-ip
+cd docgenie
+git pull
+docker-compose down
+docker-compose up -d --build
+```
+
+### View Logs
+
+**Railway:**
+```bash
+railway logs
+```
+
+**EC2:**
+```bash
+# API logs
+docker-compose logs -f api
+
+# Worker logs
+docker-compose logs -f worker
+
+# Nginx logs
+sudo tail -f /var/log/nginx/access.log
+sudo tail -f /var/log/nginx/error.log
+```
+
+### Monitor Redis Queue
+
+```bash
+# Connect to Redis
+redis-cli -u $REDIS_URL
+
+# Check queue status
+> LLEN rq:queue:default
+> LRANGE rq:queue:default 0 -1
+```
+
+## 🚨 Troubleshooting
+
+### Issue: Worker can't import docgenie package
+**Solution:** Dockerfile installs entire monorepo with `pip install -e .`
+
+### Issue: Handwriting service connection timeout
+**Solution:** Use RunPod's `/runsync` endpoint, not `/run` (synchronous)
+
+### Issue: Google token expired during job
+**Solution:** Ensure `GOOGLE_REFRESH_TOKEN`, `GOOGLE_CLIENT_ID`, `GOOGLE_CLIENT_SECRET` are set
+
+### Issue: Railway build fails (too large)
+**Solution:** Check `.dockerignore` excludes `data/` folders
+
+### Issue: Worker heartbeat timeout
+**Solution:** Job is still running, batched API takes 10-30 minutes
+
+## 📚 Next Steps
+
+1. **Monitor costs:** Railway dashboard, RunPod usage page
+2. **Setup alerts:** Railway → Settings → Notifications
+3. **Scale workers:** Railway → Worker service → Settings → Replicas
+4. **Add caching:** Redis cache for generated documents
+5. **Setup CI/CD:** GitHub Actions → Railway auto-deploy
+
+## 🎉 You're Done!
+
+Your DocGenie API is now deployed with:
+- ✅ All docgenie package imports resolved
+- ✅ GPU handwriting service on RunPod
+- ✅ Background workers for batched API
+- ✅ Auto-scaling and cost optimization
+- ✅ Google token refresh working
+- ✅ Database schema compatibility
+
+**API URL:** `https://your-domain.com`  
+**Docs:** `https://your-domain.com/docs`  
+**Health:** `https://your-domain.com/health`
+
+---
+
+## 🖥️ Local Testing Guide
+
+### Architecture
+
+```
+┌─────────────────────────────────┐
+│   DocGenie API (Port 8000)      │──┐ HTTP
+└─────────────────────────────────┘  │ localhost:8080
+                                     ▼
+┌─────────────────────────────────┐
+│ Handwriting Service (Port 8080) │
+│ - Loads WordStylist model       │
+└─────────────────────────────────┘
+```
+
+### Prerequisites
+
+1. **Python environment**: `source .venv/bin/activate`
+2. **WordStylist Model** at `WordStylist/models/ckpt.pt` and `ema_ckpt.pt`
+3. **`api/.env`** with `ANTHROPIC_API_KEY`, `HANDWRITING_SERVICE_ENABLED=true`, `HANDWRITING_SERVICE_URL=http://localhost:8080`
+
+### Step-by-Step Setup
+
+**Terminal 1 – Handwriting Service:**
+```bash
+cd handwriting_service
+DEVICE=cpu ./start.sh          # CPU (no GPU required)
+# DEVICE=cuda ./start.sh       # GPU (faster)
+```
+
+**Terminal 2 – DocGenie API:**
+```bash
+cd api
+uvicorn main:app --reload
+```
+
+**Terminal 3 – Test:**
+```bash
+curl http://localhost:8080/health   # Handwriting service
+curl http://localhost:8000/health   # API
+cd api && python test_api.py
+```
+
+### Performance Notes
+- CPU mode: ~5–10 s/word | GPU mode: ~0.5–1 s/word
+- Service processes all words in one batch for efficiency
+
+---
+
+## ⚙️ Railway-Specific Configuration
+
+### Critical Issues & Fixes
+
+**1. `.dockerignore` – Keep required data folders:**
+```
+!data/prompt_templates/
+!data/visual_element_prefabs/
+```
+
+**2. `railway.json` – Start both API and worker:**
+```json
+"startCommand": "cd api && uvicorn main:app --host 0.0.0.0 --port $PORT & rq worker --url $REDIS_URL & wait"
+```
+
+### Environment Variables
+
+#### 🔴 Required
+```bash
+ANTHROPIC_API_KEY=sk-ant-api03-xxx
+REDIS_URL=rediss://default:xxx@xxx.upstash.io:6379
+HANDWRITING_SERVICE_URL=https://api.runpod.ai/v2/ht9ajgrduitgpr/runsync
+HANDWRITING_SERVICE_ENABLED=true
+SUPABASE_URL=https://xxx.supabase.co
+SUPABASE_KEY=xxx
+GOOGLE_CLIENT_ID=xxx.apps.googleusercontent.com
+GOOGLE_CLIENT_SECRET=xxx
+```
+
+#### 🟡 Recommended
+```bash
+RUNPOD_API_KEY=xxx
+OCR_SERVICE_ENABLED=true
+OCR_USE_LOCAL=true
+OCR_ENGINE=microsoft_di
+OCR_DPI=300
+HANDWRITING_SERVICE_TIMEOUT=300
+HANDWRITING_SERVICE_MAX_RETRIES=3
+RQ_QUEUE_NAME=docgenie
+LOG_LEVEL=INFO
+```
+
+#### 🟢 Optional (defaults are fine)
+```bash
+API_HOST=0.0.0.0
+API_PORT=8000
+DEBUG_MODE=false
+CLAUDE_MODEL=claude-sonnet-4-5-20250929
+CORS_ORIGINS=*
+GOOGLE_DRIVE_FOLDER_NAME=DocGenie Documents
+TEMP_DIR=/tmp/docgenie_api
+HANDWRITING_APPLY_BLUR=false
+BBOX_NORMALIZATION_ENABLED=false
+GT_VERIFICATION_ENABLED=false
+ANALYSIS_ENABLED=false
+DEBUG_VISUALIZATION_ENABLED=false
+```
+
+### Validation Steps
+
+```bash
+# 1. Health check
+curl https://your-app.up.railway.app/health
+
+# 2. Sync generation
+curl -X POST https://your-app.up.railway.app/api/generate \
+  -H "Content-Type: application/json" \
+  -d '{"document_category": "invoice", "pages": 1}'
+
+# 3. Async generation
+curl -X POST https://your-app.up.railway.app/api/async/generate \
+  -H "Content-Type: application/json" \
+  -d '{"document_category": "invoice", "pages": 1, "google_access_token": "ya29.xxx"}'
+```
+
+### Common Railway Issues
+
+| Issue | Cause | Solution |
+|-------|-------|----------|
+| Worker not starting | Missing `rq worker` in start command | Check `railway.json` `startCommand` |
+| Missing prompt templates | `.dockerignore` too aggressive | Add `!data/prompt_templates/` |
+| Playwright errors | Browser not installed | Ensure `playwright install chromium` in Dockerfile |
+| Redis connection errors | Wrong `REDIS_URL` | Verify in Railway env variables |
+| Handwriting timeout | Batch too large | Increase `HANDWRITING_SERVICE_TIMEOUT` |
+| Large Docker image | `data/` folders included | Check `.dockerignore` excludes datasets/embeddings |
+
+---
+
+## ⚡ RunPod Batch Optimization
+
+### Problem (Old Parallel Processing)
+Each text was sent as a separate RunPod request → N texts = N workers = N× activation cost.
+
+**Example:** 10 texts → 10 workers × 18 s = 180 worker-seconds + 10× activation fees
+
+### Solution (New Batch Processing)
+All texts sent in **one** RunPod request → 1 worker handles everything.
+
+**Example:** 10 texts → 1 worker × 190 s = 190 worker-seconds + 1× activation fee  
+**Savings: ~45–60% cost reduction** (activation fees dominate RunPod pricing)
+
+### Batch Request Format (handler.py)
+
+```json
+{
+  "input": {
+    "texts": [
+      {"text": "Hello", "author_id": 42, "hw_id": "hw_0"},
+      {"text": "World", "author_id": 42, "hw_id": "hw_1"}
+    ],
+    "apply_blur": true
+  }
+}
+```
+
+**Response:**
+```json
+{
+  "status": "COMPLETED",
+  "output": {
+    "images": [
+      {"image_base64": "...", "width": 217, "height": 61, "text": "Hello", "author_id": 42, "hw_id": "hw_0"},
+      {"image_base64": "...", "width": 195, "height": 58, "text": "World", "author_id": 42, "hw_id": "hw_1"}
+    ],
+    "total_generated": 2
+  }
+}
+```
+
+> **Note:** Backward-compatible – single text requests (old format) are still supported. Handler auto-detects batch vs single based on the `"texts"` key.
+
+### Timeout Configuration
+Timeout is dynamically calculated: `num_texts × 20 + 30` seconds.  
+For large batches (20+ texts), set RunPod endpoint max execution time to 600 s.
+
+### Cost Comparison
+
+| Scenario | OLD (parallel) | NEW (batched) | Savings |
+|----------|---------------|---------------|---------|
+| 2 texts  | 2 workers × 18 s | 1 worker × 38 s | ~50% |
+| 10 texts | 10 workers × 18 s | 1 worker × 190 s | ~55% |
+| 25 texts | 25 workers × 18 s | 1 worker × 480 s | ~60% |
+
+### Integration Test
+```bash
+cd api
+python test_runpod_integration.py
+```

Dockerfile

@@ -0,0 +1,96 @@
+# ============================================
+# DocGenie API + Worker - Dockerfile (Minimal)
+# ============================================
+# Adapted for Hugging Face Spaces (Docker SDK):
+#   - Non-root user (UID 1000) — HF Spaces requirement
+#   - Port 7860                — HF Spaces default
+#   - Playwright browsers in user-owned path
+
+FROM python:3.11-slim
+
+WORKDIR /app
+
+# Install runtime system dependencies
+RUN apt-get update && apt-get install -y \
+    wget \
+    gnupg \
+    poppler-utils \
+    tesseract-ocr \
+    tesseract-ocr-eng \
+    libglib2.0-0 \
+    libnss3 \
+    libnspr4 \
+    libdbus-1-3 \
+    libatk1.0-0 \
+    libatk-bridge2.0-0 \
+    libcups2 \
+    libdrm2 \
+    libxkbcommon0 \
+    libxcomposite1 \
+    libxdamage1 \
+    libxfixes3 \
+    libxrandr2 \
+    libgbm1 \
+    libasound2 \
+    libpango-1.0-0 \
+    libcairo2 \
+    && rm -rf /var/lib/apt/lists/*
+
+# Install pip packages (no uv needed - simpler)
+COPY api/requirements.txt ./api/requirements.txt
+RUN pip install --no-cache-dir -r api/requirements.txt
+
+# Copy ONLY the docgenie modules needed by API (not the full package)
+COPY docgenie/__init__.py ./docgenie/__init__.py
+COPY docgenie/logging.py ./docgenie/logging.py
+COPY docgenie/generation ./docgenie/generation
+COPY data/prompt_templates ./data/prompt_templates
+COPY data/visual_element_prefabs ./data/visual_element_prefabs
+
+# Copy API code
+COPY api ./api
+
+# Copy startup script
+COPY start.sh ./start.sh
+RUN chmod +x start.sh
+
+# Clean up Python cache
+RUN find /usr/local/lib/python3.11/site-packages -type d -name "__pycache__" -exec rm -rf {} + 2>/dev/null || true && \
+    find /usr/local/lib/python3.11/site-packages -name "*.pyc" -delete
+
+# -------------------------------------------------------
+# Non-root user setup — required by Hugging Face Spaces
+# -------------------------------------------------------
+RUN useradd -m -u 1000 user
+
+# Install Playwright system dependencies as root (requires apt — must run before USER switch)
+RUN playwright install-deps chromium
+
+# Create writable directories and hand ownership to user
+RUN mkdir -p /tmp/docgenie /home/user/.cache/playwright && \
+    chown -R user:user /app /tmp/docgenie /home/user
+
+# Switch to non-root user for all runtime operations
+USER user
+
+# Set environment variables
+ENV HOME=/home/user \
+    PATH=/home/user/.local/bin:$PATH \
+    PYTHONUNBUFFERED=1 \
+    PYTHONPATH=/app \
+    PORT=7860 \
+    PLAYWRIGHT_BROWSERS_PATH=/home/user/.cache/playwright
+
+# Download Playwright Chromium browser binary into user-owned cache directory
+# (browser download only — system deps already installed above as root)
+RUN playwright install chromium
+
+# Expose port 7860 (Hugging Face Spaces default)
+EXPOSE 7860
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=10s --start-period=40s --retries=3 \
+    CMD python -c "import requests; requests.get('http://localhost:7860/health')"
+
+# Start command — shell script handles API + RQ worker
+CMD ["./start.sh"]

LLM_PROJECT_CONTEXT_NOTE.md

@@ -0,0 +1,254 @@
+# DocGenie Project Context Note (LLM Ready)
+
+## 1) Executive Summary
+DocGenie is an AI-driven synthetic document generation platform designed to create realistic, annotated datasets for document intelligence tasks.
+
+The project combines:
+- LLM-based document content and layout generation
+- PDF rendering and geometric extraction
+- Optional handwriting synthesis (diffusion model)
+- Optional visual element insertion (logos, stamps, barcodes, charts, photos)
+- OCR extraction and bbox normalization
+- Ground-truth preparation for downstream machine learning
+- API-first and async batch workflows for production-scale generation
+
+The core idea is to transform a small set of real seed document images plus high-level generation parameters into large, diverse, reproducible synthetic datasets suitable for training and evaluation.
+
+## 2) Problem Statement
+Real document datasets are expensive and slow to collect, often constrained by privacy, class imbalance, and weak annotation quality. This limits model quality for tasks like DocVQA, KIE, and layout understanding.
+
+Key challenges:
+- Lack of large high-quality labeled datasets
+- Domain mismatch between training and production documents
+- Manual labeling cost and inconsistency
+- Need for handwriting and visual artifacts in realistic layouts
+- Need for reproducibility and controllable data generation
+
+## 3) Proposed Solution
+DocGenie proposes a modular synthetic dataset engine with controllable realism.
+
+High-level solution flow:
+1. Select and ingest seed images that represent target document style.
+2. Use LLM prompting (vision + text) to generate HTML/CSS-based document variants and structured GT.
+3. Render HTML to PDF and extract text geometry/bboxes.
+4. Optionally replace selected text with generated handwriting.
+5. Optionally insert visual elements (stamp/logo/barcode/photo/figure).
+6. Produce final PDFs/images + OCR + normalized bboxes + verified GT + export packages.
+
+Design principles:
+- Stage-wise pipeline (clear inputs/outputs per stage)
+- Reproducibility via seeds
+- Production-ready API endpoints
+- Async job orchestration for large runs
+- Separation of CPU API workloads and GPU handwriting inference workloads
+
+## 4) Project Goals
+Primary goals:
+- Generate realistic synthetic documents at scale
+- Support multiple document AI tasks with rich annotation
+- Provide configurable realism controls (handwriting ratio, visual element types, OCR toggles)
+- Minimize generation cost with batched LLM calls
+- Enable operational deployment with monitoring and async processing
+
+Secondary goals:
+- Improve dataset diversity through seed and prompt strategies
+- Support rapid experimentation for model development
+- Keep architecture modular for independent upgrades
+
+## 5) Core Capabilities
+- Seed-image-guided generation (1-8 images per request)
+- Configurable document language/type and GT format
+- Multi-output generation per seed set (num_solutions)
+- Handwriting synthesis with writer-style consistency
+- Visual element synthesis and insertion
+- OCR extraction from final rendered artifacts
+- Normalized bbox outputs for ML pipelines
+- Optional dataset packaging/export (for training pipelines)
+- Async batch generation with status polling and result retrieval
+
+## 6) 19-Stage Pipeline (Conceptual)
+DocGenie follows a full multi-stage pipeline:
+1. Seed selection/download
+2. Prompt LLM
+3. Process LLM response and extract HTML/GT
+4. Render PDF and extract geometries
+5. Extract text bboxes
+6. Validate generated artifacts
+7. Extract handwriting region definitions
+8. Extract visual element definitions
+9. Generate handwriting images
+10. Generate visual element images
+11. Re-render PDF (without placeholders where required)
+12. Insert handwriting overlays
+13. Insert visual overlays
+14. Render document images
+15. Run OCR
+16. Normalize bboxes
+17. Prepare/verify GT
+18. Analyze run statistics
+19. Create debug/export outputs
+
+Important detail:
+- Browser geometries are often in 96 DPI and PDF geometry in 72 DPI, requiring coordinate transforms.
+- Handwriting insertion requires text-to-bbox matching and deduplication logic.
+
+## 7) API Product Surface
+Main API behavior is centered around three use patterns:
+
+1) Synchronous generation endpoint
+- Returns generated documents and metadata directly in response.
+- Suitable for development and debugging.
+
+2) Synchronous PDF/ZIP artifact endpoint
+- Returns packaged artifacts (PDF, metadata, optional assets) in downloadable form.
+- Suitable for practical batch outputs.
+
+3) Asynchronous batch endpoint
+- Queues long-running generation jobs.
+- Returns request/task id.
+- Client polls status endpoint.
+- Client fetches/downloads final output when completed.
+- Best for production and larger workloads.
+
+Typical request dimensions:
+- seed_images: list of remote URLs
+- prompt_params: language, doc type, GT settings, feature toggles, reproducibility seed
+
+## 8) System Architecture
+Monorepo-style architecture with independent service boundaries:
+
+A) Core package
+- Shared generation logic and pipeline stages.
+
+B) API service (CPU)
+- FastAPI interface
+- Orchestrates generation pipeline
+- Manages async queue and external integrations
+
+C) Background worker (CPU)
+- Executes queued async jobs
+- Handles long-running generation and packaging workflows
+
+D) Handwriting service (GPU)
+- Separate service for diffusion-based handwriting generation
+- Designed to be deployable independently
+
+E) Data stores and platform services
+- Queue broker (Redis)
+- Metadata storage (database)
+- File delivery/storage integration
+
+Architecture intent:
+- Keep API orchestration scalable and light
+- Offload expensive handwriting generation to GPU service
+- Enable independent deployment and scaling per component
+
+## 9) Handwriting Subsystem
+Handwriting generation is treated as a specialized capability:
+- Uses diffusion-style generation with writer IDs/styles
+- Supports per-word token generation and mapping
+- Supports post-processing (blur, anti-aliasing, cropping)
+- Designed for realism and style consistency within a document
+
+Operational notes:
+- Batch handling is optimized for service cost and startup overhead
+- Some model/sampling settings are constrained by the underlying handwriting model implementation
+
+## 10) Visual Element Subsystem
+Visual elements include artifacts commonly found in real documents:
+- logos
+- stamps
+- barcodes
+- photos
+- figures/charts
+
+Key behavior:
+- Placeholder-based extraction from generated HTML/geometries
+- Type normalization and filtering by request settings
+- Coordinate-aware insertion into final PDF/image artifacts
+
+## 11) Data and Output Contracts
+The project outputs ML-ready artifacts with rich metadata:
+
+Typical outputs:
+- Generated HTML/CSS
+- Intermediate and final PDFs
+- Rasterized page images
+- Word/segment/layout bboxes
+- Normalized coordinate variants
+- Handwriting images and maps
+- Visual element images and maps
+- Ground-truth objects (task dependent)
+- Optional packaged export for training pipelines
+
+This enables direct use for training/evaluation datasets, debugging, and pipeline QA.
+
+## 12) Deployment Strategy (Current Direction)
+Recommended deployment split:
+- API + worker on CPU-friendly platform
+- Handwriting service on GPU-capable platform
+- Redis and database as managed services
+
+Why this split works:
+- Different resource profiles (CPU orchestration vs GPU inference)
+- Independent scaling and cost control
+- Service isolation improves reliability and debugging
+
+## 13) Testing and Quality Strategy
+Project testing plan emphasizes:
+- Unit tests per critical stage function
+- Integration tests for service boundaries (LLM, handwriting service, queue)
+- System tests for end-to-end generation
+- Non-functional tests: performance, reliability, scalability, security
+
+Key risk areas tested heavily:
+- External API failures/retries
+- Geometry and bbox alignment
+- Async job state transitions
+- Handwriting/visual overlay correctness
+
+## 14) Known Constraints and Practical Considerations
+- Quality depends on seed representativeness and prompt quality.
+- External service availability (LLM providers, handwriting endpoint) impacts runtime reliability.
+- Coordinate conversion and matching edge cases can affect overlay precision.
+- Large batch jobs require async orchestration and observability.
+- Some advanced generation realism features may still be iterative/improving.
+
+## 15) Why This Project Matters
+DocGenie addresses a real bottleneck in document AI: obtaining large, diverse, high-quality labeled training data.
+
+It provides a controllable synthetic data engine that can:
+- accelerate experimentation
+- reduce dependence on private data access
+- improve model robustness through diversity and controlled perturbations
+- support multiple document AI tasks in one platform
+
+## 16) Suggested Prompt Context for Future LLM Tasks
+Use the following when asking an LLM to help with this codebase:
+
+Project summary:
+I am working on DocGenie, a synthetic document generation platform with a 19-stage pipeline. It uses LLM-generated HTML/CSS from seed images, renders to PDF, extracts bboxes/geometries, optionally inserts diffusion-generated handwriting and visual elements, runs OCR, normalizes bboxes, verifies GT, and exports ML-ready artifacts. The system has a FastAPI service, async worker, and separate GPU handwriting service.
+
+Primary objective:
+Improve reliability, generation quality, and production scalability of synthetic dataset generation for DocVQA/KIE/layout tasks.
+
+Technical priorities:
+- API and worker robustness
+- bbox/geometry correctness
+- handwriting and visual insertion accuracy
+- async job reliability and observability
+- deployment and cost optimization
+
+Constraints:
+- External dependencies (LLM APIs, managed queue/db, GPU service)
+- need reproducibility through seeded runs
+- preserve compatibility of output metadata for downstream ML pipelines
+
+When proposing changes:
+- Keep stage boundaries clear
+- Avoid breaking output contracts
+- Include failure handling and retries
+- Prefer measurable improvements (latency, cost, quality, reliability)
+
+## 17) Fast Context Snapshot (Short Version)
+DocGenie is an API-first synthetic document dataset generator for document AI. It takes seed images and generation settings, uses an LLM to generate document HTML/GT, renders PDFs, extracts geometry, optionally adds handwriting and visual artifacts, runs OCR, normalizes annotations, and returns/exports ML-ready data. It is built as a modular 19-stage pipeline with async job processing and a separate GPU handwriting service for scalable production usage.

README.md

@@ -0,0 +1,454 @@
+---
+title: DocGenie API
+emoji: 📄
+colorFrom: blue
+colorTo: indigo
+sdk: docker
+app_port: 7860
+pinned: false
+---
+
+# DocGenie
+
+## Project structure
+The source code under /docgenie is split into three parts:
+- **generation**: Code responsible for synthesizing datasets.
+- **evaluation**: Code responsible for training models on original/synthetic data and evaluating them. Also contains code to load these datasets.
+- **analyzation**: Code responsible for analyting original/synthetic data, e.g. clustering, LayoutFID scores etc.
+
+## Setting up project dependencies
+Install uv astral (https://docs.astral.sh/uv/getting-started/installation/)
+```
+curl -LsSf https://astral.sh/uv/install.sh | sh
+```
+
+Install dependencies (set uv cache dir to appropriate dir in your data folder as default home cache dir has limited space):
+```
+uv sync --cache-dir /data/proj/$USER/.cache/uv/
+``` 
+
+Source the uv environment
+```
+source .venv/bin/active
+```
+
+Or, directly run commands with uv run
+```
+uv run python /path/to/script
+```
+
+## Setting up dependencies for generation pipeline
+Install playwright chromium by running
+```
+playwright install chromium
+```
+
+and also download chromium for PDF conversion:
+```
+wget -O chrome.zip "https://download-chromium.appspot.com/dl/Linux_x64?type=snapshots"
+unzip chrome.zip
+```
+
+Add Chromium to your PATH
+```
+echo "export PATH=\"$(pwd)/chrome-linux:\$PATH\"" >> ~/.bashrc
+```
+
+Reload your shell
+```
+source ~/.bashrc
+```
+
+Verify installation
+```
+chrome --version
+```
+
+# Synthetization Pipeline
+- Set the env variable ANTHROPIC_API_KEY with your Anthropic API Key
+- Create a new syn dataset definition file in data/syn_dataset_definitions. For a template refer to docvqa-test.yaml
+- Execute 'docgenie/generation/main.py SynDsDefFname' where SynDsDefFname is the filename of the syn dataset definition without extension
+- Data will be stored in 'data/datasets/SynDsName' where SynDsName is field 'name' in the syn dataset definition.
+- Final PDFs will be stored in subdirectory pdf_final
+  - Handwriting synthesis is currently not implemented, so the final PDFs will be missing text. To see the PDF with the text which has to be replaced by handwriting see PDFs in sub directory pdf_pass1
+  - Visual element insertion is currently not implemented
+
+# DocVQA Handwriting Generation
+
+A toolkit for generating synthetic handwriting images for document visual question answering (DocVQA) tasks. This project provides scripts to generate, process, and enhance handwritten text overlays on documents using either font-based rendering or diffusion-based deep learning models.
+
+## Overview
+
+This repository contains tools to:
+- Generate synthetic handwriting from bounding box specifications
+- Apply post-processing effects (blur, antialiasing) for realistic rendering
+- Support multiple generation backends (font-based, diffusion model)
+- Handle word segmentation and concatenation for long words
+- Maintain consistent author styles across documents
+
+## Project Structure
+
+```
+docvqa_handwriting_generation/
+├── model/                      # Model architecture and training utilities
+│   ├── text_encoder.py
+│   ├── tokenizer.py
+│   ├── train_hugging.py
+│   └── experiments/
+│       └── hf_conditional_latent/
+│           ├── config.yaml
+│           ├── writer_id_map.json
+│           ├── checkpoints/
+│           └── cached_vae/
+├── scripts/                    # Generation and evaluation scripts
+│   ├── generate_handwriting_diffusion_raw.py
+│   ├── generate_handwriting_resized.py
+│   ├── generate_writer_style_eval.py
+│   └── add_handwriting_blur.py
+└── requirements.txt
+```
+## Directory Structure for Hnadwritten Text Images
+
+```
+data/
+├── datasets/                    
+│   ├── synthesized_datasets/  
+│   ├───── DocVQA-XYZ-Dataset/        
+│   │──────── handwriting_raw_tokens/     # Directory containing folders for each doc which inturn contains images                
+│   │────────────────7cd-ef-xy456-xxx-xxx_0/  # Directory for doc named as 7cd-ef-xy456-xxx-xxx_0 etc.
+│   │──────────────────────── hw01_0.png      # Images
+│   │──────────────────────── hw01_1.png
+│   │────────────────────────     .
+│   │────────────────────────     .
+│   │────────────────────────     .
+│   │─────────────────32xc-ef-xy456-xxx-xxx_0/    
+│   │──────────────────────── hw01_0.png
+│   │──────────────────────── hw01_1.png
+│   │─────────��──────────────     .
+│   │────────────────────────     .
+│   │────────────────────────     .
+```
+
+Dataset archives unpack directly into the repository root (e.g. `docvqa-handwritten-sizes4/`, `docvqa-test/`, `docvqa-viselems/`).
+
+## Installation
+
+### Requirements
+
+- Python 3.8+
+- PyTorch (for diffusion backend)
+- Other dependencies listed in `requirements.txt`
+
+### Setup
+
+1. Clone the repository:
+```bash
+git clone <repository-url>
+cd docvqa_handwriting_generation
+```
+
+2. Install dependencies:
+TODO: update pyproject.toml for dependencies, we now use UV
+```bash
+pip install -r requirements.txt
+```
+
+3. Download or train the diffusion model:
+
+**Pre-trained Models:** `https://drive.google.com/drive/folders/1ujMRnW3avELk-oEhlrVeQ2oTd2j7nM77?usp=sharing`
+
+Expected structure after extraction:
+```
+model/
+└── experiments/
+    └── hf_conditional_latent/
+        ├── config.yaml              # Model configuration
+        ├── writer_id_map.json       # Writer ID to index mapping
+        ├── cached_vae/             # VAE decoder (auto-downloaded on first use)
+        │   ├── config.json
+        │   └── diffusion_pytorch_model.safetensors
+        └── checkpoints/
+            ├── latest.pt            # Latest checkpoint
+            └── checkpoint-####.pt   # Epoch checkpoints
+```
+
+**Note:** The VAE decoder will be automatically downloaded from HuggingFace on first use and cached locally.
+
+4. Download datasets (optional, for testing):
+
+**DocVQA Handwritten Dataset:** `https://drive.google.com/drive/folders/1ujMRnW3avELk-oEhlrVeQ2oTd2j7nM77?usp=sharing`
+
+## Usage
+
+### 1. Diffusion-Based Handwriting Generation
+
+Generate handwriting tokens using a conditional diffusion model with writer style control and intelligent word splitting:
+
+```bash
+python scripts/generate_handwriting_diffusion_raw.py \
+    --input-dir data/docvqa-handwritten-sizes4/handwriting_bbox \
+    --output-dir output/handwriting_raw_tokens \
+    --run-dir model/experiments/hf_conditional_latent \
+    --checkpoint latest.pt \
+    --steps 30 \
+    --split-length 7 \
+    --batch-size 8 \
+    --temperature 1.0 \
+    --device cuda
+```
+
+**Key Features:**
+
+**Intelligent Word Splitting:**
+- Words longer than `--split-length` are automatically split into segments
+- Example: `--split-length 7` → "generation" becomes "generat" + "ion"
+- Segments are generated separately and stitched horizontally
+- Set `--split-length 0` to disable splitting
+
+**Writer Style Control:**
+- Each author gets a consistent style ID per document
+- Style IDs are derived from the model's trained writer embeddings
+- Maintains style consistency across all words from the same author
+
+**Conditional Diffusion:**
+- Uses HuggingFace UNet2DConditionModel with cross-attention
+- Character-level text encoding via transformer
+- VAE latent space generation (auto-downloads stabilityai/sd-vae-ft-mse)
+- Configurable sampling temperature for quality/diversity tradeoff
+
+**Arguments:**
+- `--run-dir`: Path to model experiment directory
+- `--checkpoint`: Checkpoint filename (default: `latest.pt`)
+- `--steps`: Number of diffusion steps (default: 30; more = better quality)
+- `--split-length`: Max word length before splitting (default: 7)
+- `--temperature`: Sampling temperature (0.7-0.9 = conservative, 1.0 = standard, 1.1-1.3 = creative)
+- `--batch-size`: Batch size for GPU efficiency (default: 8)
+- `--use-ema`: Use EMA weights if available in checkpoint
+
+**Output:** 
+- Images: `<output-dir>/<json_stem>/hw<id>_<word_no>.png`
+- Mapping: `<output-dir>/raw_token_map.json`
+
+**Output Features:**
+- RGBA format with transparent backgrounds
+- Tight cropping to handwriting content
+- Word segments automatically stitched horizontally
+- Baseline-aligned concatenation for natural appearance
+
+### 2. Resized Handwriting Generation
+
+Generate handwriting scaled to fit specific bounding boxes:
+
+```bash
+python scripts/generate_handwriting_resized.py \
+    --input-dir data/syn_docvqa/handwriting_bbox \
+    --output-dir output/handwriting_rendered \
+    --backend font \
+    --fonts-dir assets/fonts \
+    --max-workers 8
+```
+
+**Backends:**
+- `font`: Pillow-based pseudo-handwriting (fast, no GPU needed)
+- `diffusion`: Deep learning model (requires GPU, model artifacts)
+
+**Output:**
+- Images: `<output-dir>/<json_stem>__<hw_id>__seg<index>.png`
+- Mapping: `<output-dir>/handwriting_image_map.json`
+
+### 3. Post-Processing with Blur
+
+Add realistic blur and anti-aliasing to generated handwriting:
+
+```bash
+python scripts/add_handwriting_blur.py \
+    --input-root output/handwriting_raw_tokens \
+    --output-root output/handwriting_raw_tokens_blur \
+    --mapping-json output/handwriting_raw_tokens/raw_token_map.json \
+    --append-mapping \
+    --radius-min 0.6 \
+    --radius-max 1.8 \
+    --antialias
+```
+
+**Features:**
+- Gaussian blur with configurable radius
+- Optional downscale+upscale anti-aliasing
+- Advanced edge refinement (erosion, dilation, unsharp mask)
+- Updates mapping JSON with blurred image paths
+- Supports in-place or mirror directory output
+
+### 4. Writer Style Evaluation Exports
+
+Generate per-writer evaluation samples with a curated word list and DPM-Solver++ sampling:
+
+```bash
+python scripts/generate_writer_style_eval.py \
+    --run-dir model/experiments/hf_conditional_latent \
+    --checkpoint latest.pt \
+    --output-dir writer_eval \
+    --max-words 48 \
+    --batch-size 12 \
+    --num-steps 30 \
+    --temperature 0.7 \
+    --device cuda
+```
+
+**Outputs:**
+- PNG samples saved under `<output-dir>/writer_XXXX/`
+- `<output-dir>/writer_style_manifest.json` summarizing words, writers, and generation metadata
+
+## Input Format
+
+### Handwriting Bbox JSON
+
+Input JSON files specify bounding boxes and text for handwriting generation:
+
+```json
+[
+  {
+    "id": "hw0",
+    "text": "Example Text",
+    "author-id": "author1",
+    "bboxes": [
+      "110.69,124.79,161.76,143.41,Example,22,0,0",
+      "166.85,124.79,204.83,143.41,Text,22,0,1"
+    ]
+  }
+]
+```
+
+**Bbox format:** `x1,y1,x2,y2,text,block_no,line_no,word_no`
+- Coordinates are floats
+- Last 3 values are indices for grouping (block, line, word)
+- Text can contain any characters (including commas)
+
+## Key Features
+
+### Intelligent Word Splitting
+- Automatically splits words exceeding `--split-length` characters
+- Example: "generation" (10 chars) → "generat" + "ion" (with split_length=7)
+- Segments generated independently with same style
+- Stitched horizontally with baseline alignment
+- Configurable via `--split-length` parameter (0 = no splitting)
+
+### Writer Style Consistency
+- Each author ID gets consistent style per document
+- Style derived from trained writer embeddings in model
+- Falls back to deterministic hashing for unknown authors
+- Reproducible with same `--seed` value
+
+### Conditional Text Generation
+- Character-level transformer text encoder
+- Cross-attention conditioning in UNet
+- VAE latent space generation (64×256 latent → decoded to full resolution)
+- Temperature control for quality/diversity tradeoff
+
+### Batched GPU Generation
+- Process multiple segments in parallel
+- Configurable batch size for memory optimization
+- Progress tracking with tqdm
+
+### Output Quality
+- RGBA format with transparent backgrounds
+- Tight cropping to ink extents
+- Otsu thresholding for clean binarization
+- Baseline-aligned word segment stitching
+- Version-controlled output mappings
+
+## Advanced Options
+
+### Diffusion Generation Parameters
+- `--steps`: Number of diffusion steps (default: 30; more = higher quality, slower)
+  - Quick preview: 15-20 steps
+  - Production: 30-50 steps
+- `--split-length`: Maximum word length before splitting (default: 7; 0 = no splitting)
+- `--temperature`: Sampling temperature (default: 1.0)
+  - 0.7-0.9: Conservative, cleaner output
+  - 1.0: Standard sampling
+  - 1.1-1.3: Creative, more diverse
+- `--batch-size`: Batch size for GPU processing (default: 8)
+- `--seed`: Random seed for reproducibility (default: 42)
+- `--use-ema`: Use EMA weights if available (improves quality)
+
+### Blur Parameters
+- `--radius`: Fixed blur radius (overrides min/max)
+- `--radius-min/max`: Random uniform blur range
+- `--antialias`: Enable downscale+upscale smoothing
+- `--scale-factor`: Downscale factor for antialiasing (default: 0.75)
+
+## Troubleshooting
+
+### CUDA Out of Memory
+- Reduce `--batch-size` to 1-4
+- Reduce `--steps` (try 20-30)
+- Use CPU: `--device cpu` (much slower)
+- Close other GPU applications
+
+### Missing Model Files
+Ensure you have the trained model checkpoint in:
+```
+model/experiments/hf_conditional_latent/
+├── config.yaml
+├── writer_id_map.json
+└── checkpoints/
+    └── latest.pt
+```
+
+The VAE decoder will be auto-downloaded on first use to:
+```
+model/experiments/hf_conditional_latent/cached_vae/
+```
+
+### Import Errors
+Make sure all dependencies are installed:
+```bash
+pip install -r requirements.txt
+```
+
+Ensure model components are accessible:
+```bash
+# From project root
+python -c "from model.text_encoder import TextEncoder; from model.tokenizer import CharTokenizer"
+```
+
+### Style Not Working
+Check that `writer_id_map.json` exists in your run directory and contains the author IDs from your dataset.
+
+## Model Architecture
+
+### Components
+- **Text Encoder**: Character-level transformer (256-dim, 6 layers, 8 heads)
+- **UNet**: HuggingFace UNet2DConditionModel with cross-attention
+- **VAE**: Stable Diffusion VAE (stabilityai/sd-vae-ft-mse)
+- **Tokenizer**: Character-level with special tokens (PAD, UNK, SOS, EOS)
+
+### Training
+Refer to `model/train_hugging.py` and `training/config_latent.yaml` for training configuration.
+
+## Downloads
+
+### Pre-trained Model
+**Required for diffusion-based generation**
+- Download Link: `https://drive.google.com/drive/folders/1ujMRnW3avELk-oEhlrVeQ2oTd2j7nM77?usp=sharing`
+- Extract to: `model/experiments/`
+- Required files:
+  - `config.yaml` - Model configuration
+  - `writer_id_map.json` - Writer style mappings
+  - `checkpoints/latest.pt` - Model weights
+
+### Datasets
+**Optional - for testing and examples**
+- DocVQA Handwritten Dataset: `https://drive.google.com/drive/folders/1ujMRnW3avELk-oEhlrVeQ2oTd2j7nM77?usp=sharing`
+- Extract to: `data/`
+
+## Citation
+
+
+## License
+
+[Specify your license here]
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.

TESTING_PLAN.md

@@ -0,0 +1,1161 @@
+# Comprehensive Testing Plan & Test Cases
+## DocGenie Synthetic Document Generation API
+
+**Document Version**: 1.0  
+**Date**: March 4, 2026  
+**Project**: DocGenie - AI-Powered Synthetic Document Dataset Generator
+
+---
+
+## Table of Contents
+1. [Testing Overview](#testing-overview)
+2. [Functional Testing](#functional-testing)
+   - [Unit Testing](#unit-testing)
+   - [Integration Testing](#integration-testing)
+   - [System Testing](#system-testing)
+3. [Non-Functional Testing](#non-functional-testing)
+   - [Performance Testing](#performance-testing)
+   - [Security Testing](#security-testing)
+   - [Reliability Testing](#reliability-testing)
+   - [Scalability Testing](#scalability-testing)
+   - [Usability Testing](#usability-testing)
+4. [Test Environment Setup](#test-environment-setup)
+5. [Testing Tools & Frameworks](#testing-tools--frameworks)
+6. [Test Execution Plan](#test-execution-plan)
+7. [Success Criteria & Metrics](#success-criteria--metrics)
+8. [Risk Assessment](#risk-assessment)
+
+---
+
+## Testing Overview
+
+### Purpose
+This document outlines the comprehensive testing strategy for DocGenie API, ensuring quality, reliability, and performance of the synthetic document generation system across all 19 pipeline stages.
+
+### Scope
+- API endpoints testing (`/generate`, `/generate/pdf`, `/generate/async`)
+- 19-stage pipeline validation
+- External service integrations (Claude API, RunPod handwriting service)
+- Database operations (Supabase)
+- Background job processing (Redis Queue)
+- Error handling and recovery mechanisms
+
+### Testing Approach
+- **Test-Driven Development (TDD)**: Write tests before implementation where applicable
+- **Continuous Integration**: Automated test execution on every commit
+- **Coverage Target**: Minimum 80% code coverage for critical paths
+- **Risk-Based Testing**: Prioritize high-risk components (LLM integration, handwriting service)
+
+---
+
+## Functional Testing
+
+### A.1 Unit Testing
+
+Unit tests verify individual functions and methods in isolation. Target: 85% code coverage.
+
+#### **A.1.1 Seed Image Processing (Stage 01)**
+
+**Module**: `api/utils.py::download_seed_images()`
+
+| Test Case ID | Test Name | Input | Expected Output | Priority |
+|--------------|-----------|-------|-----------------|----------|
+| UT-SEED-001 | Download valid image URL | Valid HTTPS URL (JPEG) | Base64-encoded image string | High |
+| UT-SEED-002 | Download PNG format | Valid PNG URL | Base64-encoded PNG | High |
+| UT-SEED-003 | Handle 503 timeout error | URL returning 503 | Retry 3 times, eventual success | Critical |
+| UT-SEED-004 | Handle 502 bad gateway | URL returning 502 | Retry with exponential backoff | High |
+| UT-SEED-005 | Handle 404 not found | Invalid URL | Raise HTTPException(400) | High |
+| UT-SEED-006 | Handle connection timeout | Slow/unresponsive server | Retry then raise exception | Medium |
+| UT-SEED-007 | Validate image format | Non-image URL (HTML) | Raise validation error | Medium |
+| UT-SEED-008 | Handle oversized images | >10MB image | Process or reject gracefully | Low |
+| UT-SEED-009 | Test retry backoff timing | Mock 503 responses | Delays: 2s, 4s, 8s | Medium |
+| UT-SEED-010 | Test max retries exhausted | Persistent 503 errors | Raise exception after 3 attempts | High |
+
+**Test Implementation**:
+```python
+# test_seed_download.py
+import pytest
+from api.utils import download_seed_images
+from unittest.mock import patch, Mock
+
+@pytest.mark.asyncio
+async def test_download_valid_image():
+    url = "https://example.com/test.jpg"
+    with patch('httpx.AsyncClient') as mock_client:
+        mock_response = Mock()
+        mock_response.content = b'\xff\xd8\xff\xe0'  # JPEG header
+        mock_client.return_value.__aenter__.return_value.get.return_value = mock_response
+        
+        result = await download_seed_images([url])
+        assert len(result) == 1
+        assert isinstance(result[0], str)  # base64 string
+
+@pytest.mark.asyncio
+async def test_download_503_retry():
+    url = "https://example.com/test.jpg"
+    with patch('httpx.AsyncClient') as mock_client:
+        # First two calls: 503, third call: success
+        responses = [
+            Mock(status_code=503, raise_for_status=Mock(side_effect=httpx.HTTPStatusError("503", request=Mock(), response=Mock()))),
+            Mock(status_code=503, raise_for_status=Mock(side_effect=httpx.HTTPStatusError("503", request=Mock(), response=Mock()))),
+            Mock(content=b'\xff\xd8\xff\xe0', raise_for_status=Mock())
+        ]
+        mock_client.return_value.__aenter__.return_value.get.side_effect = responses
+        
+        result = await download_seed_images([url])
+        assert len(result) == 1
+        assert mock_client.return_value.__aenter__.return_value.get.call_count == 3
+```
+
+#### **A.1.2 HTML Processing (Stage 03)**
+
+**Module**: `api/utils.py::extract_html_documents_from_response()`
+
+| Test Case ID | Test Name | Input | Expected Output | Priority |
+|--------------|-----------|-------|-----------------|----------|
+| UT-HTML-001 | Extract single HTML | LLM response with 1 HTML | List with 1 HTML document | High |
+| UT-HTML-002 | Extract multiple HTMLs | Response with 3 HTMLs | List with 3 documents | High |
+| UT-HTML-003 | Extract ground truth | HTML with `<script id="GT">` | GT JSON extracted, script removed | Critical |
+| UT-HTML-004 | Handle malformed HTML | Invalid HTML tags | Parse with BeautifulSoup recovery | Medium |
+| UT-HTML-005 | Handle missing DOCTYPE | HTML without DOCTYPE | Add DOCTYPE or flag error | Low |
+| UT-HTML-006 | Validate CSS presence | HTML without `<style>` | Raise validation error | High |
+| UT-HTML-007 | Extract handwriting markers | HTML with `class="handwritten"` | Identify 5 handwriting elements | High |
+| UT-HTML-008 | Extract visual elements | HTML with `data-placeholder` | Identify 3 visual elements | High |
+| UT-HTML-009 | Handle empty response | Empty string from LLM | Return empty list | Medium |
+| UT-HTML-010 | Prettify minified HTML | Single-line HTML | Multi-line formatted HTML | Low |
+
+#### **A.1.3 PDF Rendering (Stage 04)**
+
+**Module**: `api/utils.py::render_html_to_pdf()`
+
+| Test Case ID | Test Name | Input | Expected Output | Priority |
+|--------------|-----------|-------|-----------------|----------|
+| UT-PDF-001 | Render A4 document | HTML with A4 page size | PDF 210×297mm | High |
+| UT-PDF-002 | Render Letter size | HTML with Letter page | PDF 215.9×279.4mm | Medium |
+| UT-PDF-003 | Extract geometries | HTML with handwriting | Geometries JSON with rects | Critical |
+| UT-PDF-004 | Handle custom fonts | HTML with @font-face | PDF with embedded fonts | Low |
+| UT-PDF-005 | Preserve CSS styling | HTML with colors/borders | PDF matches visual style | Medium |
+| UT-PDF-006 | Handle images in HTML | HTML with <img> tags | Images embedded in PDF | Low |
+| UT-PDF-007 | Extract text coordinates | HTML with paragraphs | Accurate bbox coordinates | High |
+| UT-PDF-008 | Handle landscape orientation | HTML with landscape CSS | PDF in landscape mode | Low |
+| UT-PDF-009 | Validate page dimensions | Various page sizes | Dimensions match CSS @page | High |
+| UT-PDF-010 | Handle Playwright errors | Browser crash scenario | Retry or graceful failure | Medium |
+
+#### **A.1.4 Bbox Extraction (Stage 05)**
+
+**Module**: `api/utils.py::extract_bboxes_from_rendered_pdf()`
+
+| Test Case ID | Test Name | Input | Expected Output | Priority |
+|--------------|-----------|-------|-----------------|----------|
+| UT-BBOX-001 | Extract word bboxes | Standard PDF | List of word-level bboxes | Critical |
+| UT-BBOX-002 | Extract char bboxes | Same PDF | List of char-level bboxes | High |
+| UT-BBOX-003 | Handle multi-line text | PDF with paragraphs | Correct block/line grouping | High |
+| UT-BBOX-004 | Filter whitespace | PDF with spaces/tabs | No whitespace-only bboxes | Medium |
+| UT-BBOX-005 | Handle special characters | PDF with ©, ®, ™ | Characters properly extracted | Medium |
+| UT-BBOX-006 | Handle non-Latin scripts | PDF with Chinese/Arabic | Correct unicode extraction | Low |
+| UT-BBOX-007 | Validate coordinates | Extracted bboxes | All coords within page bounds | High |
+| UT-BBOX-008 | Handle empty PDF | PDF with no text | Return empty list | Low |
+| UT-BBOX-009 | Handle rotated text | PDF with rotation | Bboxes account for rotation | Low |
+| UT-BBOX-010 | Parse bbox strings | "0_0_0 Hello 10 20 50 30" | OCRBox object with correct fields | High |
+
+#### **A.1.5 Handwriting Region Extraction (Stage 07)**
+
+**Module**: `api/utils.py::process_stage3_complete()` - handwriting section
+
+| Test Case ID | Test Name | Input | Expected Output | Priority |
+|--------------|-----------|-------|-----------------|----------|
+| UT-HW-001 | Filter by handwriting_ratio | 10 regions, ratio=0.3 | ~3 regions selected | Critical |
+| UT-HW-002 | Parse author IDs | `class="handwritten author1"` | author_id="author1" | High |
+| UT-HW-003 | Match to word bboxes | Geometry + bboxes | Correct bbox mapping | Critical |
+| UT-HW-004 | Handle signature class | `class="handwritten signature"` | is_signature=True | Medium |
+| UT-HW-005 | DPI coordinate conversion | Browser coords (96 DPI) | PDF coords (72 DPI) with 0.75 scale | High |
+| UT-HW-006 | Handle overlapping regions | 2 regions, same text | Prevent duplicate bbox usage | Medium |
+| UT-HW-007 | Validate rect boundaries | Geometries with rect | Check bboxes within rect threshold | High |
+| UT-HW-008 | Test seed reproducibility | Same seed, same input | Identical region selection | High |
+| UT-HW-009 | Handle zero ratio | ratio=0.0 | No regions selected | Medium |
+| UT-HW-010 | Handle full ratio | ratio=1.0 | All regions selected | Medium |
+
+#### **A.1.6 Handwriting Service Integration**
+
+**Module**: `api/utils.py::call_handwriting_service_batch()`
+
+| Test Case ID | Test Name | Input | Expected Output | Priority |
+|--------------|-----------|-------|-----------------|----------|
+| UT-HWSVC-001 | Batch request format | 10 texts with metadata | Correct RunPod JSON format | Critical |
+| UT-HWSVC-002 | Handle sync response | Immediate completion | Parse output.images[] | High |
+| UT-HWSVC-003 | Handle IN_PROGRESS | Delayed completion | Poll status endpoint | Critical |
+| UT-HWSVC-004 | Status polling timeout | Job exceeds 30 polls | Raise timeout exception | High |
+| UT-HWSVC-005 | Handle FAILED status | RunPod job failure | Raise exception with error | High |
+| UT-HWSVC-006 | Parse image results | Batch response | Map hw_id to image_base64 | Critical |
+| UT-HWSVC-007 | Calculate dynamic timeout | 50 texts | Timeout = 50×20+30 = 1030s | Medium |
+| UT-HWSVC-008 | Handle network errors | Connection timeout | Retry up to max_retries | High |
+| UT-HWSVC-009 | Validate authorization | Missing API key | Request includes Bearer token | Medium |
+| UT-HWSVC-010 | Test exponential backoff | Status polling | Delays: 5s, 6s, 7s... up to 10s | Low |
+
+#### **A.1.7 Visual Element Generation (Stage 10)**
+
+**Module**: `api/utils.py::generate_visual_element_images()`
+
+| Test Case ID | Test Name | Input | Expected Output | Priority |
+|--------------|-----------|-------|-----------------|----------|
+| UT-VE-001 | Select logo prefab | type="logo" | Random logo from prefabs/ | High |
+| UT-VE-002 | Select photo prefab | type="photo" | Random photo image | High |
+| UT-VE-003 | Generate barcode | type="barcode" | EAN-13 barcode image | Medium |
+| UT-VE-004 | Generate QR code | type="qr_code", content="URL" | QR code image | Medium |
+| UT-VE-005 | Test seed reproducibility | Same seed, same type | Identical prefab selection | High |
+| UT-VE-006 | Handle missing prefabs | type with no files | Fallback or error | Medium |
+| UT-VE-007 | Load SVG prefabs | SVG logo file | Convert to PNG | Low |
+| UT-VE-008 | Filter by requested types | types=["logo","signature"] | Only matching types generated | High |
+| UT-VE-009 | Normalize type synonyms | "chart" → "figure" | Consistent type mapping | Medium |
+| UT-VE-010 | Return base64 encoding | All image types | Valid base64 strings | High |
+
+#### **A.1.8 PDF Modification (Stages 12-13)**
+
+**Module**: `api/utils.py::process_stage3_complete()` - insertion sections
+
+| Test Case ID | Test Name | Input | Expected Output | Priority |
+|--------------|-----------|-------|-----------------|----------|
+| UT-PDFMOD-001 | Whiteout text regions | 5 word bboxes | White rectangles drawn | High |
+| UT-PDFMOD-002 | Insert handwriting image | Image + bbox | Image at correct position | Critical |
+| UT-PDFMOD-003 | Apply random offsets | Word bbox | Position offset within limits | Medium |
+| UT-PDFMOD-004 | Resize with aspect ratio | Wide/tall images | Scaled to fit bbox | High |
+| UT-PDFMOD-005 | Insert visual element | Logo + rect | Centered in bbox | High |
+| UT-PDFMOD-006 | Handle rotation | Element with rotation=45 | Rotated image insertion | Low |
+| UT-PDFMOD-007 | Save intermediate PDF | After handwriting | _with_handwriting.pdf created | Medium |
+| UT-PDFMOD-008 | Save final PDF | After visual elements | _final.pdf created | High |
+| UT-PDFMOD-009 | Scale factor application | 3x upscale | High-res image quality | Medium |
+| UT-PDFMOD-010 | Handle insertion errors | Invalid image data | Log error, continue | Medium |
+
+#### **A.1.9 OCR Processing (Stage 15)**
+
+**Module**: `api/utils.py::run_paddle_ocr()`
+
+| Test Case ID | Test Name | Input | Expected Output | Priority |
+|--------------|-----------|-------|-----------------|----------|
+| UT-OCR-001 | OCR English text | English document image | Accurate word recognition | Critical |
+| UT-OCR-002 | OCR with handwriting | Mixed typed/handwritten | Both text types detected | High |
+| UT-OCR-003 | Extract word bboxes | Document image | List of word-level bboxes | Critical |
+| UT-OCR-004 | Calculate confidence | OCR results | Confidence score per word | High |
+| UT-OCR-005 | Handle low quality | Blurry/noisy image | Reasonable accuracy (>70%) | Medium |
+| UT-OCR-006 | Handle rotated text | 90° rotated document | Correct orientation detection | Low |
+| UT-OCR-007 | Multi-language support | Document with German text | lang="de" parameter works | Medium |
+| UT-OCR-008 | Handle empty image | Blank white image | Empty results list | Low |
+| UT-OCR-009 | DPI configuration | Various DPI settings | Consistent accuracy | Medium |
+| UT-OCR-010 | Return image dimensions | Any image | width, height in pixels | High |
+
+#### **A.1.10 Bbox Normalization (Stage 16)**
+
+**Module**: `api/utils.py::normalize_bboxes()`
+
+| Test Case ID | Test Name | Input | Expected Output | Priority |
+|--------------|-----------|-------|-----------------|----------|
+| UT-NORM-001 | Normalize to [0,1] | Pixel bboxes, image dims | Normalized coordinates | Critical |
+| UT-NORM-002 | Handle out-of-bounds | x1 > image_width | Clipped to [0, 1] | High |
+| UT-NORM-003 | Preserve text data | Bboxes with text field | Text preserved in output | High |
+| UT-NORM-004 | Create segment bboxes | Word-level bboxes | Aggregated segment bboxes | Medium |
+| UT-NORM-005 | Handle zero dimensions | Image with width=0 | Raise validation error | Low |
+| UT-NORM-006 | Round to precision | Float coordinates | 6 decimal places | Low |
+| UT-NORM-007 | Maintain bbox order | Ordered input list | Same order in output | Medium |
+| UT-NORM-008 | Handle negative coords | bbox with x0=-5 | Clipped to 0 | Medium |
+| UT-NORM-009 | Validate bbox format | Various input formats | Consistent output schema | High |
+| UT-NORM-010 | Handle empty list | No bboxes | Return empty list | Low |
+
+#### **A.1.11 Dataset Export (Stage 19)**
+
+**Module**: `api/utils.py::export_to_msgpack()`
+
+| Test Case ID | Test Name | Input | Expected Output | Priority |
+|--------------|-----------|-------|-----------------|----------|
+| UT-EXPORT-001 | Create msgpack file | Complete document data | Valid .msgpack file | Critical |
+| UT-EXPORT-002 | Encode image bytes | PNG image | Binary image in msgpack | High |
+| UT-EXPORT-003 | Store normalized bboxes | Normalized coordinates | Bboxes in [0,1] range | High |
+| UT-EXPORT-004 | Store ground truth | GT JSON | GT dict in msgpack | High |
+| UT-EXPORT-005 | Store metadata | Document metadata | Metadata dict in msgpack | Medium |
+| UT-EXPORT-006 | Validate msgpack format | Generated file | Readable by msgpack.load() | Critical |
+| UT-EXPORT-007 | Handle large files | 10MB+ image | Compression applied | Low |
+| UT-EXPORT-008 | Store words list | OCR words | Ordered word list | High |
+| UT-EXPORT-009 | Handle missing fields | Partial data | Fill with null/defaults | Medium |
+| UT-EXPORT-010 | Return file path | Export operation | Absolute path to .msgpack | Medium |
+
+#### **A.1.12 Validation Functions**
+
+**Module**: `api/utils.py::validate_*()`
+
+| Test Case ID | Test Name | Input | Expected Output | Priority |
+|--------------|-----------|-------|-----------------|----------|
+| UT-VAL-001 | Validate HTML structure | Valid HTML5 | (True, None) | High |
+| UT-VAL-002 | Detect missing DOCTYPE | HTML without DOCTYPE | (False, "Missing DOCTYPE") | Medium |
+| UT-VAL-003 | Detect missing CSS | HTML without <style> | (False, "Missing CSS") | High |
+| UT-VAL-004 | Validate PDF file | Valid PDF | (True, None) | High |
+| UT-VAL-005 | Detect corrupt PDF | Truncated PDF file | (False, "Corrupt PDF") | High |
+| UT-VAL-006 | Validate bbox count | 100 bboxes, min=50 | (True, None) | Medium |
+| UT-VAL-007 | Detect insufficient bboxes | 10 bboxes, min=50 | (False, "Insufficient bboxes") | Medium |
+| UT-VAL-008 | Validate bbox coordinates | Valid bboxes | (True, None) | High |
+| UT-VAL-009 | Detect invalid coordinates | x0 > x1 | (False, "Invalid bbox") | High |
+| UT-VAL-010 | Validate page count | Multi-page PDF | (False, "Expected 1 page") | Medium |
+
+**Total Unit Tests**: 120+ test cases
+
+---
+
+### A.2 Integration Testing
+
+Integration tests verify interactions between multiple components. Target: Complete workflow coverage.
+
+#### **A.2.1 Pipeline Stage Integration**
+
+**Purpose**: Verify data flow between consecutive pipeline stages
+
+| Test Case ID | Test Name | Components | Test Scenario | Priority |
+|--------------|-----------|------------|---------------|----------|
+| IT-PIPE-001 | Stages 01-03 integration | Seed download → LLM → HTML extraction | Download seeds, call LLM, extract HTML successfully | Critical |
+| IT-PIPE-002 | Stages 03-05 integration | HTML extraction → PDF render → Bbox extraction | Clean HTML renders to PDF, bboxes extracted | Critical |
+| IT-PIPE-003 | Stages 07-09 integration | HW extraction → Service call | HW regions trigger service batch request | Critical |
+| IT-PIPE-004 | Stages 09-12 integration | HW generation → Insertion | Generated images inserted at correct positions | Critical |
+| IT-PIPE-005 | Stages 14-15 integration | Image render → OCR | Final image passed to OCR successfully | High |
+| IT-PIPE-006 | Stages 15-16 integration | OCR → Normalization | OCR bboxes normalized with correct dimensions | High |
+| IT-PIPE-007 | Stages 07-13 complete | Full Stage 3 | Handwriting + visual elements end-to-end | Critical |
+| IT-PIPE-008 | Stages 14-19 complete | Full Stages 4-5 | OCR → export complete workflow | High |
+| IT-PIPE-009 | Stages 01-19 minimal | End-to-end minimal | No handwriting/VE, basic generation | Critical |
+| IT-PIPE-010 | Stages 01-19 full | End-to-end full features | All features enabled, complete dataset | Critical |
+
+#### **A.2.2 External Service Integration**
+
+**Purpose**: Verify interactions with external APIs and services
+
+| Test Case ID | Test Name | Services | Test Scenario | Priority |
+|--------------|-----------|----------|---------------|----------|
+| IT-EXT-001 | Claude API integration | Claude Messages API | Send prompt, receive valid response | Critical |
+| IT-EXT-002 | Claude error handling | Claude API | Handle rate limits (429) gracefully | High |
+| IT-EXT-003 | Claude retry logic | Claude API | Automatic retry on transient errors | High |
+| IT-EXT-004 | RunPod sync integration | RunPod /runsync | Send batch, receive images | Critical |
+| IT-EXT-005 | RunPod async integration | RunPod /run + status | Queue job, poll until completion | High |
+| IT-EXT-006 | RunPod auth | RunPod API | Bearer token authentication works | Medium |
+| IT-EXT-007 | Supabase storage | Supabase storage API | Upload/download seed images | Medium |
+| IT-EXT-008 | Supabase database | Supabase DB | Store generation metadata | Medium |
+| IT-EXT-009 | Redis Queue | RQ worker | Enqueue async job, process in background | High |
+| IT-EXT-010 | Google Drive | Drive API (optional) | Export to Google Drive if configured | Low |
+
+#### **A.2.3 Database Operations**
+
+**Purpose**: Verify database interactions (Supabase)
+
+| Test Case ID | Test Name | Operations | Test Scenario | Priority |
+|--------------|-----------|------------|---------------|----------|
+| IT-DB-001 | Insert generation record | INSERT | New generation logged in DB | High |
+| IT-DB-002 | Update generation status | UPDATE | Status changes reflected | High |
+| IT-DB-003 | Query by task ID | SELECT | Retrieve generation by ID | High |
+| IT-DB-004 | Store metadata | INSERT | Complete metadata stored | Medium |
+| IT-DB-005 | Handle connection errors | Network failure | Retry or graceful degradation | High |
+| IT-DB-006 | Transaction rollback | Error mid-transaction | Data consistency maintained | Medium |
+| IT-DB-007 | Concurrent updates | Multiple workers | No race conditions | Medium |
+| IT-DB-008 | Pagination | Large result sets | Efficient pagination | Low |
+| IT-DB-009 | Search functionality | Full-text search | Search by doc_type, language | Low |
+| IT-DB-010 | Data retention | Cleanup old data | Archive/delete after N days | Low |
+
+#### **A.2.4 API Endpoint Integration**
+
+**Purpose**: Test complete request/response cycles through endpoints
+
+| Test Case ID | Test Name | Endpoint | Test Scenario | Priority |
+|--------------|-----------|----------|---------------|----------|
+| IT-API-001 | GET /health | Health check | Returns 200 with system status | Critical |
+| IT-API-002 | POST /generate | Legacy endpoint | Returns JSON with complete data | High |
+| IT-API-003 | POST /generate/pdf | Sync PDF endpoint | Returns ZIP file download | Critical |
+| IT-API-004 | POST /generate/async | Async endpoint | Returns task ID | Critical |
+| IT-API-005 | GET /generate/async/status/{id} | Status check | Returns current job status | Critical |
+| IT-API-006 | GET /generate/async/result/{id} | Result download | Returns ZIP when complete | High |
+| IT-API-007 | Request validation | All endpoints | Invalid params rejected with 400 | High |
+| IT-API-008 | Authentication | Protected endpoints | Requires valid API key | High |
+| IT-API-009 | Rate limiting | All endpoints | Enforces rate limits | Medium |
+| IT-API-010 | CORS headers | All endpoints | Correct CORS configuration | Medium |
+
+#### **A.2.5 Background Worker Integration**
+
+**Purpose**: Test async job processing via Redis Queue
+
+| Test Case ID | Test Name | Components | Test Scenario | Priority |
+|--------------|-----------|------------|---------------|----------|
+| IT-WORKER-001 | Job enqueue | API → RQ | Job added to queue successfully | Critical |
+| IT-WORKER-002 | Job processing | Worker → Pipeline | Worker picks up and processes job | Critical |
+| IT-WORKER-003 | Job status updates | Worker → DB | Status updated throughout processing | High |
+| IT-WORKER-004 | Job failure handling | Worker error | Failed job logged, error reported | High |
+| IT-WORKER-005 | Job retry | Transient failure | Failed job retried up to max attempts | High |
+| IT-WORKER-006 | Job timeout | Long-running job | Timeout enforced, job killed | Medium |
+| IT-WORKER-007 | Result storage | Worker → Storage | Results saved to correct location | High |
+| IT-WORKER-008 | Queue priority | Multiple jobs | High priority jobs processed first | Low |
+| IT-WORKER-009 | Worker scaling | Multiple workers | Jobs distributed across workers | Medium |
+| IT-WORKER-010 | Worker health | Worker crash | Replaced automatically, jobs reassigned | High |
+
+**Total Integration Tests**: 50+ test cases
+
+---
+
+### A.3 System Testing
+
+System tests verify end-to-end workflows from user perspective. Target: All user journeys covered.
+
+#### **A.3.1 Complete Generation Workflows**
+
+| Test Case ID | Test Name | Workflow | Test Scenario | Expected Outcome | Priority |
+|--------------|-----------|----------|---------------|------------------|----------|
+| ST-GEN-001 | Basic document generation | Minimal config | Generate 1 English invoice, no handwriting/VE | PDF + metadata returned in <60s | Critical |
+| ST-GEN-002 | Handwriting generation | Enable handwriting | Generate document with handwriting | Handwriting visible in PDF | Critical |
+| ST-GEN-003 | Visual elements | Enable VE | Generate document with logo + barcode | Elements visible in PDF | High |
+| ST-GEN-004 | Full feature set | All features enabled | Generate with HW + VE + OCR + analysis | Complete dataset ZIP | Critical |
+| ST-GEN-005 | Multi-document batch | num_solutions=5 | Generate 5 documents from 3 seeds | 5 complete documents | High |
+| ST-GEN-006 | Reproducible generation | Same seed value | Generate twice with seed=42 | Identical outputs | High |
+| ST-GEN-007 | Multi-language | language="german" | Generate German document | Correct language output | Medium |
+| ST-GEN-008 | Various doc types | doc_type variations | Test invoice, receipt, form, letter | All types work | High |
+| ST-GEN-009 | Different GT formats | gt_type="kie" / "qa" | Test both GT formats | Correct GT structure | High |
+| ST-GEN-010 | Custom seed images | User-provided URLs | Generate from user's images | Images influence output | High |
+
+#### **A.3.2 Error Handling Workflows**
+
+| Test Case ID | Test Name | Error Condition | Test Scenario | Expected Outcome | Priority |
+|--------------|-----------|-----------------|---------------|------------------|----------|
+| ST-ERR-001 | Invalid seed URL | 404 not found | Submit invalid image URL | HTTP 400 with clear error message | High |
+| ST-ERR-002 | LLM API failure | Claude API down | Submit request during outage | HTTP 503 with retry-after | Critical |
+| ST-ERR-003 | Handwriting service failure | RunPod timeout | Enable handwriting, service fails | HTTP 500, generation stopped | Critical |
+| ST-ERR-004 | Invalid parameters | Missing required field | Omit doc_type parameter | HTTP 422 with validation details | High |
+| ST-ERR-005 | Rate limit exceeded | Too many requests | Submit 100 concurrent requests | HTTP 429 with retry info | High |
+| ST-ERR-006 | Payload too large | Huge request | Submit 50 seed image URLs | HTTP 413 payload too large | Medium |
+| ST-ERR-007 | Malformed JSON | Invalid JSON | Submit broken JSON request | HTTP 400 with parse error | High |
+| ST-ERR-008 | Authentication failure | Missing/invalid API key | Request without auth | HTTP 401 unauthorized | High |
+| ST-ERR-009 | Database connection loss | DB unavailable | Submit during DB outage | Graceful degradation or 503 | Medium |
+| ST-ERR-010 | Disk space exhausted | No storage space | Generate large batch | HTTP 507 insufficient storage | Low |
+
+#### **A.3.3 Async Processing Workflows**
+
+| Test Case ID | Test Name | Workflow | Test Scenario | Expected Outcome | Priority |
+|--------------|-----------|----------|---------------|------------------|----------|
+| ST-ASYNC-001 | Submit async job | POST /generate/async | Submit batch job | Receive task ID immediately | Critical |
+| ST-ASYNC-002 | Check pending status | GET status before completion | Poll status endpoint | Returns "pending" or "processing" | High |
+| ST-ASYNC-003 | Check completed status | GET status after completion | Poll status after 5 minutes | Returns "completed" | Critical |
+| ST-ASYNC-004 | Download results | GET result/{id} | Download after completion | Returns ZIP file | Critical |
+| ST-ASYNC-005 | Check failed status | Job fails during processing | Check status of failed job | Returns "failed" with error details | High |
+| ST-ASYNC-006 | Multiple concurrent jobs | Submit 10 jobs | 10 async submissions | All jobs process independently | High |
+| ST-ASYNC-007 | Job cancellation | Cancel in-progress job | Submit, then cancel | Job stops, partial results cleaned | Medium |
+| ST-ASYNC-008 | Result expiration | Check old results | Access 7-day old result | HTTP 410 gone (expired) | Low |
+| ST-ASYNC-009 | Progress updates | Monitor long job | Poll during processing | Progress % increases | Medium |
+| ST-ASYNC-010 | Worker restart recovery | Worker crashes mid-job | Kill worker process | Job reassigned, completes | High |
+
+#### **A.3.4 Data Quality Workflows**
+
+| Test Case ID | Test Name | Quality Check | Test Scenario | Expected Outcome | Priority |
+|--------------|-----------|---------------|---------------|------------------|----------|
+| ST-QUAL-001 | OCR accuracy | Compare OCR to ground truth | Generate doc, compare OCR text to GT | >90% accuracy | High |
+| ST-QUAL-002 | Bbox alignment | Visual inspection | Generate doc with debug viz | Bboxes align with text | High |
+| ST-QUAL-003 | Handwriting quality | Visual realism | Generate handwritten doc | Handwriting looks realistic | Medium |
+| ST-QUAL-004 | Visual element placement | Correct positioning | Generate with logo + barcode | Elements at correct positions | High |
+| ST-QUAL-005 | GT completeness | All GT fields present | Generate KIE document | All expected GT fields extracted | High |
+| ST-QUAL-006 | Dataset format validity | msgpack validation | Export dataset | PyTorch can load msgpack | High |
+| ST-QUAL-007 | Image resolution | Check output image | Render final image | Minimum 220 DPI quality | Medium |
+| ST-QUAL-008 | PDF compliance | PDF/A validation | Generate PDF | Valid PDF/A format | Low |
+| ST-QUAL-009 | Metadata accuracy | Check metadata fields | Generate document | Metadata matches actual data | High |
+| ST-QUAL-010 | Reproducibility | Same input → same output | Generate 3 times with seed | All outputs identical | High |
+
+#### **A.3.5 Performance Workflows**
+
+| Test Case ID | Test Name | Performance Metric | Test Scenario | Target Performance | Priority |
+|--------------|-----------|-------------------|---------------|---------------------|----------|
+| ST-PERF-001 | Basic generation time | Time to completion | Generate minimal document | <60 seconds | High |
+| ST-PERF-002 | Handwriting generation time | Time with HW | Generate with 20 HW words | <300 seconds | High |
+| ST-PERF-003 | Batch generation time | Multiple documents | Generate 10 documents | <15 minutes | Medium |
+| ST-PERF-004 | API response time | Endpoint latency | Submit request | <500ms to return task ID | High |
+| ST-PERF-005 | Status check latency | Status endpoint | Check job status | <100ms response time | Medium |
+| ST-PERF-006 | Concurrent requests | Load handling | 50 concurrent requests | All complete successfully | High |
+| ST-PERF-007 | Large payload | Big request | 8 seed images, 10 solutions | Processes without timeout | Medium |
+| ST-PERF-008 | Memory usage | Resource consumption | Generate 100 documents | <8GB RAM per worker | Medium |
+| ST-PERF-009 | Disk I/O | Storage performance | Rapid sequential generations | No I/O bottleneck | Low |
+| ST-PERF-010 | Network bandwidth | Data transfer | Download large result ZIP | Download completes in <60s | Low |
+
+**Total System Tests**: 50+ test cases
+
+---
+
+## Non-Functional Testing
+
+### B.1 Performance Testing
+
+Purpose: Verify system performance under various load conditions.
+
+#### **B.1.1 Load Testing**
+
+**Tool**: Apache JMeter / Locust
+
+| Test Case ID | Test Name | Load Profile | Metrics | Acceptance Criteria | Priority |
+|--------------|-----------|--------------|---------|---------------------|----------|
+| NFT-LOAD-001 | Normal load | 10 concurrent users, 1 hour | Throughput, response time | Avg response <5s, 0 errors | Critical |
+| NFT-LOAD-002 | Peak load | 50 concurrent users, 30 min | Throughput, error rate | <5% error rate, response <15s | Critical |
+| NFT-LOAD-003 | Sustained load | 25 concurrent users, 4 hours | CPU, memory, throughput | Stable resource usage, no leaks | High |
+| NFT-LOAD-004 | Ramp-up load | 1→100 users over 30 min | System behavior | Graceful scaling or degradation | High |
+| NFT-LOAD-005 | Spike load | Sudden 0→100 users | Response time spike | Recovers within 2 minutes | Medium |
+
+**Test Script Example (Locust)**:
+```python
+# locustfile.py
+from locust import HttpUser, task, between
+
+class DocGenieUser(HttpUser):
+    wait_time = between(5, 15)
+    
+    @task(3)
+    def generate_basic_document(self):
+        payload = {
+            "seed_images": ["https://example.com/seed1.jpg"],
+            "prompt_params": {
+                "language": "english",
+                "doc_type": "invoice",
+                "num_solutions": 1,
+                "enable_handwriting": False,
+                "enable_visual_elements": False
+            }
+        }
+        self.client.post("/generate", json=payload, timeout=120)
+    
+    @task(1)
+    def check_async_status(self):
+        # Assume task_id from previous task
+        self.client.get(f"/generate/async/status/{self.task_id}")
+```
+
+#### **B.1.2 Stress Testing**
+
+**Purpose**: Determine system breaking point
+
+| Test Case ID | Test Name | Stress Condition | Metrics | Acceptance Criteria | Priority |
+|--------------|-----------|------------------|---------|---------------------|----------|
+| NFT-STRESS-001 | User overload | 200+ concurrent users | Max capacity | Identifies max users before failure | High |
+| NFT-STRESS-002 | Memory stress | Generate 1000 docs without cleanup | Memory usage | OOM protection, graceful failure | High |
+| NFT-STRESS-003 | CPU stress | Complex documents, no throttling | CPU utilization | System remains responsive | Medium |
+| NFT-STRESS-004 | Disk stress | Fill 95% of disk space | I/O performance | Handles low disk gracefully | Medium |
+| NFT-STRESS-005 | Network stress | Simulate slow network | Timeout handling | Appropriate timeouts, retries | Medium |
+
+#### **B.1.3 Endurance Testing (Soak Testing)**
+
+**Purpose**: Detect memory leaks and performance degradation over time
+
+| Test Case ID | Test Name | Duration | Load | Metrics | Acceptance Criteria | Priority |
+|--------------|-----------|----------|------|---------|---------------------|----------|
+| NFT-ENDUR-001 | 24-hour test | 24 hours | 10 concurrent users | Memory, CPU over time | No memory leaks, stable performance | High |
+| NFT-ENDUR-002 | 7-day test | 7 days | 5 concurrent users | All resources | System stable, no degradation | Medium |
+| NFT-ENDUR-003 | Weekend load | 48 hours | Variable load | Error rate | <1% errors throughout | Medium |
+
+#### **B.1.4 Scalability Testing**
+
+**Purpose**: Verify horizontal and vertical scaling
+
+| Test Case ID | Test Name | Scaling Type | Test Scenario | Acceptance Criteria | Priority |
+|--------------|-----------|--------------|---------------|---------------------|----------|
+| NFT-SCALE-001 | Horizontal scaling | Add workers | 1→5 workers, measure throughput | Linear throughput increase | High |
+| NFT-SCALE-002 | Vertical scaling | Increase CPU/RAM | 2→8 cores, 4→16GB RAM | Performance improvement | Medium |
+| NFT-SCALE-003 | Auto-scaling | Dynamic load | Trigger auto-scale rules | Scales up/down automatically | Medium |
+| NFT-SCALE-004 | Database scaling | Database load | High concurrent DB ops | No DB bottleneck | High |
+| NFT-SCALE-005 | Storage scaling | Large datasets | Generate 10,000 documents | Storage handles volume | Low |
+
+#### **B.1.5 Benchmark Testing**
+
+**Purpose**: Establish performance baselines
+
+| Test Case ID | Component | Benchmark | Target | Priority |
+|--------------|-----------|-----------|--------|----------|
+| NFT-BENCH-001 | Seed download | 1 image (1MB) | <2 seconds | High |
+| NFT-BENCH-002 | LLM call | 1 prompt (standard) | <30 seconds | Critical |
+| NFT-BENCH-003 | PDF rendering | 1 A4 page | <3 seconds | High |
+| NFT-BENCH-004 | Bbox extraction | 500 words | <2 seconds | Medium |
+| NFT-BENCH-005 | Handwriting service | 10 words batch | <200 seconds | Critical |
+| NFT-BENCH-006 | Visual element generation | 5 elements | <5 seconds | Medium |
+| NFT-BENCH-007 | OCR processing | 1 A4 page (300 DPI) | <5 seconds | High |
+| NFT-BENCH-008 | Msgpack export | 1 document | <2 seconds | Medium |
+| NFT-BENCH-009 | Complete pipeline (minimal) | End-to-end | <60 seconds | Critical |
+| NFT-BENCH-010 | Complete pipeline (full) | End-to-end with HW | <300 seconds | Critical |
+
+---
+
+### B.2 Security Testing
+
+Purpose: Identify vulnerabilities and ensure data protection.
+
+#### **B.2.1 Authentication & Authorization Testing**
+
+| Test Case ID | Test Name | Security Control | Test Scenario | Expected Outcome | Priority |
+|--------------|-----------|------------------|---------------|------------------|----------|
+| NFT-SEC-001 | API key validation | Authentication | Request without API key | HTTP 401 Unauthorized | Critical |
+| NFT-SEC-002 | Invalid API key | Authentication | Request with wrong key | HTTP 401 Unauthorized | Critical |
+| NFT-SEC-003 | Expired API key | Token expiration | Request with expired key | HTTP 401 with renewal info | High |
+| NFT-SEC-004 | API key rotation | Key management | Rotate keys, test old key | Old key rejected | Medium |
+| NFT-SEC-005 | Role-based access | Authorization | User tries admin endpoint | HTTP 403 Forbidden | High |
+| NFT-SEC-006 | Resource ownership | Authorization | User accesses other's job | HTTP 403 Forbidden | High |
+| NFT-SEC-007 | JWT validation | Token security | Tampered JWT token | Signature validation fails | High |
+| NFT-SEC-008 | Session hijacking | Session security | Stolen session token | Token invalidated after detection | Medium |
+| NFT-SEC-009 | Brute force protection | Rate limiting | 100 failed auth attempts | Account locked, IP blocked | High |
+| NFT-SEC-010 | Multi-factor auth | MFA | Admin login without MFA | MFA required | Low |
+
+#### **B.2.2 Input Validation & Injection Testing**
+
+| Test Case ID | Test Name | Vulnerability | Test Scenario | Expected Outcome | Priority |
+|--------------|-----------|---------------|---------------|------------------|----------|
+| NFT-SEC-011 | SQL injection | Injection | Inject SQL in parameters | Parameterized queries prevent injection | Critical |
+| NFT-SEC-012 | XSS attack | Cross-site scripting | Inject `<script>` in doc_type | Input sanitized, script not executed | High |
+| NFT-SEC-013 | Command injection | OS command injection | Inject shell commands | Commands not executed | Critical |
+| NFT-SEC-014 | Path traversal | Directory traversal | `../../etc/passwd` in filename | Access denied | Critical |
+| NFT-SEC-015 | SSRF attack | Server-side request forgery | seed_image URL to internal IP | Internal IPs blocked | High |
+| NFT-SEC-016 | XXE attack | XML external entity | Upload XML with external entity | External entities disabled | Medium |
+| NFT-SEC-017 | LLM prompt injection | Prompt manipulation | Inject ignore instructions | Prompt sandboxing prevents escape | High |
+| NFT-SEC-018 | Buffer overflow | Memory safety | Send 10MB+ parameter | Request rejected, no crash | Medium |
+| NFT-SEC-019 | Unicode attack | Unicode bypass | Unicode normalization tricks | Normalized before processing | Low |
+| NFT-SEC-020 | Regex DoS | ReDoS | Complex regex in input | Timeout protection active | Medium |
+
+#### **B.2.3 Data Protection Testing**
+
+| Test Case ID | Test Name | Protection Mechanism | Test Scenario | Expected Outcome | Priority |
+|--------------|-----------|---------------------|---------------|------------------|----------|
+| NFT-SEC-021 | Data encryption at rest | Storage encryption | Check stored files | Files encrypted on disk | High |
+| NFT-SEC-022 | Data encryption in transit | TLS/HTTPS | Inspect network traffic | All traffic over HTTPS | Critical |
+| NFT-SEC-023 | API key exposure | Secret management | Check logs, errors | API keys never logged | Critical |
+| NFT-SEC-024 | PII handling | Data privacy | Generate docs with PII | PII not stored beyond retention | High |
+| NFT-SEC-025 | Data sanitization | Data cleanup | Delete job after 7 days | All data removed | High |
+| NFT-SEC-026 | Backup encryption | Backup security | Check backup files | Backups encrypted | Medium |
+| NFT-SEC-027 | Secure headers | HTTP headers | Check response headers | Security headers present | High |
+| NFT-SEC-028 | CORS policy | Cross-origin security | Request from unauthorized origin | CORS policy blocks request | High |
+| NFT-SEC-029 | Cookie security | Cookie flags | Check cookie attributes | HttpOnly, Secure, SameSite set | Medium |
+| NFT-SEC-030 | Sensitive data in URLs | URL security | Check for secrets in URLs | No sensitive data in query params | High |
+
+#### **B.2.4 Dependency & Supply Chain Security**
+
+| Test Case ID | Test Name | Security Aspect | Test Method | Expected Outcome | Priority |
+|--------------|-----------|-----------------|-------------|------------------|----------|
+| NFT-SEC-031 | Vulnerable dependencies | CVE scanning | Run `pip-audit` | No high/critical vulnerabilities | High |
+| NFT-SEC-032 | Outdated packages | Package versions | Check `requirements.txt` | All packages recent (<6 months) | Medium |
+| NFT-SEC-033 | Malicious packages | Supply chain | Verify package checksums | Checksums match official registry | High |
+| NFT-SEC-034 | License compliance | Legal compliance | Check package licenses | All licenses compatible | Low |
+| NFT-SEC-035 | Container security | Docker image | Scan with Trivy | No critical image vulnerabilities | High |
+
+**Security Testing Tools**:
+- **OWASP ZAP**: Automated security scanning
+- **Burp Suite**: Manual penetration testing
+- **pip-audit**: Python dependency vulnerability scanning
+- **Trivy**: Container image scanning
+- **Bandit**: Python code security linter
+
+---
+
+### B.3 Reliability Testing
+
+Purpose: Verify system stability and fault tolerance.
+
+#### **B.3.1 Fault Tolerance Testing**
+
+| Test Case ID | Test Name | Fault Condition | Test Scenario | Expected Outcome | Priority |
+|--------------|-----------|-----------------|---------------|------------------|----------|
+| NFT-REL-001 | Database failover | Primary DB failure | Kill primary DB instance | Failover to standby, no downtime | Critical |
+| NFT-REL-002 | Worker crash recovery | Worker process crash | Kill worker mid-job | Job reassigned, completes | High |
+| NFT-REL-003 | Network partition | Network split | Simulate network partition | System detects, retries | High |
+| NFT-REL-004 | External API failure | Claude API down | LLM service unavailable | Graceful error, retry queue | Critical |
+| NFT-REL-005 | Handwriting service failure | RunPod timeout | Service exceeds timeout | Exception raised, clear error | Critical |
+| NFT-REL-006 | Disk full | No storage space | Fill disk to 100% | Rejects new jobs, alerts sent | High |
+| NFT-REL-007 | Redis failure | Queue unavailable | Redis server down | Async jobs fail with clear error | High |
+| NFT-REL-008 | Load balancer failure | LB goes down | Kill load balancer | Requests reach servers via backup | Medium |
+| NFT-REL-009 | DNS resolution failure | DNS timeout | DNS server unreachable | Falls back to IP or cached DNS | Low |
+| NFT-REL-010 | Partial service degradation | Some features down | VE prefabs missing | Skips VE, completes other features | Medium |
+
+#### **B.3.2 Data Integrity Testing**
+
+| Test Case ID | Test Name | Integrity Check | Test Scenario | Expected Outcome | Priority |
+|--------------|-----------|-----------------|---------------|------------------|----------|
+| NFT-REL-011 | Transaction atomicity | Database transactions | Simulate crash mid-transaction | Either all or no changes applied | High |
+| NFT-REL-012 | Data corruption detection | Checksum validation | Corrupt file on disk | Corruption detected, file rejected | High |
+| NFT-REL-013 | Concurrent write safety | Race conditions | Multiple writes to same resource | Last write wins or lock prevents | High |
+| NFT-REL-014 | Duplicate prevention | Idempotency | Submit same request twice | Duplicate detected, not processed | Medium |
+| NFT-REL-015 | Backup restoration | Backup recovery | Restore from backup | Data fully restored, consistent | High |
+
+#### **B.3.3 Recovery Testing**
+
+| Test Case ID | Test Name | Recovery Scenario | Test Procedure | Expected Outcome | Priority |
+|--------------|-----------|-------------------|----------------|------------------|----------|
+| NFT-REL-016 | Crash recovery | Server crash | Kill server, restart | Server recovers, in-flight jobs resume | Critical |
+| NFT-REL-017 | Database restore | DB corruption | Restore from backup | System operational with latest data | High |
+| NFT-REL-018 | Disaster recovery | Complete site failure | Failover to DR site | Service restored within RTO (4 hours) | Critical |
+| NFT-REL-019 | Job queue recovery | Redis crash | Redis restart with persistence | Queued jobs not lost | High |
+| NFT-REL-020 | Config recovery | Bad config deployment | Deploy bad config | Rollback to previous config | Medium |
+
+---
+
+### B.4 Scalability Testing
+
+Purpose: Verify system can handle growth in load and data.
+
+#### **B.4.1 Capacity Testing**
+
+| Test Case ID | Test Name | Capacity Metric | Test Scenario | Target Capacity | Priority |
+|--------------|-----------|-----------------|---------------|-----------------|----------|
+| NFT-SCAL-001 | Max concurrent users | User capacity | Gradually increase users | Support 100+ concurrent users | High |
+| NFT-SCAL-002 | Max documents per hour | Throughput | Generate continuously | Process 500+ docs/hour | High |
+| NFT-SCAL-003 | Max queue depth | Job queue | Enqueue 10,000 jobs | Queue handles all jobs | Medium |
+| NFT-SCAL-004 | Max dataset size | Storage | Generate large dataset | Handle 1TB+ datasets | Low |
+| NFT-SCAL-005 | Max file size | Upload limit | Upload large seed image | Accept up to 10MB images | Medium |
+
+#### **B.4.2 Elasticity Testing**
+
+| Test Case ID | Test Name | Scaling Behavior | Test Scenario | Expected Outcome | Priority |
+|--------------|-----------|------------------|---------------|------------------|----------|
+| NFT-SCAL-006 | Scale-up | Add resources | Increase from 2→10 workers | Linear throughput increase | High |
+| NFT-SCAL-007 | Scale-down | Remove resources | Decrease from 10→2 workers | Graceful job completion | High |
+| NFT-SCAL-008 | Auto-scale up | Load increase | Load triggers scale-up | New instances launched | Medium |
+| NFT-SCAL-009 | Auto-scale down | Load decrease | Low load triggers scale-down | Excess instances terminated | Medium |
+| NFT-SCAL-010 | Burst scaling | Sudden spike | 0→100 requests instantly | Scale-up handles burst | High |
+
+---
+
+### B.5 Usability Testing
+
+Purpose: Verify API ease of use and developer experience.
+
+#### **B.5.1 API Documentation Testing**
+
+| Test Case ID | Test Name | Documentation Aspect | Test Scenario | Expected Outcome | Priority |
+|--------------|-----------|---------------------|---------------|------------------|----------|
+| NFT-USAB-001 | API docs completeness | All endpoints documented | Review /docs | All endpoints, params documented | High |
+| NFT-USAB-002 | Example accuracy | Code examples | Test all code examples | Examples work without modification | High |
+| NFT-USAB-003 | Error messages clarity | Error documentation | Check error responses | Errors have clear messages, codes | High |
+| NFT-USAB-004 | OpenAPI spec validity | Swagger/OpenAPI | Validate spec | Spec passes OpenAPI validation | Medium |
+| NFT-USAB-005 | Interactive docs | Try-it-out feature | Use /docs to test | Can test endpoints in browser | Medium |
+
+#### **B.5.2 Developer Experience Testing**
+
+| Test Case ID | Test Name | DX Aspect | Test Scenario | Expected Outcome | Priority |
+|--------------|-----------|-----------|---------------|------------------|----------|
+| NFT-USAB-006 | SDK availability | Client libraries | Check for Python/JS SDKs | SDKs available, documented | Low |
+| NFT-USAB-007 | Quick start guide | Getting started | Follow quick start | Working request in <10 minutes | High |
+| NFT-USAB-008 | API versioning | Version management | Check version headers | Versions clearly indicated | Medium |
+| NFT-USAB-009 | Changelog maintenance | Release notes | Review changelog | All changes documented | Low |
+| NFT-USAB-010 | Deprecation notices | Breaking changes | Check deprecated features | Clear deprecation warnings | Medium |
+
+---
+
+### B.6 Compatibility Testing
+
+Purpose: Verify system works across different environments.
+
+#### **B.6.1 Browser Compatibility** (for API docs)
+
+| Test Case ID | Browser | Version | Expected Outcome |
+|--------------|---------|---------|------------------|
+| NFT-COMPAT-001 | Chrome | Latest | /docs fully functional |
+| NFT-COMPAT-002 | Firefox | Latest | /docs fully functional |
+| NFT-COMPAT-003 | Safari | Latest | /docs fully functional |
+| NFT-COMPAT-004 | Edge | Latest | /docs fully functional |
+
+#### **B.6.2 Platform Compatibility**
+
+| Test Case ID | Platform | Test Scenario | Expected Outcome | Priority |
+|--------------|----------|---------------|------------------|----------|
+| NFT-COMPAT-005 | Docker | Deploy in container | Runs without issues | Critical |
+| NFT-COMPAT-006 | Railway | Deploy to Railway | Successful deployment | High |
+| NFT-COMPAT-007 | AWS | Deploy to ECS/Lambda | Runs on AWS | Medium |
+| NFT-COMPAT-008 | GCP | Deploy to Cloud Run | Runs on GCP | Low |
+| NFT-COMPAT-009 | Azure | Deploy to App Service | Runs on Azure | Low |
+
+#### **B.6.3 Python Version Compatibility**
+
+| Test Case ID | Python Version | Test Scenario | Expected Outcome | Priority |
+|--------------|----------------|---------------|------------------|----------|
+| NFT-COMPAT-010 | Python 3.11 | Run full test suite | All tests pass | Critical |
+| NFT-COMPAT-011 | Python 3.10 | Run full test suite | All tests pass | High |
+| NFT-COMPAT-012 | Python 3.12 | Run full test suite | All tests pass | Medium |
+
+---
+
+### B.7 Maintainability Testing
+
+Purpose: Verify system is easy to maintain and debug.
+
+#### **B.7.1 Logging & Monitoring**
+
+| Test Case ID | Test Name | Aspect | Test Scenario | Expected Outcome | Priority |
+|--------------|-----------|--------|---------------|------------------|----------|
+| NFT-MAINT-001 | Log completeness | Logging | Check logs during generation | All stages logged | High |
+| NFT-MAINT-002 | Log levels | Log filtering | Filter by ERROR, INFO, DEBUG | Correct levels used | Medium |
+| NFT-MAINT-003 | Structured logging | Log format | Parse log entries | JSON-formatted, parseable | High |
+| NFT-MAINT-004 | Error traceability | Error tracking | Trace error through logs | Request ID tracks full flow | High |
+| NFT-MAINT-005 | Metrics collection | Monitoring | Check Prometheus metrics | Key metrics exported | High |
+| NFT-MAINT-006 | Health checks | Monitoring | Call /health endpoint | Returns detailed status | Critical |
+| NFT-MAINT-007 | Alert configuration | Alerting | Trigger alert condition | Alert fired, notification sent | Medium |
+| NFT-MAINT-008 | Dashboard usability | Visualization | View Grafana dashboards | Clear, actionable insights | Medium |
+
+#### **B.7.2 Code Quality**
+
+| Test Case ID | Test Name | Quality Metric | Tool | Acceptance Criteria | Priority |
+|--------------|-----------|----------------|------|---------------------|----------|
+| NFT-MAINT-009 | Code coverage | Test coverage | pytest-cov | >80% coverage | High |
+| NFT-MAINT-010 | Code complexity | Cyclomatic complexity | radon | CC <10 per function | Medium |
+| NFT-MAINT-011 | Code duplication | DRY principle | pylint | <5% duplicated code | Low |
+| NFT-MAINT-012 | Code style | PEP 8 compliance | flake8 | No style violations | Medium |
+| NFT-MAINT-013 | Type hints | Type coverage | mypy | >90% type hints | Medium |
+| NFT-MAINT-014 | Security linting | Vulnerability scan | bandit | No high-severity issues | High |
+
+---
+
+## Test Environment Setup
+
+### Test Environments
+
+| Environment | Purpose | Configuration | Access |
+|-------------|---------|---------------|--------|
+| **Local Dev** | Development testing | Local Docker Compose | Developers |
+| **CI/CD** | Automated testing | GitHub Actions runners | Automated |
+| **Staging** | Pre-production testing | Mirrors production | QA team |
+| **Production** | Live system | Full infrastructure | Ops team |
+
+### Test Data Management
+
+**Seed Image Dataset**:
+- **Source**: Curated test set of 50 diverse seed images
+- **Location**: `tests/fixtures/seed_images/`
+- **Categories**: Invoice samples, receipt samples, form samples, letter samples
+- **Licensing**: Public domain or test-licensed images
+
+**Test Parameters**:
+```yaml
+# tests/fixtures/test_params.yaml
+test_cases:
+  minimal:
+    language: "english"
+    doc_type: "invoice"
+    num_solutions: 1
+    enable_handwriting: false
+    enable_visual_elements: false
+  
+  full_features:
+    language: "english"
+    doc_type: "medical_form"
+    num_solutions: 2
+    enable_handwriting: true
+    handwriting_ratio: 0.3
+    enable_visual_elements: true
+    visual_element_types: ["logo", "signature", "barcode"]
+    enable_ocr: true
+    enable_dataset_export: true
+```
+
+**Mock Services**:
+- **Mock Claude API**: Returns predefined HTML responses for testing
+- **Mock RunPod API**: Returns test handwriting images, simulates delays
+- **Mock Supabase**: In-memory database for testing
+
+---
+
+## Testing Tools & Frameworks
+
+### Test Frameworks
+
+| Tool | Purpose | Usage |
+|------|---------|-------|
+| **pytest** | Unit & integration testing | `pytest tests/` |
+| **pytest-asyncio** | Async test support | Async function testing |
+| **pytest-cov** | Code coverage | `pytest --cov=api` |
+| **httpx** | HTTP client testing | API request mocking |
+| **respx** | HTTP mock library | Mock external APIs |
+| **pytest-mock** | Mocking framework | Mock functions, classes |
+| **Faker** | Test data generation | Generate realistic data |
+
+### Load Testing Tools
+
+| Tool | Purpose | Usage |
+|------|---------|-------|
+| **Locust** | Load & stress testing | `locust -f locustfile.py` |
+| **Apache JMeter** | Performance testing | GUI-based test scenarios |
+| **k6** | Cloud-native load testing | Scripted load tests |
+
+### Security Testing Tools
+
+| Tool | Purpose | Usage |
+|------|---------|-------|
+| **OWASP ZAP** | Security scanning | Automated vulnerability scan |
+| **Burp Suite** | Penetration testing | Manual security testing |
+| **pip-audit** | Dependency scanning | `pip-audit -r requirements.txt` |
+| **Bandit** | Code security linting | `bandit -r api/` |
+| **Trivy** | Container scanning | `trivy image docgenie-api:latest` |
+
+### Monitoring & Observability
+
+| Tool | Purpose | Usage |
+|------|---------|-------|
+| **Prometheus** | Metrics collection | Scrape /metrics endpoint |
+| **Grafana** | Metrics visualization | Dashboard creation |
+| **ELK Stack** | Log aggregation | Centralized logging |
+| **Sentry** | Error tracking | Automatic error reporting |
+
+---
+
+## Test Execution Plan
+
+### Phase 1: Unit Testing (Week 1-2)
+**Objective**: Achieve 80%+ code coverage
+
+**Tasks**:
+1. Write unit tests for all utility functions (`api/utils.py`)
+2. Test all pipeline stages individually (Stages 01-19)
+3. Mock external dependencies (Claude API, RunPod, Supabase)
+4. Achieve minimum 80% code coverage
+5. Set up CI/CD pipeline for automated testing
+
+**Deliverables**:
+- 120+ unit test cases passing
+- Coverage report >80%
+- CI/CD pipeline configured
+
+### Phase 2: Integration Testing (Week 3)
+**Objective**: Verify component interactions
+
+**Tasks**:
+1. Test pipeline stage integrations (01-03, 03-05, 07-09, etc.)
+2. Test external service integrations (Claude, RunPod, Supabase)
+3. Test database operations (CRUD, transactions)
+4. Test API endpoint workflows
+5. Test background worker integration
+
+**Deliverables**:
+- 50+ integration test cases passing
+- All critical workflows tested
+- Service mocks validated
+
+### Phase 3: System Testing (Week 4)
+**Objective**: End-to-end workflow validation
+
+**Tasks**:
+1. Test complete generation workflows (minimal, full features)
+2. Test error handling scenarios
+3. Test async processing workflows
+4. Test data quality and accuracy
+5. Test performance benchmarks
+
+**Deliverables**:
+- 50+ system test cases passing
+- All user journeys tested
+- Performance baselines established
+
+### Phase 4: Non-Functional Testing (Week 5-6)
+**Objective**: Verify performance, security, reliability
+
+**Tasks**:
+1. **Performance**: Load, stress, endurance, scalability tests
+2. **Security**: Penetration testing, vulnerability scanning
+3. **Reliability**: Fault tolerance, recovery testing
+4. **Usability**: Documentation review, DX testing
+
+**Deliverables**:
+- Load test report (normal, peak, sustained)
+- Security audit report
+- Reliability test report
+- Performance benchmarks
+
+### Phase 5: Regression Testing (Ongoing)
+**Objective**: Prevent defect reintroduction
+
+**Tasks**:
+1. Run full test suite on every commit (CI/CD)
+2. Add tests for every bug fix
+3. Update tests for new features
+4. Maintain >80% code coverage
+
+**Frequency**: Continuous (automated on every PR/commit)
+
+---
+
+## Success Criteria & Metrics
+
+### Test Completion Criteria
+
+| Criteria | Target | Critical |
+|----------|--------|----------|
+| Unit test coverage | >80% | Yes |
+| Integration tests passing | 100% | Yes |
+| System tests passing | 100% | Yes |
+| Load test: Normal load | 0% errors | Yes |
+| Load test: Peak load | <5% errors | Yes |
+| Security: Critical vulnerabilities | 0 | Yes |
+| Security: High vulnerabilities | <5 | Yes |
+| Performance: Basic generation | <60s | Yes |
+| Performance: Handwriting generation | <300s | Yes |
+| Uptime SLA | >99.5% | No |
+
+### Quality Metrics
+
+**Code Quality**:
+- Code coverage: >80%
+- Cyclomatic complexity: <10
+- Code duplication: <5%
+- Type hint coverage: >90%
+
+**Performance**:
+- API response time (P95): <500ms
+- Document generation (minimal): <60s
+- Document generation (with handwriting): <300s
+- Throughput: >500 docs/hour
+
+**Reliability**:
+- Uptime: >99.5%
+- MTBF (Mean Time Between Failures): >720 hours (30 days)
+- MTTR (Mean Time To Recover): <30 minutes
+- Error rate: <1%
+
+**Security**:
+- Zero critical vulnerabilities
+- <5 high-severity vulnerabilities
+- Dependency update cadence: <30 days behind
+
+---
+
+## Risk Assessment
+
+### High-Risk Areas
+
+| Component | Risk Level | Mitigation Strategy | Priority |
+|-----------|------------|---------------------|----------|
+| Claude API integration | **HIGH** | Retry logic, fallback prompts, rate limiting | Critical |
+| RunPod handwriting service | **HIGH** | Timeout handling, batch optimization, error raising | Critical |
+| PDF rendering (Playwright) | **MEDIUM** | Headless browser stability, resource limits | High |
+| OCR accuracy | **MEDIUM** | Multiple OCR engine options, confidence thresholds | High |
+| Async job processing | **MEDIUM** | Worker health checks, job retry mechanisms | High |
+| Database transactions | **MEDIUM** | ACID compliance, connection pooling | High |
+| File storage | **LOW** | Disk space monitoring, cleanup policies | Medium |
+
+### Test Risk Mitigation
+
+| Risk | Impact | Probability | Mitigation |
+|------|--------|-------------|------------|
+| External API unavailable during tests | High | Medium | Use mocks, record/replay mode |
+| Test data corruption | Medium | Low | Version control test fixtures |
+| Test environment instability | High | Medium | Docker isolation, reproducible builds |
+| Long test execution time | Low | High | Parallel execution, selective testing |
+| Flaky tests | Medium | Medium | Retry logic, better assertions |
+
+---
+
+## Test Reporting
+
+### Test Reports
+
+**Daily Reports** (Automated):
+- Test execution summary (pass/fail counts)
+- Code coverage trends
+- Failed test details
+- Performance benchmark comparison
+
+**Weekly Reports** (Manual):
+- Test progress against plan
+- New defects discovered
+- Defect resolution rate
+- Risk updates
+
+**Release Reports** (Per Release):
+- Complete test execution summary
+- All test case results
+- Performance test results
+- Security scan results
+- Known issues and limitations
+
+### Defect Tracking
+
+**Defect Workflow**:
+1. **Report**: Tester creates defect in issue tracker
+2. **Triage**: Team prioritizes defect (P0-Critical, P1-High, P2-Medium, P3-Low)
+3. **Assign**: Developer assigned to fix
+4. **Fix**: Developer implements fix
+5. **Verify**: Tester verifies fix
+6. **Close**: Defect closed, regression test added
+
+**Defect Metrics**:
+- Defect discovery rate
+- Defect resolution rate
+- Defect escape rate (to production)
+- Mean time to resolve (MTTR)
+
+---
+
+## Continuous Improvement
+
+### Test Optimization
+
+**Quarterly Reviews**:
+- Review test coverage (identify gaps)
+- Remove obsolete tests
+- Update test data
+- Optimize test execution time
+- Review test environment stability
+
+**Automation Goals**:
+- Automate 100% of unit tests
+- Automate 90% of integration tests
+- Automate 70% of system tests
+- Automate 50% of non-functional tests
+
+---
+
+## Appendix
+
+### Test Case Template
+
+```markdown
+## Test Case ID: [ID]
+
+**Test Name**: [Descriptive name]
+
+**Component**: [Module/Component under test]
+
+**Test Type**: [Unit/Integration/System/Non-Functional]
+
+**Priority**: [Critical/High/Medium/Low]
+
+**Prerequisites**:
+- [List any setup required]
+
+**Test Steps**:
+1. [Step 1]
+2. [Step 2]
+3. [Step 3]
+
+**Test Data**:
+- [Input data required]
+
+**Expected Result**:
+- [What should happen]
+
+**Actual Result**:
+- [What actually happened - filled during execution]
+
+**Status**: [Pass/Fail/Blocked/Not Run]
+
+**Notes**:
+- [Any additional observations]
+```
+
+### Glossary
+
+- **API**: Application Programming Interface
+- **CI/CD**: Continuous Integration/Continuous Deployment
+- **DPI**: Dots Per Inch
+- **GT**: Ground Truth
+- **HW**: Handwriting
+- **KIE**: Key Information Extraction
+- **LLM**: Large Language Model
+- **MTBF**: Mean Time Between Failures
+- **MTTR**: Mean Time To Recover
+- **OCR**: Optical Character Recognition
+- **P95**: 95th Percentile
+- **SLA**: Service Level Agreement
+- **VE**: Visual Element
+
+---
+
+**Document Control**:
+- **Author**: DocGenie QA Team
+- **Reviewers**: Development Team, Product Manager
+- **Approval**: Project Lead
+- **Next Review Date**: [3 months from approval]
+
+---
+
+**END OF DOCUMENT**

api/README.md

@@ -0,0 +1,1220 @@
+# DocGenie API
+
+FastAPI-based REST API for generating synthetic documents using LLMs. This API is **optimized for ML dataset creation** with comprehensive handwriting and visual element support.
+
+## Features
+
+- 🚀 **Simple REST API** - Easy to integrate with any frontend
+- 🖼️ **URL-based seed images** - Provide seed images via URLs
+- 🎨 **Customizable prompts** - Control document type, language, and ground truth format
+- ✍️ **Handwriting Generation** - WordStylist diffusion model with 339 author styles
+- 🎯 **Visual Elements** - Stamps, logos, barcodes, photos, figures
+- 📊 **ML-Ready Datasets** - Individual token images with complete metadata
+- 📄 **Complete output** - Returns PDF, HTML, CSS, and bounding boxes
+- ⚡ **Async processing** - Fast and efficient document generation
+
+## ML Dataset Creation
+
+The API is **fully equipped for ML training dataset creation** with `output_detail: "dataset"` mode:
+
+### ✅ Handwriting Data
+- **Individual token images**: Each handwriting field saved as separate PNG (`hw0.png`, `hw1.png`, ...)
+- **Author style IDs**: 339 unique writer styles (0-338) for style-consistent generation
+- **Text content**: Original text for each handwriting field
+- **Position data**: Precise bounding boxes (x, y, width, height) in mm
+- **Signature detection**: Boolean flag for signature vs regular handwriting
+- **Image dimensions**: Width and height for each generated token
+
+### ✅ Visual Element Data
+- **Stamps**: Generated with realistic textures, borders, and rotations
+  - Text content preserved
+  - Red/green color variants
+  - Circle/rectangle shapes
+- **Logos**: Random selection from 6+ logo prefabs
+- **Barcodes**: Code128 format with customizable content
+- **Photos**: Random selection from 5+ photo prefabs
+- **Figures/Charts**: Random selection from 6+ chart/diagram prefabs
+- **Individual images**: Each element saved as separate PNG with transparency
+
+### ✅ Dataset Metadata
+- **Token mapping JSON**: Complete mapping with:
+  - Token IDs and references
+  - Style IDs for handwriting
+  - Element types for visual elements
+  - Position rectangles
+  - Image filenames
+  - Content text
+- **Ground truth annotations**: QA pairs, classification labels, NER tags
+- **Bounding boxes**: Word, segment, and layout-level bboxes
+- **Normalized coordinates**: [0,1] scaled for ML frameworks
+- **Msgpack export**: Compatible with datadings library
+
+### ✅ Additional ML Features
+- **OCR results**: Word-level bboxes and text for Document AI training
+- **Layout elements**: Document structure annotations
+- **Page dimensions**: Physical measurements (mm) and pixel dimensions
+- **Reproducibility**: Seed-based generation for consistent results
+
+## Pipeline Overview
+
+The API implements a simplified version of the DocGenie generation pipeline:
+
+1. **Download seed images** from URLs
+2. **Convert to base64** for LLM input
+3. **Build custom prompt** with user parameters
+4. **Call Claude API** to generate HTML documents
+5. **Extract HTML/CSS** and ground truth from response
+6. **Render to PDF** using Playwright
+7. **Extract bounding boxes** from PDF
+8. **Return results** as JSON with base64-encoded PDF
+
+## Installation
+
+### Prerequisites
+
+- Python 3.10+
+- DocGenie main package installed
+- Playwright browsers installed
+
+### Setup
+
+1. Install dependencies (all API dependencies are included in the main project):
+```bash
+# Using uv (recommended)
+uv sync
+
+# Or using pip
+pip install -e .
+
+# Or install API-specific dependencies
+cd api/
+pip install -r requirements.txt
+```
+
+**Note**: For async endpoint support, ensure you have:
+- `redis>=5.0.0` and `rq>=1.15.0` (job queue)
+- `supabase>=2.0.0` (database)
+- `google-api-python-client>=2.100.0` (Google Drive integration)
+
+2. Install Playwright browsers:
+```bash
+playwright install chromium
+```
+
+3. Install Tesseract OCR (for local OCR support):
+```bash
+# Ubuntu/Debian
+sudo apt-get update && sudo apt-get install tesseract-ocr
+
+# macOS
+brew install tesseract
+
+# Windows
+# Download installer from: https://github.com/UB-Mannheim/tesseract/wiki
+```
+
+4. Set your Anthropic API key:
+```bash
+export ANTHROPIC_API_KEY="your-api-key-here"
+```
+
+5. Configure OCR in `.env`:
+```bash
+cp .env.example .env
+# Edit .env and set:
+OCR_SERVICE_ENABLED=true
+OCR_USE_LOCAL=true  # Use local Tesseract (recommended)
+```
+
+## Running the API
+
+### Development Mode
+
+```bash
+cd api
+python main.py
+```
+
+The API will be available at `http://localhost:8000`
+
+### Production Mode
+
+```bash
+cd api
+uvicorn main:app --host 0.0.0.0 --port 8000 --workers 4
+```
+
+## API Endpoints
+
+### Health Check
+
+```http
+GET /health
+```
+
+**Response:**
+```json
+{
+  "status": "healthy",
+  "version": "1.0.0"
+}
+```
+
+### Generate Documents
+
+```http
+POST /generate
+```
+
+**Request Body:**
+```json
+{
+  "seed_images": [
+    "https://example.com/seed1.jpg",
+    "https://example.com/seed2.jpg"
+  ],
+  "prompt_params": {
+    "language": "English",
+    "doc_type": "business and administrative",
+    "gt_type": "Multiple questions about each document, with their answers taken **verbatim** from the document.",
+    "gt_format": "{\"<Text of question 1>\": \"<Answer to question 1>\", \"<Text of question 2>\": \"<Answer to question 2>\", ...}",
+    "num_solutions": 3
+  },
+  "model": "claude-sonnet-4-5-20250929",
+  "api_key": "optional-api-key"
+}
+```
+
+**Response:**
+```json
+{
+  "success": true,
+  "message": "Successfully generated 3 documents",
+  "total_documents": 3,
+  "documents": [
+    {
+      "document_id": "uuid-123_0",
+      "html": "<!DOCTYPE html>...",
+      "css": "body { ... }",
+      "ground_truth": {
+        "What is the invoice number?": "INV-12345",
+        "What is the total amount?": "$1,234.56"
+      },
+      "pdf_base64": "JVBERi0xLjQK...",
+      "bboxes": [
+        {
+          "text": "Invoice",
+          "x": 0.1,
+          "y": 0.05,
+          "width": 0.2,
+          "height": 0.03,
+          "page": 0
+        }
+      ],
+      "page_width_mm": 210.0,
+      "page_height_mm": 297.0
+    }
+  ]
+}
+```
+
+### Generate Documents (Async) - **Recommended for Production**
+
+```http
+POST /generate/async
+```
+
+**🎯 Cost Optimization**: This endpoint uses Claude's **Batch API** for **50% cost savings** ($2.50 vs $5.00 per 1M input tokens).
+
+**⏱️ Latency**: 5-30 minutes (vs 30-120 seconds for direct API)
+
+**✅ Best For**: Multi-user production systems with non-realtime requirements
+
+**Request Body:**
+```json
+{
+  "user_id": 123,
+  "seed_images": [
+    "https://example.com/seed1.jpg",
+    "https://example.com/seed2.jpg"
+  ],
+  "prompt_params": {
+    "language": "English",
+    "doc_type": "business and administrative",
+    "num_solutions": 3,
+    "enable_handwriting": true,
+    "enable_visual_elements": true,
+    "enable_ocr": true,
+    "output_detail": "dataset"
+  }
+}
+```
+
+**Response:**
+```json
+{
+  "request_id": "550e8400-e29b-41d4-a716-446655440000",
+  "status": "queued",
+  "estimated_time_minutes": 10,
+  "poll_url": "/jobs/550e8400-e29b-41d4-a716-446655440000/status",
+  "created_at": "2025-01-15T12:00:00Z"
+}
+```
+
+**Workflow:**
+1. Submit generation request → Get `request_id`
+2. Poll status endpoint every 30-60 seconds
+3. When `status: "completed"`, download from Google Drive
+4. Results uploaded to user's Google Drive with shareable link
+
+### Check Job Status
+
+```http
+GET /jobs/{request_id}/status
+```
+
+**Response (Queued):**
+```json
+{
+  "request_id": "550e8400-e29b-41d4-a716-446655440000",
+  "status": "queued",
+  "created_at": "2025-01-15T12:00:00Z",
+  "updated_at": "2025-01-15T12:00:00Z"
+}
+```
+
+**Response (Processing):**
+```json
+{
+  "request_id": "550e8400-e29b-41d4-a716-446655440000",
+  "status": "processing",
+  "created_at": "2025-01-15T12:00:00Z",
+  "updated_at": "2025-01-15T12:05:00Z",
+  "progress": "Creating batch request..."
+}
+```
+
+**Response (Completed):**
+```json
+{
+  "request_id": "550e8400-e29b-41d4-a716-446655440000",
+  "status": "completed",
+  "created_at": "2025-01-15T12:00:00Z",
+  "updated_at": "2025-01-15T12:15:00Z",
+  "download_url": "https://drive.google.com/file/d/abc123xyz/view?usp=sharing",
+  "file_size_mb": 15.4,
+  "document_count": 3
+}
+```
+
+**Response (Failed):**
+```json
+{
+  "request_id": "550e8400-e29b-41d4-a716-446655440000",
+  "status": "failed",
+  "created_at": "2025-01-15T12:00:00Z",
+  "updated_at": "2025-01-15T12:08:00Z",
+  "error_message": "Batch processing timeout"
+}
+```
+
+**Status Values:**
+- `queued`: Job submitted, waiting for worker
+- `processing`: Worker picked up job, creating batch
+- `generating`: Batch submitted to Claude, waiting for completion
+- `completed`: Documents generated and uploaded to Google Drive
+- `failed`: Error occurred (see `error_message`)
+
+### List User Jobs
+
+```http
+GET /jobs/user/{user_id}?limit=50&offset=0
+```
+
+**Response:**
+```json
+{
+  "user_id": 123,
+  "jobs": [
+    {
+      "request_id": "550e8400-e29b-41d4-a716-446655440000",
+      "status": "completed",
+      "created_at": "2025-01-15T12:00:00Z",
+      "download_url": "https://drive.google.com/...",
+      "document_count": 3
+    },
+    {
+      "request_id": "660e8400-e29b-41d4-a716-446655440111",
+      "status": "processing",
+      "created_at": "2025-01-15T12:30:00Z"
+    }
+  ],
+  "count": 2,
+  "limit": 50,
+  "offset": 0
+}
+```
+
+## Usage Examples
+
+### cURL
+
+```bash
+curl -X POST http://localhost:8000/generate \
+  -H "Content-Type: application/json" \
+  -d '{
+    "seed_images": [
+      "https://example.com/receipt1.jpg",
+      "https://example.com/receipt2.jpg"
+    ],
+    "prompt_params": {
+      "language": "English",
+      "doc_type": "receipts",
+      "num_solutions": 2
+    }
+  }'
+```
+
+### Python (Direct API)
+
+```python
+import requests
+import base64
+
+response = requests.post(
+    "http://localhost:8000/generate",
+    json={
+        "seed_images": [
+            "https://example.com/seed1.jpg",
+            "https://example.com/seed2.jpg"
+        ],
+        "prompt_params": {
+            "language": "English",
+            "doc_type": "business forms",
+            "num_solutions": 3
+        }
+    }
+)
+
+result = response.json()
+
+# Save first PDF
+if result["success"]:
+    pdf_data = base64.b64decode(result["documents"][0]["pdf_base64"])
+    with open("generated_doc.pdf", "wb") as f:
+        f.write(pdf_data)
+```
+
+### Python (Async API with Polling) - **Recommended**
+
+```python
+import requests
+import time
+
+# Step 1: Submit job
+response = requests.post(
+    "http://localhost:8000/generate/async",
+    json={
+        "user_id": 123,
+        "seed_images": [
+            "https://example.com/seed1.jpg",
+            "https://example.com/seed2.jpg"
+        ],
+        "prompt_params": {
+            "language": "English",
+            "doc_type": "receipts and invoices",
+            "num_solutions": 5,
+            "enable_handwriting": True,
+            "enable_visual_elements": True,
+            "enable_ocr": True,
+            "output_detail": "dataset"
+        }
+    }
+)
+
+job = response.json()
+request_id = job["request_id"]
+print(f"✓ Job submitted: {request_id}")
+print(f"  Estimated time: {job['estimated_time_minutes']} minutes")
+
+# Step 2: Poll status until complete
+while True:
+    status_response = requests.get(
+        f"http://localhost:8000/jobs/{request_id}/status"
+    )
+    status = status_response.json()
+    
+    print(f"  Status: {status['status']}", end="")
+    if status.get("progress"):
+        print(f" - {status['progress']}")
+    else:
+        print()
+    
+    if status["status"] == "completed":
+        print(f"✓ Generation complete!")
+        print(f"  Download: {status['download_url']}")
+        print(f"  Size: {status.get('file_size_mb', 0):.1f} MB")
+        print(f"  Documents: {status.get('document_count', 0)}")
+        break
+    elif status["status"] == "failed":
+        print(f"✗ Generation failed: {status.get('error_message')}")
+        break
+    
+    # Wait 30 seconds before next poll
+    time.sleep(30)
+
+# Step 3: Download from Google Drive (if completed)
+if status["status"] == "completed":
+    # User can download from their Google Drive using the shareable link
+    print(f"\nDownload your documents at:\n{status['download_url']}")
+```
+
+### JavaScript
+
+```javascript
+const response = await fetch('http://localhost:8000/generate', {
+  method: 'POST',
+  headers: {
+    'Content-Type': 'application/json',
+  },
+  body: JSON.stringify({
+    seed_images: [
+      'https://example.com/seed1.jpg',
+      'https://example.com/seed2.jpg'
+    ],
+    prompt_params: {
+      language: 'English',
+      doc_type: 'invoices',
+      num_solutions: 2
+    }
+  })
+});
+
+const result = await response.json();
+
+// Convert base64 PDF to blob
+const pdfBlob = await fetch(`data:application/pdf;base64,${result.documents[0].pdf_base64}`)
+  .then(res => res.blob());
+```
+
+## Configuration
+
+### Prompt Parameters
+
+- **language**: Language for generated documents (default: "English")
+- **doc_type**: Type of documents to generate (e.g., "business and administrative", "receipts", "forms")
+- **gt_type**: Description of ground truth type to generate
+- **gt_format**: Format specification for ground truth JSON
+- **num_solutions**: Number of document variations (1-5)
+
+### Stage 3-5 Advanced Features
+
+The API supports advanced document synthesis and dataset packaging:
+
+#### Stage 3: Handwriting & Visual Elements
+- **enable_handwriting**: Add handwritten text using diffusion model (default: false)
+- **handwriting_ratio**: Percentage of text to convert to handwriting 0-1 (default: 0.5)
+- **enable_visual_elements**: Add stamps, barcodes, logos (default: false)
+- **visual_element_types**: Types of elements to add: ["stamp", "logo", "figure", "barcode", "photo"] (default: all types)
+
+#### Stage 4: OCR
+- **enable_ocr**: Perform OCR on generated document (default: false)
+- **ocr_language**: OCR language code (default: "en")
+
+#### Stage 5: Dataset Packaging
+- **enable_bbox_normalization**: Normalize bboxes to [0,1] scale (default: false)
+- **enable_gt_verification**: Verify ground truth quality (default: false)
+- **enable_analysis**: Generate dataset statistics (default: false)
+- **enable_debug_visualization**: Create bbox overlay images (default: false)
+
+#### Dataset Export (Msgpack Format)
+- **enable_dataset_export**: Export as msgpack dataset format (default: false)
+- **dataset_export_format**: Export format - only "msgpack" is supported (default: "msgpack")
+
+**Note**: Only msgpack format is implemented in the current pipeline. COCO and HuggingFace export formats mentioned in some documentation are not yet available.
+
+#### Output Detail Level
+- **output_detail**: Controls how much data is returned/saved (default: "minimal")
+  - `"minimal"` (default): Final outputs only (PDFs, images, metadata) - 2-5 MB per document
+  - `"dataset"`: Includes individual token images for ML training - 10-20 MB per document
+    - Individual handwriting token images (`handwriting_tokens/hw0.png`, ...)
+    - Individual visual element images (`visual_elements/logo_0.png`, ...)
+    - Token mapping JSON with style IDs and positions
+  - `"complete"`: All intermediate files and debug info - 20-50 MB per document
+    - Everything from `dataset` mode
+    - Intermediate PDFs from each processing stage
+    - Generation logs
+    - ⚠️ **Warning**: Can result in 50+ MB JSON responses for `/generate` endpoint
+
+**Recommendation**: Use `"minimal"` for production, `"dataset"` for ML research, `"complete"` for debugging (only with `/generate/pdf`).
+
+**Example with dataset output detail:**
+```python
+import requests
+import base64
+import json
+
+# Generate ML training dataset
+response = requests.post(
+    "http://localhost:8000/generate",
+    json={
+        "seed_images": ["https://example.com/seed.jpg"],
+        "prompt_params": {
+            "language": "English",
+            "doc_type": "receipts and invoices",
+            "num_solutions": 5,
+            
+            # Enable handwriting and visual elements
+            "enable_handwriting": True,
+            "handwriting_ratio": 0.4,
+            "enable_visual_elements": True,
+            "visual_element_types": ["stamp", "logo", "figure", "barcode", "photo"],  # All types by default
+            
+            # Enable dataset features
+            "enable_ocr": True,
+            "enable_bbox_normalization": True,
+            "enable_dataset_export": True,
+            
+            # IMPORTANT: Set output_detail to "dataset" for ML training
+            "output_detail": "dataset",
+            
+            # Use seed for reproducibility
+            "seed": 42
+        }
+    }
+)
+
+result = response.json()
+
+# Process each generated document
+for doc in result["documents"]:
+    doc_id = doc["document_id"]
+    print(f"\\nProcessing {doc_id}:")
+    
+    # 1. Save individual handwriting token images
+    if doc.get("handwriting_token_images"):
+        print(f"  - Handwriting tokens: {len(doc['handwriting_token_images'])}")
+        for hw_id, img_b64 in doc["handwriting_token_images"].items():
+            with open(f"dataset/{doc_id}/{hw_id}.png", "wb") as f:
+                f.write(base64.b64decode(img_b64))
+    
+    # 2. Save individual visual element images
+    if doc.get("visual_element_images"):
+        print(f"  - Visual elements: {len(doc['visual_element_images'])}")
+        for ve_id, img_b64 in doc["visual_element_images"].items():
+            with open(f"dataset/{doc_id}/{ve_id}.png", "wb") as f:
+                f.write(base64.b64decode(img_b64))
+    
+    # 3. Save token mapping for ML training
+    if doc.get("token_mapping"):
+        mapping = doc["token_mapping"]
+        print(f"  - Mapping: {mapping['handwriting']['total_count']} HW + {mapping['visual_elements']['total_count']} VE")
+        with open(f"dataset/{doc_id}/token_mapping.json", "w") as f:
+            json.dump(mapping, f, indent=2)
+    
+    # 4. Save ground truth annotations
+    if doc.get("ground_truth"):
+        with open(f"dataset/{doc_id}/ground_truth.json", "w") as f:
+            json.dump(doc["ground_truth"], f, indent=2)
+    
+    # 5. Save bounding boxes (normalized coordinates)
+    if doc.get("normalized_bboxes_word"):
+        with open(f"dataset/{doc_id}/bboxes_normalized.json", "w") as f:
+            json.dump(doc["normalized_bboxes_word"], f, indent=2)
+    
+    # 6. Save final document image
+    if doc.get("image_base64"):
+        with open(f"dataset/{doc_id}/final_image.png", "wb") as f:
+            f.write(base64.b64decode(doc["image_base64"]))
+    
+    # 7. Save msgpack dataset file
+    if doc.get("dataset_export") and doc["dataset_export"].get("msgpack_base64"):
+        with open(f"dataset/{doc_id}/dataset.msgpack", "wb") as f:
+            f.write(base64.b64decode(doc["dataset_export"]["msgpack_base64"]))
+
+print(f"\\n✅ Generated {len(result['documents'])} ML-ready documents")
+```
+
+### PDF Generation Endpoint (Recommended for Large Datasets)
+
+For bulk generation with comprehensive file outputs, use `/generate/pdf`:
+
+```bash
+curl -X POST http://localhost:8000/generate/pdf \
+  -H "Content-Type: application/json" \
+  -d '{
+    "seed_images": ["https://example.com/seed1.jpg"],
+    "prompt_params": {
+      "num_solutions": 3,
+      "enable_handwriting": true,
+      "enable_ocr": true,
+      "enable_bbox_normalization": true,
+      "enable_dataset_export": true,
+      "output_detail": "dataset"
+    }
+  }' \
+  --output documents.zip
+```
+
+#### ZIP File Contents
+
+Based on `output_detail` level:
+
+**Minimal (default):**
+- `document_<id>.pdf` - Generated PDF files
+- `document_<id>/` - Per-document directories with:
+  - `document.html`, `document.css` - Source files
+  - `ground_truth.json`, `bboxes.json` - Annotations
+  - `final_image.png` - Final rendered image (if Stage 3 enabled)
+  - `handwriting_regions.json`, `visual_elements.json` - Stage 3 metadata (if enabled)
+  - `ocr_results.json` - OCR word-level data (if OCR enabled)
+- `README.md` - Package documentation
+- `metadata.json` - Combined metadata
+
+**Dataset (for ML training):**
+- All files from "minimal" level, plus:
+  - `handwriting_tokens/` - Individual token images (`hw0.png`, `hw1.png`, ...)
+  - `visual_elements/` - Individual element images (`logo_0.png`, `stamp_1.png`, ...)
+  - `token_mapping.json` - Complete mapping with style IDs and positions
+  - `dataset.msgpack` - Msgpack dataset file (if export enabled)
+  - `normalized_bboxes_word.json` - Normalized coordinates (if Stage 5 enabled)
+
+**Complete (for debugging):**
+- All files from "dataset" level, plus:
+  - Intermediate PDFs from each processing stage
+  - Generation logs with timing information
+  - `debug_visualization.png` - Bbox overlay images
+
+### Supported Models
+
+- `claude-sonnet-4-5-20250929` (default, recommended)
+- `claude-3-5-sonnet-20241022`
+
+### Environment Variables
+
+- `ANTHROPIC_API_KEY`: Your Anthropic API key (required if not provided in request)
+
+## API Documentation
+
+Interactive API documentation is available when the server is running:
+
+- **Swagger UI**: http://localhost:8000/docs
+- **ReDoc**: http://localhost:8000/redoc
+
+## Error Handling
+
+The API returns appropriate HTTP status codes:
+
+- `200 OK`: Successful generation
+- `400 Bad Request`: Invalid input (e.g., invalid image URLs)
+- `401 Unauthorized`: Missing or invalid API key
+- `500 Internal Server Error`: Processing error
+
+Error response format:
+```json
+{
+  "detail": "Error message describing what went wrong"
+}
+```
+
+## Performance Considerations
+
+- **Concurrent requests**: The API can handle multiple requests concurrently
+- **Image size**: Larger seed images take longer to process
+- **Number of solutions**: More solutions = longer processing time
+- **Model selection**: Sonnet is slower but higher quality than Haiku
+
+## Limitations
+
+- Maximum 10 seed images per request
+- Maximum 5 document variations (`num_solutions`)
+- Single-page documents only
+- Timeout: 60 seconds per PDF render
+
+## Troubleshooting
+
+### Playwright browser not found
+
+```bash
+playwright install chromium
+```
+
+### API key not working
+
+Make sure your API key is set correctly:
+```bash
+echo $ANTHROPIC_API_KEY
+```
+
+### PDF rendering fails
+
+Ensure Chromium is installed and accessible:
+```bash
+playwright show-trace
+```
+
+## Integration with Frontend
+
+Example React integration:
+
+```jsx
+const [loading, setLoading] = useState(false);
+const [result, setResult] = useState(null);
+
+const generateDocuments = async () => {
+  setLoading(true);
+  
+  try {
+    const response = await fetch('http://localhost:8000/generate', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        seed_images: seedImageUrls,
+        prompt_params: {
+          language: 'English',
+          doc_type: documentType,
+          num_solutions: 3
+        }
+      })
+    });
+    
+    const data = await response.json();
+    setResult(data);
+  } catch (error) {
+    console.error('Generation failed:', error);
+  } finally {
+    setLoading(false);
+  }
+};
+```
+
+### React Integration (Async API with Progress)
+
+```jsx
+import { useState, useEffect } from 'react';
+
+function DocumentGenerator({ userId, seedImages }) {
+  const [requestId, setRequestId] = useState(null);
+  const [status, setStatus] = useState(null);
+  const [progress, setProgress] = useState(0);
+
+  // Submit job
+  const handleGenerate = async () => {
+    const response = await fetch('http://localhost:8000/generate/async', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        user_id: userId,
+        seed_images: seedImages,
+        prompt_params: {
+          language: 'English',
+          doc_type: 'receipts',
+          num_solutions: 3,
+          enable_handwriting: true,
+          output_detail: 'dataset'
+        }
+      })
+    });
+    
+    const job = await response.json();
+    setRequestId(job.request_id);
+    setStatus('queued');
+  };
+
+  // Poll job status
+  useEffect(() => {
+    if (!requestId || status === 'completed' || status === 'failed') return;
+
+    const interval = setInterval(async () => {
+      const response = await fetch(`http://localhost:8000/jobs/${requestId}/status`);
+      const jobStatus = await response.json();
+      
+      setStatus(jobStatus.status);
+      
+      // Update progress bar
+      const progressMap = {
+        'queued': 10,
+        'processing': 30,
+        'generating': 60,
+        'completed': 100,
+        'failed': 0
+      };
+      setProgress(progressMap[jobStatus.status] || 0);
+      
+      if (jobStatus.status === 'completed') {
+        // Open Google Drive download link
+        window.open(jobStatus.download_url, '_blank');
+      }
+    }, 30000); // Poll every 30 seconds
+
+    return () => clearInterval(interval);
+  }, [requestId, status]);
+
+  return (
+    <div>
+      <button onClick={handleGenerate} disabled={status && status !== 'completed'}>
+        Generate Documents
+      </button>
+      
+      {status && (
+        <div className="progress-container">
+          <div className="progress-bar" style={{ width: `${progress}%` }} />
+          <p>Status: {status}</p>
+          {status === 'completed' && (
+            <a href={`http://localhost:8000/jobs/${requestId}/status`}>
+              Download Results
+            </a>
+          )}
+        </div>
+      )}
+    </div>
+  );
+}
+```
+
+## Background Processing Setup
+
+The async endpoints (`/generate/async`) require a background worker system for job processing.
+
+### Prerequisites
+
+1. **Redis** - Job queue storage
+2. **Supabase** - Database for job tracking and user data
+3. **Google Drive OAuth** - For uploading results to user's Drive
+
+### Installing Redis
+
+**Ubuntu/Debian:**
+```bash
+sudo apt-get update
+sudo apt-get install redis-server
+sudo systemctl start redis
+sudo systemctl enable redis
+```
+
+**macOS:**
+```bash
+brew install redis
+brew services start redis
+```
+
+**Docker:**
+```bash
+docker run -d -p 6379:6379 --name redis redis:7-alpine
+```
+
+**Verify Redis is running:**
+```bash
+redis-cli ping
+# Should return: PONG
+```
+
+### Configuring Supabase
+
+1. Create a Supabase project at [supabase.com](https://supabase.com)
+
+2. Create the required tables in your Supabase SQL Editor:
+
+```sql
+-- Document generation requests
+CREATE TABLE document_requests (
+  id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
+  user_id INTEGER NOT NULL,
+  status TEXT NOT NULL CHECK (status IN ('queued', 'processing', 'generating', 'completed', 'failed')),
+  request_metadata JSONB NOT NULL,
+  error_message TEXT,
+  created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+  updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+);
+
+-- Generated documents
+CREATE TABLE generated_documents (
+  id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
+  request_id UUID NOT NULL REFERENCES document_requests(id),
+  document_id TEXT NOT NULL,
+  file_url TEXT,
+  zip_url TEXT,
+  file_size_mb DECIMAL,
+  created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+);
+
+-- User integrations (Google Drive OAuth)
+CREATE TABLE user_integrations (
+  id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
+  user_id INTEGER NOT NULL,
+  integration_type TEXT NOT NULL CHECK (integration_type IN ('google_drive', 'dropbox')),
+  access_token TEXT NOT NULL,
+  refresh_token TEXT,
+  token_expiry TIMESTAMPTZ,
+  created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+  updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+  UNIQUE(user_id, integration_type)
+);
+
+-- Analytics events
+CREATE TABLE analytics_events (
+  id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
+  user_id INTEGER,
+  event_type TEXT NOT NULL,
+  entity_id UUID,
+  event_data JSONB,
+  created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+);
+
+-- Indexes for performance
+CREATE INDEX idx_document_requests_user_id ON document_requests(user_id);
+CREATE INDEX idx_document_requests_status ON document_requests(status);
+CREATE INDEX idx_generated_documents_request_id ON generated_documents(request_id);
+CREATE INDEX idx_user_integrations_user_id ON user_integrations(user_id);
+CREATE INDEX idx_analytics_events_user_id ON analytics_events(user_id);
+```
+
+3. Add your Supabase credentials to `.env`:
+
+```bash
+# In api/.env
+SUPABASE_URL=https://your-project-ref.supabase.co
+SUPABASE_KEY=your-anon-or-service-role-key
+```
+
+### Configuring Google Drive OAuth
+
+Users need to connect their Google Drive account for result storage:
+
+1. Create a Google Cloud Project at [console.cloud.google.com](https://console.cloud.google.com)
+2. Enable Google Drive API
+3. Create OAuth 2.0 credentials (Web application)
+4. Add authorized redirect URIs (e.g., `http://localhost:3000/auth/google/callback`)
+5. Download credentials JSON
+
+6. Users authenticate via OAuth flow (implement in your frontend):
+
+```python
+# Example OAuth flow (implement in your auth system)
+from google_auth_oauthlib.flow import Flow
+
+flow = Flow.from_client_config(
+    client_config={
+        "web": {
+            "client_id": "YOUR_CLIENT_ID",
+            "client_secret": "YOUR_CLIENT_SECRET",
+            "auth_uri": "https://accounts.google.com/o/oauth2/auth",
+            "token_uri": "https://oauth2.googleapis.com/token",
+            "redirect_uris": ["http://localhost:3000/auth/google/callback"]
+        }
+    },
+    scopes=["https://www.googleapis.com/auth/drive.file"]
+)
+
+# User visits auth URL, gets redirected back with code
+authorization_url, state = flow.authorization_url(access_type='offline', include_granted_scopes='true')
+
+# Exchange code for tokens
+flow.fetch_token(code=authorization_code)
+credentials = flow.credentials
+
+# Store in Supabase user_integrations table
+supabase.table('user_integrations').insert({
+    'user_id': user_id,
+    'integration_type': 'google_drive',
+    'access_token': credentials.token,
+    'refresh_token': credentials.refresh_token,
+    'token_expiry': credentials.expiry
+}).execute()
+```
+
+### Starting the Background Worker
+
+1. Configure environment variables in `api/.env`:
+
+```bash
+# Redis Configuration
+REDIS_URL=redis://localhost:6379/0
+RQ_QUEUE_NAME=docgenie
+
+# Batch Processing
+BATCH_POLL_INTERVAL=30  # seconds
+BATCH_DATA_DIR=/tmp/docgenie_batches
+MESSAGE_DATA_DIR=/tmp/docgenie_messages
+
+# Google Drive
+GOOGLE_DRIVE_FOLDER_NAME=DocGenie Documents
+
+# Supabase (already configured above)
+SUPABASE_URL=https://your-project.supabase.co
+SUPABASE_KEY=your_key_here
+
+# Claude API
+ANTHROPIC_API_KEY=your_api_key_here
+```
+
+2. Start the worker:
+
+```bash
+cd api/
+./start_worker.sh
+```
+
+The worker will:
+- ✓ Check Redis connection
+- ✓ Validate Supabase configuration
+- ✓ Verify Claude API key
+- ✓ Create temporary directories
+- ✓ Start RQ worker listening on `docgenie` queue
+
+**Output:**
+```
+🚀 Starting DocGenie RQ Worker...
+✓ Loading .env file...
+✓ Redis connected
+✓ Supabase configured
+✓ Claude API key configured
+✓ Temporary directories created
+
+============================================
+Worker Configuration:
+  Queue: docgenie
+  Redis: redis://localhost:6379/0
+  Batch Data: /tmp/docgenie_batches
+  Message Data: /tmp/docgenie_messages
+============================================
+
+✅ Starting RQ worker (press Ctrl+C to stop)...
+
+12:00:00 RQ worker 'worker-abc123' started on docgenie queue
+```
+
+### Running Multiple Workers (Production)
+
+For production systems with high load, run multiple workers:
+
+```bash
+# Terminal 1
+./start_worker.sh
+
+# Terminal 2
+./start_worker.sh
+
+# Terminal 3
+./start_worker.sh
+```
+
+Each worker processes jobs independently from the same queue.
+
+**For detailed scaling instructions**, see [SCALING.md](SCALING.md).
+
+### Monitoring Workers
+
+```bash
+# View worker status
+rq info --url redis://localhost:6379/0
+
+# View queue status
+rq info --queue docgenie --url redis://localhost:6379/0
+
+# View failed jobs
+rq info --queue failed --url redis://localhost:6379/0
+```
+
+### Architecture Overview
+
+```
+┌─────────────┐        ┌─────────────┐        ┌─────────────────┐
+│   FastAPI   │───────▶│    Redis    │◀───────│  RQ Workers     │
+│   Server    │        │   Queue     │        │  (1-5 instances)│
+│             │        │             │        │                 │
+│ /generate/  │        │ Job Queue:  │        │ • Downloads     │
+│  async      │        │ - queued    │        │ • Claude Batch  │
+│             │        │ - pending   │        │ • PDF render    │
+│ /jobs/      │        │ - active    │        │ • Handwriting   │
+│  {id}/      │        │             │        │ • OCR           │
+│  status     │        │             │        │ • ZIP creation  │
+└──────┬──────┘        └─────────────┘        └────────┬────────┘
+       │                                               │
+       │                                               │
+       ▼                                               ▼
+┌──────────────────────────────────────────────────────────────┐
+│                          Supabase                             │
+│  • document_requests (job tracking)                           │
+│  • generated_documents (results metadata)                     │
+│  • user_integrations (Google Drive OAuth)                     │
+│  • analytics_events (usage tracking)                          │
+└───────────────────────────────────────────────────────────────┘
+       │
+       │ Upload Results
+       ▼
+┌──────────────────────────────────────────────────────────────┐
+│                      Google Drive                             │
+│  • User's "DocGenie Documents" folder                         │
+│  • ZIP files with generated documents                         │
+│  • Shareable links returned to API                            │
+└──────────────────────────────────────────────────────────────┘
+```
+
+### Cost Comparison: Direct vs Batched API
+
+| API Type | Cost (Input) | Cost (Output) | Latency | Use Case |
+|----------|-------------|---------------|---------|----------|
+| Direct   | $5.00/1M tokens | $15.00/1M tokens | 30-120s | Real-time, interactive |
+| **Batched** | **$2.50/1M tokens** | **$7.50/1M tokens** | 5-30 min | **Background jobs (recommended)** |
+
+**Example Cost Calculation:**
+- Generate 100 documents per day
+- Each request: 5,000 input tokens, 10,000 output tokens
+
+**Direct API Cost:**
+- Input: (100 × 5,000 / 1M) × $5.00 = $2.50/day
+- Output: (100 × 10,000 / 1M) × $15.00 = $15.00/day
+- **Total: $17.50/day = $525/month**
+
+**Batched API Cost:**
+- Input: (100 × 5,000 / 1M) × $2.50 = $1.25/day
+- Output: (100 × 10,000 / 1M) × $7.50 = $7.50/day
+- **Total: $8.75/day = $262.50/month**
+
+**💰 Savings: $262.50/month (50% reduction)**
+
+## Scaling Workers
+
+The API uses Redis Queue (RQ) workers for background job processing. Scale workers based on load:
+
+| User Load | Workers | Redis RAM | Notes |
+|-----------|---------|-----------|-------|
+| < 10 req/hr | 1 | 256 MB | Development |
+| 10–50 req/hr | 2–3 | 512 MB | Small production |
+| 50–200 req/hr | 3–5 | 1 GB | Medium production |
+| > 200 req/hr | 5+ | 2+ GB | Large production |
+
+### Starting Workers
+
+```bash
+# Single worker (development)
+./start_worker.sh
+
+# Multiple workers (production) — run in separate terminals
+./start_worker.sh   # Terminal 1
+./start_worker.sh   # Terminal 2
+
+# Docker Compose — scale to 3 workers
+docker-compose up --scale worker=3
+
+# Monitor
+rq info --url redis://localhost:6379/0
+rq info --queue docgenie --url redis://localhost:6379/0
+```
+
+### Railway Multi-Worker (Separate Service)
+1. Railway dashboard → New Service → GitHub Repo (same repo)
+2. Name: `docgenie-worker`
+3. Custom Start Command: `rq worker --url $REDIS_URL`
+4. Add the same environment variables as the API service
+
+> For most use cases the **combined** mode (API + worker in one service, see `railway.json`) is sufficient and cheaper.
+
+## Contributing
+
+This API is a simplified interface to the DocGenie pipeline. For the full pipeline with all features, see the main DocGenie documentation.
+
+## License
+
+Same as DocGenie main project.

api/TESTING.md

@@ -0,0 +1,936 @@
+# Testing Guide: DocGenie API
+
+Complete guide for testing the document generation API endpoints with Google Drive integration.
+
+## Table of Contents
+
+1. [Prerequisites](#prerequisites)
+2. [Quick Start](#quick-start)
+3. [Getting Google Drive Token](#getting-google-drive-token)
+4. [Testing Async API](#testing-async-api)
+5. [Testing Sync PDF API](#testing-sync-pdf-api)
+6. [Manual Testing with cURL](#manual-testing-with-curl)
+7. [Frontend Integration Example](#frontend-integration-example)
+8. [Troubleshooting](#troubleshooting)
+
+---
+
+## Prerequisites
+
+### 1. Start Required Services
+
+```bash
+# Terminal 1: Start Redis
+
+## Option A: Local Redis (Recommended for Development)
+# Install Redis (Ubuntu/Debian)
+sudo apt-get update && sudo apt-get install redis-server -y
+sudo systemctl start redis-server
+sudo systemctl enable redis-server
+
+# Verify Redis is running
+redis-cli ping  # Should return "PONG"
+
+## Option B: Docker (if Docker is installed)
+# docker run -d -p 6379:6379 --name redis redis:7-alpine
+
+# Terminal 2: Start FastAPI Server
+cd docgenie/api
+python main.py
+
+# Terminal 3: Start RQ Worker
+cd docgenie/api
+./start_worker.sh
+```
+
+### 2. Configure Environment
+
+Make sure your `api/.env` file has:
+
+```bash
+# Required
+ANTHROPIC_API_KEY=your_claude_api_key
+SUPABASE_URL=https://your-project.supabase.co
+SUPABASE_KEY=your_supabase_key
+REDIS_URL=redis://localhost:6379/0
+
+# Optional (for token refresh)
+GOOGLE_CLIENT_ID=your_client_id.apps.googleusercontent.com
+GOOGLE_CLIENT_SECRET=your_client_secret
+```
+
+### 3. Create Supabase Tables
+
+Run the SQL from [DEPLOYMENT.md](DEPLOYMENT.md#32-create-database-schema) in your Supabase SQL Editor.
+
+---
+
+## Quick Start
+
+### Option 1: Using Test Script (Easiest)
+
+```bash
+# Get Google Drive token first (one-time setup)
+python api/test_get_google_token.py \
+  --client-id YOUR_CLIENT_ID \
+  --client-secret YOUR_CLIENT_SECRET
+
+# Copy the access token, then run test
+python api/test_async_api.py --google-token YOUR_ACCESS_TOKEN
+```
+
+### Option 2: Using OAuth Playground (Quick Test)
+
+1. Go to [OAuth Playground](https://developers.google.com/oauthplayground/)
+2. Configure with your credentials
+3. Get access token
+4. Run test script with token
+
+---
+
+## Getting Google Drive Token
+
+### Method 1: Using Helper Script (Recommended)
+
+Our helper script automates the OAuth flow:
+
+```bash
+cd docgenie/api
+
+python test_get_google_token.py \
+  --client-id YOUR_GOOGLE_CLIENT_ID \
+  --client-secret YOUR_GOOGLE_CLIENT_SECRET
+```
+
+**What it does:**
+1. Opens browser for Google authorization
+2. Starts local server on port 8080 for callback
+3. Exchanges authorization code for tokens
+4. Displays access token and refresh token
+
+**Output:**
+```
+Access Token: ya29.a0AfH6SMBx...
+Refresh Token: 1//0gw...
+```
+
+### Method 2: OAuth Playground (No Code)
+
+1. **Go to**: https://developers.google.com/oauthplayground/
+
+2. **Configure Credentials**:
+   - Click gear icon (⚙) in top right
+   - Check "Use your own OAuth credentials"
+   - Enter your Client ID and Client Secret
+
+3. **Authorize API**:
+   - In left panel, scroll to "Drive API v3"
+   - Select: `https://www.googleapis.com/auth/drive.file`
+   - Click "Authorize APIs"
+   - Sign in with your Google account
+
+4. **Get Token**:
+   - Click "Exchange authorization code for tokens"
+   - Copy the "Access token" value
+
+### Method 3: Manual cURL (For Advanced Users)
+
+**Step 1: Get Authorization Code**
+
+Open this URL in browser (replace YOUR_CLIENT_ID):
+
+```
+https://accounts.google.com/o/oauth2/v2/auth?client_id=YOUR_CLIENT_ID&redirect_uri=http://localhost:8080&response_type=code&scope=https://www.googleapis.com/auth/drive.file&access_type=offline&prompt=consent
+```
+
+**Step 2: Exchange Code for Token**
+
+After authorization, you'll be redirected to:
+```
+http://localhost:8080/?code=AUTHORIZATION_CODE
+```
+
+Exchange the code:
+
+```bash
+curl -X POST https://oauth2.googleapis.com/token \
+  -d "code=AUTHORIZATION_CODE" \
+  -d "client_id=YOUR_CLIENT_ID" \
+  -d "client_secret=YOUR_CLIENT_SECRET" \
+  -d "redirect_uri=http://localhost:8080" \
+  -d "grant_type=authorization_code"
+```
+
+Response:
+```json
+{
+  "access_token": "ya29.a0AfH6SMBx...",
+  "refresh_token": "1//0gw...",
+  "expires_in": 3600,
+  "token_type": "Bearer"
+}
+```
+
+---
+
+## Testing Async API
+
+The async API (`/generate/async`) is optimized for batch processing with 50% cost savings. Jobs are queued and processed in the background, with status polling.
+
+### Full Automated Test
+
+```bash
+cd docgenie/api
+
+# Set token as environment variable
+export GOOGLE_DRIVE_TOKEN="ya29.a0AfH6SMBx..."
+
+# Run test (generates 2 documents by default)
+python test_async_api.py
+
+# Or pass token directly
+python test_async_api.py --google-token "ya29.a0AfH6SMBx..."
+```
+
+**Test Flow:**
+1. ✓ Health check
+2. ✓ Submit async job
+3. ✓ Poll status (every 30 seconds)
+4. ✓ List user jobs
+5. ✓ Display Google Drive link
+
+**Expected Output:**
+```
+================================================================================
+                        ASYNC API TEST SUITE
+================================================================================
+Base URL: http://localhost:8000
+User ID: 1
+Documents to Generate: 2
+================================================================================
+
+============================================================
+1. Testing API Health
+============================================================
+✓ API is healthy: {'status': 'healthy', 'version': '1.0.0'}
+
+============================================================
+2. Submitting Async Job
+============================================================
+Payload:
+  User ID: 1
+  Seed Images: 1
+  Num Solutions: 2
+  Google Token: ya29.a0AfH6SMBx...
+
+✓ Job submitted successfully!
+  Request ID: 550e8400-e29b-41d4-a716-446655440000
+  Status: queued
+  Estimated Time: 10 minutes
+  Poll URL: /jobs/550e8400-e29b-41d4-a716-446655440000/status
+
+============================================================
+3. Polling Job Status
+============================================================
+Polling every 30 seconds (max 60 attempts)
+Status flow: queued → processing → generating → completed/failed
+
+[12:00:00] Poll 1/60: QUEUED
+[12:00:30] Poll 2/60: PROCESSING - Creating batch request...
+[12:01:00] Poll 3/60: GENERATING - Batch submitted to Claude...
+[12:08:30] Poll 17/60: GENERATING - Polling batch status...
+[12:15:00] Poll 30/60: COMPLETED
+
+============================================================
+✓ JOB COMPLETED!
+============================================================
+  Download URL: https://drive.google.com/file/d/abc123xyz/view?usp=sharing
+  File Size: 15.4 MB
+  Document Count: 2
+  Created: 2026-02-28T12:00:00Z
+  Completed: 2026-02-28T12:15:00Z
+
+================================================================================
+                           TEST SUMMARY
+================================================================================
+✓ ALL TESTS PASSED!
+
+Your documents are available at:
+  https://drive.google.com/file/d/abc123xyz/view?usp=sharing
+
+Next steps:
+  1. Open the Google Drive link in your browser
+  2. Download the ZIP file
+  3. Extract and verify generated documents
+```
+
+### Test Options
+
+```bash
+# Custom number of documents
+python test_async_api.py --google-token TOKEN --num-solutions 5
+
+# Custom API URL (if deployed)
+python test_async_api.py --google-token TOKEN --base-url https://api.yourdomain.com
+
+# Different user ID
+python test_async_api.py --google-token TOKEN --user-id 42
+
+# With refresh token
+python test_async_api.py \
+  --google-token ACCESS_TOKEN \
+  --google-refresh-token REFRESH_TOKEN
+
+# Show help for getting token
+python test_async_api.py --help-token
+```
+
+---Testing Sync PDF API
+
+The sync PDF API (`/generate/pdf`) returns results immediately (20-60s) and supports three modes of operation. Perfect for smaller batch sizes and real-time workflows.
+
+### Three Operating Modes
+
+**Mode 1: Quick Demo (No Tracking)**
+- Returns ZIP immediately
+- No Supabase records created
+- Perfect for quick testing and demos
+- No user_id required
+
+**Mode 2: Demo with Tracking**
+- Returns ZIP immediately
+- Creates Supabase record for tracking
+- Can poll status during generation
+- Requires user_id
+
+**Mode 3: Full Production**
+- Returns ZIP immediately
+- Creates Supabase record
+- Uploads to Google Drive in background
+- Requires user_id + google_drive_token
+- Best for production use
+
+### Full Automated Test
+
+```bash
+cd docgenie/api
+
+# Mode 1: Quick demo (no tracking)
+python test_sync_pdf_api.py
+
+# Mode 2: Demo with tracking
+python test_sync_pdf_api.py --user-id 123
+
+# Mode 3: Full production (tracking + GDrive)
+python test_sync_pdf_api.py \
+  --user-id 123 \
+  --google-token "ya29.a0AfH6SMBx..." \
+  --google-refresh-token "1//0gw..."
+```
+
+**Test Flow for All Modes:**
+1. ✓ Health check
+2. ✓ Test Mode 1: Quick demo (always runs)
+3. ✓ Test Mode 2: With tracking (if user_id provided)
+4. ✓ Test Mode 3: Full production (if user_id + token provided)
+5. ✓ Validate ZIP contents
+6. ✓ Test status polling (Modes 2 & 3)
+7. ✓ Verify GDrive upload (Mode 3)
+
+**Expected Output:**
+```
+================================================================================
+DocGenie /generate/pdf Endpoint Test Suite
+================================================================================
+
+================================================================================
+1. Testing API Health
+================================================================================
+✓ API is healthy: {'status': 'healthy', 'version': '1.0.0'}
+
+================================================================================
+2. Testing Mode 1: Quick Demo (No Tracking)
+================================================================================
+This mode returns ZIP immediately without creating Supabase records.
+Use for quick testing and demos.
+
+Payload:
+  Seed Images: 1
+  Num Solutions: 1
+  User ID: None (no tracking)
+  Google Token: None
+
+⏳ Calling /generate/pdf (expect 20-60 seconds)...
+
+✓ Response received in 42.3 seconds
+
+Response Headers:
+  Content-Type: application/zip
+  Content-Disposition: attachment; filename=docgenie_documents.zip
+  X-Request-ID: NOT SET (expected in mode 1)
+  X-Status-URL: NOT SET (expected in mode 1)
+
+✓ ZIP file size: 145.2 KB
+✓ ZIP contains 18 files:
+    - README.md
+    - metadata.json
+    - analysis/document_1.json
+    - annotations/gt/document_1.json
+    - bbox/bbox_pdf/word/document_1.json
+    - html/document_1.css
+    - html/document_1.html
+    - img/document_1.png
+    - pdf/pdf_final/document_1.pdf
+    - pdf/pdf_initial/document_1.pdf
+  ✓ Contains metadata.json
+  ✓ Contains README.md
+
+✅ Mode 1 (Quick Demo) Test PASSED
+   ⚡ Fast response: 42.3s
+   📦 Valid ZIP file
+   ✓ No tracking overhead
+
+================================================================================
+3. Testing Mode 2: Demo with Progress Tracking
+================================================================================
+This mode returns ZIP immediately AND creates Supabase record.
+Client can poll /jobs/{request_id}/status during generation.
+
+Payload:
+  User ID: 123 (tracking enabled)
+  Seed Images: 1
+  Num Solutions: 2
+  Google Token: None
+
+⏳ Calling /generate/pdf (expect 20-60 seconds)...
+
+✓ Response received in 58.7 seconds
+
+Response Headers:
+  Content-Type: application/zip
+  ✓ X-Request-ID: 550e8400-e29b-41d4-a716-446655440000
+  ✓ X-Status-URL: /jobs/550e8400-e29b-41d4-a716-446655440000/status
+
+✓ ZIP file size: 287.4 KB
+✓ ZIP contains 32 files
+✓ Found 4 PDF files
+
+⏳ Testing status polling endpoint...
+✓ Status endpoint working:
+  Request ID: 550e8400-e29b-41d4-a716-446655440000
+  Status: completed
+  Created: 2026-03-01T10:15:00Z
+  Updated: 2026-03-01T10:15:58Z
+  ✓ Job marked as completed
+
+✅ Mode 2 (Tracking) Test PASSED
+   ⚡ Fast response: 58.7s
+   📦 Valid ZIP file
+   📊 Progress tracking enabled
+   ✓ Can poll status during generation
+
+================================================================================
+4. Testing Mode 3: Full Production (Tracking + GDrive Upload)
+================================================================================
+This mode returns ZIP immediately AND uploads to Google Drive in background.
+Best for production use with full tracking and backup.
+
+Payload:
+  User ID: 123
+  Google Token: ya29.a0AfH6SMBx...
+  Google Refresh: Yes
+  Seed Images: 1
+  Num Solutions: 1
+
+⏳ Calling /generate/pdf (expect 20-60 seconds)...
+
+✓ Response received in 45.1 seconds
+
+Response Headers:
+  ✓ X-Request-ID: 660f9511-f3ac-52e5-b827-557766551111
+  ✓ X-Status-URL: /jobs/660f9511-f3ac-52e5-b827-557766551111/status
+
+✓ ZIP file size: 151.8 KB
+✓ ZIP contains 18 files
+
+⏳ ZIP returned immediately, GDrive upload happening in background...
+   (This doesn't block the response)
+
+⏳ Waiting 10 seconds for background GDrive upload...
+✓ Status after background upload:
+  Status: completed
+  ✓ GDrive URL: https://drive.google.com/file/d/abc123xyz/view?usp=...
+  ✓ Background upload completed!
+
+✅ Mode 3 (Full Production) Test PASSED
+   ⚡ Fast response: 45.1s (GDrive doesn't block)
+   📦 Valid ZIP file delivered immediately
+   📊 Progress tracking enabled
+   ☁️  Google Drive backup scheduled
+   ✓ Production-ready configuration
+
+================================================================================
+TEST SUMMARY
+================================================================================
+  ✅ health: PASSED
+  ✅ mode_1: PASSED
+  ✅ mode_2: PASSED
+  ✅ mode_3: PASSED
+
+4/4 tests passed
+
+🎉 All tests passed!
+================================================================================
+```
+
+### Test Options
+
+```bash
+# Mode 1 only (default)
+python test_sync_pdf_api.py
+
+# Mode 2 with custom user ID
+python test_sync_pdf_api.py --user-id 456
+
+# Mode 3 with custom API URL
+python test_sync_pdf_api.py \
+  --base-url https://api.yourdomain.com \
+  --user-id 123 \
+  --google-token TOKEN \
+  --google-refresh-token REFRESH_TOKEN
+```
+
+### Comparing Sync vs Async
+
+| Feature | Sync (`/generate/pdf`) | Async (`/generate/async`) |
+|---------|------------------------|---------------------------|
+| **Response Time** | 20-60 seconds | 5-30 minutes |
+| **Best For** | 1-3 documents | 5-50+ documents |
+| **Cost** | Standard API pricing | 50% cheaper (Batch API) |
+| **Result Delivery** | Direct ZIP download | Google Drive upload |
+| **Progress Tracking** | Optional (Modes 2 & 3) | Always enabled |
+| **Use Case** | Real-time workflows, demos | Bulk generation, scheduled jobs |
+
+**When to use Sync:**
+- Generating 1-3 documents
+- Need immediate results
+- Real-time user interactions
+- Quick testing and demos
+
+**When to use Async:**
+- Generating 5+ documents
+- Cost optimization (50% savings)
+- Background/scheduled processing
+- Large batch jobs
+
+---
+
+## Manual Testing with cURL
+
+### Async API (`/generate/async`)
+
+#### 1. Submit Async Job
+
+```bash
+curl -X POST http://localhost:8000/generate/async \
+  -H "Content-Type: application/json" \
+  -d '{
+    "user_id": 1,
+    "google_drive_token": "ya29.a0AfH6SMBx...",
+    "seed_images": ["https://ocr.space/Content/Images/receipt-ocr-original.webp"],
+    "prompt_params": {
+      "language": "English",
+      "doc_type": "receipts",
+      "num_solutions": 2,
+      "enable_handwriting": false,
+      "enable_visual_elements": false,
+      "output_detail": "minimal"
+    }
+  }'
+```
+
+**Response:**
+```json
+{
+  "request_id": "550e8400-e29b-41d4-a716-446655440000",
+  "status": "queued",
+  "estimated_time_minutes": 10,
+  "poll_url": "/jobs/550e8400-e29b-41d4-a716-446655440000/status",
+  "created_at": "2026-02-28T12:00:00Z"
+}
+```
+
+#### 2. Check Job Status
+
+```bash
+curl http://localhost:8000/jobs/550e8400-e29b-41d4-a716-446655440000/status
+```
+
+**Response (Processing):**
+```json
+{
+  "request_id": "550e8400-e29b-41d4-a716-446655440000",
+  "status": "processing",
+  "created_at": "2026-02-28T12:00:00Z",
+  "updated_at": "2026-02-28T12:02:00Z",
+  "progress": "Creating batch request..."
+}
+```
+
+**Response (Completed):**
+```json
+{
+  "request_id": "550e8400-e29b-41d4-a716-446655440000",
+  "status": "completed",
+  "created_at": "2026-02-28T12:00:00Z",
+  "updated_at": "2026-02-28T12:15:00Z",
+  "download_url": "https://drive.google.com/file/d/abc123xyz/view?usp=sharing",
+  "file_size_mb": 15.4,
+  "document_count": 2
+}
+```
+
+#### 3. List User Jobs
+
+```bash
+curl "http://localhost:8000/jobs/user/1?limit=10&offset=0"
+```
+
+**Response:**
+```json
+{
+  "user_id": 1,
+  "jobs": [
+    {
+      "request_id": "550e8400-e29b-41d4-a716-446655440000",
+      "status": "completed",
+      "created_at": "2026-02-28T12:00:00Z",
+      "download_url": "https://drive.google.com/file/d/abc123xyz/view"
+    }
+  ],
+  "count": 1,
+  "limit": 10,
+  "offset": 0
+}
+```
+
+### Sync PDF API (`/generate/pdf`)
+
+#### Mode 1: Quick Demo (No Tracking)
+
+```bash
+curl -X POST http://localhost:8000/generate/pdf \
+  -H "Content-Type: application/json" \
+  -d '{
+    "seed_images": ["https://ocr.space/Content/Images/receipt-ocr-original.webp"],
+    "prompt_params": {
+      "language": "English",
+      "doc_type": "receipts",
+      "num_solutions": 1,
+      "enable_handwriting": false,
+      "enable_visual_elements": false,
+      "output_detail": "minimal"
+    }
+  }' \
+  --output documents.zip
+```
+
+**Response:**
+- Returns ZIP file directly (binary)
+- No tracking headers
+- File saved as `documents.zip`
+
+#### Mode 2: Demo with Tracking
+
+```bash
+curl -X POST http://localhost:8000/generate/pdf \
+  -H "Content-Type: application/json" \
+  -d '{
+    "user_id": 123,
+    "seed_images": ["https://ocr.space/Content/Images/receipt-ocr-original.webp"],
+    "prompt_params": {
+      "language": "English",
+      "doc_type": "business documents",
+      "num_solutions": 2,
+      "enable_handwriting": false,
+      "output_detail": "minimal"
+    }
+  }' \
+  --output documents.zip \
+  -D headers.txt
+```
+
+**Response:**
+- Returns ZIP file directly (binary)
+- Headers saved to `headers.txt` contain:
+  - `X-Request-ID: 550e8400-e29b-41d4-a716-446655440000`
+  - `X-Status-URL: /jobs/550e8400-e29b-41d4-a716-446655440000/status`
+
+**Check Status:**
+```bash
+# Extract request_id from headers.txt, then:
+curl http://localhost:8000/jobs/550e8400-e29b-41d4-a716-446655440000/status
+```
+
+#### Mode 3: Full Production (Tracking + GDrive)
+
+```bash
+curl -X POST http://localhost:8000/generate/pdf \
+  -H "Content-Type: application/json" \
+  -d '{
+    "user_id": 123,
+    "google_drive_token": "ya29.a0AfH6SMBx...",
+    "google_drive_refresh_token": "1//0gw...",
+    "seed_images": ["https://ocr.space/Content/Images/receipt-ocr-original.webp"],
+    "prompt_params": {
+      "language": "English",
+      "doc_type": "invoices",
+      "num_solutions": 1,
+      "enable_handwriting": false,
+      "output_detail": "dataset"
+    }
+  }' \
+  --output documents.zip \
+  -D headers.txt
+```
+
+**Response:**
+- Returns ZIP file immediately (binary)
+- Google Drive upload happens in background
+- Wait 10-30 seconds, then check status for GDrive URL:
+
+```bash
+curl http://localhost:8000/jobs/550e8400-e29b-41d4-a716-446655440000/status
+```
+
+**Response (after background upload):**
+```json
+{
+  "request_id": "550e8400-e29b-41d4-a716-446655440000",
+  "status": "completed",
+  "created_at": "2026-03-01T10:00:00Z",
+  "updated_at": "2026-03-01T10:00:45Z",
+  "results": {
+    "download_url": "https://drive.google.com/file/d/abc123xyz/view?usp=sharing",
+    "file_size_mb": 0.15,
+    "document_count": 1,
+    "zip_filename": "docgenie_550e8400-e29b-41d4-a716-446655440000.zip"
+  }
+}
+```
+
+---
+
+## Frontend Integration Example
+
+### React + TypeScript
+
+```typescript
+import { useState, useEffect } from 'react';
+
+interface JobStatus {
+  request_id: string;
+  status: 'queued' | 'processing' | 'generating' | 'completed' | 'failed';
+  download_url?: string;
+  error_message?: string;
+}
+
+function DocumentGenerator() {
+  const [jobId, setJobId] = useState<string | null>(null);
+  const [status, setStatus] = useState<JobStatus | null>(null);
+  const [googleToken, setGoogleToken] = useState<string>('');
+
+  // Step 1: Google OAuth (implement separately)
+  const handleGoogleAuth = async () => {
+    // Redirect to Google OAuth
+    const clientId = 'YOUR_CLIENT_ID';
+    const redirectUri = 'https://yourapp.com/auth/callback';
+    const scope = 'https://www.googleapis.com/auth/drive.file';
+    
+    const authUrl = `https://accounts.google.com/o/oauth2/v2/auth?` +
+      `client_id=${clientId}&` +
+      `redirect_uri=${redirectUri}&` +
+      `response_type=code&` +
+      `scope=${scope}&` +
+      `access_type=offline&` +
+      `prompt=consent`;
+    
+    window.location.href = authUrl;
+  };
+
+  // Step 2: Submit job
+  const handleGenerateDocuments = async () => {
+    const response = await fetch('http://localhost:8000/generate/async', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        user_id: 1,
+        google_drive_token: googleToken,
+        seed_images: ['https://example.com/seed.jpg'],
+        prompt_params: {
+          language: 'English',
+          doc_type: 'receipts',
+          num_solutions: 3
+        }
+      })
+    });
+
+    const job = await response.json();
+    setJobId(job.request_id);
+  };
+
+  // Step 3: Poll status
+  useEffect(() => {
+    if (!jobId) return;
+
+    const interval = setInterval(async () => {
+      const response = await fetch(
+        `http://localhost:8000/jobs/${jobId}/status`
+      );
+      const data = await response.json();
+      setStatus(data);
+
+      if (data.status === 'completed' || data.status === 'failed') {
+        clearInterval(interval);
+      }
+    }, 30000); // Poll every 30 seconds
+
+    return () => clearInterval(interval);
+  }, [jobId]);
+
+  return (
+    <div>
+      {!googleToken ? (
+        <button onClick={handleGoogleAuth}>
+          Connect Google Drive
+        </button>
+      ) : (
+        <button onClick={handleGenerateDocuments}>
+          Generate Documents
+        </button>
+      )}
+
+      {status && (
+        <div>
+          <p>Status: {status.status}</p>
+          {status.status === 'completed' && (
+            <a href={status.download_url} target="_blank">
+              Download Documents
+            </a>
+          )}
+          {status.status === 'failed' && (
+            <p>Error: {status.error_message}</p>
+          )}
+        </div>
+      )}
+    </div>
+  );
+}
+```
+
+---
+
+## Troubleshooting
+
+### Issue: "google_drive_token is required"
+
+**Cause**: No token provided in request
+
+**Solution**:
+```bash
+# Make sure you're passing the token
+python test_async_api.py --google-token "ya29.a0AfH6SMBx..."
+```
+
+### Issue: "Failed to refresh Google Drive token"
+
+**Cause**: Token expired and no refresh token provided
+
+**Solutions**:
+1. Get a new token (tokens expire in ~1 hour)
+2. Include refresh token in request
+3. Frontend should refresh tokens automatically
+
+### Issue: "Google Drive upload failed: insufficient permissions"
+
+**Cause**: Token doesn't have drive.file scope
+
+**Solution**: Re-authorize with correct scope:
+```
+https://www.googleapis.com/auth/drive.file
+```
+
+### Issue: Worker not processing jobs
+
+**Check 1**: Is Redis running?
+```bash
+redis-cli ping  # Should return "PONG"
+```
+
+**Check 2**: Is worker running?
+```bash
+# Check worker logs
+journalctl -u docgenie-worker@1 -f
+
+# Or check RQ info
+rq info --url redis://localhost:6379/0
+```
+
+**Check 3**: Check failed queue
+```bash
+rq info --queue failed --url redis://localhost:6379/0
+```
+
+### Issue: Job stuck in "generating" status
+
+**Cause**: Batch API taking longer than expected
+
+**Solution**: Wait up to 30 minutes for batched requests. Check Anthropic dashboard:
+https://console.anthropic.com/settings/batches
+
+### Issue: Cannot access Google Drive link
+
+**Cause**: File not shared properly
+
+**Solution**: Check worker logs for sharing errors. File should have "anyone with link" permission.
+
+---
+
+## Performance Testing
+
+### Test Batch API Cost Savings
+
+```bash
+# Generate 10 documents
+time python test_async_api.py --google-token TOKEN --num-solutions 10
+
+# Compare with direct API (for reference)
+curl -X POST http://localhost:8000/generate \
+  -H "Content-Type: application/json" \
+  -d '{"seed_images": ["..."], "prompt_params": {"num_solutions": 10}}'
+```
+
+**Expected Results:**
+- **Batched API**: 10-20 minutes, ~$2.50 per 1M tokens
+- **Direct API**: 3-5 minutes, ~$5.00 per 1M tokens
+- **Cost Savings**: 50%
+
+---
+
+## Next Steps
+
+1. ✅ Test locally with script
+2. ✅ Verify Google Drive upload
+3. ✅ Test with your frontend
+4. ✅ Deploy to production (see [DEPLOYMENT.md](DEPLOYMENT.md))
+5. ✅ Set up monitoring (see [SCALING.md](SCALING.md))
+
+---
+
+## Additional Resources
+
+- **API Documentation**: http://localhost:8000/docs
+- **Deployment Guide**: [DEPLOYMENT.md](DEPLOYMENT.md)
+- **Scaling Guide**: [SCALING.md](SCALING.md)
+- **Google OAuth Docs**: https://developers.google.com/identity/protocols/oauth2
+- **Anthropic Batch API**: https://docs.anthropic.com/en/docs/batch-api

api/__init__.py

@@ -0,0 +1,4 @@
+"""
+DocGenie FastAPI - REST API for document generation.
+"""
+__version__ = "1.0.0"

api/config.py

@@ -0,0 +1,128 @@
+"""
+Configuration settings for DocGenie API
+"""
+import os
+from typing import Optional, List
+
+
+class Settings:
+    """API configuration settings"""
+    
+    # ==================== LLM Configuration ====================
+    ANTHROPIC_API_KEY: str = os.getenv("ANTHROPIC_API_KEY", "")
+    CLAUDE_MODEL: str = os.getenv("CLAUDE_MODEL", "claude-sonnet-4-5-20250929")
+    # Backward compatibility
+    LLM_MODEL: str = os.getenv("LLM_MODEL", CLAUDE_MODEL)
+    
+    # ==================== Handwriting Service (Stage 3) ====================
+    HANDWRITING_SERVICE_URL: str = os.getenv(
+        "HANDWRITING_SERVICE_URL",
+        "http://localhost:8080"
+    )
+    RUNPOD_API_KEY: str = os.getenv("RUNPOD_API_KEY", "")
+    HANDWRITING_SERVICE_TIMEOUT: int = int(os.getenv("HANDWRITING_SERVICE_TIMEOUT", "300"))
+    HANDWRITING_SERVICE_MAX_RETRIES: int = int(os.getenv("HANDWRITING_SERVICE_MAX_RETRIES", "3"))
+    HANDWRITING_SERVICE_ENABLED: bool = os.getenv("HANDWRITING_SERVICE_ENABLED", "false").lower() == "true"
+    HANDWRITING_APPLY_BLUR: bool = os.getenv("HANDWRITING_APPLY_BLUR", "false").lower() == "true"
+    
+    # ==================== OCR Service (Stage 4) ====================
+    OCR_SERVICE_URL: str = os.getenv("OCR_SERVICE_URL", "http://localhost:8000")
+    OCR_SERVICE_TIMEOUT: int = int(os.getenv("OCR_SERVICE_TIMEOUT", "30"))
+    OCR_SERVICE_ENABLED: bool = os.getenv("OCR_SERVICE_ENABLED", "false").lower() == "true"
+    OCR_ENGINE: str = os.getenv("OCR_ENGINE", "microsoft_di")
+    OCR_DPI: int = int(os.getenv("OCR_DPI", "300"))  # DPI for PDF to image conversion
+    
+    # Local Tesseract OCR (alternative to remote service)
+    OCR_USE_LOCAL: bool = os.getenv("OCR_USE_LOCAL", "false").lower() == "true"
+    OCR_TESSERACT_LANG: str = os.getenv("OCR_TESSERACT_LANG", "eng")  # Tesseract language
+    OCR_TESSERACT_CONFIG: str = os.getenv("OCR_TESSERACT_CONFIG", "--psm 3")  # Tesseract config
+    
+    # ==================== Stage 5: Dataset Packaging ====================
+    # Stage 16: BBox normalization
+    BBOX_NORMALIZATION_ENABLED: bool = os.getenv("BBOX_NORMALIZATION_ENABLED", "false").lower() == "true"
+    BBOX_NORMALIZATION_SCALE: str = os.getenv("BBOX_NORMALIZATION_SCALE", "0-1")  # "0-1" or "0-1000"
+    
+    # Stage 17: GT verification
+    GT_VERIFICATION_ENABLED: bool = os.getenv("GT_VERIFICATION_ENABLED", "false").lower() == "true"
+    GT_VERIFICATION_SIMILARITY_CUTOFF: float = float(os.getenv("GT_VERIFICATION_SIMILARITY_CUTOFF", "0.8"))
+    GT_VERIFICATION_OVERLAP_THRESHOLD: float = float(os.getenv("GT_VERIFICATION_OVERLAP_THRESHOLD", "0.5"))
+    
+    # Stage 18: Analysis
+    ANALYSIS_ENABLED: bool = os.getenv("ANALYSIS_ENABLED", "false").lower() == "true"
+    ANALYSIS_MIN_ANNOTATION_COUNT: int = int(os.getenv("ANALYSIS_MIN_ANNOTATION_COUNT", "1"))
+    
+    # Stage 19: Debug visualization
+    DEBUG_VISUALIZATION_ENABLED: bool = os.getenv("DEBUG_VISUALIZATION_ENABLED", "false").lower() == "true"
+    DEBUG_SHOW_TEXT_IN_BBOX: bool = os.getenv("DEBUG_SHOW_TEXT_IN_BBOX", "true").lower() == "true"
+    DEBUG_BBOX_COLOR_RGB: str = os.getenv("DEBUG_BBOX_COLOR_RGB", "255,0,0")  # Red default
+    
+    # Dataset export
+    DATASET_EXPORT_ENABLED: bool = os.getenv("DATASET_EXPORT_ENABLED", "false").lower() == "true"
+    DATASET_EXPORT_FORMAT: str = os.getenv("DATASET_EXPORT_FORMAT", "msgpack")  # msgpack, coco, huggingface
+    DATASET_EXPORT_DIR: str = os.getenv("DATASET_EXPORT_DIR", "/tmp/docgenie_datasets")
+    DATASET_RESIZE_IMAGES: bool = os.getenv("DATASET_RESIZE_IMAGES", "false").lower() == "true"
+    DATASET_CLIP_BBOXES_TO_FOREGROUND: bool = os.getenv("DATASET_CLIP_BBOXES_TO_FOREGROUND", "false").lower() == "true"
+    
+    # ==================== API Server Configuration ====================
+    API_HOST: str = os.getenv("API_HOST", "0.0.0.0")
+    API_PORT: int = int(os.getenv("API_PORT", "8000"))
+    DEBUG_MODE: bool = os.getenv("DEBUG_MODE", "false").lower() == "true"
+    
+    # ==================== CORS Configuration ====================
+    CORS_ORIGINS: List[str] = [
+        origin.strip() 
+        for origin in os.getenv("CORS_ORIGINS", "*").split(",")
+        if origin.strip()
+    ] or ["*"]
+    
+    # ==================== File Storage ====================
+    TEMP_DIR: str = os.getenv("TEMP_DIR", "/tmp/docgenie_api")
+    
+    # ==================== Logging ====================
+    LOG_LEVEL: str = os.getenv("LOG_LEVEL", "INFO")
+    
+    # ==================== Database (Optional) ====================
+    DATABASE_URL: Optional[str] = os.getenv("DATABASE_URL", None)
+    REDIS_URL: Optional[str] = os.getenv("REDIS_URL", "redis://localhost:6379/0")
+    
+    # ==================== Supabase ====================
+    SUPABASE_URL: str = os.getenv("SUPABASE_URL", "")
+    SUPABASE_KEY: str = os.getenv("SUPABASE_KEY", "")
+    
+    # ==================== Background Jobs ====================
+    RQ_QUEUE_NAME: str = os.getenv("RQ_QUEUE_NAME", "docgenie")
+    BATCH_POLL_INTERVAL: int = int(os.getenv("BATCH_POLL_INTERVAL", "30"))  # seconds
+    BATCH_PROMPT_CHUNK_SIZE: int = int(os.getenv("BATCH_PROMPT_CHUNK_SIZE", "4"))  # documents per prompt
+    BATCH_DATA_DIR: str = os.getenv("BATCH_DATA_DIR", "/tmp/docgenie_batches")
+    MESSAGE_DATA_DIR: str = os.getenv("MESSAGE_DATA_DIR", "/tmp/docgenie_messages")
+    
+    # ==================== Google Drive ====================
+    GOOGLE_DRIVE_FOLDER_NAME: str = os.getenv("GOOGLE_DRIVE_FOLDER_NAME", "DocGenie Documents")
+    GOOGLE_CLIENT_ID: Optional[str] = os.getenv("GOOGLE_CLIENT_ID", None)  # For token refresh only
+    GOOGLE_CLIENT_SECRET: Optional[str] = os.getenv("GOOGLE_CLIENT_SECRET", None)  # For token refresh only
+    
+    # ==================== Monitoring ====================
+    SENTRY_DSN: Optional[str] = os.getenv("SENTRY_DSN", None)
+    ENABLE_METRICS: bool = os.getenv("ENABLE_METRICS", "false").lower() == "true"
+    METRICS_PORT: int = int(os.getenv("METRICS_PORT", "9090"))
+    
+    # ==================== AWS (Optional) ====================
+    AWS_ACCESS_KEY_ID: Optional[str] = os.getenv("AWS_ACCESS_KEY_ID", None)
+    AWS_SECRET_ACCESS_KEY: Optional[str] = os.getenv("AWS_SECRET_ACCESS_KEY", None)
+    AWS_REGION: str = os.getenv("AWS_REGION", "us-east-1")
+    S3_BUCKET: Optional[str] = os.getenv("S3_BUCKET", None)
+    
+    @classmethod
+    def validate(cls) -> bool:
+        """Validate required settings"""
+        if not cls.ANTHROPIC_API_KEY:
+            raise ValueError("ANTHROPIC_API_KEY environment variable is required")
+        return True
+    
+    @classmethod
+    def get_cors_origins(cls) -> List[str]:
+        """Get CORS origins list"""
+        return cls.CORS_ORIGINS if cls.CORS_ORIGINS != ["*"] else ["*"]
+
+
+settings = Settings()

api/dataset_exporter.py

@@ -0,0 +1,733 @@
+"""
+Dataset Export Manager for DocGenie API
+
+Handles organizing generated documents into a proper dataset structure
+following the original pipeline's SyntheticDatasetFileStructure pattern.
+"""
+
+import pathlib
+import json
+import base64
+import shutil
+from typing import Dict, List, Optional, Any
+
+
+class DatasetExporter:
+    """
+    Manages export of generated documents to organized dataset structure.
+    
+    Structure follows original pipeline pattern:
+    - Single msgpack for all documents
+    - Categorized folders (html/, pdf/, bbox/, etc.)
+    - Subfolders for per-document tokens
+    """
+    
+    def __init__(self, base_path: pathlib.Path, dataset_name: str = "docgenie_documents"):
+        """
+        Initialize dataset exporter.
+        
+        Args:
+            base_path: Base directory for dataset export
+            dataset_name: Name of the dataset (will be subfolder name)
+        """
+        self.base_path = base_path / dataset_name
+        self.dataset_name = dataset_name
+        self.documents = []
+        
+        # Create directory structure
+        self._create_directory_structure()
+    
+    def _create_directory_structure(self):
+        """Create the organized directory structure."""
+        directories = [
+            # Root level
+            self.base_path,
+            
+            # HTML files and CSS
+            self.html_dir,
+            
+            # PDF stages
+            self.pdf_initial_dir,
+            self.pdf_with_handwriting_dir,
+            self.pdf_with_visual_elements_dir,
+            self.pdf_final_dir,
+            
+            # Images
+            self.img_dir,
+            
+            # Bounding boxes
+            self.bbox_pdf_word_dir,
+            self.bbox_pdf_char_dir,
+            self.bbox_final_word_dir,
+            self.bbox_final_segment_dir,
+            self.bbox_final_normalized_word_dir,
+            self.bbox_final_normalized_segment_dir,
+            
+            # Annotations
+            self.raw_annotations_dir,
+            self.gt_dir,
+            self.gt_verification_dir,
+            self.token_mapping_dir,
+            
+            # Handwriting
+            self.handwriting_regions_dir,
+            self.handwriting_tokens_dir,
+            
+            # Visual elements
+            self.visual_element_definitions_dir,
+            self.visual_element_images_dir,
+            
+            # Layout elements
+            self.layout_dir,
+            
+            # Geometries
+            self.geometries_dir,
+            
+            # OCR results
+            self.ocr_results_dir,
+            
+            # Analysis
+            self.analysis_dir,
+            
+            # Debug visualizations
+            self.debug_dir,
+        ]
+        
+        for directory in directories:
+            directory.mkdir(parents=True, exist_ok=True)
+    
+    # ==================== Directory Properties ====================
+    
+    @property
+    def html_dir(self) -> pathlib.Path:
+        """HTML and CSS files"""
+        return self.base_path / "html"
+    
+    @property
+    def pdf_initial_dir(self) -> pathlib.Path:
+        """PDFs before any synthesis"""
+        return self.base_path / "pdf" / "pdf_initial"
+    
+    @property
+    def pdf_with_handwriting_dir(self) -> pathlib.Path:
+        """PDFs with only handwriting added"""
+        return self.base_path / "pdf" / "pdf_with_handwriting"
+    
+    @property
+    def pdf_with_visual_elements_dir(self) -> pathlib.Path:
+        """PDFs with only visual elements added"""
+        return self.base_path / "pdf" / "pdf_with_visual_elements"
+    
+    @property
+    def pdf_final_dir(self) -> pathlib.Path:
+        """PDFs with both handwriting and visual elements"""
+        return self.base_path / "pdf" / "pdf_final"
+    
+    @property
+    def img_dir(self) -> pathlib.Path:
+        """Final rendered images"""
+        return self.base_path / "img"
+    
+    @property
+    def bbox_pdf_word_dir(self) -> pathlib.Path:
+        """Word-level bounding boxes extracted from PDF (ground truth positions)"""
+        return self.base_path / "bbox" / "bbox_pdf" / "word"
+    
+    @property
+    def bbox_pdf_char_dir(self) -> pathlib.Path:
+        """Character-level bounding boxes extracted from PDF"""
+        return self.base_path / "bbox" / "bbox_pdf" / "char"
+    
+    @property
+    def bbox_final_word_dir(self) -> pathlib.Path:
+        """Final word-level bounding boxes (from OCR if modifications applied, else from PDF)"""
+        return self.base_path / "bbox" / "bbox_final" / "word"
+    
+    @property
+    def bbox_final_segment_dir(self) -> pathlib.Path:
+        """Final segment-level bounding boxes (from OCR if modifications applied, else from PDF)"""
+        return self.base_path / "bbox" / "bbox_final" / "segment"
+    
+    @property
+    def bbox_final_normalized_word_dir(self) -> pathlib.Path:
+        """Normalized word-level bounding boxes"""
+        return self.base_path / "bbox" / "bbox_final_normalized" / "word"
+    
+    @property
+    def bbox_final_normalized_segment_dir(self) -> pathlib.Path:
+        """Normalized segment-level bounding boxes"""
+        return self.base_path / "bbox" / "bbox_final_normalized" / "segment"
+    
+    @property
+    def raw_annotations_dir(self) -> pathlib.Path:
+        """Raw annotations (layout boxes before normalization)"""
+        return self.base_path / "annotations" / "raw_annotations"
+    
+    @property
+    def gt_dir(self) -> pathlib.Path:
+        """Ground truth annotations"""
+        return self.base_path / "annotations" / "gt"
+    
+    @property
+    def gt_verification_dir(self) -> pathlib.Path:
+        """Ground truth verification results"""
+        return self.base_path / "annotations" / "gt_verification"
+    
+    @property
+    def token_mapping_dir(self) -> pathlib.Path:
+        """Token mapping files"""
+        return self.base_path / "annotations" / "token_mapping"
+    
+    @property
+    def handwriting_regions_dir(self) -> pathlib.Path:
+        """Handwriting region definitions"""
+        return self.base_path / "handwriting" / "handwriting_regions"
+    
+    @property
+    def handwriting_tokens_dir(self) -> pathlib.Path:
+        """Handwriting token images (per-document subfolders)"""
+        return self.base_path / "handwriting" / "handwriting_tokens"
+    
+    @property
+    def visual_element_definitions_dir(self) -> pathlib.Path:
+        """Visual element definitions"""
+        return self.base_path / "visual_elements" / "visual_element_definitions"
+    
+    @property
+    def visual_element_images_dir(self) -> pathlib.Path:
+        """Visual element images (per-document subfolders)"""
+        return self.base_path / "visual_elements" / "visual_element_images"
+    
+    @property
+    def layout_dir(self) -> pathlib.Path:
+        """Layout element definitions"""
+        return self.base_path / "layout"
+    
+    @property
+    def geometries_dir(self) -> pathlib.Path:
+        """Extracted geometries from HTML"""
+        return self.base_path / "geometries"
+    
+    @property
+    def ocr_results_dir(self) -> pathlib.Path:
+        """OCR results"""
+        return self.base_path / "ocr_results"
+    
+    @property
+    def analysis_dir(self) -> pathlib.Path:
+        """Analysis statistics"""
+        return self.base_path / "analysis"
+    
+    @property
+    def debug_dir(self) -> pathlib.Path:
+        """Debug visualizations"""
+        return self.base_path / "debug"
+    
+    @property
+    def msgpack_path(self) -> pathlib.Path:
+        """
+        Path to the dataset msgpack file.
+        
+        This file aggregates all documents in the dataset into a single msgpack
+        for efficient loading during ML training.
+        """
+        return self.base_path / "dataset.msgpack"
+    
+    @property
+    def metadata_path(self) -> pathlib.Path:
+        """Path to dataset metadata JSON"""
+        return self.base_path / "metadata.json"
+    
+    # ==================== Export Methods ====================
+    
+    def add_document(
+        self,
+        document_id: str,
+        html: str,
+        css: str,
+        pdf_initial: Optional[bytes] = None,
+        pdf_with_handwriting: Optional[bytes] = None,
+        pdf_with_visual_elements: Optional[bytes] = None,
+        pdf_final: Optional[bytes] = None,
+        final_image: Optional[bytes] = None,
+        ground_truth: Optional[dict] = None,
+        raw_annotations: Optional[list] = None,
+        bboxes_pdf_word: Optional[list] = None,
+        bboxes_pdf_char: Optional[list] = None,
+        bboxes_final_word: Optional[list] = None,
+        bboxes_final_segment: Optional[list] = None,
+        bboxes_normalized_word: Optional[dict] = None,
+        bboxes_normalized_segment: Optional[dict] = None,
+        gt_verification: Optional[dict] = None,
+        token_mapping: Optional[dict] = None,
+        handwriting_regions: Optional[list] = None,
+        handwriting_images: Optional[dict] = None,  # {hw_id: base64_png}
+        visual_elements: Optional[list] = None,
+        visual_element_images: Optional[dict] = None,  # {ve_id: base64_png}
+        layout_elements: Optional[list] = None,
+        geometries: Optional[list] = None,  # List of element geometry dicts
+        ocr_results: Optional[dict] = None,
+        analysis_stats: Optional[dict] = None,
+        debug_visualization: Optional[bytes] = None,
+    ):
+        """
+        Add a document to the dataset export.
+        
+        Args:
+            document_id: Unique document identifier
+            html: Document HTML content
+            css: Document CSS content
+            pdf_initial: Initial PDF bytes (before modifications)
+            pdf_with_handwriting: PDF bytes after handwriting insertion
+            pdf_with_visual_elements: PDF bytes after visual element insertion (no handwriting)
+            pdf_final: PDF bytes with both handwriting and visual elements
+            final_image: Final rendered image (PNG bytes)
+            ground_truth: Ground truth annotations
+            raw_annotations: Raw layout boxes (before normalization)
+            bboxes_pdf_word: Word-level bboxes from PDF (ground truth)
+            bboxes_pdf_char: Character-level bboxes from PDF
+            bboxes_final_word: Final word-level bboxes (OCR or PDF)
+            bboxes_final_segment: Final segment-level bboxes (OCR or PDF)
+            bboxes_normalized_word: Normalized word-level bboxes
+            bboxes_normalized_segment: Normalized segment-level bboxes
+            gt_verification: Ground truth verification results
+            token_mapping: Token to bbox mapping
+            handwriting_regions: Handwriting region metadata
+            handwriting_images: Dict of handwriting token images
+            visual_elements: Visual element metadata
+            visual_element_images: Dict of visual element images
+            layout_elements: Layout element definitions
+            geometries: Extracted geometries from HTML
+            ocr_results: OCR results
+            analysis_stats: Analysis statistics
+            debug_visualization: Debug visualization image (PNG bytes)
+        """
+        # Save HTML and CSS
+        (self.html_dir / f"{document_id}.html").write_text(html, encoding='utf-8')
+        (self.html_dir / f"{document_id}.css").write_text(css, encoding='utf-8')
+        
+        # Save all PDF stages
+        if pdf_initial:
+            (self.pdf_initial_dir / f"{document_id}.pdf").write_bytes(pdf_initial)
+        
+        if pdf_with_handwriting:
+            (self.pdf_with_handwriting_dir / f"{document_id}.pdf").write_bytes(pdf_with_handwriting)
+        
+        if pdf_with_visual_elements:
+            (self.pdf_with_visual_elements_dir / f"{document_id}.pdf").write_bytes(pdf_with_visual_elements)
+        
+        if pdf_final:
+            (self.pdf_final_dir / f"{document_id}.pdf").write_bytes(pdf_final)
+        
+        # Save final image
+        if final_image:
+            (self.img_dir / f"{document_id}.png").write_bytes(final_image)
+        
+        # Save annotations
+        if raw_annotations:
+            (self.raw_annotations_dir / f"{document_id}.json").write_text(
+                json.dumps(raw_annotations, indent=2, ensure_ascii=False), encoding='utf-8'
+            )
+        
+        if ground_truth:
+            (self.gt_dir / f"{document_id}.json").write_text(
+                json.dumps(ground_truth, indent=2, ensure_ascii=False), encoding='utf-8'
+            )
+        
+        if gt_verification:
+            (self.gt_verification_dir / f"{document_id}.json").write_text(
+                json.dumps(gt_verification, indent=2, ensure_ascii=False), encoding='utf-8'
+            )
+        
+        if token_mapping:
+            (self.token_mapping_dir / f"{document_id}.json").write_text(
+                json.dumps(token_mapping, indent=2, ensure_ascii=False), encoding='utf-8'
+            )
+        
+        # Save bounding boxes
+        if bboxes_pdf_word:
+            (self.bbox_pdf_word_dir / f"{document_id}.json").write_text(
+                json.dumps(bboxes_pdf_word, indent=2, ensure_ascii=False), encoding='utf-8'
+            )
+        
+        if bboxes_pdf_char:
+            (self.bbox_pdf_char_dir / f"{document_id}.json").write_text(
+                json.dumps(bboxes_pdf_char, indent=2, ensure_ascii=False), encoding='utf-8'
+            )
+        
+        if bboxes_final_word:
+            (self.bbox_final_word_dir / f"{document_id}.json").write_text(
+                json.dumps(bboxes_final_word, indent=2, ensure_ascii=False), encoding='utf-8'
+            )
+        
+        if bboxes_final_segment:
+            (self.bbox_final_segment_dir / f"{document_id}.json").write_text(
+                json.dumps(bboxes_final_segment, indent=2, ensure_ascii=False), encoding='utf-8'
+            )
+        
+        if bboxes_normalized_word:
+            (self.bbox_final_normalized_word_dir / f"{document_id}.json").write_text(
+                json.dumps(bboxes_normalized_word, indent=2, ensure_ascii=False), encoding='utf-8'
+            )
+        
+        if bboxes_normalized_segment:
+            (self.bbox_final_normalized_segment_dir / f"{document_id}.json").write_text(
+                json.dumps(bboxes_normalized_segment, indent=2, ensure_ascii=False), encoding='utf-8'
+            )
+        
+        # Save handwriting data
+        if handwriting_regions:
+            (self.handwriting_regions_dir / f"{document_id}.json").write_text(
+                json.dumps(handwriting_regions, indent=2, ensure_ascii=False), encoding='utf-8'
+            )
+        
+        if handwriting_images:
+            # Create subfolder for this document's tokens
+            doc_hw_tokens_dir = self.handwriting_tokens_dir / document_id
+            doc_hw_tokens_dir.mkdir(parents=True, exist_ok=True)
+            
+            for hw_id, img_b64 in handwriting_images.items():
+                img_bytes = base64.b64decode(img_b64)
+                (doc_hw_tokens_dir / f"{hw_id}.png").write_bytes(img_bytes)
+        
+        # Save visual element data
+        if visual_elements:
+            (self.visual_element_definitions_dir / f"{document_id}.json").write_text(
+                json.dumps(visual_elements, indent=2, ensure_ascii=False), encoding='utf-8'
+            )
+        
+        if visual_element_images:
+            # Create subfolder for this document's visual elements
+            doc_ve_images_dir = self.visual_element_images_dir / document_id
+            doc_ve_images_dir.mkdir(parents=True, exist_ok=True)
+            
+            for ve_id, img_b64 in visual_element_images.items():
+                img_bytes = base64.b64decode(img_b64)
+                (doc_ve_images_dir / f"{ve_id}.png").write_bytes(img_bytes)
+        
+        # Save other data
+        if layout_elements:
+            (self.layout_dir / f"{document_id}.json").write_text(
+                json.dumps(layout_elements, indent=2, ensure_ascii=False), encoding='utf-8'
+            )
+        
+        if geometries:
+            (self.geometries_dir / f"{document_id}.json").write_text(
+                json.dumps(geometries, indent=2, ensure_ascii=False), encoding='utf-8'
+            )
+        
+        if ocr_results:
+            (self.ocr_results_dir / f"{document_id}.json").write_text(
+                json.dumps(ocr_results, indent=2, ensure_ascii=False), encoding='utf-8'
+            )
+        
+        if analysis_stats:
+            (self.analysis_dir / f"{document_id}.json").write_text(
+                json.dumps(analysis_stats, indent=2, ensure_ascii=False), encoding='utf-8'
+            )
+        
+        if debug_visualization:
+            (self.debug_dir / f"{document_id}_debug.png").write_bytes(debug_visualization)
+        
+        # Track document for metadata
+        self.documents.append({
+            'document_id': document_id,
+            'has_handwriting': handwriting_regions is not None and len(handwriting_regions) > 0,
+            'has_visual_elements': visual_elements is not None and len(visual_elements) > 0,
+            'has_ocr': ocr_results is not None,
+            'modification_type': (
+                "both" if pdf_final
+                else "handwriting" if pdf_with_handwriting
+                else "visual_elements" if pdf_with_visual_elements
+                else None
+            )
+        })
+    
+    def finalize(
+        self,
+        request_id: Optional[str] = None,
+        user_id: Optional[int] = None,
+        prompt_params: Optional[dict] = None,
+        api_mode: str = "sync"
+    ) -> pathlib.Path:
+        """
+        Finalize the dataset export by creating metadata, README, and optionally msgpack.
+        
+        Args:
+            request_id: Request UUID for tracking
+            user_id: User ID who made the request
+            prompt_params: Prompt parameters used for generation
+            api_mode: "sync" or "async"
+        
+        Returns:
+            Path to the dataset base directory
+        """
+        # Create metadata
+        metadata = {
+            'dataset_name': self.dataset_name,
+            'num_documents': len(self.documents),
+            'documents': self.documents,
+            'structure_version': '2.0',
+            'structure_description': 'Organized dataset following original pipeline structure',
+            'generation_metadata': {
+                'request_id': request_id,
+                'user_id': user_id,
+                'api_mode': api_mode,
+                'prompt_params': prompt_params or {}
+            }
+        }
+        
+        self.metadata_path.write_text(
+            json.dumps(metadata, indent=2, ensure_ascii=False), encoding='utf-8'
+        )
+        
+        # Create README
+        readme_content = self._generate_readme()
+        (self.base_path / "README.md").write_text(readme_content, encoding='utf-8')
+        
+        # Create msgpack dataset only if explicitly enabled
+        enable_dataset_export = prompt_params.get('enable_dataset_export', False) if prompt_params else False
+        dataset_export_format = prompt_params.get('dataset_export_format', 'msgpack') if prompt_params else 'msgpack'
+        
+        if enable_dataset_export and dataset_export_format.lower() == 'msgpack':
+            # Also check if bbox normalization was enabled (required for msgpack)
+            enable_bbox_normalization = prompt_params.get('enable_bbox_normalization', False) if prompt_params else False
+            
+            if enable_bbox_normalization:
+                self._create_msgpack_dataset()
+            else:
+                print(f"  ⚠ Msgpack export requested but bbox_normalization is disabled")
+                print(f"     Msgpack requires normalized bboxes. Enable 'enable_bbox_normalization: true' to export msgpack.")
+        
+        return self.base_path
+    
+    def _create_msgpack_dataset(self):
+        """
+        Create a single msgpack file aggregating all documents.
+        
+        This follows the original pipeline's approach of creating one msgpack
+        with all documents for easy loading in ML training pipelines.
+        """
+        try:
+            from datadings.writer import FileWriter
+            
+            print(f"  📦 Creating msgpack dataset...")
+            
+            # Collect all samples
+            samples = []
+            for doc in self.documents:
+                doc_id = doc['document_id']
+                
+                # Read normalized bboxes (required for msgpack)
+                bbox_word_path = self.bbox_final_normalized_word_dir / f"{doc_id}.json"
+                bbox_segment_path = self.bbox_final_normalized_segment_dir / f"{doc_id}.json"
+                
+                # Skip if bboxes don't exist
+                if not bbox_word_path.exists():
+                    print(f"  ⚠ Skipping {doc_id}: no normalized bboxes found")
+                    continue
+                
+                # Read word bboxes
+                word_bboxes_data = json.loads(bbox_word_path.read_text(encoding='utf-8'))
+                
+                # Read segment bboxes (fallback to word if not available)
+                if bbox_segment_path.exists():
+                    segment_bboxes_data = json.loads(bbox_segment_path.read_text(encoding='utf-8'))
+                else:
+                    segment_bboxes_data = word_bboxes_data
+                
+                # Extract words and bboxes
+                words = [item['text'] for item in word_bboxes_data if 'text' in item]
+                word_bboxes = [item['bbox'] for item in word_bboxes_data if 'bbox' in item]
+                segment_bboxes = [item['bbox'] for item in segment_bboxes_data if 'bbox' in item]
+                
+                # Ensure bbox format is [x0, y0, x2, y2] (normalized)
+                # If dict format, convert
+                word_bboxes = [
+                    bbox if isinstance(bbox, list) else [bbox['x0'], bbox['y0'], bbox['x2'], bbox['y2']]
+                    for bbox in word_bboxes
+                ]
+                segment_bboxes = [
+                    bbox if isinstance(bbox, list) else [bbox['x0'], bbox['y0'], bbox['x2'], bbox['y2']]
+                    for bbox in segment_bboxes
+                ]
+                
+                # Read ground truth
+                gt_path = self.gt_dir / f"{doc_id}.json"
+                annotations = {}
+                if gt_path.exists():
+                    annotations = json.loads(gt_path.read_text(encoding='utf-8'))
+                
+                # Determine image file path
+                img_path = self.img_dir / f"{doc_id}.png"
+                if not img_path.exists():
+                    # Fallback to PDF
+                    img_path = self.pdf_final_dir / f"{doc_id}.pdf"
+                    if not img_path.exists():
+                        img_path = self.pdf_initial_dir / f"{doc_id}.pdf"
+                
+                # Create sample dictionary matching original pipeline format
+                sample = {
+                    'key': doc_id,
+                    'sample_id': doc_id,
+                    'image_file_path': str(img_path),
+                    'words': words,
+                    'word_bboxes': word_bboxes,
+                    'segment_level_bboxes': segment_bboxes,
+                }
+                
+                # Add annotations if present
+                if annotations:
+                    sample.update(annotations)
+                
+                samples.append(sample)
+            
+            if not samples:
+                print(f"  ⚠ No samples to write to msgpack - skipping")
+                return
+            
+            # Write all samples to msgpack
+            with FileWriter(self.msgpack_path, overwrite=True) as writer:
+                for sample in samples:
+                    writer.write(sample)
+            
+            print(f"  ✓ Created msgpack dataset: {self.msgpack_path.name} ({len(samples)} documents)")
+            
+        except ImportError:
+            print(f"  ⚠ datadings not installed - skipping msgpack creation")
+            print(f"    Install with: pip install datadings")
+        except Exception as e:
+            print(f"  ⚠ Failed to create msgpack: {str(e)}")
+            import traceback
+            traceback.print_exc()
+    
+    def _generate_readme(self) -> str:
+        """Generate README content for the dataset."""
+        return f"""# DocGenie Dataset: {self.dataset_name}
+
+Generated using DocGenie API - Synthetic Document Generation Pipeline
+
+## Dataset Structure
+
+This dataset follows the original pipeline's organized structure with categorized folders:
+
+```
+{self.dataset_name}/
+├── dataset.msgpack                    # Aggregated dataset (all documents)
+├── metadata.json                      # Dataset metadata
+├── README.md                          # This file
+│
+├── html/                              # HTML and CSS files
+│   ├── document_1.html
+│   ├── document_1.css
+│   └── ...
+│
+├── pdf/                               # PDF files at different stages
+│   ├── pdf_initial/                  # Before synthesis
+│   ├── pdf_with_handwriting/         # With handwriting only
+│   ├── pdf_with_visual_elements/     # With visual elements only
+│   └── pdf_final/                    # With both features
+│
+├── img/                               # Final rendered images
+│   ├── document_1.png
+│   └── ...
+│
+├── bbox/                              # Bounding boxes
+│   ├── bbox_pdf/                     # Extracted from PDF (ground truth positions)
+│   │   ├── word/                     # Word-level from PDF
+│   │   └── char/                     # Character-level from PDF
+│   ├── bbox_final/                   # Final bboxes (OCR if modified, else PDF)
+│   │   ├── word/                     # Word-level (unnormalized)
+│   │   └── segment/                  # Segment-level (unnormalized)
+│   └── bbox_final_normalized/        # Normalized (0-1 range)
+│       ├── word/                     # Word-level normalized
+│       └── segment/                  # Segment-level normalized
+│
+├── annotations/                       # Ground truth and mappings
+│   ├── raw_annotations/              # Raw layout boxes (before normalization)
+│   ├── gt/                           # Ground truth annotations
+│   ├── gt_verification/              # Verification results
+│   └── token_mapping/                # Token-to-bbox mappings
+│
+├── handwriting/                       # Handwriting data
+│   ├── handwriting_regions/          # Region definitions
+│   └── handwriting_tokens/           # Token images (subfolders per document)
+│       ├── document_1/
+│       │   ├── hw1_b3_l1_w0.png
+│       │   └── ...
+│       └── ...
+│
+├── visual_elements/                   # Visual element data
+│   ├── visual_element_definitions/   # Element definitions
+│   └── visual_element_images/        # Element images (subfolders per document)
+│       ├── document_1/
+│       │   ├── ve0.png
+│       │   └── ...
+│       └── ...
+│
+├── layout/                            # Layout element definitions
+├── geometries/                        # Extracted geometries
+├── ocr_results/                       # OCR results
+├── analysis/                          # Analysis statistics
+└── debug/                             # Debug visualizations
+```
+
+## Dataset Statistics
+
+- **Total Documents**: {len(self.documents)}
+- **Documents with Handwriting**: {sum(1 for d in self.documents if d['has_handwriting'])}
+- **Documents with Visual Elements**: {sum(1 for d in self.documents if d['has_visual_elements'])}
+- **Documents with OCR**: {sum(1 for d in self.documents if d['has_ocr'])}
+
+## Usage
+
+This dataset is designed for document understanding and OCR tasks. Files are organized by category for easy access and processing.
+
+### Loading the Entire Dataset (Msgpack)
+
+The easiest way to load all documents for ML training:
+
+```python
+from datadings.reader import MsgpackReader
+
+# Load the aggregated dataset
+reader = MsgpackReader('dataset.msgpack')
+
+# Iterate through all documents
+for sample in reader:
+    doc_id = sample['sample_id']
+    words = sample['words']
+    word_bboxes = sample['word_bboxes']  # Normalized [x0, y0, x2, y2]
+    image_path = sample['image_file_path']
+    # Ground truth annotations are included in the sample
+```
+
+For more information on msgpack format, see: https://github.com/mweiss/datadings
+
+### Loading Individual Documents
+
+Each document is identified by its `document_id` (e.g., "document_1"). To load a document:
+
+1. **HTML/CSS**: `html/document_1.html`, `html/document_1.css`
+2. **PDF stages**: Check `pdf/pdf_initial/`, `pdf/pdf_final/`, etc.
+3. **Images**: `img/document_1.png`
+4. **Annotations**: `annotations/gt/document_1.json`, `annotations/raw_annotations/document_1.json`
+5. **Bounding boxes**: 
+   - PDF-extracted (ground truth): `bbox/bbox_pdf/word/document_1.json`, `bbox/bbox_pdf/char/document_1.json`
+   - Final bboxes: `bbox/bbox_final/word/document_1.json` (OCR or PDF)
+   - Normalized: `bbox/bbox_final_normalized/word/document_1.json`
+6. **Tokens**: `handwriting/handwriting_tokens/document_1/`, `visual_elements/visual_element_images/document_1/`
+
+### Notes
+
+- Bounding boxes in `bbox_pdf` are extracted from PDF and represent ground truth text positions
+- Bounding boxes in `bbox_final` are from OCR (if document has handwriting/visual elements) or PDF (otherwise)
+- Bounding boxes in `bbox_final_normalized` are normalized to [0, 1] range for ML training
+- Character-level bboxes (`bbox_pdf/char/`) provide fine-grained text localization
+- Raw annotations show the original layout boxes before normalization
+- Token images are organized in per-document subfolders
+- OCR results and analysis are only present if those features were enabled
+
+---
+Generated by DocGenie API v2.0
+"""

api/example_usage.py

@@ -0,0 +1,143 @@
+"""
+Example usage of the DocGenie API.
+Demonstrates how to call the API and save generated documents.
+"""
+import asyncio
+import base64
+import json
+from pathlib import Path
+
+import httpx
+
+
+async def generate_documents_example():
+    """
+    Example: Generate documents from seed images.
+    """
+    # API endpoint
+    api_url = "http://localhost:8000/generate"
+    
+    # Example seed image URLs (replace with your actual URLs)
+    seed_image_urls = [
+        "https://example.com/receipt1.jpg",
+        "https://example.com/receipt2.jpg",
+        # Add more seed image URLs here
+    ]
+    
+    # Request payload
+    payload = {
+        "seed_images": seed_image_urls,
+        "prompt_params": {
+            "language": "English",
+            "doc_type": "business and administrative documents",
+            "gt_type": "Multiple questions about each document, with their answers taken **verbatim** from the document.",
+            "gt_format": '{"<Text of question 1>": "<Answer to question 1>", "<Text of question 2>": "<Answer to question 2>", ...}',
+            "num_solutions": 3
+        },
+        "model": "claude-sonnet-4-5-20250929"
+        # "api_key": "your-api-key"  # Optional if ANTHROPIC_API_KEY env var is set
+    }
+    
+    print("Sending request to DocGenie API...")
+    print(f"Seed images: {len(seed_image_urls)}")
+    print(f"Requested solutions: {payload['prompt_params']['num_solutions']}")
+    
+    async with httpx.AsyncClient(timeout=300.0) as client:
+        response = await client.post(api_url, json=payload)
+        
+        if response.status_code != 200:
+            print(f"Error: {response.status_code}")
+            print(response.text)
+            return
+        
+        result = response.json()
+    
+    print(f"\nSuccess! Generated {result['total_documents']} documents")
+    
+    # Create output directory
+    output_dir = Path("api_output")
+    output_dir.mkdir(exist_ok=True)
+    
+    # Process each generated document
+    for idx, doc in enumerate(result["documents"]):
+        doc_id = doc["document_id"]
+        print(f"\n--- Document {idx + 1} (ID: {doc_id}) ---")
+        
+        # Save PDF
+        pdf_path = output_dir / f"{doc_id}.pdf"
+        pdf_bytes = base64.b64decode(doc["pdf_base64"])
+        with open(pdf_path, "wb") as f:
+            f.write(pdf_bytes)
+        print(f"  PDF saved: {pdf_path}")
+        
+        # Save HTML
+        html_path = output_dir / f"{doc_id}.html"
+        with open(html_path, "w", encoding="utf-8") as f:
+            f.write(doc["html"])
+        print(f"  HTML saved: {html_path}")
+        
+        # Save CSS
+        css_path = output_dir / f"{doc_id}.css"
+        with open(css_path, "w", encoding="utf-8") as f:
+            f.write(doc["css"])
+        print(f"  CSS saved: {css_path}")
+        
+        # Save ground truth
+        if doc["ground_truth"]:
+            gt_path = output_dir / f"{doc_id}_gt.json"
+            with open(gt_path, "w", encoding="utf-8") as f:
+                json.dump(doc["ground_truth"], f, indent=2, ensure_ascii=False)
+            print(f"  Ground truth saved: {gt_path}")
+            print(f"  GT entries: {len(doc['ground_truth'])}")
+        
+        # Save bounding boxes
+        bbox_path = output_dir / f"{doc_id}_bboxes.json"
+        bboxes_data = [bbox for bbox in doc["bboxes"]]
+        with open(bbox_path, "w", encoding="utf-8") as f:
+            json.dump(bboxes_data, f, indent=2)
+        print(f"  Bounding boxes saved: {bbox_path}")
+        print(f"  BBox count: {len(doc['bboxes'])}")
+        
+        # Print document info
+        print(f"  Dimensions: {doc['page_width_mm']:.1f}mm x {doc['page_height_mm']:.1f}mm")
+    
+    print(f"\n✅ All files saved to: {output_dir.absolute()}")
+
+
+async def health_check_example():
+    """
+    Example: Check if the API is running.
+    """
+    api_url = "http://localhost:8000/health"
+    
+    print("Checking API health...")
+    
+    async with httpx.AsyncClient() as client:
+        response = await client.get(api_url)
+        
+        if response.status_code == 200:
+            result = response.json()
+            print(f"✅ API is healthy!")
+            print(f"   Status: {result['status']}")
+            print(f"   Version: {result['version']}")
+        else:
+            print(f"❌ API is not responding: {response.status_code}")
+
+
+if __name__ == "__main__":
+    print("DocGenie API - Example Usage\n")
+    
+    # Run health check
+    asyncio.run(health_check_example())
+    
+    print("\n" + "="*60 + "\n")
+    
+    # Run document generation example
+    # NOTE: Replace seed_image_urls in the function with actual URLs
+    # asyncio.run(generate_documents_example())
+    
+    print("\n⚠️  To run document generation:")
+    print("   1. Make sure the API is running (python api/main.py)")
+    print("   2. Replace seed_image_urls in this script with actual image URLs")
+    print("   3. Set ANTHROPIC_API_KEY environment variable")
+    print("   4. Uncomment the generate_documents_example() line above")

api/google_drive.py

@@ -0,0 +1,271 @@
+"""
+Google Drive integration for uploading generated documents.
+Accepts OAuth tokens directly from frontend (no backend OAuth flow).
+"""
+
+import io
+import pathlib
+from typing import Optional
+from google.oauth2.credentials import Credentials
+from googleapiclient.discovery import build
+from googleapiclient.http import MediaFileUpload, MediaIoBaseUpload
+from googleapiclient.errors import HttpError
+from google.auth.transport.requests import Request
+from datetime import datetime, timedelta
+
+from .config import settings
+
+
+class GoogleDriveClient:
+    """Google Drive API client for file uploads using frontend-provided tokens"""
+    
+    def __init__(self, access_token: str, refresh_token: Optional[str] = None):
+        """
+        Initialize Google Drive client with OAuth tokens from frontend.
+        
+        Args:
+            access_token: Google OAuth access token (provided by frontend)
+            refresh_token: Google OAuth refresh token (optional, for token renewal)
+        
+        Raises:
+            ValueError: If token is invalid or expired
+        """
+        self.access_token = access_token
+        self.refresh_token = refresh_token
+        self.credentials = self._create_credentials()
+        self.service = build('drive', 'v3', credentials=self.credentials)
+    
+    def _create_credentials(self) -> Credentials:
+        """Create credentials object from provided tokens"""
+        # Validate refresh token requirements
+        if self.refresh_token:
+            # If refresh_token is provided, we need client credentials for auto-refresh
+            if not settings.GOOGLE_CLIENT_ID or not settings.GOOGLE_CLIENT_SECRET:
+                raise ValueError(
+                    "GOOGLE_CLIENT_ID and GOOGLE_CLIENT_SECRET must be set in .env "
+                    "to support token refresh. Either:\n"
+                    "1. Set these environment variables, OR\n"
+                    "2. Ensure the access token doesn't expire during processing (get fresh token)"
+                )
+            
+            credentials = Credentials(
+                token=self.access_token,
+                refresh_token=self.refresh_token,
+                token_uri='https://oauth2.googleapis.com/token',
+                client_id=settings.GOOGLE_CLIENT_ID,
+                client_secret=settings.GOOGLE_CLIENT_SECRET,
+                scopes=['https://www.googleapis.com/auth/drive.file']
+            )
+        else:
+            # No refresh token - token must be valid for entire operation
+            credentials = Credentials(
+                token=self.access_token,
+                scopes=['https://www.googleapis.com/auth/drive.file']
+            )
+        
+        # Try to refresh if expired upfront (only if refresh_token available)
+        if credentials.expired and credentials.refresh_token:
+            try:
+                print(f"[Google Drive] Token expired, refreshing...")
+                credentials.refresh(Request())
+                print(f"[Google Drive] Token refreshed successfully")
+            except Exception as e:
+                raise ValueError(
+                    f"Failed to refresh Google Drive token: {str(e)}. "
+                    "User needs to re-authenticate."
+                )
+        elif credentials.expired:
+            raise ValueError(
+                "Google Drive token has expired and no refresh token provided. "
+                "User needs to re-authenticate with a fresh token."
+            )
+        
+        return credentials
+    
+    def upload_file(
+        self,
+        file_path: pathlib.Path,
+        filename: Optional[str] = None,
+        folder_name: str = "DocGenie Documents",
+        mime_type: str = "application/zip"
+    ) -> str:
+        """
+        Upload a file to user's Google Drive.
+        
+        Args:
+            file_path: Path to local file to upload
+            filename: Name for file in Google Drive (default: use file_path name)
+            folder_name: Name of folder to create/use in Drive
+            mime_type: MIME type of the file
+        
+        Returns:
+            Google Drive file URL (shareable link)
+        
+        Raises:
+            HttpError: If upload fails
+        """
+        try:
+            # Get or create folder
+            folder_id = self._get_or_create_folder(folder_name)
+            
+            # Prepare file metadata
+            file_metadata = {
+                'name': filename or file_path.name,
+                'parents': [folder_id]
+            }
+            
+            # Upload file
+            media = MediaFileUpload(
+                str(file_path),
+                mimetype=mime_type,
+                resumable=True
+            )
+            
+            file = self.service.files().create(
+                body=file_metadata,
+                media_body=media,
+                fields='id, webViewLink, webContentLink'
+            ).execute()
+            
+            # Make file accessible (reader permissions)
+            self._share_file(file['id'])
+            
+            # Return shareable link
+            return file.get('webViewLink', file.get('webContentLink'))
+        
+        except HttpError as error:
+            print(f"Google Drive upload error: {error}")
+            raise
+    
+    def upload_bytes(
+        self,
+        file_bytes: bytes,
+        filename: str,
+        folder_name: str = "DocGenie Documents",
+        mime_type: str = "application/zip"
+    ) -> str:
+        """
+        Upload bytes directly to Google Drive (without saving to disk).
+        
+        Args:
+            file_bytes: File content as bytes
+            filename: Name for file in Google Drive
+            folder_name: Name of folder to create/use in Drive
+            mime_type: MIME type of the file
+        
+        Returns:
+            Google Drive file URL (shareable link)
+        """
+        try:
+            folder_id = self._get_or_create_folder(folder_name)
+            
+            file_metadata = {
+                'name': filename,
+                'parents': [folder_id]
+            }
+            
+            # Create media from bytes
+            media = MediaIoBaseUpload(
+                io.BytesIO(file_bytes),
+                mimetype=mime_type,
+                resumable=True
+            )
+            
+            file = self.service.files().create(
+                body=file_metadata,
+                media_body=media,
+                fields='id, webViewLink, webContentLink'
+            ).execute()
+            
+            self._share_file(file['id'])
+            
+            return file.get('webViewLink', file.get('webContentLink'))
+        
+        except HttpError as error:
+            print(f"Google Drive upload error: {error}")
+            raise
+    
+    def _get_or_create_folder(self, folder_name: str) -> str:
+        """
+        Get or create a folder in user's Google Drive.
+        
+        Args:
+            folder_name: Name of the folder
+        
+        Returns:
+            Folder ID
+        """
+        # Search for existing folder
+        query = f"name='{folder_name}' and mimeType='application/vnd.google-apps.folder' and trashed=false"
+        results = self.service.files().list(
+            q=query,
+            spaces='drive',
+            fields='files(id, name)'
+        ).execute()
+        
+        folders = results.get('files', [])
+        
+        if folders:
+            # Folder exists, return its ID
+            return folders[0]['id']
+        
+        # Create new folder
+        file_metadata = {
+            'name': folder_name,
+            'mimeType': 'application/vnd.google-apps.folder'
+        }
+        
+        folder = self.service.files().create(
+            body=file_metadata,
+            fields='id'
+        ).execute()
+        
+        return folder['id']
+    
+    def _share_file(self, file_id: str):
+        """
+        Make file shareable (anyone with link can view).
+        
+        Args:
+            file_id: Google Drive file ID
+        """
+        try:
+            permission = {
+                'type': 'anyone',
+                'role': 'reader'
+            }
+            
+            self.service.permissions().create(
+                fileId=file_id,
+                body=permission
+            ).execute()
+        
+        except HttpError as error:
+            print(f"Warning: Could not share file {file_id}: {error}")
+            # Don't raise - file uploaded successfully even if sharing fails
+
+
+def upload_to_google_drive(
+    access_token: str,
+    file_path: pathlib.Path,
+    refresh_token: Optional[str] = None,
+    filename: Optional[str] = None
+) -> str:
+    """
+    Convenience function to upload a file to user's Google Drive.
+    
+    Args:
+        access_token: Google OAuth access token (from frontend)
+        file_path: Path to file to upload
+        refresh_token: Google OAuth refresh token (optional)
+        filename: Optional custom filename
+    
+    Returns:
+        Google Drive URL
+    
+    Raises:
+        ValueError: If token is invalid or expired
+        HttpError: If upload fails
+    """
+    client = GoogleDriveClient(access_token=access_token, refresh_token=refresh_token)
+    return client.upload_file(file_path, filename)

api/main.py

@@ -0,0 +1,1756 @@
+"""
+FastAPI application for DocGenie document generation.
+
+FULLY INTEGRATED PIPELINE (All 19 Stages):
+
+✅ Stage 1-2: Core Pipeline (Stages 01-06)
+1. Seed Selection: Download and encode seed images
+2. LLM Prompting: Call Claude API (batched client support)
+3. Response Processing: Extract and validate HTML/GT
+4. PDF Rendering: Generate PDFs with geometry extraction
+5. BBox Extraction: Extract bounding boxes from PDFs
+6. Validation: Verify geometries and bboxes
+
+✅ Stage 3: Feature Synthesis (Stages 07-13)  
+7. Extract handwriting definitions from HTML
+8. Extract visual element definitions from HTML
+9. Generate handwriting images (WordStylist diffusion model)
+10. Create visual elements (stamps, barcodes, logos)
+11. Render second-pass PDF with features
+12. Insert handwriting images into PDF
+13. Insert visual elements into PDF
+
+✅ Stage 4: Image Finalization & OCR (Stages 14-15)
+14. Render final PDF to high-quality image (pdf2image)
+15. Perform OCR on final image (Microsoft Document Intelligence)
+
+✅ Stage 5: Dataset Packaging (Stages 16-19)
+16. Normalize bounding boxes to [0,1] scale
+17. Verify and prepare ground truth annotations
+18. Generate document analysis and statistics
+19. Create debug visualization overlays
+
+See API_PIPELINE_STATUS.md for detailed integration status.
+"""
+import os
+import sys
+import pathlib
+import tempfile
+import uuid
+import json
+import zipfile
+import asyncio
+import shutil
+import warnings
+from typing import List, Optional
+from contextlib import asynccontextmanager
+
+# Suppress resource_tracker warnings in development mode (with uvicorn --reload)
+# These warnings are harmless - they occur because the reloader creates child processes
+# that share semaphores. The lifespan handler below ensures proper cleanup.
+warnings.filterwarnings("ignore", category=UserWarning, module="resource_tracker")
+
+# Load environment variables from .env file if it exists
+from dotenv import load_dotenv
+load_dotenv()
+
+# Add parent directory to path for docgenie imports
+sys.path.insert(0, str(pathlib.Path(__file__).parent.parent))
+
+from fastapi import FastAPI, HTTPException, status, BackgroundTasks
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import FileResponse, StreamingResponse
+import uvicorn
+import io
+
+from docgenie import ENV
+
+from .schemas import (
+    GenerateDocumentRequest,
+    GenerateDocumentResponse,
+    DocumentResult,
+    BoundingBox,
+    HealthResponse,
+    DatasetExportInfo
+)
+from .utils import (
+    download_image_to_base64,
+    build_prompt,
+    call_claude_api_direct,
+    extract_html_documents_from_response,
+    extract_ground_truth,
+    extract_css_from_html,
+    render_html_to_pdf,
+    extract_bboxes_from_rendered_pdf,
+    pdf_to_base64,
+    validate_html_structure,
+    validate_pdf,
+    validate_bboxes,
+    process_stage3_complete,
+    process_stage4_ocr,
+    process_stage5_complete
+)
+from .config import settings
+
+
+# Lifespan context manager for proper startup/shutdown
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    """Handle application lifecycle - startup and shutdown."""
+    # Startup
+    print("🚀 DocGenie API starting up...")
+    yield
+    # Shutdown - give pending tasks time to complete
+    print("🛑 DocGenie API shutting down gracefully...")
+    await asyncio.sleep(0.5)  # Allow pending async operations to complete
+    print("✓ Shutdown complete")
+
+
+# Initialize FastAPI app with lifespan
+app = FastAPI(
+    title="DocGenie API",
+    description="API for generating synthetic documents using LLMs",
+    version="1.0.0",
+    docs_url="/docs",
+    lifespan=lifespan
+)
+
+# Add CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=settings.get_cors_origins(),  # Configure in .env
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+
+@app.get("/", response_model=HealthResponse)
+async def root():
+    """Root endpoint - health check."""
+    return HealthResponse(status="healthy", version="1.0.0")
+
+
+@app.get("/health", response_model=HealthResponse)
+async def health_check():
+    """Health check endpoint."""
+    return HealthResponse(status="healthy", version="1.0.0")
+
+
+@app.post("/generate", response_model=GenerateDocumentResponse)
+async def generate_documents(request: GenerateDocumentRequest):
+    """
+    Generate synthetic documents from seed images.
+    
+    Pipeline:
+    1. Download seed images from URLs
+    2. Convert images to base64
+    3. Build prompt with user parameters
+    4. Call Claude API
+    5. Extract HTML documents from response
+    6. Extract ground truth and CSS
+    7. Render HTML to PDF
+    8. Extract bounding boxes
+    9. Return results
+    """
+    try:
+        # Step 1 & 2: Download and convert seed images to base64
+        print(f"Downloading {len(request.seed_images)} seed images...")
+        seed_images_base64 = []
+        
+        # Parse request_id and handle assets
+        user_id_from_input, request_id = parse_request_id(request.request_id)
+        user_id = user_id_from_input
+        assets_temp_dir = None
+        
+        # Download assets if possible
+        try:
+            from .supabase_client import supabase_client
+            # Try to get user_id from database if not in request_id
+            effective_user_id = user_id
+            if not effective_user_id:
+                effective_user_id = supabase_client.get_user_id_from_request(request_id)
+            
+            if effective_user_id and request_id:
+                assets_path = f"{effective_user_id}/{request_id}/assets"
+                files = supabase_client.list_files("doc_storage", assets_path)
+                asset_files = [f for f in files if f.get('id') is not None]
+                
+                if asset_files:
+                    assets_temp_dir = pathlib.Path(tempfile.mkdtemp())
+                    print(f"Found {len(asset_files)} assets in storage, downloading...")
+                    for file_info in asset_files:
+                        file_name = file_info['name']
+                        try:
+                            file_content = supabase_client.download_file("doc_storage", f"{assets_path}/{file_name}")
+                            with open(assets_temp_dir / file_name, 'wb') as f:
+                                f.write(file_content)
+                        except Exception as e:
+                            print(f"  ⚠ Failed to download asset {file_name}: {e}")
+        except Exception as e:
+            print(f"  ⚠ Asset check failed: {e}")
+            
+        for url in request.seed_images:
+            try:
+                img_b64 = await download_image_to_base64(str(url))
+                seed_images_base64.append(img_b64)
+            except Exception as e:
+                raise HTTPException(
+                    status_code=status.HTTP_400_BAD_REQUEST,
+                    detail=f"Failed to download image from {url}: {str(e)}"
+                )
+        
+        print(f"Successfully downloaded {len(seed_images_base64)} images")
+        
+        # Step 3: Build prompt
+        prompt_template_path = ENV.PROMPT_TEMPLATES_DIR / "ClaudeRefined12" / "seed-based-json.txt"
+        
+        if not prompt_template_path.exists():
+            raise HTTPException(
+                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                detail=f"Prompt template not found at {prompt_template_path}"
+            )
+        
+        prompt = build_prompt(
+            language=request.prompt_params.language,
+            doc_type=request.prompt_params.doc_type,
+            gt_type=request.prompt_params.gt_type,
+            gt_format=request.prompt_params.gt_format,
+            num_solutions=request.prompt_params.num_solutions,
+            num_seed_images=len(seed_images_base64),
+            prompt_template_path=prompt_template_path,
+            enable_visual_elements=request.prompt_params.enable_visual_elements,
+            visual_element_types=request.prompt_params.visual_element_types
+        )
+        
+        print("Prompt built successfully")
+        
+        # Step 4: Call Claude API (using settings)
+        if not settings.ANTHROPIC_API_KEY:
+            raise HTTPException(
+                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                detail="ANTHROPIC_API_KEY environment variable not set"
+            )
+        
+        print(f"Calling Claude API with model {settings.CLAUDE_MODEL}...")
+        llm_response = await call_claude_api_direct(
+            prompt=prompt,
+            seed_images_base64=seed_images_base64,
+            api_key=settings.ANTHROPIC_API_KEY,
+            model=settings.CLAUDE_MODEL
+        )
+        
+        print(f"Received LLM response ({len(llm_response)} chars)")
+        
+        # Step 5: Extract HTML documents
+        html_documents = extract_html_documents_from_response(llm_response)
+        
+        if not html_documents:
+            raise HTTPException(
+                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                detail="No valid HTML documents found in LLM response"
+            )
+        
+        print(f"Extracted {len(html_documents)} HTML documents")
+        
+        # Process each document
+        results = []
+        
+        # Create temporary directory for PDFs
+        with tempfile.TemporaryDirectory() as tmp_dir:
+            tmp_path = pathlib.Path(tmp_dir)
+            
+            for idx, html in enumerate(html_documents):
+                try:
+                    doc_id = f"{uuid.uuid4()}_{idx}"
+                    print(f"Processing document {idx + 1}/{len(html_documents)} (ID: {doc_id})")
+                    
+                    # Initialize original_pdf_path (will be set after rendering)
+                    original_pdf_path = None
+                    
+                    # Validate HTML structure (pipeline_03 validation)
+                    is_valid, error_msg = validate_html_structure(html)
+                    if not is_valid:
+                        print(f"  ⚠ HTML validation failed: {error_msg}")
+                        continue
+                    
+                    # Step 6: Extract ground truth and CSS (pipeline_03)
+                    gt, html_clean = extract_ground_truth(html)
+                    css, _ = extract_css_from_html(html_clean)
+                    
+                    # DEBUG: Check if LLM generated handwriting classes
+                    print(f"\n  🔍 DEBUG - Handwriting Detection:")
+                    print(f"     - Contains 'handwritten' class: {'handwritten' in html_clean}")
+                    
+                    # Check for author classes (format: author1, author2, etc. - NO DASH)
+                    import re
+                    author_pattern = re.compile(r'\bauthor\d+\b')
+                    author_matches = author_pattern.findall(html_clean)
+                    
+                    if 'handwritten' in html_clean:
+                        # Count occurrences
+                        hw_count = html_clean.count('handwritten')
+                        print(f"     - 'handwritten' occurrences: {hw_count}")
+                        print(f"     - Author classes found: {len(author_matches)}")
+                        if author_matches:
+                            unique_authors = set(author_matches)
+                            print(f"     - Unique author IDs: {sorted(unique_authors)}")
+                        else:
+                            print(f"     - ⚠️ NO author classes found (expected format: author1, author2, etc.)")
+                        
+                        # Show first match context
+                        idx = html_clean.find('handwritten')
+                        context_start = max(0, idx - 50)
+                        context_end = min(len(html_clean), idx + 150)
+                        print(f"     - First match context: ...{html_clean[context_start:context_end]}...")
+                    else:
+                        print(f"     - ⚠️ NO handwriting classes found in LLM output!")
+                        # Show sample of HTML to see structure
+                        print(f"     - HTML sample (first 500 chars): {html_clean[:500]}")
+                    
+                    print(f"  🔍 DEBUG - Visual Elements Detection:")
+                    print(f"     - Contains 'data-placeholder': {'data-placeholder' in html_clean}")
+                    if 'data-placeholder' in html_clean:
+                        ve_count = html_clean.count('data-placeholder')
+                        print(f"     - 'data-placeholder' occurrences: {ve_count}")
+                    print()
+                    
+                    # Step 7: Render to PDF (pipeline_04) and extract geometries
+                    pdf_path = tmp_path / f"{doc_id}.pdf"
+                    pdf_path, width_mm, height_mm, geometries = await render_html_to_pdf(
+                        html=html_clean,
+                        output_pdf_path=pdf_path
+                    )
+                    
+                    print(f"  ✓ Rendered PDF: {width_mm:.1f}mm x {height_mm:.1f}mm")
+                    
+                    # Validate PDF (pipeline_06 style validation)
+                    is_valid, error_msg = validate_pdf(pdf_path)
+                    if not is_valid:
+                        print(f"  ⚠ PDF validation failed: {error_msg}")
+                        continue
+                    
+                    # Step 8: Extract bounding boxes (pipeline_05)
+                    bboxes_raw = extract_bboxes_from_rendered_pdf(pdf_path)
+                    
+                    # Validate bboxes (pipeline_06 style validation)
+                    is_valid, error_msg = validate_bboxes(bboxes_raw, min_bbox_count=1)
+                    if not is_valid:
+                        print(f"  ⚠ BBox validation failed: {error_msg}")
+                        # Continue anyway with empty bboxes for API response
+                    
+                    bboxes = [BoundingBox(**bbox) for bbox in bboxes_raw]
+                    
+                    print(f"  ✓ Extracted {len(bboxes)} bounding boxes")
+                    
+                    # Step 9: Convert PDF to base64
+                    pdf_b64 = pdf_to_base64(pdf_path)
+                    
+                    # Step 10: Process Stage 3 (Handwriting & Visual Elements) if enabled
+                    final_image_b64 = None
+                    handwriting_regions = []
+                    visual_elements = []
+                    handwriting_images = {}
+                    visual_element_images = {}
+                    ocr_results = None
+                    modified_pdf_path = None
+                    
+                    # Track original PDF path before modification
+                    original_pdf_path = pdf_path
+                    
+                    if request.prompt_params.enable_handwriting or request.prompt_params.enable_visual_elements:
+                        print(f"  🎨 Processing Stages 07-13 (Handwriting & Visual Elements)...")
+                        
+                        try:
+                            final_image_b64, handwriting_regions, visual_elements, handwriting_images, visual_element_images, pdf_with_handwriting_path, pdf_final_path = await process_stage3_complete(
+                                pdf_path=pdf_path,
+                                geometries=geometries,
+                                ground_truth=gt,
+                                bboxes_raw=bboxes_raw,
+                                page_width_mm=width_mm,
+                                page_height_mm=height_mm,
+                                enable_handwriting=request.prompt_params.enable_handwriting,
+                                handwriting_ratio=request.prompt_params.handwriting_ratio,
+                                enable_visual_elements=request.prompt_params.enable_visual_elements,
+                                visual_element_types=request.prompt_params.visual_element_types,
+                                seed=request.prompt_params.seed,
+                                assets_dir=assets_temp_dir,
+                                barcode_number=request.prompt_params.barcode_number
+                            )
+                            
+                            # Use final PDF if modifications were made
+                            if pdf_final_path and pdf_final_path.exists():
+                                pdf_path = pdf_final_path
+                                pdf_b64 = pdf_to_base64(pdf_path)
+                            elif pdf_with_handwriting_path and pdf_with_handwriting_path.exists():
+                                pdf_path = pdf_with_handwriting_path
+                                pdf_b64 = pdf_to_base64(pdf_path)
+                            
+                            print(f"  ✓ Stages 07-13 complete: {len(handwriting_regions)} handwriting regions, {len(visual_elements)} visual elements")
+                            print(f"    - Individual tokens: {len(handwriting_images)} handwriting, {len(visual_element_images)} visual elements")
+                            
+                        except Exception as e:
+                            print(f"  ⚠ Stages 07-13 processing failed: {str(e)}")
+                            # Continue with original PDF if Stage 3 fails
+                    
+                    # Step 11: Process Stages 14-15 (Image Finalization & OCR) if needed
+                    if request.prompt_params.enable_ocr or (final_image_b64 is None and (request.prompt_params.enable_handwriting or request.prompt_params.enable_visual_elements)):
+                        print(f"  📄 Processing Stages 14-15 (Image Finalization & OCR)...")
+                        
+                        try:
+                            stage4_image, ocr_results = await process_stage4_ocr(
+                                pdf_path=pdf_path,
+                                enable_ocr=request.prompt_params.enable_ocr,
+                                dpi=settings.OCR_DPI
+                            )
+                            
+                            # Use Stage 4 image if Stage 3 didn't generate one
+                            if final_image_b64 is None and stage4_image:
+                                final_image_b64 = stage4_image
+                            
+                            if ocr_results:
+                                print(f"  ✓ Stages 14-15 complete: Image rendered, OCR: {len(ocr_results.get('words', []))} words")
+                            else:
+                                print(f"  ✓ Stage 14 complete: Image rendered")
+                                
+                        except Exception as e:
+                            print(f"  ⚠ Stages 14-15 processing failed: {str(e)}")
+                            # Continue without Stage 4
+                    
+                    # Step 12: Process Stages 16-18 (Dataset Packaging) if needed
+                    stage5_results = {}
+                    if any([
+                        request.prompt_params.enable_bbox_normalization,
+                        request.prompt_params.enable_gt_verification,
+                        request.prompt_params.enable_analysis,
+                        request.prompt_params.enable_debug_visualization
+                    ]):
+                        print(f"  📦 Processing Stages 16-18 (Dataset Packaging)...")
+                        
+                        try:
+                            stage5_results = await process_stage5_complete(
+                                document_id=doc_id,
+                                pdf_path=pdf_path,
+                                image_base64=final_image_b64,
+                                ocr_results=ocr_results,
+                                ground_truth=gt,
+                                has_handwriting=request.prompt_params.enable_handwriting,
+                                has_visual_elements=request.prompt_params.enable_visual_elements,
+                                layout_elements=visual_elements,  # Use visual elements as layout proxy
+                                enable_bbox_normalization=request.prompt_params.enable_bbox_normalization,
+                                enable_gt_verification=request.prompt_params.enable_gt_verification,
+                                enable_analysis=request.prompt_params.enable_analysis,
+                                enable_debug_visualization=request.prompt_params.enable_debug_visualization
+                            )
+                            print(f"  ✓ Stages 16-18 complete")
+                        except Exception as e:
+                            print(f"  ⚠ Stages 16-18 processing failed: {str(e)}")
+                            # Continue without Stage 5
+                    
+                    # Step 13: Export to dataset format if requested
+                    dataset_export_info = None
+                    if request.prompt_params.enable_dataset_export:
+                        print(f"  📦 Exporting dataset format ({request.prompt_params.dataset_export_format})...")
+                        
+                        try:
+                            from .utils import export_to_msgpack
+                            
+                            # Only msgpack format is currently supported
+                            if request.prompt_params.dataset_export_format.lower() == "msgpack":
+                                # Prepare data for export
+                                export_words = []
+                                export_word_bboxes = []
+                                export_segment_bboxes = []
+                                
+                                # Get normalized bboxes if available (Stage 5), otherwise use raw OCR
+                                if stage5_results.get('normalized_bboxes_word'):
+                                    # Use Stage 5 normalized bboxes
+                                    for bbox_entry in stage5_results['normalized_bboxes_word']:
+                                        export_words.append(bbox_entry.get('text', ''))
+                                        bbox = bbox_entry.get('bbox', [0, 0, 1, 1])
+                                        export_word_bboxes.append(bbox)
+                                    
+                                    if stage5_results.get('normalized_bboxes_segment'):
+                                        for bbox_entry in stage5_results['normalized_bboxes_segment']:
+                                            bbox = bbox_entry.get('bbox', [0, 0, 1, 1])
+                                            export_segment_bboxes.append(bbox)
+                                elif ocr_results:
+                                    # Fallback: normalize OCR bboxes manually
+                                    from pdf2image import convert_from_path
+                                    images = convert_from_path(pdf_path, dpi=settings.OCR_DPI)
+                                    img_width, img_height = images[0].size if images else (1000, 1000)
+                                    
+                                    for word in ocr_results.get('words', []):
+                                        export_words.append(word.get('text', ''))
+                                        bbox = word.get('bbox', {'x0': 0, 'y0': 0, 'x1': 1, 'y1': 1})
+                                        # Normalize to [0,1]
+                                        norm_bbox = [
+                                            bbox['x0'] / img_width,
+                                            bbox['y0'] / img_height,
+                                            bbox['x1'] / img_width,
+                                            bbox['y1'] / img_height
+                                        ]
+                                        export_word_bboxes.append(norm_bbox)
+                                        export_segment_bboxes.append(norm_bbox)  # Use words as segments
+                                else:
+                                    print(f"  ⚠ No OCR data available for msgpack export")
+                                
+                                if export_words and export_word_bboxes:
+                                    # Create msgpack file in temp directory
+                                    msgpack_path = pathlib.Path(tempfile.gettempdir()) / f"{doc_id}_dataset.msgpack"
+                                    
+                                    await export_to_msgpack(
+                                        document_id=doc_id,
+                                        image_path=None,
+                                        image_base64=final_image_b64,
+                                        words=export_words,
+                                        word_bboxes=export_word_bboxes,
+                                        segment_bboxes=export_segment_bboxes if export_segment_bboxes else export_word_bboxes,
+                                        ground_truth=gt,
+                                        output_path=msgpack_path,
+                                        image_width=None,
+                                        image_height=None
+                                    )
+                                    
+                                    # Read msgpack file as base64 for response
+                                    if msgpack_path.exists():
+                                        with open(msgpack_path, 'rb') as f:
+                                            msgpack_bytes = f.read()
+                                            msgpack_b64 = base64.b64encode(msgpack_bytes).decode('utf-8')
+                                        
+                                        dataset_export_info = DatasetExportInfo(
+                                            format="msgpack",
+                                            num_samples=1,
+                                            output_path=str(msgpack_path),
+                                            msgpack_base64=msgpack_b64 if len(msgpack_bytes) < 10_000_000 else None,  # Only include if < 10MB
+                                            metadata={
+                                                "document_id": doc_id,
+                                                "num_words": len(export_words),
+                                                "has_ground_truth": gt is not None,
+                                                "has_ocr": ocr_results is not None
+                                            }
+                                        )
+                                        print(f"  ✓ Dataset exported to msgpack: {msgpack_path}")
+                            else:
+                                print(f"  ⚠ Export format '{request.prompt_params.dataset_export_format}' not supported. Only 'msgpack' is available.")
+                        
+                        except Exception as e:
+                            print(f"  ⚠ Dataset export failed: {str(e)}")
+                            import traceback
+                            traceback.print_exc()
+                    
+                    # Prepare individual tokens based on output_detail level
+                    handwriting_token_images_response = None
+                    visual_element_images_response = None
+                    token_mapping_response = None
+                    
+                    output_detail = request.prompt_params.output_detail
+                    
+                    if output_detail in ["dataset", "complete"]:
+                        # Include individual token images for dataset/complete levels
+                        from .utils import create_token_mapping_json
+                        
+                        if handwriting_images or visual_element_images:
+                            handwriting_token_images_response = handwriting_images
+                            visual_element_images_response = visual_element_images
+                            token_mapping_response = create_token_mapping_json(
+                                handwriting_regions,
+                                handwriting_images,
+                                visual_elements,
+                                visual_element_images
+                            )
+                            print(f"  📦 Output detail '{output_detail}': Including {len(handwriting_images)} handwriting tokens, {len(visual_element_images)} visual elements")
+                    
+                    # Create result
+                    result = DocumentResult(
+                        document_id=doc_id,
+                        html=html_clean,
+                        css=css,
+                        ground_truth=gt,
+                        pdf_base64=pdf_b64,
+                        bboxes=bboxes,
+                        page_width_mm=width_mm,
+                        page_height_mm=height_mm,
+                        image_base64=final_image_b64,
+                        handwriting_regions=handwriting_regions,
+                        visual_elements=visual_elements,
+                        handwriting_token_images=handwriting_token_images_response,
+                        visual_element_images=visual_element_images_response,
+                        token_mapping=token_mapping_response,
+                        ocr_results=ocr_results,
+                        # Stage 5 results
+                        normalized_bboxes_word=stage5_results.get('normalized_bboxes_word'),
+                        normalized_bboxes_segment=stage5_results.get('normalized_bboxes_segment'),
+                        gt_verification=stage5_results.get('gt_verification'),
+                        analysis_stats=stage5_results.get('analysis_stats'),
+                        debug_visualization=stage5_results.get('debug_visualization'),
+                        dataset_export=dataset_export_info
+                    )
+                    
+                    results.append(result)
+                    
+                except Exception as e:
+                    print(f"Error processing document {idx}: {str(e)}")
+                    # Continue with other documents
+                    continue
+        
+        if not results:
+            raise HTTPException(
+                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                detail="Failed to process any documents"
+            )
+        
+        print(f"Successfully generated {len(results)} documents")
+        
+        # Add warning message for large responses
+        output_detail = request.prompt_params.output_detail
+        message = f"Successfully generated {len(results)} documents"
+        
+        if output_detail == "complete":
+            message += " ⚠️ WARNING: 'complete' output detail level may result in 50+ MB response"
+        elif output_detail == "dataset":
+            message += " (dataset mode: includes individual tokens)"
+        
+        return GenerateDocumentResponse(
+            success=True,
+            message=message,
+            documents=results,
+            total_documents=len(results)
+        )
+    
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"Internal server error: {str(e)}"
+        )
+    finally:
+        # Clean up assets directory if it exists
+        if 'assets_temp_dir' in locals() and assets_temp_dir and assets_temp_dir.exists():
+            try:
+                shutil.rmtree(assets_temp_dir, ignore_errors=True)
+                print(f"✓ Cleaned up assets directory {assets_temp_dir}")
+            except:
+                pass
+
+
+def parse_request_id(input_str: str) -> tuple:
+    """Extract user_id and request_id from input string (format: user_id/request_id or just request_id)."""
+    if "/" in input_str:
+        parts = input_str.split("/", 1)
+        return parts[0], parts[1]
+    return None, input_str
+
+
+@app.post("/generate/pdf")
+async def generate_document_pdf(
+    request: GenerateDocumentRequest,
+    background_tasks: BackgroundTasks
+):
+    """
+    Generate documents and return them as downloadable PDF files (FAST DEMO ENDPOINT).
+    
+    This endpoint generates documents and returns a ZIP file immediately (20-60 seconds).
+    
+    **Workflow:**
+    1. Frontend creates document_requests entry in Supabase with status="pending"
+    2. Frontend sends request_id to this endpoint along with tokens and seed images
+    3. API fetches existing request, validates, and starts generation
+    4. API updates status through: processing → generating → completed/failed
+    5. ZIP file is returned immediately
+    6. If google_drive_token provided: ZIP is uploaded to GDrive in background
+    
+    **Request Parameters:**
+    - request_id: UUID of existing document_requests entry (required)
+    - seed_images: List of image URLs to use as document backgrounds (required)
+    - google_drive_token: OAuth token for GDrive upload (optional, enables backup)
+    - google_drive_refresh_token: Refresh token for GDrive (optional)
+    - prompt_params: Document generation parameters
+    
+    **Use Cases:**
+    - Quick demos and testing (with direct Claude API)  
+    - Production with progress tracking and GDrive backup
+    
+    **For batch processing:** Use `/generate/async` (50% cheaper, 5-30 minutes)
+    """
+    # Get request_id from database
+    user_id_from_input, request_id = parse_request_id(request.request_id)
+    user_id = user_id_from_input
+    supabase_enabled = False
+    gdrive_enabled = False
+    
+    try:
+        # Import supabase_client
+        from .supabase_client import supabase_client
+        
+        # Get existing request from database
+        existing_request = supabase_client.get_request(request_id)
+        if not existing_request:
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND,
+                detail=f"Request {request_id} not found in database"
+            )
+        
+        # Use user_id from input if available, otherwise from database
+        if not user_id:
+            user_id = existing_request["user_id"]
+        
+        supabase_enabled = True
+        
+        print(f"[Request {request_id}] Processing request for user {user_id}")
+        print(f"[Request {request_id}] Current status: {existing_request['status']}")
+        
+        # Validate Google Drive token if provided
+        if request.google_drive_token:
+            gdrive_enabled = True
+            
+        # Download assets from Supabase storage if they exist
+        assets_temp_dir = None
+        if supabase_enabled:
+            try:
+                assets_path = f"{user_id}/{request_id}/assets"
+                files = supabase_client.list_files("doc_storage", assets_path)
+                
+                # Filter out directories
+                asset_files = [f for f in files if f.get('id') is not None]
+                
+                if asset_files:
+                    assets_temp_dir = pathlib.Path(tempfile.mkdtemp())
+                    print(f"[Request {request_id}] Found {len(asset_files)} assets in storage, downloading...")
+                    
+                    for file_info in asset_files:
+                        file_name = file_info['name']
+                        try:
+                            file_content = supabase_client.download_file("doc_storage", f"{assets_path}/{file_name}")
+                            with open(assets_temp_dir / file_name, 'wb') as f:
+                                f.write(file_content)
+                            print(f"  ✓ Downloaded {file_name}")
+                        except Exception as download_err:
+                            print(f"  ⚠ Failed to download {file_name}: {download_err}")
+                else:
+                    print(f"[Request {request_id}] No assets found in {assets_path}")
+            except Exception as e:
+                print(f"[Request {request_id}] ⚠ Asset check/download failed: {e}")
+            print(f"[Request {request_id}] GDrive integration enabled")
+        
+        # Log analytics
+        try:
+            supabase_client.log_analytics_event(
+                user_id=user_id,
+                event_type="document_generation_started_sync",
+                entity_id=request_id
+            )
+        except Exception as e:
+            print(f"[Request {request_id}] Warning: Analytics logging failed: {e}")
+            
+    except HTTPException:
+        raise
+    except Exception as e:
+        print(f"Error: Failed to fetch request from database: {e}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"Failed to fetch request: {str(e)}"
+        )
+    
+    # Update status: Downloading seed images
+    if supabase_enabled:
+        try:
+            supabase_client.update_request_status(request_id, "downloading")
+            print(f"[Request {request_id}] Status: downloading (fetching seed images)")
+        except Exception as e:
+            print(f"Warning: Status update failed: {e}")
+    
+    try:
+        # Step 1 & 2: Download and convert seed images to base64
+        print(f"Downloading {len(request.seed_images)} seed images...")
+        seed_images_base64 = []
+        for url in request.seed_images:
+            try:
+                img_b64 = await download_image_to_base64(str(url))
+                seed_images_base64.append(img_b64)
+            except Exception as e:
+                raise HTTPException(
+                    status_code=status.HTTP_400_BAD_REQUEST,
+                    detail=f"Failed to download image from {url}: {str(e)}"
+                )
+        
+        print(f"Successfully downloaded {len(seed_images_base64)} images")
+        
+        # Step 3: Build prompt
+        prompt_template_path = ENV.PROMPT_TEMPLATES_DIR / "ClaudeRefined12" / "seed-based-json.txt"
+        
+        if not prompt_template_path.exists():
+            raise HTTPException(
+                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                detail=f"Prompt template not found at {prompt_template_path}"
+            )
+        
+        prompt = build_prompt(
+            language=request.prompt_params.language,
+            doc_type=request.prompt_params.doc_type,
+            gt_type=request.prompt_params.gt_type,
+            gt_format=request.prompt_params.gt_format,
+            num_solutions=request.prompt_params.num_solutions,
+            num_seed_images=len(seed_images_base64),
+            prompt_template_path=prompt_template_path,
+            enable_visual_elements=request.prompt_params.enable_visual_elements,
+            visual_element_types=request.prompt_params.visual_element_types
+        )
+        
+        print("Prompt built successfully")
+        
+        # Update status: Generating (calling LLM)
+        if supabase_enabled:
+            try:
+                supabase_client.update_request_status(request_id, "generating")
+                print(f"[Request {request_id}] Status: generating (calling LLM)")
+            except Exception as e:
+                print(f"Warning: Status update failed: {e}")
+        
+        # Step 4: Call Claude API (using settings)
+        print(f"Calling Claude API with model {settings.CLAUDE_MODEL}...")
+        llm_response = await call_claude_api_direct(
+            prompt=prompt,
+            seed_images_base64=seed_images_base64,
+            api_key=settings.ANTHROPIC_API_KEY,
+            model=settings.CLAUDE_MODEL
+        )
+        
+        print(f"Received LLM response ({len(llm_response)} chars)")
+        
+        # Step 5: Extract HTML documents
+        html_documents = extract_html_documents_from_response(llm_response)
+        
+        if not html_documents:
+            raise HTTPException(
+                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                detail="No valid HTML documents found in LLM response"
+            )
+        
+        print(f"Extracted {len(html_documents)} HTML documents")
+        
+        # Extract output_detail early to use in ZIP packaging later
+        output_detail = request.prompt_params.output_detail
+        
+        # Create temporary directory for PDFs
+        with tempfile.TemporaryDirectory() as tmp_dir:
+            tmp_path = pathlib.Path(tmp_dir)
+            
+            # Initialize DatasetExporter for organized structure
+            from .dataset_exporter import DatasetExporter
+            exporter = DatasetExporter(tmp_path, dataset_name="docgenie_documents")
+            
+            pdf_files = []
+            metadata = []
+            
+            for idx, html in enumerate(html_documents):
+                try:
+                    doc_id = f"document_{idx + 1}"
+                    print(f"Processing document {idx + 1}/{len(html_documents)} (ID: {doc_id})")
+                    
+                    # Initialize original_pdf_path (will be set after rendering)
+                    original_pdf_path = None
+                    
+                    # Extract ground truth
+                    gt, html_clean = extract_ground_truth(html)
+                    
+                    # DEBUG: Check if LLM generated handwriting classes
+                    print(f"\n  🔍 DEBUG - Handwriting Detection:")
+                    print(f"     - Contains 'handwritten' class: {'handwritten' in html_clean}")
+                    
+                    # Check for author classes (format: author1, author2, etc. - NO DASH)
+                    import re
+                    author_pattern = re.compile(r'\bauthor\d+\b')
+                    author_matches = author_pattern.findall(html_clean)
+                    
+                    if 'handwritten' in html_clean:
+                        # Count occurrences
+                        hw_count = html_clean.count('handwritten')
+                        print(f"     - 'handwritten' occurrences: {hw_count}")
+                        print(f"     - Author classes found: {len(author_matches)}")
+                        if author_matches:
+                            unique_authors = set(author_matches)
+                            print(f"     - Unique author IDs: {sorted(unique_authors)}")
+                        else:
+                            print(f"     - ⚠️ NO author classes found (expected format: author1, author2, etc.)")
+                        
+                        # Show first match context
+                        idx = html_clean.find('handwritten')
+                        context_start = max(0, idx - 50)
+                        context_end = min(len(html_clean), idx + 150)
+                        print(f"     - First match context: ...{html_clean[context_start:context_end]}...")
+                    else:
+                        print(f"     - ⚠️ NO handwriting classes found in LLM output!")
+                        # Show sample of HTML to see structure
+                        print(f"     - HTML sample (first 500 chars): {html_clean[:500]}")
+                    
+                    print(f"  🔍 DEBUG - Visual Elements Detection:")
+                    print(f"     - Contains 'data-placeholder': {'data-placeholder' in html_clean}")
+                    if 'data-placeholder' in html_clean:
+                        ve_count = html_clean.count('data-placeholder')
+                        print(f"     - 'data-placeholder' occurrences: {ve_count}")
+                    print()
+                    
+                    # Render to PDF and extract geometries
+                    pdf_path = tmp_path / f"{doc_id}.pdf"
+                    pdf_path, width_mm, height_mm, geometries = await render_html_to_pdf(
+                        html=html_clean,
+                        output_pdf_path=pdf_path
+                    )
+                    
+                    print(f"  - Rendered PDF: {width_mm:.1f}mm x {height_mm:.1f}mm")
+                    
+                    # Extract bounding boxes
+                    bboxes_raw = extract_bboxes_from_rendered_pdf(pdf_path)
+                    
+                    print(f"  - Extracted {len(bboxes_raw)} bounding boxes")
+                    
+                    # Extract CSS for Stage 3
+                    css, _ = extract_css_from_html(html_clean)
+                    
+                    # Step: Process Stage 3 (Handwriting & Visual Elements) if enabled
+                    final_image_b64 = None
+                    handwriting_regions = []
+                    visual_elements = []
+                    handwriting_images = {}
+                    visual_element_images = {}
+                    ocr_results = None
+                    pdf_with_handwriting_path = None
+                    pdf_final_path = None
+                    
+                    # Track original PDF path before modification
+                    original_pdf_path = pdf_path
+                    
+                    if request.prompt_params.enable_handwriting or request.prompt_params.enable_visual_elements:
+                        print(f"  🎨 Processing Stages 07-13 (Handwriting & Visual Elements)...")
+                        
+                        try:
+                            final_image_b64, handwriting_regions, visual_elements, handwriting_images, visual_element_images, pdf_with_handwriting_path, pdf_final_path = await process_stage3_complete(
+                                pdf_path=pdf_path,
+                                geometries=geometries,
+                                ground_truth=gt,
+                                bboxes_raw=bboxes_raw,
+                                page_width_mm=width_mm,
+                                page_height_mm=height_mm,
+                                enable_handwriting=request.prompt_params.enable_handwriting,
+                                handwriting_ratio=request.prompt_params.handwriting_ratio,
+                                enable_visual_elements=request.prompt_params.enable_visual_elements,
+                                visual_element_types=request.prompt_params.visual_element_types,
+                                seed=request.prompt_params.seed,
+                                assets_dir=assets_temp_dir,
+                                barcode_number=request.prompt_params.barcode_number
+                            )
+                            
+                            # Use final PDF if modifications were made
+                            if pdf_final_path and pdf_final_path.exists():
+                                pdf_path = pdf_final_path
+                            elif pdf_with_handwriting_path and pdf_with_handwriting_path.exists():
+                                pdf_path = pdf_with_handwriting_path
+                            
+                            print(f"  ✓ Stages 07-13 complete: {len(handwriting_regions)} handwriting regions, {len(visual_elements)} visual elements")
+                            print(f"    - Individual tokens: {len(handwriting_images)} handwriting, {len(visual_element_images)} visual elements")
+                            
+                        except Exception as e:
+                            print(f"  ⚠ Stages 07-13 processing failed: {str(e)}")
+                            # Continue with original PDF if Stage 3 fails
+                    
+                    # Step: Process Stages 14-15 (Image Finalization & OCR) if needed
+                    if request.prompt_params.enable_ocr:
+                        print(f"  📄 Processing Stages 14-15 (OCR)...")
+                        
+                        try:
+                            stage4_image, ocr_results = await process_stage4_ocr(
+                                pdf_path=pdf_path,
+                                enable_ocr=True,
+                                dpi=settings.OCR_DPI
+                            )
+                            
+                            if ocr_results:
+                                print(f"  ✓ Stages 14-15 complete: OCR: {len(ocr_results.get('words', []))} words")
+                                
+                        except Exception as e:
+                            print(f"  ⚠ Stages 14-15 processing failed: {str(e)}")
+                            # Continue without Stage 4
+                    
+                    # Step: Process Stages 16-18 (Dataset Packaging) if needed
+                    stage5_results = {}
+                    if any([
+                        request.prompt_params.enable_bbox_normalization,
+                        request.prompt_params.enable_gt_verification,
+                        request.prompt_params.enable_analysis,
+                        request.prompt_params.enable_debug_visualization
+                    ]):
+                        print(f"  📦 Processing Stages 16-18 (Dataset Packaging)...")
+                        
+                        try:
+                            stage5_results = await process_stage5_complete(
+                                document_id=doc_id,
+                                pdf_path=pdf_path,
+                                image_base64=final_image_b64,
+                                ocr_results=ocr_results,
+                                ground_truth=gt,
+                                has_handwriting=request.prompt_params.enable_handwriting,
+                                has_visual_elements=request.prompt_params.enable_visual_elements,
+                                layout_elements=visual_elements,
+                                enable_bbox_normalization=request.prompt_params.enable_bbox_normalization,
+                                enable_gt_verification=request.prompt_params.enable_gt_verification,
+                                enable_analysis=request.prompt_params.enable_analysis,
+                                enable_debug_visualization=request.prompt_params.enable_debug_visualization
+                            )
+                            print(f"  ✓ Stages 16-18 complete")
+                        except Exception as e:
+                            print(f"  ⚠ Stages 16-18 processing failed: {str(e)}")
+                            # Continue without Stages 16-18
+                    
+                    # Track PDFs for metadata
+                    if original_pdf_path and pdf_path != original_pdf_path:
+                        pdf_files.append(original_pdf_path)
+                        pdf_files.append(pdf_path)
+                    else:
+                        pdf_files.append(pdf_path)
+                    
+                    # Extract bbox_pdf (word + char) from original PDF (ground truth positions)
+                    from .utils import extract_all_bboxes_from_pdf, extract_raw_annotations_from_geometries
+                    print(f"  📦 Extracting bbox_pdf (word + char level) from original PDF...")
+                    
+                    try:
+                        bboxes_pdf = extract_all_bboxes_from_pdf(original_pdf_path if original_pdf_path else pdf_path)
+                        bbox_pdf_word = bboxes_pdf.get('word', [])
+                        bbox_pdf_char = bboxes_pdf.get('char', [])
+                        print(f"    ✓ Extracted {len(bbox_pdf_word)} word bboxes, {len(bbox_pdf_char)} char bboxes from PDF")
+                    except Exception as e:
+                        print(f"    ⚠ bbox_pdf extraction failed: {e}")
+                        bbox_pdf_word = bboxes_raw  # Fallback to raw bboxes
+                        bbox_pdf_char = []
+                    
+                    # Extract raw_annotations (layout boxes before normalization)
+                    raw_annotations = None
+                    if geometries:
+                        print(f"  📦 Extracting raw_annotations from geometries...")
+                        try:
+                            raw_annotations = extract_raw_annotations_from_geometries(geometries)
+                            print(f"    ✓ Extracted {len(raw_annotations)} layout annotations")
+                        except Exception as e:
+                            print(f"    ⚠ raw_annotations extraction failed: {e}")
+                    
+                    # Decode final image to bytes
+                    final_image_bytes = None
+                    if final_image_b64:
+                        import base64
+                        final_image_bytes = base64.b64decode(final_image_b64)
+                    
+                    # Decode debug visualization
+                    debug_viz_bytes = None
+                    if stage5_results.get('debug_visualization'):
+                        debug_viz_dict = stage5_results['debug_visualization']
+                        if debug_viz_dict and 'bbox_overlay_base64' in debug_viz_dict:
+                            debug_viz_b64 = debug_viz_dict['bbox_overlay_base64']
+                            debug_viz_bytes = base64.b64decode(debug_viz_b64)
+                    
+                    # Prepare token mapping if tokens exist
+                    token_mapping_data = None
+                    if output_detail in ["dataset", "complete"]:
+                        if handwriting_images or visual_element_images:
+                            from .utils import create_token_mapping_json
+                            token_mapping_data = create_token_mapping_json(
+                                handwriting_regions,
+                                handwriting_images,
+                                visual_elements,
+                                visual_element_images
+                            )
+                            print(f"  📦 Output detail '{output_detail}': Prepared {len(handwriting_images)} handwriting tokens, {len(visual_element_images)} visual elements")
+                    
+                    # Extract bbox_final_word and bbox_final_segment (from OCR or PDF)
+                    bbox_final_word = None
+                    bbox_final_segment = None
+                    if ocr_results and ocr_results.get('words'):
+                        # Use OCR results as final bboxes
+                        bbox_final_word = ocr_results.get('words', [])
+                        bbox_final_segment = ocr_results.get('lines', [])
+                    else:
+                        # Fallback to PDF bboxes if no OCR
+                        bbox_final_word = bbox_pdf_word
+                        bbox_final_segment = []  # No line-level data without OCR
+                    
+                    # Read PDF bytes for exporter (capture all stages)
+                    pdf_initial_bytes = original_pdf_path.read_bytes()
+                    pdf_with_handwriting_bytes = pdf_with_handwriting_path.read_bytes() if pdf_with_handwriting_path and pdf_with_handwriting_path.exists() else None
+                    pdf_final_bytes = pdf_final_path.read_bytes() if pdf_final_path and pdf_final_path.exists() else None
+                    
+                    # For visual elements only (no handwriting), pdf_final_path actually points to the VE-only PDF
+                    pdf_with_visual_elements_bytes = None
+                    if pdf_final_bytes and not pdf_with_handwriting_bytes:
+                        # Only visual elements were added, not handwriting
+                        pdf_with_visual_elements_bytes = pdf_final_bytes
+                        pdf_final_bytes = None  # No "final" with both modifications
+                    
+                    # Add document to exporter
+                    print(f"  📦 Adding document to dataset exporter...")
+                    exporter.add_document(
+                        document_id=doc_id,
+                        html=html_clean,
+                        css=css,
+                        pdf_initial=pdf_initial_bytes,
+                        pdf_with_handwriting=pdf_with_handwriting_bytes,
+                        pdf_with_visual_elements=pdf_with_visual_elements_bytes,
+                        pdf_final=pdf_final_bytes,
+                        final_image=final_image_bytes,
+                        ground_truth=gt,
+                        raw_annotations=raw_annotations,
+                        bboxes_pdf_word=bbox_pdf_word,
+                        bboxes_pdf_char=bbox_pdf_char,
+                        bboxes_final_word=bbox_final_word,
+                        bboxes_final_segment=bbox_final_segment,
+                        bboxes_normalized_word=stage5_results.get('normalized_bboxes_word'),
+                        bboxes_normalized_segment=stage5_results.get('normalized_bboxes_segment'),
+                        gt_verification=stage5_results.get('gt_verification'),
+                        token_mapping=token_mapping_data,
+                        handwriting_regions=handwriting_regions,
+                        handwriting_images=handwriting_images,
+                        visual_elements=visual_elements,
+                        visual_element_images=visual_element_images,
+                        layout_elements=visual_elements,
+                        geometries=geometries,
+                        ocr_results=ocr_results,
+                        analysis_stats=stage5_results.get('analysis_stats'),
+                        debug_visualization=debug_viz_bytes
+                    )
+                    print(f"  ✓ Document {doc_id} added to dataset")
+                    
+                    # Store metadata
+                    metadata.append({
+                        "document_id": doc_id,
+                        "filename": f"{doc_id}.pdf",
+                        "bboxes": bboxes_raw,
+                        "ground_truth": gt,
+                        "geometries": geometries,
+                        "page_width_mm": width_mm,
+                        "page_height_mm": height_mm,
+                        "handwriting_regions": handwriting_regions,
+                        "visual_elements": visual_elements,
+                        "has_stage3_image": final_image_b64 is not None,
+                        "ocr_results": ocr_results,
+                        # Stage 5 results
+                        "normalized_bboxes_word": stage5_results.get('normalized_bboxes_word'),
+                        "normalized_bboxes_segment": stage5_results.get('normalized_bboxes_segment'),
+                        "gt_verification": stage5_results.get('gt_verification'),
+                        "analysis_stats": stage5_results.get('analysis_stats'),
+                        "debug_visualization_available": stage5_results.get('debug_visualization') is not None
+                    })
+                    
+                except Exception as e:
+                    print(f"Error processing document {idx}: {str(e)}")
+                    # Continue with other documents
+                    continue
+            
+            if not pdf_files:
+                raise HTTPException(
+                    status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                    detail="Failed to process any documents"
+                )
+            
+            print(f"Successfully generated {len(pdf_files)} documents")
+            
+            # Finalize dataset export (writes metadata.json and README.md)
+            print(f"📦 Finalizing dataset export...")
+            exporter.finalize(
+                request_id=request_id if request_id else "unnamed",
+                user_id=user_id,
+                prompt_params=request.prompt_params.dict(),
+                api_mode="sync"
+            )
+            print(f"✓ Dataset structure finalized at {exporter.base_path}")
+            
+            # Update status: Zipping
+            if supabase_enabled:
+                try:
+                    supabase_client.update_request_status(request_id, "zipping")
+                    print(f"[Request {request_id}] Status: zipping (creating ZIP archive)")
+                except Exception as e:
+                    print(f"Warning: Status update failed: {e}")
+            
+            # Create ZIP from organized dataset
+            print(f"📦 Creating ZIP archive from dataset...")
+            zip_buffer = io.BytesIO()
+            with zipfile.ZipFile(zip_buffer, 'w', zipfile.ZIP_DEFLATED) as zip_file:
+                # Add all files from exporter.base_path
+                for file_path in exporter.base_path.rglob('*'):
+                    if file_path.is_file():
+                        arcname = file_path.relative_to(exporter.base_path.parent)
+                        zip_file.write(file_path, arcname)
+            
+            zip_buffer.seek(0)
+            zip_size_mb = len(zip_buffer.getvalue()) / (1024 * 1024)
+            print(f"✓ ZIP created: {zip_size_mb:.2f} MB")
+            
+            # Update status: Completed
+            if supabase_enabled and request_id:
+                try:
+                    from .supabase_client import supabase_client
+                    supabase_client.update_request_status(request_id, "completed")
+                    print(f"[Request {request_id}] Status: completed")
+                except Exception as e:
+                    print(f"[Request {request_id}] ⚠ Supabase update failed: {e}")
+            
+            # Save ZIP to temporary file for background upload
+            temp_zip_path = pathlib.Path(tempfile.gettempdir()) / f"docgenie_{request_id}.zip"
+            temp_zip_path.write_bytes(zip_buffer.getvalue())
+
+            # Schedule background task: Upload to Google Drive
+            if gdrive_enabled and request_id and request.google_drive_token:
+                # Update status: Uploading
+                try:
+                    supabase_client.update_request_status(request_id, "uploading")
+                    print(f"[Request {request_id}] Status: uploading (uploading to Google Drive)")
+                except Exception as e:
+                    print(f"Warning: Status update failed: {e}")
+                
+                print(f"[Request {request_id}] Scheduling GDrive upload in background...")
+                
+                background_tasks.add_task(
+                    upload_zip_to_gdrive_background,
+                    request_id=request_id,
+                    zip_path=temp_zip_path,
+                    access_token=request.google_drive_token,
+                    refresh_token=request.google_drive_refresh_token,
+                    num_documents=len(pdf_files)
+                )
+            
+            # Save files for Supabase background upload
+            if supabase_enabled:
+                import shutil
+                supabase_temp_dir = pathlib.Path(tempfile.gettempdir()) / f"docgenie_supabase_{request_id}"
+                if supabase_temp_dir.exists():
+                    shutil.rmtree(supabase_temp_dir, ignore_errors=True)
+                
+                # Copy exporter base_path to persistent temp dir
+                shutil.copytree(exporter.base_path, supabase_temp_dir)
+                
+                print(f"[Request {request_id}] Scheduling Supabase document upload in background...")
+                background_tasks.add_task(
+                    upload_documents_to_supabase_background,
+                    request_id=request_id,
+                    user_id=str(user_id),
+                    temp_dir=str(supabase_temp_dir),
+                    num_documents=len(exporter.documents),
+                    model_version=settings.LLM_MODEL,
+                    zip_path=str(temp_zip_path) if 'temp_zip_path' in locals() else None
+                )
+            
+            # Prepare response headers with tracking info
+            headers = {
+                "Content-Disposition": f"attachment; filename=docgenie_documents_{uuid.uuid4().hex[:8]}.zip"
+            }
+            
+            # Add tracking header if Supabase enabled
+            if supabase_enabled and request_id:
+                headers["X-Request-ID"] = request_id
+                headers["X-Status-URL"] = f"/jobs/{request_id}/status"
+                print(f"[Request {request_id}] Returning ZIP with tracking headers")
+            
+            return StreamingResponse(
+                zip_buffer,
+                media_type="application/zip",
+                headers=headers
+            )
+    
+    except HTTPException as e:
+        # Update status to failed if Supabase enabled
+        if supabase_enabled and request_id:
+            try:
+                from .supabase_client import supabase_client
+                supabase_client.update_request_status(request_id, "failed", error_message=str(e.detail))
+                print(f"[Request {request_id}] Status: failed - {e.detail}")
+            except Exception as update_error:
+                print(f"Warning: Status update failed: {update_error}")
+        raise
+    except Exception as e:
+        # Update status to failed if Supabase enabled
+        if supabase_enabled and request_id:
+            try:
+                from .supabase_client import supabase_client
+                supabase_client.update_request_status(request_id, "failed", error_message=str(e))
+                print(f"[Request {request_id}] Status: failed - {str(e)}")
+            except Exception as sup_err:
+                print(f"[Request {request_id}] ⚠ Supabase update failed: {sup_err}")
+        print(f"Unexpected error: {str(e)}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"Internal server error: {str(e)}"
+        )
+
+
+# ==================== Background Task Functions ====================
+
+def upload_documents_to_supabase_background(
+    request_id: str,
+    user_id: str,
+    temp_dir: str,
+    num_documents: int,
+    model_version: str,
+    zip_path: Optional[str] = None
+):
+    """
+    Background task to upload individual documents to Supabase Storage.
+    """
+    import shutil
+    import pathlib
+    import traceback
+    
+    try:
+        print(f"[Background Task {request_id}] Starting Supabase individual document upload...")
+        from .supabase_client import supabase_client
+        
+        base_path = pathlib.Path(temp_dir)
+        
+        # Upload zip if provided
+        zip_url = None
+        if zip_path and pathlib.Path(zip_path).exists():
+            zip_file = pathlib.Path(zip_path)
+            zip_storage_path = f"{user_id}/{request_id}/generated/docgenie_{request_id}.zip"
+            supabase_client.upload_to_storage("doc_storage", zip_storage_path, zip_file.read_bytes(), "application/zip")
+            zip_url = supabase_client.get_public_url("doc_storage", zip_storage_path)
+            print(f"[Background Task {request_id}] ✓ Uploaded ZIP to Supabase: {zip_url}")
+        
+        for idx in range(num_documents):
+            doc_id = f"document_{idx + 1}"
+            
+            # Paths to upload
+            doc_storage_path = f"{user_id}/{request_id}/generated/{idx}_doc.pdf"
+            gt_storage_path = f"{user_id}/{request_id}/generated/{idx}_gt.json"
+            html_storage_path = f"{user_id}/{request_id}/generated/{idx}_src.html"
+            bbox_storage_path = f"{user_id}/{request_id}/generated/{idx}_bbox.json"
+            
+            # Local paths
+            local_pdf = base_path / "pdf" / "pdf_final" / f"{doc_id}.pdf"
+            if not local_pdf.exists():
+                local_pdf = base_path / "pdf" / "pdf_initial" / f"{doc_id}.pdf"
+                
+            local_gt = base_path / "annotations" / "gt" / f"{doc_id}.json"
+            local_html = base_path / "html" / f"{doc_id}.html"
+            local_bbox = base_path / "bbox" / "bbox_final" / "word" / f"{doc_id}.json"
+            
+            # Upload files
+            pdf_url = None
+            if local_pdf.exists():
+                supabase_client.upload_to_storage("doc_storage", doc_storage_path, local_pdf.read_bytes(), "application/pdf")
+                pdf_url = supabase_client.get_public_url("doc_storage", doc_storage_path)
+                
+            if local_gt.exists():
+                supabase_client.upload_to_storage("doc_storage", gt_storage_path, local_gt.read_bytes(), "application/json")
+                
+            if local_html.exists():
+                supabase_client.upload_to_storage("doc_storage", html_storage_path, local_html.read_bytes(), "text/html")
+                
+            if local_bbox.exists():
+                supabase_client.upload_to_storage("doc_storage", bbox_storage_path, local_bbox.read_bytes(), "application/json")
+                
+            supabase_client.create_generated_document(
+                request_id=request_id,
+                file_url=pdf_url,
+                file_type="application/pdf" if pdf_url else None,
+                model_version=model_version,
+                doc_index=idx,
+                doc_storage_path=doc_storage_path if local_pdf.exists() else None,
+                gt_storage_path=gt_storage_path if local_gt.exists() else None,
+                html_storage_path=html_storage_path if local_html.exists() else None,
+                bbox_storage_path=bbox_storage_path if local_bbox.exists() else None,
+                zip_url=zip_url
+            )
+            print(f"[Background Task {request_id}] ✓ Uploaded and tracked document {idx}")
+            
+    except Exception as e:
+        print(f"[Background Task {request_id}] ⚠ Supabase upload failed: {str(e)}")
+        traceback.print_exc()
+    finally:
+        try:
+            # Clean up temporary directory
+            shutil.rmtree(temp_dir, ignore_errors=True)
+            print(f"[Background Task {request_id}] ✓ Cleaned up temporary directory {temp_dir}")
+        except Exception as e:
+            print(f"[Background Task {request_id}] ⚠ Failed to clean up temp dir: {e}")
+
+def upload_zip_to_gdrive_background(
+    request_id: str,
+    zip_path: pathlib.Path,
+    access_token: str,
+    refresh_token: Optional[str],
+    num_documents: int
+):
+    """
+    Background task to upload ZIP file to Google Drive.
+    
+    Args:
+        request_id: Supabase request ID
+        zip_path: Path to temporary ZIP file
+        access_token: Google Drive OAuth access token
+        refresh_token: Google Drive refresh token (optional)
+        num_documents: Number of documents in ZIP
+    """
+    try:
+        print(f"[Background Task {request_id}] Starting GDrive upload...")
+        
+        from .google_drive import GoogleDriveClient
+        from .supabase_client import supabase_client
+        
+        # Upload to Google Drive
+        client = GoogleDriveClient(
+            access_token=access_token,
+            refresh_token=refresh_token
+        )
+        
+        filename = f"docgenie_{request_id}.zip"
+        gdrive_url = client.upload_file(
+            file_path=zip_path,
+            filename=filename,
+            folder_name=settings.GOOGLE_DRIVE_FOLDER_NAME,
+            mime_type="application/zip"
+        )
+        
+        print(f"[Background Task {request_id}] ✓ Uploaded to GDrive: {gdrive_url}")
+        
+        supabase_client.create_generated_document(
+            request_id=request_id,
+            file_url=gdrive_url,
+            file_type="application/zip",
+            model_version=settings.LLM_MODEL
+        )
+        
+        print(f"[Background Task {request_id}] ✓ Updated Supabase with GDrive URL")
+        
+        # Update status to completed
+        supabase_client.update_request_status(request_id, "completed")
+        print(f"[Background Task {request_id}] ✓ Status updated to completed")
+        
+        # Clean up temporary file
+        zip_path.unlink(missing_ok=True)
+        print(f"[Background Task {request_id}] ✓ Cleaned up temp file")
+        
+    except Exception as e:
+        print(f"[Background Task {request_id}] ✗ GDrive upload failed: {str(e)}")
+        import traceback
+        traceback.print_exc()
+        
+        # Update status to completed_gdrive_failed since token was provided
+        try:
+            from .supabase_client import supabase_client
+            supabase_client.update_request_status(request_id, "completed_gdrive_failed")
+            print(f"[Background Task {request_id}] Status updated to completed_gdrive_failed")
+        except Exception as status_err:
+            print(f"[Background Task {request_id}] Failed to update status: {status_err}")
+        
+        # Clean up temp file even if upload failed
+        try:
+            zip_path.unlink(missing_ok=True)
+        except Exception:
+            pass
+
+
+# ==================== New Async Endpoints (Batched API) ====================
+
+from redis import Redis
+from rq import Queue
+from rq.job import Job
+from .supabase_client import supabase_client
+from .worker import process_document_generation_job
+
+
+# Initialize Redis and RQ
+try:
+    redis_conn = Redis.from_url(settings.REDIS_URL)
+    job_queue = Queue(settings.RQ_QUEUE_NAME, connection=redis_conn)
+    print(f"✓ Connected to Redis: {settings.REDIS_URL}")
+    print(f"✓ RQ Queue: {settings.RQ_QUEUE_NAME}")
+except Exception as e:
+    print(f"⚠ Warning: Redis connection failed: {e}")
+    print("  Async endpoints will not work without Redis")
+    redis_conn = None
+    job_queue = None
+
+
+@app.post("/generate/async")
+async def generate_documents_async(request: GenerateDocumentRequest):
+    """
+    Generate synthetic documents asynchronously using batched Claude API.
+    
+    **Workflow:**
+    1. Frontend creates document_requests entry in Supabase with status="pending"
+    2. Frontend sends request_id to this endpoint along with tokens and seed images
+    3. API fetches existing request, validates, and enqueues background job
+    4. API returns immediately with job info
+    5. Background worker processes job and updates status: processing → generating → completed/failed
+    6. User polls /jobs/{request_id}/status for progress
+    7. Upon completion, ZIP is automatically uploaded to Google Drive
+    
+    Uses batched Claude API for 50% cost savings (but takes 5-30 minutes).
+    
+    Request body:
+        - request_id: UUID of existing document_requests entry (required)
+        - seed_images: List[str] (Supabase storage URLs) (required)
+        - google_drive_token: OAuth token for GDrive upload (optional)
+        - google_drive_refresh_token: Refresh token for GDrive (optional)
+        - prompt_params: dict (language, doc_type, num_solutions, etc.)
+    
+    Returns:
+        - request_id: UUID to track job
+        - status: "pending"
+        - estimated_time_minutes: int
+        - poll_url: URL to check status
+    """
+    if not job_queue:
+        raise HTTPException(
+            status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
+            detail="Background job queue not available. Redis connection required."
+        )
+    
+    # Get request_id from request
+    user_id_from_input, request_id = parse_request_id(request.request_id)
+    user_id = user_id_from_input
+    
+    try:
+        # Fetch request from Supabase
+        existing_request = supabase_client.get_request(request_id)
+        if not existing_request:
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND,
+                detail=f"Request {request_id} not found in database"
+            )
+        
+        # Use user_id from input if available, otherwise from database
+        if not user_id:
+            user_id = existing_request["user_id"]
+        
+        print(f"[Request {request_id}] Processing async request for user {user_id}")
+        print(f"[Request {request_id}] Current status: {existing_request['status']}")
+        
+
+        
+        # Validate seed images
+        if not request.seed_images:
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail="At least one seed image is required"
+            )
+        
+        # Update status to processing (job is being queued)
+        supabase_client.update_request_status(request_id, "processing")
+        print(f"[Request {request_id}] Status: processing (queuing job)")
+        
+        # Prepare job data
+        job_data = {
+            "user_id": user_id,
+            "google_drive_token": request.google_drive_token,
+            "google_drive_refresh_token": request.google_drive_refresh_token,
+            "seed_images": [str(url) for url in request.seed_images],
+            "prompt_params": request.prompt_params.dict()
+        }
+        
+        # Enqueue background job
+        job = job_queue.enqueue(
+            process_document_generation_job,
+            request_id=request_id,
+            request_data=job_data,
+            job_timeout='2h',  # 2 hours max (batched API can take time)
+            result_ttl=86400,  # Keep result for 24 hours
+            failure_ttl=86400  # Keep failure info for 24 hours
+        )
+        
+        print(f"Enqueued job {job.id} for request {request_id}")
+        
+        # Estimate time based on num_solutions
+        num_solutions = request.prompt_params.num_solutions
+        if num_solutions <= 3:
+            estimated_time = 10  # ~10 minutes for small batch
+        elif num_solutions <= 10:
+            estimated_time = 20  # ~20 minutes for medium batch
+        else:
+            estimated_time = 30 + (num_solutions - 10) * 2  # Scale up
+        
+        # Log analytics
+        supabase_client.log_analytics_event(
+            user_id=user_id,
+            event_type="document_generation_requested",
+            entity_id=request_id
+        )
+        
+        return {
+            "request_id": request_id,
+            "status": "pending",
+            "estimated_time_minutes": estimated_time,
+            "num_documents": num_solutions,
+            "poll_url": f"/jobs/{request_id}/status",
+            "message": f"Job queued successfully. Check status at /jobs/{request_id}/status"
+        }
+    
+    except HTTPException as http_exc:
+        # Update status to failed
+        try:
+            supabase_client.update_request_status(request_id, "failed", error_message=str(http_exc.detail))
+            print(f"[Request {request_id}] Status: failed - {http_exc.detail}")
+        except Exception as update_error:
+            print(f"Warning: Status update failed: {update_error}")
+        raise
+    except Exception as e:
+        print(f"Error creating async job: {str(e)}")
+        import traceback
+        traceback.print_exc()
+        
+        # Update status to failed
+        try:
+            supabase_client.update_request_status(request_id, "failed", error_message=str(e))
+            print(f"[Request {request_id}] Status: failed - {str(e)}")
+        except Exception as update_error:
+            print(f"Warning: Status update failed: {update_error}")
+        
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"Failed to create job: {str(e)}"
+        )
+    finally:
+        # Clean up assets directory if it exists
+        if 'assets_temp_dir' in locals() and assets_temp_dir and assets_temp_dir.exists():
+            try:
+                shutil.rmtree(assets_temp_dir, ignore_errors=True)
+                print(f"[Request {request_id}] ✓ Cleaned up assets directory {assets_temp_dir}")
+            except:
+                pass
+
+
+@app.get("/jobs/{request_id}/status")
+async def get_job_status(request_id: str):
+    """
+    Get status of a document generation job.
+    
+    Returns:
+        - request_id: UUID
+        - status: pending | processing | generating | completed | failed
+        - created_at: ISO timestamp
+        - updated_at: ISO timestamp
+        - error_message: str (if failed)
+        - results: dict with download_url (if completed)
+    """
+    try:
+        # Get request from Supabase
+        request_data = supabase_client.get_request(request_id)
+        
+        if not request_data:
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND,
+                detail=f"Request {request_id} not found"
+            )
+        
+        response = {
+            "request_id": request_id,
+            "status": request_data["status"],
+            "created_at": request_data["created_at"],
+            "updated_at": request_data["updated_at"],
+            "num_documents": request_data["metadata"]["prompt_params"]["num_solutions"]
+        }
+        
+        # Add error message if failed
+        if request_data["status"] == "failed":
+            response["error_message"] = request_data.get("error_message")
+        
+        # Add result URL if completed
+        if request_data["status"] == "completed":
+            # Get generated documents
+            generated_docs = supabase_client.get_generated_documents(request_id)
+            
+            if generated_docs:
+                response["results"] = {
+                    "documents": [
+                        {
+                            "id": doc.get("id"),
+                            "doc_index": doc.get("doc_index"),
+                            "pdf_url": doc.get("file_url"),
+                            "doc_storage_path": doc.get("doc_storage_path"),
+                            "gt_storage_path": doc.get("gt_storage_path"),
+                            "html_storage_path": doc.get("html_storage_path"),
+                            "bbox_storage_path": doc.get("bbox_storage_path")
+                        } for doc in generated_docs if doc.get("doc_index") is not None
+                    ],
+                    "zip_filename": f"docgenie_{request_id}.zip"
+                }
+                
+                # If there's a zip file (legacy or background GDrive task), add it too
+                zip_docs = [doc for doc in generated_docs if doc.get("file_type") == "application/zip"]
+                if zip_docs:
+                    response["results"]["download_url"] = zip_docs[0].get("file_url")
+        
+        return response
+    
+    except HTTPException:
+        raise
+    except Exception as e:
+        print(f"Error fetching job status: {str(e)}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"Failed to fetch job status: {str(e)}"
+        )
+
+
+@app.get("/jobs/user/{user_id}")
+async def get_user_jobs(user_id: int, limit: int = 50, offset: int = 0):
+    """
+    Get all jobs for a user.
+    
+    Query params:
+        - limit: int (default: 50, max: 100)
+        - offset: int (default: 0)
+    
+    Returns:
+        List of job status objects
+    """
+    try:
+        # Validate limit
+        if limit > 100:
+            limit = 100
+        
+        # Get user's requests from Supabase
+        requests = supabase_client.get_user_requests(user_id, limit, offset)
+        
+        results = []
+        for request_data in requests:
+            result = {
+                "request_id": request_data["id"],
+                "status": request_data["status"],
+                "created_at": request_data["created_at"],
+                "updated_at": request_data["updated_at"],
+                "num_documents": request_data["metadata"]["prompt_params"]["num_solutions"]
+            }
+            
+            if request_data["status"] == "failed":
+                result["error_message"] = request_data.get("error_message")
+            
+            if request_data["status"] == "completed":
+                # Get generated documents
+                generated_docs = supabase_client.get_generated_documents(request_data["id"])
+                if generated_docs:
+                    result["download_url"] = generated_docs[0]["file_url"]
+            
+            results.append(result)
+        
+        return {
+            "user_id": user_id,
+            "jobs": results,
+            "count": len(results),
+            "limit": limit,
+            "offset": offset
+        }
+    
+    except Exception as e:
+        print(f"Error fetching user jobs: {str(e)}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"Failed to fetch user jobs: {str(e)}"
+        )
+
+
+if __name__ == "__main__":
+    uvicorn.run(
+        "main:app",
+        host=settings.API_HOST,
+        port=settings.API_PORT,
+        reload=settings.DEBUG_MODE
+    )

api/quick_test.sh

@@ -0,0 +1,93 @@
+#!/bin/bash
+# Quick test script - tests async API with Google Drive upload
+# Usage: ./quick_test.sh YOUR_GOOGLE_ACCESS_TOKEN
+
+set -e
+
+GOOGLE_TOKEN=$1
+BASE_URL=${2:-"http://localhost:8000"}
+
+if [ -z "$GOOGLE_TOKEN" ]; then
+    echo "Usage: ./quick_test.sh YOUR_GOOGLE_ACCESS_TOKEN [BASE_URL]"
+    echo ""
+    echo "To get a Google token, run:"
+    echo "  python test_get_google_token.py --client-id YOUR_ID --client-secret YOUR_SECRET"
+    echo ""
+    echo "Or see TESTING.md for detailed instructions"
+    exit 1
+fi
+
+echo "==========================================="
+echo "Quick Test: Async API + Google Drive"
+echo "==========================================="
+echo "API: $BASE_URL"
+echo "Token: ${GOOGLE_TOKEN:0:20}..."
+echo ""
+
+# Step 1: Health check
+echo "1. Health Check..."
+curl -s "$BASE_URL/health" | python -m json.tool
+echo ""
+
+# Step 2: Submit job
+echo "2. Submitting Job..."
+RESPONSE=$(curl -s -X POST "$BASE_URL/generate/async" \
+  -H "Content-Type: application/json" \
+  -d "{
+    \"user_id\": 1,
+    \"google_drive_token\": \"$GOOGLE_TOKEN\",
+    \"seed_images\": [\"https://ocr.space/Content/Images/receipt-ocr-original.webp\"],
+    \"prompt_params\": {
+      \"language\": \"English\",
+      \"doc_type\": \"receipts\",
+      \"num_solutions\": 1,
+      \"enable_handwriting\": false,
+      \"enable_visual_elements\": false,
+      \"output_detail\": \"minimal\"
+    }
+  }")
+
+echo "$RESPONSE" | python -m json.tool
+echo ""
+
+REQUEST_ID=$(echo "$RESPONSE" | python -c "import sys, json; print(json.load(sys.stdin)['request_id'])" 2>/dev/null || echo "")
+
+if [ -z "$REQUEST_ID" ]; then
+    echo "✗ Failed to submit job"
+    exit 1
+fi
+
+echo "✓ Job ID: $REQUEST_ID"
+echo ""
+
+# Step 3: Poll status
+echo "3. Polling Status (will check 5 times, 10s apart)..."
+for i in {1..5}; do
+    echo "   Poll $i/5..."
+    STATUS=$(curl -s "$BASE_URL/jobs/$REQUEST_ID/status")
+    CURRENT_STATUS=$(echo "$STATUS" | python -c "import sys, json; print(json.load(sys.stdin)['status'])" 2>/dev/null || echo "unknown")
+    echo "   Status: $CURRENT_STATUS"
+    
+    if [ "$CURRENT_STATUS" = "completed" ]; then
+        echo ""
+        echo "✓ JOB COMPLETED!"
+        echo "$STATUS" | python -m json.tool
+        exit 0
+    elif [ "$CURRENT_STATUS" = "failed" ]; then
+        echo ""
+        echo "✗ JOB FAILED"
+        echo "$STATUS" | python -m json.tool
+        exit 1
+    fi
+    
+    if [ $i -lt 5 ]; then
+        sleep 10
+    fi
+done
+
+echo ""
+echo "⏱ Job still in progress. Continue polling manually:"
+echo "   curl $BASE_URL/jobs/$REQUEST_ID/status"
+echo ""
+echo "Or use the full test script:"
+echo "   python test_async_api.py --google-token $GOOGLE_TOKEN"

api/requirements.txt

@@ -0,0 +1,79 @@
+# ============================================
+# DocGenie API Requirements
+# ============================================
+# NOTE: These dependencies are also specified in the root pyproject.toml
+# This file exists for standalone API deployment convenience
+# For development, use: uv sync (from root directory)
+# For production API-only deployment: pip install -r requirements.txt
+# Aligned with pyproject.toml versions used to run pipeline locally
+
+# FastAPI Framework
+fastapi>=0.109.0
+uvicorn[standard]>=0.27.0
+python-multipart>=0.0.6
+
+# Pydantic for data validation
+pydantic==2.11.7
+pydantic-core==2.33.2
+pydantic-settings>=2.11.0
+
+# Environment variables
+python-dotenv>=1.0.0
+
+# HTTP client for async requests
+httpx==0.28.1
+aiohttp==3.12.15
+
+# Retry logic for external services
+tenacity>=8.2.3
+
+# Claude API
+anthropic==0.64.0
+
+# HTML rendering and PDF generation
+playwright>=1.55.0
+beautifulsoup4==4.13.4
+lxml>=5.1.0
+
+# PDF processing
+PyMuPDF==1.26.3
+pdf2image==1.17.0
+pypdf2==3.0.1
+
+# Image processing for Stage 3
+Pillow==11.3.0
+numpy==1.26.4
+
+# CSS parsing for Stage 3
+cssutils==2.11.1
+
+# Progress bars and logging
+rich==14.1.0
+
+# Additional utilities
+python-dateutil==2.9.0.post0
+requests==2.32.5
+
+# Background job queue (Redis + RQ)
+redis>=5.0.0
+rq>=1.15.0
+
+# Supabase client for database
+supabase>=2.0.0
+
+# Google Drive API integration
+google-api-python-client>=2.100.0
+google-auth-httplib2>=0.2.0
+google-auth-oauthlib>=1.2.0
+
+# ============================================
+# Optional dependencies for advanced features
+# ============================================
+# OCR support (requires system tesseract-ocr)
+pytesseract>=0.3.10
+
+# Barcode generation
+python-barcode>=0.15.1
+
+# Dataset export in msgpack format
+datadings>=0.4.3

api/schemas.py

@@ -0,0 +1,339 @@
+"""
+Pydantic schemas for API request/response models.
+"""
+from typing import List, Optional
+from pydantic import BaseModel, HttpUrl, Field, field_validator
+
+
+class PromptParameters(BaseModel):
+    """Parameters for customizing the document generation prompt."""
+    language: str = Field(
+        default="English",
+        description="Language for generated documents"
+    )
+    doc_type: str = Field(
+        default="business and administrative",
+        description="Type of documents to generate (e.g., 'business and administrative', 'receipts', 'forms')"
+    )
+    gt_type: str = Field(
+        default="Multiple questions about each document, with their answers taken **verbatim** from the document.",
+        description="Description of ground truth type to generate"
+    )
+    gt_format: str = Field(
+        default='{"<Text of question 1>": "<Answer to question 1>", "<Text of question 2>": "<Answer to question 2>", ...}',
+        description="Format specification for ground truth JSON"
+    )
+    num_solutions: int = Field(
+        default=1,
+        ge=1,
+        le=5,
+        description="Number of document variations to generate (1-5)"
+    )
+    # Stage 3: Feature Synthesis parameters
+    enable_handwriting: bool = Field(
+        default=False,
+        description="Enable handwriting generation (requires EC2 handwriting service)"
+    )
+    handwriting_ratio: float = Field(
+        default=0.2,
+        ge=0.0,
+        le=1.0,
+        description="Proportion of text to convert to handwriting (0.0-1.0)"
+    )
+    enable_visual_elements: bool = Field(
+        default=True,
+        description="Enable visual element generation (stamps, logos, barcodes)"
+    )
+    visual_element_types: List[str] = Field(
+        default=["stamp", "logo", "figure", "barcode", "photo"],
+        description="Types of visual elements to generate (stamp, logo, figure, barcode, photo)"
+    )
+    barcode_number: Optional[str] = Field(
+        default=None,
+        description="Optional fixed number for barcode generation (numeric only)"
+    )
+    seed: Optional[int] = Field(
+        default=None,
+        description="Random seed for reproducible generation",
+        examples=[None, 42]
+    )
+    # Stage 4: Image Finalization & OCR parameters
+    enable_ocr: bool = Field(
+        default=True,
+        description="Enable OCR on final document images (requires OCR service)"
+    )
+    ocr_language: str = Field(
+        default="en",
+        description="Language for OCR (e.g., 'en', 'de', 'fr')"
+    )
+    # Stage 5: Dataset Packaging parameters
+    enable_bbox_normalization: bool = Field(
+        default=True,
+        description="Normalize bounding boxes to [0,1] scale (Stage 16)"
+    )
+    enable_gt_verification: bool = Field(
+        default=True,
+        description="Verify and prepare ground truth annotations (Stage 17)"
+    )
+    enable_analysis: bool = Field(
+        default=True,
+        description="Generate dataset statistics and analysis (Stage 18)"
+    )
+    enable_debug_visualization: bool = Field(
+        default=True,
+        description="Create debug visualization overlays (Stage 19)"
+    )
+    enable_dataset_export: bool = Field(
+        default=True,
+        description="Export as msgpack dataset format"
+    )
+    dataset_export_format: str = Field(
+        default="msgpack",
+        description="Dataset export format: 'msgpack', 'coco', 'huggingface'"
+    )
+    output_detail: str = Field(
+        default="dataset",
+        description="Output detail level: 'minimal' (final outputs only), 'dataset' (includes individual tokens/elements for ML), 'complete' (all intermediate files and debug info). Warning: 'complete' mode can produce 50+ MB responses."
+    )
+
+
+class SeedImage(BaseModel):
+    """Seed image URL for document generation."""
+    url: HttpUrl = Field(
+        description="URL of the seed image",
+        default=HttpUrl("https://ocr.space/Content/Images/receipt-ocr-original.webp")
+    )
+
+
+class GenerateDocumentRequest(BaseModel):
+    """Request schema for document generation endpoint."""
+    request_id: str = Field(
+        description="Document request UUID from document_requests table (created by frontend)"
+    )
+    google_drive_token: Optional[str] = Field(
+        default=None,
+        description="Google Drive OAuth access token. Frontend provides this after OAuth flow (optional)."
+    )
+    google_drive_refresh_token: Optional[str] = Field(
+        default=None,
+        description="Google Drive refresh token (optional, for automatic token renewal)"
+    )
+    seed_images: List[HttpUrl] = Field(
+        default=[HttpUrl("https://ocr.space/Content/Images/receipt-ocr-original.webp")],
+        description="List of seed image URLs (1-10 images)"
+    )
+    prompt_params: PromptParameters = Field(
+        default_factory=PromptParameters,
+        description="Parameters for customizing the generation prompt"
+    )
+    
+    @field_validator('seed_images')
+    @classmethod
+    def validate_seed_images(cls, v):
+        if not v:
+            raise ValueError('At least one seed image is required')
+        if len(v) < 1:
+            raise ValueError('At least one seed image is required')
+        if len(v) > 10:
+            raise ValueError('Maximum 10 seed images allowed')
+        return v
+
+
+class OCRWord(BaseModel):
+    """OCR word-level result."""
+    text: str = Field(description="Recognized text")
+    confidence: float = Field(ge=0.0, le=1.0, description="OCR confidence score (0-1)")
+    x: float = Field(description="X coordinate (pixels)")
+    y: float = Field(description="Y coordinate (pixels)")
+    width: float = Field(description="Width (pixels)")
+    height: float = Field(description="Height (pixels)")
+
+
+class OCRLine(BaseModel):
+    """OCR line-level result."""
+    text: str = Field(description="Recognized text")
+    confidence: float = Field(ge=0.0, le=1.0, description="OCR confidence score (0-1)")
+    x: float = Field(description="X coordinate (pixels)")
+    y: float = Field(description="Y coordinate (pixels)")
+    width: float = Field(description="Width (pixels)")
+    height: float = Field(description="Height (pixels)")
+    words: List[OCRWord] = Field(default_factory=list, description="Words in this line")
+
+
+class OCRResult(BaseModel):
+    """OCR results for a document."""
+    image_width: int = Field(description="Image width in pixels")
+    image_height: int = Field(description="Image height in pixels")
+    words: List[OCRWord] = Field(default_factory=list, description="Word-level OCR results")
+    lines: List[OCRLine] = Field(default_factory=list, description="Line-level OCR results")
+    angle: float = Field(default=0.0, description="Detected text orientation angle")
+
+
+class NormalizedBBox(BaseModel):
+    """Normalized bounding box (Stage 16)."""
+    text: str = Field(description="Text content")
+    x0: float = Field(ge=0.0, le=1.0, description="Normalized X min (0-1)")
+    y0: float = Field(ge=0.0, le=1.0, description="Normalized Y min (0-1)")
+    x2: float = Field(ge=0.0, le=1.0, description="Normalized X max (0-1)")
+    y2: float = Field(ge=0.0, le=1.0, description="Normalized Y max (0-1)")
+    block_no: Optional[int] = Field(default=None, description="Block number")
+    line_no: Optional[int] = Field(default=None, description="Line number")
+    word_no: Optional[int] = Field(default=None, description="Word number")
+
+
+class GTVerificationResult(BaseModel):
+    """Ground truth verification results (Stage 17)."""
+    passed: bool = Field(description="Whether GT verification passed")
+    skipped: bool = Field(default=False, description="Whether verification was skipped")
+    confirmed_keys: List[str] = Field(default_factory=list, description="Confirmed GT keys")
+    similarities: List[float] = Field(default_factory=list, description="Similarity scores")
+    num_layout_elements: Optional[int] = Field(default=None, description="Number of layout elements")
+    valid_labels: bool = Field(default=True, description="Whether all labels are valid")
+
+
+class AnalysisStats(BaseModel):
+    """Dataset analysis and statistics (Stage 18)."""
+    total_documents: int = Field(description="Total documents processed")
+    valid_documents: int = Field(description="Documents passing all validation")
+    error_counts: dict = Field(default_factory=dict, description="Error type counts")
+    has_handwriting: int = Field(default=0, description="Documents with handwriting")
+    has_visual_elements: int = Field(default=0, description="Documents with visual elements")
+    has_ocr: int = Field(default=0, description="Documents with OCR results")
+    multipage_count: int = Field(default=0, description="Multipage documents")
+    token_usage: Optional[dict] = Field(default=None, description="LLM token usage statistics")
+
+
+class DebugVisualization(BaseModel):
+    """Debug visualization data (Stage 19)."""
+    bbox_overlay_base64: Optional[str] = Field(default=None, description="Image with bbox overlays (PNG base64)")
+    visual_elements_overlay_base64: Optional[str] = Field(default=None, description="Image with visual element overlays")
+    handwriting_overlay_base64: Optional[str] = Field(default=None, description="Image with handwriting overlays")
+
+
+class DatasetExportInfo(BaseModel):
+    """Dataset export metadata."""
+    format: str = Field(description="Export format (msgpack, coco, etc.)")
+    num_samples: int = Field(description="Number of samples in export")
+    output_path: Optional[str] = Field(default=None, description="Path to exported dataset")
+    msgpack_base64: Optional[str] = Field(default=None, description="Msgpack file as base64 (for small datasets)")
+    metadata: dict = Field(default_factory=dict, description="Dataset metadata")
+
+
+class BoundingBox(BaseModel):
+    """Bounding box for a text element in the document."""
+    text: str = Field(description="Text content")
+    x: float = Field(description="X coordinate (normalized 0-1)")
+    y: float = Field(description="Y coordinate (normalized 0-1)")
+    width: float = Field(description="Width (normalized 0-1)")
+    height: float = Field(description="Height (normalized 0-1)")
+    page: int = Field(default=0, description="Page number (0-indexed)")
+
+
+class HandwritingRegion(BaseModel):
+    """Information about a handwriting region in the document."""
+    region_id: str = Field(description="Unique region identifier")
+    text: str = Field(description="Text content")
+    author_id: int = Field(ge=0, le=656, description="Author ID for style consistency (0-656)")
+    bbox: BoundingBox = Field(description="Bounding box of the region")
+
+
+class VisualElement(BaseModel):
+    """Information about a visual element in the document."""
+    element_id: str = Field(description="Unique element identifier")
+    element_type: str = Field(description="Type of visual element (stamp, logo, etc.)")
+    content: Optional[str] = Field(default=None, description="Content (e.g., stamp text)")
+    bbox: BoundingBox = Field(description="Bounding box of the element")
+
+
+class DocumentResult(BaseModel):
+    """Result for a single generated document."""
+    document_id: str = Field(description="Unique document identifier")
+    html: str = Field(description="Generated HTML content")
+    css: str = Field(description="Extracted CSS styles")
+    ground_truth: Optional[dict] = Field(
+        default=None,
+        description="Ground truth data extracted from the document"
+    )
+    pdf_base64: str = Field(description="Base64-encoded PDF document")
+    bboxes: List[BoundingBox] = Field(
+        default_factory=list,
+        description="Bounding boxes for text elements"
+    )
+    page_width_mm: float = Field(description="Page width in millimeters")
+    page_height_mm: float = Field(description="Page height in millimeters")
+    # Stage 3 additions
+    handwriting_regions: Optional[List[dict]] = Field(
+        default=None,
+        description="Handwriting regions with metadata (if enabled)"
+    )
+    visual_elements: Optional[List[dict]] = Field(
+        default=None,
+        description="Visual elements with metadata (if enabled)"
+    )
+    image_base64: Optional[str] = Field(
+        default=None,
+        description="Final rendered image with handwriting/visuals (PNG base64, if Stage 3 enabled)"
+    )
+    # Stage 3 individual tokens (dataset/complete output detail levels)
+    handwriting_token_images: Optional[dict] = Field(
+        default=None,
+        description="Individual handwriting token images {hw_id: base64_png} (output_detail: dataset/complete)"
+    )
+    visual_element_images: Optional[dict] = Field(
+        default=None,
+        description="Individual visual element images {ve_id: base64_png} (output_detail: dataset/complete)"
+    )
+    token_mapping: Optional[dict] = Field(
+        default=None,
+        description="Token mapping with positions and style IDs (output_detail: dataset/complete)"
+    )
+    # Stage 4 additions
+    ocr_results: Optional[OCRResult] = Field(
+        default=None,
+        description="OCR results from final image (if OCR enabled)"
+    )
+    # Stage 5 additions
+    normalized_bboxes_word: Optional[List[NormalizedBBox]] = Field(
+        default=None,
+        description="Word-level normalized bounding boxes (if Stage 16 enabled)"
+    )
+    normalized_bboxes_segment: Optional[List[NormalizedBBox]] = Field(
+        default=None,
+        description="Segment-level normalized bounding boxes (if Stage 16 enabled)"
+    )
+    gt_verification: Optional[GTVerificationResult] = Field(
+        default=None,
+        description="Ground truth verification results (if Stage 17 enabled)"
+    )
+    analysis_stats: Optional[AnalysisStats] = Field(
+        default=None,
+        description="Document analysis statistics (if Stage 18 enabled)"
+    )
+    debug_visualization: Optional[DebugVisualization] = Field(
+        default=None,
+        description="Debug visualization overlays (if Stage 19 enabled)"
+    )
+    dataset_export: Optional[DatasetExportInfo] = Field(
+        default=None,
+        description="Dataset export information (if export enabled)"
+    )
+
+
+class GenerateDocumentResponse(BaseModel):
+    """Response schema for document generation endpoint."""
+    success: bool = Field(description="Whether generation was successful")
+    message: str = Field(description="Status message")
+    documents: List[DocumentResult] = Field(
+        default_factory=list,
+        description="List of generated documents"
+    )
+    total_documents: int = Field(
+        default=0,
+        description="Total number of documents generated"
+    )
+
+
+class HealthResponse(BaseModel):
+    """Health check response."""
+    status: str = Field(default="healthy")
+    version: str = Field(default="1.0.0")

api/start.sh

@@ -0,0 +1,42 @@
+#!/bin/bash
+
+# Start the DocGenie API server
+# Note: All dependencies should be installed via 'uv sync' or 'pip install -e .'
+
+echo "Starting DocGenie API..."
+
+# Check if .env file exists
+if [ ! -f .env ]; then
+    echo "Warning: .env file not found. Using .env.example as template."
+    echo "Please copy .env.example to .env and set your ANTHROPIC_API_KEY"
+    
+    if [ -f .env.example ]; then
+        cp .env.example .env
+        echo "Created .env file from .env.example"
+    fi
+fi
+
+# Load environment variables
+if [ -f .env ]; then
+    export $(cat .env | grep -v '^#' | xargs)
+fi
+
+# Check if ANTHROPIC_API_KEY is set
+if [ -z "$ANTHROPIC_API_KEY" ]; then
+    echo "Error: ANTHROPIC_API_KEY not set in .env file"
+    exit 1
+fi
+
+# Default values
+HOST=${API_HOST:-0.0.0.0}
+PORT=${API_PORT:-8000}
+WORKERS=${API_WORKERS:-4}
+
+echo "Configuration:"
+echo "  Host: $HOST"
+echo "  Port: $PORT"
+echo "  Workers: $WORKERS"
+echo ""
+
+# Start the API
+uvicorn main:app --host $HOST --port $PORT --workers $WORKERS --reload

api/start_worker.sh

@@ -0,0 +1,95 @@
+#!/bin/bash
+# ============================================
+# DocGenie RQ Worker Startup Script
+# ============================================
+# This script starts an RQ (Redis Queue) worker for processing
+# background document generation jobs.
+
+set -e  # Exit on error
+
+echo "🚀 Starting DocGenie RQ Worker..."
+
+# Activate virtual environment
+VENV_PATH="../.venv"
+if [ -d "$VENV_PATH" ]; then
+    echo "✓ Activating virtual environment..."
+    source "$VENV_PATH/bin/activate"
+else
+    echo "⚠ Warning: Virtual environment not found at $VENV_PATH"
+fi
+
+# Load environment variables from .env using Python (handles special characters properly)
+if [ -f .env ]; then
+    echo "✓ Loading .env file..."
+    eval $(python -c "
+import os
+from dotenv import load_dotenv
+load_dotenv()
+for key, value in os.environ.items():
+    # Only export DocGenie related variables
+    if key.startswith(('REDIS', 'SUPABASE', 'ANTHROPIC', 'BATCH', 'MESSAGE', 'RQ_', 'GOOGLE')):
+        # Properly escape single quotes in the value
+        safe_value = value.replace(\"'\", \"'\\\\''\" )
+        print(f\"export {key}='{safe_value}'\")
+")
+else
+    echo "⚠ Warning: .env file not found"
+fi
+
+# Check Redis connection
+echo "🔍 Checking Redis connection..."
+if ! python -c "import redis; r = redis.from_url('${REDIS_URL:-redis://localhost:6379/0}'); r.ping()" 2>/dev/null; then
+    echo "❌ Error: Cannot connect to Redis at ${REDIS_URL:-redis://localhost:6379/0}"
+    echo "   Please ensure Redis is running:"
+    echo "   $ docker run -d -p 6379:6379 redis:latest"
+    echo "   OR"
+    echo "   $ redis-server"
+    exit 1
+fi
+echo "✓ Redis connected"
+
+# Check Supabase configuration
+if [ -z "$SUPABASE_URL" ] || [ -z "$SUPABASE_KEY" ]; then
+    echo "❌ Error: SUPABASE_URL and SUPABASE_KEY must be set in .env"
+    exit 1
+fi
+echo "✓ Supabase configured"
+
+# Check Claude API key
+if [ -z "$ANTHROPIC_API_KEY" ]; then
+    echo "❌ Error: ANTHROPIC_API_KEY must be set in .env"
+    exit 1
+fi
+echo "✓ Claude API key configured"
+
+# Create temporary directories
+mkdir -p "${BATCH_DATA_DIR:-/tmp/docgenie_batches}"
+mkdir -p "${MESSAGE_DATA_DIR:-/tmp/docgenie_messages}"
+echo "✓ Temporary directories created"
+
+# Start worker
+QUEUE_NAME="${RQ_QUEUE_NAME:-docgenie}"
+echo ""
+echo "============================================"
+echo "Worker Configuration:"
+echo "  Queue: $QUEUE_NAME"
+echo "  Redis: ${REDIS_URL:-redis://localhost:6379/0}"
+echo "  Batch Data: ${BATCH_DATA_DIR:-/tmp/docgenie_batches}"
+echo "  Message Data: ${MESSAGE_DATA_DIR:-/tmp/docgenie_messages}"
+echo "============================================"
+echo ""
+echo "✅ Starting RQ worker (press Ctrl+C to stop)..."
+echo ""
+
+# Run RQ worker
+# - Listen on specified queue
+# - Burst mode: exit when queue is empty (use for testing)
+# - Remove --burst for production (keeps running)
+# Use PYTHONPATH to ensure worker.py can be imported
+PYTHONPATH="$(pwd):$PYTHONPATH" rq worker "$QUEUE_NAME" \
+    --url "${REDIS_URL:-redis://localhost:6379/0}" \
+    --verbose
+    # --burst  # Uncomment for testing (exit when queue empty)
+
+# Note: Worker will keep running until Ctrl+C is pressed
+# In production, use a process manager like systemd or supervisor

api/supabase_client.py

@@ -0,0 +1,283 @@
+"""
+Supabase client for database operations.
+Handles document requests, generated documents, and user integrations.
+"""
+
+from typing import Optional, Dict, Any, List
+import os
+from datetime import datetime
+from supabase import create_client, Client
+from .config import settings
+
+
+class SupabaseClient:
+    """Wrapper for Supabase operations related to document generation"""
+    
+    def __init__(self):
+        if not settings.SUPABASE_URL or not settings.SUPABASE_KEY:
+            raise ValueError("SUPABASE_URL and SUPABASE_KEY must be set in environment")
+        
+        self.client: Client = create_client(
+            settings.SUPABASE_URL,
+            settings.SUPABASE_KEY
+        )
+    
+    # ==================== Document Requests ====================
+    
+    def create_document_request(
+        self,
+        user_id: int,
+        metadata: Dict[str, Any],
+        status: str = "pending"
+    ) -> str:
+        """
+        Create a new document generation request.
+        
+        Args:
+            user_id: User ID from users table
+            metadata: Request parameters (seed_images, prompt_params, etc.)
+            status: Initial status (default: 'pending')
+        
+        Returns:
+            request_id (UUID)
+        """
+        result = self.client.table("document_requests").insert({
+            "user_id": user_id,
+            "metadata": metadata,
+            "status": status,
+            "created_at": datetime.now().isoformat(),
+            "updated_at": datetime.now().isoformat()
+        }).execute()
+        
+        return result.data[0]["id"]
+    
+    def update_request_status(
+        self,
+        request_id: str,
+        status: str,
+        error_message: Optional[str] = None
+    ):
+        """
+        Update document request status.
+        
+        Args:
+            request_id: UUID of the request
+            status: New status (pending, processing, generating, completed, failed, etc.)
+            error_message: Error message if status is 'failed'
+        """
+        update_data = {
+            "status": status,
+            "updated_at": datetime.now().isoformat()
+        }
+        
+        if error_message:
+            update_data["error_message"] = error_message
+        
+        self.client.table("document_requests").update(update_data).eq(
+            "id", request_id
+        ).execute()
+    
+    def get_request(self, request_id: str) -> Optional[Dict[str, Any]]:
+        """
+        Get document request by ID.
+        
+        Returns:
+            Dict with keys: id, user_id, metadata, status, created_at, updated_at, error_message
+        """
+        result = self.client.table("document_requests").select("*").eq(
+            "id", request_id
+        ).execute()
+        
+        return result.data[0] if result.data else None
+    
+    def get_user_id_from_request(self, request_id: str) -> Optional[int]:
+        """
+        Get user_id from a document request.
+        
+        Args:
+            request_id: Document request UUID
+            
+        Returns:
+            user_id or None if request not found
+        """
+        result = self.client.table("document_requests").select("user_id").eq(
+            "id", request_id
+        ).execute()
+        
+        return result.data[0]["user_id"] if result.data else None
+    
+    def get_user_requests(
+        self,
+        user_id: int,
+        limit: int = 50,
+        offset: int = 0
+    ) -> List[Dict[str, Any]]:
+        """Get all requests for a user, ordered by created_at DESC"""
+        result = self.client.table("document_requests").select(
+            "*"
+        ).eq("user_id", user_id).order(
+            "created_at", desc=True
+        ).range(offset, offset + limit - 1).execute()
+        
+        return result.data
+    
+    # ==================== Generated Documents ====================
+    
+    def create_generated_document(
+        self,
+        request_id: str,
+        file_url: Optional[str] = None,
+        file_type: Optional[str] = None,
+        model_version: Optional[str] = None,
+        doc_index: Optional[int] = None,
+        doc_storage_path: Optional[str] = None,
+        gt_storage_path: Optional[str] = None,
+        html_storage_path: Optional[str] = None,
+        bbox_storage_path: Optional[str] = None,
+        zip_url: Optional[str] = None,
+        flagged: bool = False,
+        flag_reason: Optional[str] = None
+    ) -> str:
+        """
+        Create record for a generated document.
+        
+        Args:
+            request_id: Parent request UUID (FK to document_requests)
+            file_url: Google Drive URL or other storage URL
+            file_type: MIME type (e.g., 'application/zip', 'application/pdf')
+            model_version: Model version used for generation (optional)
+            doc_index: Index of the document within the request (optional)
+            doc_storage_path: Path to the generated PDF in Supabase storage (optional)
+            gt_storage_path: Path to the ground truth JSON in Supabase storage (optional)
+            html_storage_path: Path to the HTML source in Supabase storage (optional)
+            bbox_storage_path: Path to the bbox JSON in Supabase storage (optional)
+            flagged: Whether the document is flagged for review
+            flag_reason: Reason for flagging
+        
+        Returns:
+            id (UUID) - Database record ID
+        """
+        insert_data = {
+            "request_id": request_id,
+            "created_at": datetime.now().isoformat(),
+            "updated_at": datetime.now().isoformat(),
+            "flagged": flagged
+        }
+        
+        if file_url is not None:
+            insert_data["file_url"] = file_url
+        if file_type is not None:
+            insert_data["file_type"] = file_type
+        if model_version is not None:
+            insert_data["model_version"] = model_version
+        if doc_index is not None:
+            insert_data["doc_index"] = doc_index
+        if doc_storage_path is not None:
+            insert_data["doc_storage_path"] = doc_storage_path
+        if gt_storage_path is not None:
+            insert_data["gt_storage_path"] = gt_storage_path
+        if html_storage_path is not None:
+            insert_data["html_storage_path"] = html_storage_path
+        if bbox_storage_path is not None:
+            insert_data["bbox_storage_path"] = bbox_storage_path
+        if zip_url is not None:
+            insert_data["zip_url"] = zip_url
+        if flag_reason is not None:
+            insert_data["flag_reason"] = flag_reason
+            
+        result = self.client.table("generated_documents").insert(insert_data).execute()
+        
+        return result.data[0]["id"]
+    
+    def upload_to_storage(
+        self,
+        bucket_name: str,
+        path: str,
+        file_bytes: bytes,
+        content_type: str
+    ) -> Dict[str, Any]:
+        """
+        Upload a file to Supabase storage.
+        
+        Args:
+            bucket_name: The name of the Supabase storage bucket
+            path: The path/filename to store the file as
+            file_bytes: The raw bytes of the file
+            content_type: MIME type of the file
+            
+        Returns:
+            Upload result dictionary containing the path
+        """
+        return self.client.storage.from_(bucket_name).upload(
+            file=file_bytes,
+            path=path,
+            file_options={"content-type": content_type, "upsert": "true"}
+        )
+        
+    def list_files(self, bucket_name: str, path: str) -> List[Dict[str, Any]]:
+        """List files in a Supabase storage bucket at a given path."""
+        return self.client.storage.from_(bucket_name).list(path)
+
+    def download_file(self, bucket_name: str, path: str) -> bytes:
+        """Download a file from Supabase storage."""
+        return self.client.storage.from_(bucket_name).download(path)
+        
+    def get_public_url(self, bucket_name: str, path: str) -> str:
+        """Get the public URL for a file in Supabase storage."""
+        return self.client.storage.from_(bucket_name).get_public_url(path)
+    
+    def get_generated_documents(
+        self,
+        request_id: str
+    ) -> List[Dict[str, Any]]:
+        """Get all generated documents for a request"""
+        result = self.client.table("generated_documents").select("*").eq(
+            "request_id", request_id
+        ).execute()
+        
+        return result.data
+    
+    # ==================== User Integrations ====================
+    
+    def get_user_google_drive_integration(
+        self,
+        user_id: int
+    ) -> Optional[Dict[str, Any]]:
+        """Get user's Google Drive integration credentials"""
+        result = self.client.table("user_integrations").select("*").eq(
+            "user_id", user_id
+        ).eq("provider", "google_drive").execute()
+        
+        return result.data[0] if result.data else None
+    
+    def update_google_drive_tokens(
+        self,
+        user_id: int,
+        access_token: str,
+        refresh_token: Optional[str] = None,
+        expires_at: Optional[datetime] = None
+    ):
+        """[DEPRECATED] Update Google Drive OAuth tokens"""
+        # This method is deprecated - frontend now handles OAuth
+        # Kept for backward compatibility only
+        pass
+    
+    # ==================== Analytics ====================
+    
+    def log_analytics_event(
+        self,
+        user_id: int,
+        event_type: str,
+        entity_id: Optional[str] = None
+    ):
+        """Log analytics event"""
+        self.client.table("analytics_events").insert({
+            "user_id": user_id,
+            "event_type": event_type,
+            "entity_id": entity_id,
+            "created_at": datetime.now().isoformat()
+        }).execute()
+
+
+# Global instance
+supabase_client = SupabaseClient()

api/test_api.py

@@ -0,0 +1,261 @@
+#!/usr/bin/env python3
+"""
+Test script for DocGenie API.
+Verifies all components are properly installed and configured.
+"""
+import sys
+import os
+from pathlib import Path
+
+
+def test_imports():
+    """Test that all required modules can be imported."""
+    print("Testing imports...")
+    
+    try:
+        import fastapi
+        print("  ✓ FastAPI")
+    except ImportError as e:
+        print(f"  ✗ FastAPI: {e}")
+        return False
+    
+    try:
+        import uvicorn
+        print("  ✓ Uvicorn")
+    except ImportError as e:
+        print(f"  ✗ Uvicorn: {e}")
+        return False
+    
+    try:
+        import pydantic
+        print("  ✓ Pydantic")
+    except ImportError as e:
+        print(f"  ✗ Pydantic: {e}")
+        return False
+    
+    try:
+        import requests
+        print("  ✓ Requests")
+    except ImportError as e:
+        print(f"  ✗ Requests: {e}")
+        return False
+    
+    try:
+        from PIL import Image
+        print("  ✓ Pillow")
+    except ImportError as e:
+        print(f"  ✗ Pillow: {e}")
+        return False
+    
+    try:
+        from bs4 import BeautifulSoup
+        print("  ✓ BeautifulSoup4")
+    except ImportError as e:
+        print(f"  ✗ BeautifulSoup4: {e}")
+        return False
+    
+    try:
+        from playwright.async_api import async_playwright
+        print("  ✓ Playwright")
+    except ImportError as e:
+        print(f"  ✗ Playwright: {e}")
+        return False
+    
+    try:
+        import anthropic
+        print("  ✓ Anthropic")
+    except ImportError as e:
+        print(f"  ✗ Anthropic: {e}")
+        return False
+    
+    try:
+        from docgenie import ENV
+        print("  ✓ DocGenie")
+    except ImportError as e:
+        print(f"  ✗ DocGenie: {e}")
+        return False
+    
+    return True
+
+
+def test_api_structure():
+    """Test that API files are in place."""
+    print("\nTesting API structure...")
+    
+    api_dir = Path(__file__).parent
+    
+    files = {
+        "main.py": "Main API application",
+        "schemas.py": "Request/Response models",
+        "utils.py": "Processing utilities",
+        "README.md": "Documentation",
+        "__init__.py": "Package init"
+    }
+    
+    all_present = True
+    for filename, description in files.items():
+        filepath = api_dir / filename
+        if filepath.exists():
+            print(f"  ✓ {filename}: {description}")
+        else:
+            print(f"  ✗ {filename}: Missing!")
+            all_present = False
+    
+    return all_present
+
+
+def test_docgenie_integration():
+    """Test integration with DocGenie modules."""
+    print("\nTesting DocGenie integration...")
+    
+    try:
+        from docgenie import ENV
+        prompt_template = ENV.PROMPT_TEMPLATES_DIR / "ClaudeRefined12" / "seed-based-json.txt"
+        
+        if prompt_template.exists():
+            print(f"  ✓ Prompt template found: {prompt_template}")
+        else:
+            print(f"  ✗ Prompt template not found: {prompt_template}")
+            return False
+        
+        # Test reading template
+        content = prompt_template.read_text(encoding='utf-8')
+        if "{language}" in content and "{doc_type}" in content:
+            print("  ✓ Prompt template has required placeholders")
+        else:
+            print("  ✗ Prompt template missing placeholders")
+            return False
+        
+        return True
+    
+    except Exception as e:
+        print(f"  ✗ Error: {e}")
+        return False
+
+
+def test_environment():
+    """Test environment configuration."""
+    print("\nTesting environment...")
+    
+    api_key = os.getenv("ANTHROPIC_API_KEY")
+    if api_key:
+        print(f"  ✓ ANTHROPIC_API_KEY is set (length: {len(api_key)})")
+    else:
+        print("  ⚠ ANTHROPIC_API_KEY not set (optional for testing)")
+    
+    python_version = sys.version_info
+    if python_version >= (3, 10):
+        print(f"  ✓ Python version: {python_version.major}.{python_version.minor}.{python_version.micro}")
+    else:
+        print(f"  ✗ Python version: {python_version.major}.{python_version.minor}.{python_version.micro} (3.10+ required)")
+        return False
+    
+    return True
+
+
+def test_playwright_browsers():
+    """Test if Playwright browsers are installed."""
+    print("\nTesting Playwright browsers...")
+    
+    try:
+        import subprocess
+        result = subprocess.run(
+            ["playwright", "show-trace", "--help"],
+            capture_output=True,
+            timeout=5
+        )
+        
+        if result.returncode == 0:
+            print("  ✓ Playwright CLI is available")
+        else:
+            print("  ⚠ Playwright CLI might have issues")
+        
+        # Check if chromium is installed
+        # This is a basic check - actual browser installation is verified at runtime
+        print("  ℹ Chromium will be verified when rendering PDFs")
+        
+        return True
+    
+    except FileNotFoundError:
+        print("  ✗ Playwright CLI not found")
+        return False
+    except Exception as e:
+        print(f"  ⚠ Could not verify Playwright: {e}")
+        return True  # Non-critical for this test
+
+
+def test_api_modules():
+    """Test that API modules can be imported."""
+    print("\nTesting API modules...")
+    
+    try:
+        # Add parent and current directory to path
+        api_dir = Path(__file__).parent
+        project_root = api_dir.parent
+        sys.path.insert(0, str(project_root))
+        sys.path.insert(0, str(api_dir))
+        
+        import schemas
+        print("  ✓ schemas module")
+        
+        import utils
+        print("  ✓ utils module")
+        
+        # Test that schema models exist
+        schemas.GenerateDocumentRequest
+        schemas.GenerateDocumentResponse
+        schemas.DocumentResult
+        print("  ✓ All schema models defined")
+        
+        return True
+    
+    except Exception as e:
+        print(f"  ✗ Error importing API modules: {e}")
+        return False
+
+
+def main():
+    """Run all tests."""
+    print("="*60)
+    print("DocGenie API - Test Suite")
+    print("="*60)
+    
+    results = {
+        "Imports": test_imports(),
+        "API Structure": test_api_structure(),
+        "Environment": test_environment(),
+        "DocGenie Integration": test_docgenie_integration(),
+        "Playwright": test_playwright_browsers(),
+        "API Modules": test_api_modules()
+    }
+    
+    print("\n" + "="*60)
+    print("Test Results Summary")
+    print("="*60)
+    
+    for test_name, result in results.items():
+        status = "✓ PASS" if result else "✗ FAIL"
+        print(f"{status}: {test_name}")
+    
+    all_passed = all(results.values())
+    
+    print("\n" + "="*60)
+    if all_passed:
+        print("✅ All tests passed! API is ready to use.")
+        print("\nTo start the API:")
+        print("  cd api")
+        print("  python main.py")
+        print("\nThen visit: http://localhost:8000/docs")
+    else:
+        print("⚠️  Some tests failed. Please fix issues before running the API.")
+        print("\nCommon fixes:")
+        print("  uv sync  # or: pip install -e .")
+        print("  playwright install chromium")
+        print("  export ANTHROPIC_API_KEY='your-key'")
+    print("="*60)
+    
+    return 0 if all_passed else 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

api/test_async_api.py

@@ -0,0 +1,321 @@
+#!/usr/bin/env python3
+"""
+Test script for async document generation API with Google Drive upload.
+
+Tests the complete async workflow with all features enabled:
+- Handwriting insertion
+- Visual elements (stamps, logos, figures, barcodes, photos)
+- OCR processing
+- Ground truth verification
+- Analysis and debug visualization
+- Dataset export
+- Google Drive upload
+
+Usage:
+    python test_async_api.py
+
+The script uses hardcoded tokens and polls continuously for status updates.
+"""
+
+import requests
+import time
+import sys
+
+
+# Configuration
+BASE_URL = "http://localhost:8000"
+POLL_INTERVAL = 10  # seconds between status checks
+
+# Test payload with all features enabled
+PAYLOAD = {
+    "user_id": 123,
+    "google_drive_token": "ya29.a0ATkoCc5wSA3DqNSI35d2EOCfLku0NWULKJYNMPhngjTwcnEKrcNcut1vawhiErgauHc85BrZdF5pug1xzp9Zu1oWATlzIMrMo5jqKDaXWThC0GuRifayOstjOetZnRLPRxVlmjx4k_xm7rto_pN6mT1CUrnte0Qkwf7FJVtF08JzJqaCG9Vvamag4OkkOhy-LB8MsUQaCgYKAXASARISFQHGX2MiAX_4jMvIlv2OkO7WurUUVA0206",
+    "google_drive_refresh_token": "1//03aLYGLUIYIl0CgYIARAAGAMSNwF-L9IrCfdJ-QHJHisqG86UjBvaEalyhWZdDcwbfLENt4V1ckik_wIkmsgjRwC9-SFeHrj-Yk4",
+    "seed_images": [
+        "https://ocr.space/Content/Images/receipt-ocr-original.webp"
+    ],
+    "prompt_params": {
+        "language": "English",
+        "doc_type": "business and administrative",
+        "gt_type": "Multiple questions about each document, with their answers taken **verbatim** from the document.",
+        "gt_format": "{\"<Text of question 1>\": \"<Answer to question 1>\", \"<Text of question 2>\": \"<Answer to question 2>\", ...}",
+        "num_solutions": 1,
+        "enable_handwriting": True,
+        "handwriting_ratio": 0.3,
+        "enable_visual_elements": True,
+        "visual_element_types": [
+            "stamp",
+            "logo",
+            "figure",
+            "barcode",
+            "photo"
+        ],
+        "seed": None,  # Use None for random behavior, or set to integer for reproducibility
+        "enable_ocr": True,
+        "ocr_language": "en",
+        "enable_bbox_normalization": True,
+        "enable_gt_verification": True,
+        "enable_analysis": True,
+        "enable_debug_visualization": True,
+        "enable_dataset_export": True,
+        "dataset_export_format": "msgpack",
+        "output_detail": "dataset"
+    }
+}
+
+
+def test_health():
+    """Test API health endpoint"""
+    print("=" * 80)
+    print("TESTING API HEALTH")
+    print("=" * 80)
+    
+    try:
+        response = requests.get(f"{BASE_URL}/health", timeout=5)
+        response.raise_for_status()
+        print(f"✓ API is healthy: {response.json()}\n")
+        return True
+    except Exception as e:
+        print(f"✗ Health check failed: {e}\n")
+        return False
+
+
+def submit_async_job():
+    """Submit async document generation job"""
+    print("=" * 80)
+    print("SUBMITTING ASYNC JOB")
+    print("=" * 80)
+    
+    print("\nConfiguration:")
+    print(f"  User ID: {PAYLOAD['user_id']}")
+    print(f"  Seed Images: {len(PAYLOAD['seed_images'])}")
+    print(f"  Num Solutions: {PAYLOAD['prompt_params']['num_solutions']}")
+    print(f"  Handwriting: {PAYLOAD['prompt_params']['enable_handwriting']} (ratio: {PAYLOAD['prompt_params']['handwriting_ratio']})")
+    print(f"  Visual Elements: {PAYLOAD['prompt_params']['enable_visual_elements']} (types: {len(PAYLOAD['prompt_params']['visual_element_types'])})")
+    print(f"  OCR: {PAYLOAD['prompt_params']['enable_ocr']}")
+    print(f"  GT Verification: {PAYLOAD['prompt_params']['enable_gt_verification']}")
+    print(f"  Analysis: {PAYLOAD['prompt_params']['enable_analysis']}")
+    print(f"  Debug Viz: {PAYLOAD['prompt_params']['enable_debug_visualization']}")
+    print(f"  Dataset Export: {PAYLOAD['prompt_params']['enable_dataset_export']}")
+    print(f"  Google Drive Upload: Yes")
+    print()
+    
+    try:
+        print("⏳ Submitting job to /generate/async...")
+        response = requests.post(
+            f"{BASE_URL}/generate/async",
+            json=PAYLOAD,
+            timeout=30
+        )
+        response.raise_for_status()
+        result = response.json()
+        
+        request_id = result["request_id"]
+        
+        print(f"\n✓ Job submitted successfully!")
+        print(f"  Request ID: {request_id}")
+        print(f"  Status: {result['status']}")
+        print(f"  Estimated Time: {result.get('estimated_time_minutes', 'N/A')} minutes")
+        print(f"  Poll URL: {result.get('poll_url', 'N/A')}")
+        
+        return request_id
+        
+    except requests.exceptions.HTTPError as e:
+        print(f"\n✗ Job submission failed: {e}")
+        if e.response:
+            print(f"  Response: {e.response.text}")
+        return None
+    except Exception as e:
+        print(f"\n✗ Unexpected error: {e}")
+        return None
+
+
+def poll_job_status(request_id):
+    """Poll job status continuously until completion or failure"""
+    print("\n" + "=" * 80)
+    print("CONTINUOUS STATUS POLLING")
+    print("=" * 80)
+    print(f"Request ID: {request_id}")
+    print(f"Polling every {POLL_INTERVAL} seconds...")
+    print("Press Ctrl+C to stop polling\n")
+    
+    poll_count = 0
+    last_status = None
+    last_progress = None
+    
+    while True:
+        poll_count += 1
+        timestamp = time.strftime("%H:%M:%S")
+        
+        try:
+            response = requests.get(
+                f"{BASE_URL}/jobs/{request_id}/status",
+                timeout=10
+            )
+            response.raise_for_status()
+            status_data = response.json()
+            
+            current_status = status_data["status"]
+            current_progress = status_data.get("progress")
+            
+            # Only print if status or progress changed
+            if current_status != last_status or current_progress != last_progress:
+                print(f"[{timestamp}] Poll #{poll_count}: {current_status.upper()}", end="")
+                if current_progress:
+                    print(f" - {current_progress}", end="")
+                print()
+                
+                last_status = current_status
+                last_progress = current_progress
+            
+            # Check terminal states
+            if current_status == "completed":
+                print("\n" + "=" * 80)
+                print("✓ JOB COMPLETED!")
+                print("=" * 80)
+                
+                results = status_data.get('results', {})
+                download_url = results.get('download_url')
+                
+                if download_url:
+                    print(f"  ✓ Google Drive URL: {download_url}")
+                else:
+                    print(f"  ⚠ Google Drive URL not available")
+                
+                if results.get('file_size_mb'):
+                    print(f"  File Size: {results['file_size_mb']:.2f} MB")
+                
+                print(f"  Document Count: {results.get('document_count', 'N/A')}")
+                print(f"  Created: {status_data.get('created_at')}")
+                print(f"  Completed: {status_data.get('updated_at')}")
+                
+                return status_data
+            
+            elif current_status == "failed":
+                print("\n" + "=" * 80)
+                print("✗ JOB FAILED!")
+                print("=" * 80)
+                print(f"  Error: {status_data.get('error_message', 'Unknown error')}")
+                print(f"  Created: {status_data.get('created_at')}")
+                print(f"  Failed: {status_data.get('updated_at')}")
+                return status_data
+            
+            # Wait before next poll
+            time.sleep(POLL_INTERVAL)
+        
+        except KeyboardInterrupt:
+            print("\n\n⚠ Polling interrupted by user")
+            print(f"You can continue polling manually:")
+            print(f"  GET {BASE_URL}/jobs/{request_id}/status")
+            return {"status": "interrupted"}
+        
+        except Exception as e:
+            print(f"\n⚠ Error polling status: {e}")
+            time.sleep(POLL_INTERVAL)
+
+
+def list_user_jobs():
+    """List all jobs for the test user"""
+    print("\n" + "=" * 80)
+    print("LISTING USER JOBS")
+    print("=" * 80)
+    
+    user_id = PAYLOAD['user_id']
+    
+    try:
+        response = requests.get(
+            f"{BASE_URL}/jobs/user/{user_id}",
+            params={"limit": 10, "offset": 0},
+            timeout=10
+        )
+        response.raise_for_status()
+        result = response.json()
+        
+        jobs = result.get("jobs", [])
+        print(f"\n✓ Found {len(jobs)} jobs for user {user_id}:\n")
+        
+        for i, job in enumerate(jobs, 1):
+            print(f"{i}. Request {job['request_id'][:8]}...")
+            print(f"   Status: {job['status']}")
+            print(f"   Created: {job.get('created_at', 'N/A')}")
+            if job.get('download_url'):
+                print(f"   Download: {job['download_url']}")
+            print()
+        
+        return jobs
+        
+    except Exception as e:
+        print(f"\n✗ Error listing jobs: {e}")
+        return []
+
+
+def main():
+    print("\n" + "=" * 80)
+    print(" " * 15 + "ASYNC PDF API TEST - FULL FEATURE SET")
+    print("=" * 80)
+    print(f"Base URL: {BASE_URL}")
+    print(f"User ID: {PAYLOAD['user_id']}")
+    print("=" * 80)
+    print()
+    
+    # Step 1: Health check
+    if not test_health():
+        print("\n❌ API is not accessible. Make sure the server is running.")
+        print(f"   Expected URL: {BASE_URL}")
+        sys.exit(1)
+    
+    # Step 2: Submit job
+    request_id = submit_async_job()
+    
+    if not request_id:
+        print("\n❌ Failed to submit job. Test aborted.")
+        sys.exit(1)
+    
+    # Step 3: Poll status continuously
+    final_status = poll_job_status(request_id)
+    
+    # Step 4: List all user jobs
+    list_user_jobs()
+    
+    # Final summary
+    print("\n" + "=" * 80)
+    print(" " * 30 + "SUMMARY")
+    print("=" * 80)
+    
+    status = final_status.get("status")
+    
+    if status == "completed":
+        print("✅ ALL TESTS PASSED!")
+        print("\nFeatures tested:")
+        print("  ✓ Async job submission")
+        print("  ✓ Handwriting insertion")
+        print("  ✓ Visual elements (5 types)")
+        print("  ✓ OCR processing")
+        print("  ✓ Ground truth verification")
+        print("  ✓ Analysis & debug visualization")
+        print("  ✓ Dataset export")
+        print("  ✓ Google Drive upload")
+        print("  ✓ Continuous status polling")
+        print(f"\n✓ Your documents are available at:")
+        print(f"  {final_status.get('results', {}).get('download_url')}")
+        sys.exit(0)
+    
+    elif status == "failed":
+        print("❌ JOB FAILED")
+        print(f"Error: {final_status.get('error_message')}")
+        sys.exit(1)
+    
+    elif status == "interrupted":
+        print("⏸ POLLING INTERRUPTED")
+        print(f"Job is still running. Check status manually:")
+        print(f"  GET {BASE_URL}/jobs/{request_id}/status")
+        sys.exit(0)
+    
+    else:
+        print("⏱ JOB STILL IN PROGRESS")
+        print(f"Check status manually: GET {BASE_URL}/jobs/{request_id}/status")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

api/test_get_google_token.py

@@ -0,0 +1,274 @@
+"""
+Helper script to get Google Drive OAuth token for testing.
+
+This script implements the OAuth flow to get access and refresh tokens
+from Google Drive API for testing purposes.
+
+Prerequisites:
+1. Google Cloud Project with Drive API enabled
+2. OAuth 2.0 Client ID credentials
+3. Add http://localhost:8080 as authorized redirect URI
+
+Usage:
+    python test_get_google_token.py --client-id YOUR_CLIENT_ID --client-secret YOUR_CLIENT_SECRET
+"""
+
+import argparse
+import webbrowser
+from urllib.parse import urlencode, parse_qs
+from http.server import HTTPServer, BaseHTTPRequestHandler
+import requests
+
+
+# Global variable to store authorization code
+auth_code = None
+
+
+class OAuthCallbackHandler(BaseHTTPRequestHandler):
+    """HTTP server to handle OAuth callback"""
+    
+    def do_GET(self):
+        global auth_code
+        
+        # Parse query parameters
+        query = self.path.split('?', 1)[-1]
+        params = parse_qs(query)
+        
+        if 'code' in params:
+            auth_code = params['code'][0]
+            
+            # Send success response
+            self.send_response(200)
+            self.send_header('Content-type', 'text/html')
+            self.end_headers()
+            
+            html = """
+            <html>
+            <head><title>Authorization Successful</title></head>
+            <body style="font-family: Arial; text-align: center; padding: 50px;">
+                <h1 style="color: green;">✓ Authorization Successful!</h1>
+                <p>You can close this window and return to the terminal.</p>
+            </body>
+            </html>
+            """
+            self.wfile.write(html.encode())
+        else:
+            # Error response
+            self.send_response(400)
+            self.send_header('Content-type', 'text/html')
+            self.end_headers()
+            
+            error = params.get('error', ['Unknown error'])[0]
+            html = f"""
+            <html>
+            <head><title>Authorization Failed</title></head>
+            <body style="font-family: Arial; text-align: center; padding: 50px;">
+                <h1 style="color: red;">✗ Authorization Failed</h1>
+                <p>Error: {error}</p>
+                <p>Please try again.</p>
+            </body>
+            </html>
+            """
+            self.wfile.write(html.encode())
+    
+    def log_message(self, format, *args):
+        """Suppress default logging"""
+        pass
+
+
+def get_google_drive_token(client_id: str, client_secret: str, redirect_uri: str = "http://localhost:8080"):
+    """
+    Get Google Drive OAuth tokens through OAuth flow.
+    
+    Args:
+        client_id: Google OAuth client ID
+        client_secret: Google OAuth client secret
+        redirect_uri: OAuth redirect URI (must match Google Cloud Console)
+    
+    Returns:
+        dict with 'access_token' and 'refresh_token'
+    """
+    global auth_code
+    
+    print("=" * 80)
+    print(" " * 20 + "GOOGLE DRIVE OAUTH TOKEN GENERATOR")
+    print("=" * 80)
+    print()
+    
+    # Step 1: Generate authorization URL
+    auth_params = {
+        'client_id': client_id,
+        'redirect_uri': redirect_uri,
+        'response_type': 'code',
+        'scope': 'https://www.googleapis.com/auth/drive.file',
+        'access_type': 'offline',  # Get refresh token
+        'prompt': 'consent'  # Force consent to get refresh token
+    }
+    
+    auth_url = f"https://accounts.google.com/o/oauth2/v2/auth?{urlencode(auth_params)}"
+    
+    print("Step 1: Authorize with Google")
+    print("-" * 80)
+    print("\nOpening authorization URL in your browser...")
+    print("If it doesn't open automatically, copy this URL:\n")
+    print(auth_url)
+    print()
+    
+    # Open browser
+    webbrowser.open(auth_url)
+    
+    # Step 2: Start local server to receive callback
+    print("Step 2: Waiting for authorization...")
+    print("-" * 80)
+    print(f"Local server listening on {redirect_uri}")
+    print("Complete the authorization in your browser.")
+    print()
+    
+    server = HTTPServer(('localhost', 8080), OAuthCallbackHandler)
+    
+    # Wait for one request (the callback)
+    while auth_code is None:
+        server.handle_request()
+    
+    server.server_close()
+    
+    if not auth_code:
+        print("✗ Failed to get authorization code")
+        return None
+    
+    print("✓ Authorization code received!")
+    print()
+    
+    # Step 3: Exchange code for tokens
+    print("Step 3: Exchanging code for tokens...")
+    print("-" * 80)
+    
+    token_url = "https://oauth2.googleapis.com/token"
+    token_data = {
+        'code': auth_code,
+        'client_id': client_id,
+        'client_secret': client_secret,
+        'redirect_uri': redirect_uri,
+        'grant_type': 'authorization_code'
+    }
+    
+    try:
+        response = requests.post(token_url, data=token_data)
+        response.raise_for_status()
+        tokens = response.json()
+        
+        print("✓ Tokens received!")
+        print()
+        print("=" * 80)
+        print(" " * 30 + "TOKENS")
+        print("=" * 80)
+        print()
+        print("Access Token:")
+        print(tokens['access_token'])
+        print()
+        
+        if 'refresh_token' in tokens:
+            print("Refresh Token:")
+            print(tokens['refresh_token'])
+            print()
+        else:
+            print("⚠ No refresh token received (user may have authorized before)")
+            print("  To get a refresh token:")
+            print("  1. Go to: https://myaccount.google.com/permissions")
+            print("  2. Remove your app's access")
+            print("  3. Run this script again")
+            print()
+        
+        print("Expires In: {} seconds".format(tokens.get('expires_in', 'N/A')))
+        print()
+        
+        # Show usage instructions
+        print("=" * 80)
+        print(" " * 25 + "USAGE INSTRUCTIONS")
+        print("=" * 80)
+        print()
+        print("Option 1: Use with test script directly")
+        print("-" * 80)
+        print("python test_async_api.py \\")
+        print(f"  --google-token {tokens['access_token']}")
+        if 'refresh_token' in tokens:
+            print(f"  --google-refresh-token {tokens['refresh_token']}")
+        print()
+        
+        print("Option 2: Set environment variable")
+        print("-" * 80)
+        print(f"export GOOGLE_DRIVE_TOKEN=\"{tokens['access_token']}\"")
+        if 'refresh_token' in tokens:
+            print(f"export GOOGLE_DRIVE_REFRESH_TOKEN=\"{tokens['refresh_token']}\"")
+        print("python test_async_api.py")
+        print()
+        
+        print("Option 3: Use in your frontend")
+        print("-" * 80)
+        print("Store these tokens in your frontend application and include them")
+        print("in API requests to /generate/async endpoint.")
+        print()
+        
+        print("=" * 80)
+        
+        return tokens
+        
+    except Exception as e:
+        print(f"✗ Failed to exchange code for tokens: {e}")
+        if hasattr(e, 'response') and e.response:
+            print(f"Response: {e.response.text}")
+        return None
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Get Google Drive OAuth token for testing"
+    )
+    parser.add_argument(
+        "--client-id",
+        type=str,
+        required=True,
+        help="Google OAuth Client ID"
+    )
+    parser.add_argument(
+        "--client-secret",
+        type=str,
+        required=True,
+        help="Google OAuth Client Secret"
+    )
+    parser.add_argument(
+        "--redirect-uri",
+        type=str,
+        default="http://localhost:8080",
+        help="OAuth redirect URI (default: http://localhost:8080)"
+    )
+    
+    args = parser.parse_args()
+    
+    print()
+    print("Prerequisites Check:")
+    print("-" * 80)
+    print(f"✓ Client ID: {args.client_id[:20]}...")
+    print(f"✓ Client Secret: {args.client_secret[:10]}...")
+    print(f"✓ Redirect URI: {args.redirect_uri}")
+    print()
+    print("Make sure you've added this redirect URI to your Google Cloud Console:")
+    print("  https://console.cloud.google.com/apis/credentials")
+    print()
+    input("Press Enter to continue...")
+    print()
+    
+    tokens = get_google_drive_token(
+        client_id=args.client_id,
+        client_secret=args.client_secret,
+        redirect_uri=args.redirect_uri
+    )
+    
+    if tokens:
+        print("✓ SUCCESS! Use the tokens above to test the async API.")
+    else:
+        print("✗ FAILED to get tokens. Please check your credentials and try again.")
+
+
+if __name__ == "__main__":
+    main()

api/test_runpod_integration.py

@@ -0,0 +1,123 @@
+"""
+Test script to verify RunPod handwriting service integration.
+This script tests the integration between the API and the deployed RunPod service.
+"""
+import asyncio
+import sys
+from pathlib import Path
+
+# Add parent directory to path
+sys.path.insert(0, str(Path(__file__).parent))
+
+from .utils import call_handwriting_service_batch
+from .config import settings
+
+
+async def test_runpod_integration():
+    """Test the RunPod handwriting service integration"""
+    
+    print("=" * 80)
+    print("RunPod Handwriting Service Integration Test")
+    print("=" * 80)
+    
+    # Check configuration
+    print("\n1. Configuration:")
+    print(f"   - HANDWRITING_SERVICE_URL: {settings.HANDWRITING_SERVICE_URL}")
+    print(f"   - HANDWRITING_SERVICE_ENABLED: {settings.HANDWRITING_SERVICE_ENABLED}")
+    print(f"   - HANDWRITING_SERVICE_TIMEOUT: {settings.HANDWRITING_SERVICE_TIMEOUT}s")
+    print(f"   - HANDWRITING_SERVICE_MAX_RETRIES: {settings.HANDWRITING_SERVICE_MAX_RETRIES}")
+    print(f"   - RUNPOD_API_KEY: {'Set' if settings.RUNPOD_API_KEY else 'Not set (optional)'}")
+    print(f"   - HANDWRITING_APPLY_BLUR: {settings.HANDWRITING_APPLY_BLUR}")
+    
+    if not settings.HANDWRITING_SERVICE_ENABLED:
+        print("\n❌ HANDWRITING_SERVICE_ENABLED is false. Please enable it in .env")
+        return
+    
+    # Prepare test data
+    test_texts = [
+        {
+            "text": "Hello",
+            "author_id": 42,
+            "hw_id": "test_hw_0"
+        },
+        {
+            "text": "World",
+            "author_id": 42,
+            "hw_id": "test_hw_1"
+        },
+        {
+            "text": "DocGenie",
+            "author_id": 100,
+            "hw_id": "test_hw_2"
+        },
+        {
+            "text": "Batch",
+            "author_id": 150,
+            "hw_id": "test_hw_3"
+        },
+        {
+            "text": "Processing",
+            "author_id": 200,
+            "hw_id": "test_hw_4"
+        }
+    ]
+    
+    print(f"\n2. Testing TRUE BATCH PROCESSING (cost-efficient):")
+    print(f"   - {len(test_texts)} texts will be sent in ONE request")
+    print(f"   - Activates ONLY 1 RunPod worker (instead of {len(test_texts)} workers)")
+    print(f"   - Expected cost savings: ~45% compared to parallel processing")
+    for text in test_texts:
+        print(f"   - '{text['text']}' (author_id: {text['author_id']})")
+    
+    # Call the service
+    print("\n3. Calling RunPod service with BATCH request...")
+    import time
+    start_time = time.time()
+    
+    try:
+        results = await call_handwriting_service_batch(test_texts)
+        
+        elapsed = time.time() - start_time
+        
+        print(f"\n4. Results:")
+        print(f"   - Successfully generated: {len(results)}/{len(test_texts)}")
+        print(f"   - Total time: {elapsed:.1f}s ({elapsed/len(results):.1f}s per text)")
+        print(f"   - Worker activations: 1 (would be {len(test_texts)} with old parallel method)")
+        
+        if results:
+            print("\n5. Sample result details:")
+            for i, result in enumerate(results[:2]):  # Show first 2 results
+                print(f"\n   Result {i+1}:")
+                print(f"   - hw_id: {result.get('hw_id')}")
+                print(f"   - text: {result.get('text')}")
+                print(f"   - author_id: {result.get('author_id')}")
+                print(f"   - width: {result.get('width')}px")
+                print(f"   - height: {result.get('height')}px")
+                print(f"   - image_base64: {result.get('image_base64')[:50]}... ({len(result.get('image_base64', ''))} chars)")
+            
+            print("\n" + "=" * 80)
+            print("✅ BATCH PROCESSING TEST PASSED!")
+            print("=" * 80)
+            print("\nCost Analysis:")
+            print(f"  OLD (parallel):  {len(test_texts)} workers × 18s = {len(test_texts) * 18}s total worker time")
+            print(f"  NEW (batched):   1 worker × {int(elapsed)}s = {int(elapsed)}s total worker time")
+            print(f"  Savings:         ~{int((1 - elapsed / (len(test_texts) * 18)) * 100)}% reduction in worker activation costs")
+            print("\nThe API now sends all {len(test_texts)} texts in ONE request, activating only 1 worker.")
+            print("This significantly reduces RunPod costs while maintaining quality.")
+        else:
+            print("\n⚠️ No results returned. Check the error messages above.")
+            
+    except Exception as e:
+        print(f"\n❌ Integration test FAILED!")
+        print(f"Error: {e}")
+        import traceback
+        traceback.print_exc()
+        print("\nPossible issues:")
+        print("1. Check that HANDWRITING_SERVICE_URL in .env is correct")
+        print("2. Verify the RunPod endpoint is deployed with v12 (batch support)")
+        print("3. Check if RUNPOD_API_KEY is required and set correctly")
+        print("4. Ensure the service handler supports batch input format")
+
+
+if __name__ == "__main__":
+    asyncio.run(test_runpod_integration())

api/test_sync_pdf_api.py

@@ -0,0 +1,312 @@
+#!/usr/bin/env python3
+"""
+Test script for /generate/pdf endpoint (sync API with tracking & GDrive upload).
+
+Tests the complete flow with all features enabled:
+- Handwriting insertion
+- Visual elements (stamps, logos, figures, barcodes, photos)
+- OCR processing
+- Ground truth verification
+- Analysis and debug visualization
+- Dataset export
+- Google Drive upload
+
+Usage:
+    python test_sync_pdf_api.py
+
+The script uses hardcoded tokens and polls continuously for status updates.
+"""
+
+import requests
+import time
+import sys
+import zipfile
+import io
+
+
+# Configuration
+BASE_URL = "http://localhost:8000"
+POLL_INTERVAL = 10  # seconds between status checks
+
+# Test payload with all features enabled
+PAYLOAD = {
+    "user_id": 123,
+    "google_drive_token": "ya29.a0ATkoCc5wSA3DqNSI35d2EOCfLku0NWULKJYNMPhngjTwcnEKrcNcut1vawhiErgauHc85BrZdF5pug1xzp9Zu1oWATlzIMrMo5jqKDaXWThC0GuRifayOstjOetZnRLPRxVlmjx4k_xm7rto_pN6mT1CUrnte0Qkwf7FJVtF08JzJqaCG9Vvamag4OkkOhy-LB8MsUQaCgYKAXASARISFQHGX2MiAX_4jMvIlv2OkO7WurUUVA0206",
+    "google_drive_refresh_token": "1//03aLYGLUIYIl0CgYIARAAGAMSNwF-L9IrCfdJ-QHJHisqG86UjBvaEalyhWZdDcwbfLENt4V1ckik_wIkmsgjRwC9-SFeHrj-Yk4",
+    "seed_images": [
+        "https://ocr.space/Content/Images/receipt-ocr-original.webp"
+    ],
+    "prompt_params": {
+        "language": "English",
+        "doc_type": "business and administrative",
+        "gt_type": "Multiple questions about each document, with their answers taken **verbatim** from the document.",
+        "gt_format": "{\"<Text of question 1>\": \"<Answer to question 1>\", \"<Text of question 2>\": \"<Answer to question 2>\", ...}",
+        "num_solutions": 1,
+        "enable_handwriting": True,
+        "handwriting_ratio": 0.3,
+        "enable_visual_elements": True,
+        "visual_element_types": [
+            "stamp",
+            "logo",
+            "figure",
+            "barcode",
+            "photo"
+        ],
+        "seed": None,  # Use None for random behavior, or set to integer for reproducibility
+        "enable_ocr": True,
+        "ocr_language": "en",
+        "enable_bbox_normalization": True,
+        "enable_gt_verification": True,
+        "enable_analysis": True,
+        "enable_debug_visualization": True,
+        "enable_dataset_export": True,
+        "dataset_export_format": "msgpack",
+        "output_detail": "dataset"
+    }
+}
+
+
+def test_health():
+    """Test API health endpoint"""
+    print("=" * 80)
+    print("TESTING API HEALTH")
+    print("=" * 80)
+    
+    try:
+        response = requests.get(f"{BASE_URL}/health", timeout=5)
+        response.raise_for_status()
+        print(f"✓ API is healthy: {response.json()}\n")
+        return True
+    except Exception as e:
+        print(f"✗ Health check failed: {e}\n")
+        return False
+
+
+def test_sync_endpoint():
+    """Test sync /generate/pdf endpoint with continuous polling"""
+    print("=" * 80)
+    print("TESTING SYNC /generate/pdf ENDPOINT")
+    print("=" * 80)
+    print("\nConfiguration:")
+    print(f"  User ID: {PAYLOAD['user_id']}")
+    print(f"  Seed Images: {len(PAYLOAD['seed_images'])}")
+    print(f"  Num Solutions: {PAYLOAD['prompt_params']['num_solutions']}")
+    print(f"  Handwriting: {PAYLOAD['prompt_params']['enable_handwriting']} (ratio: {PAYLOAD['prompt_params']['handwriting_ratio']})")
+    print(f"  Visual Elements: {PAYLOAD['prompt_params']['enable_visual_elements']} (types: {len(PAYLOAD['prompt_params']['visual_element_types'])})")
+    print(f"  OCR: {PAYLOAD['prompt_params']['enable_ocr']}")
+    print(f"  GT Verification: {PAYLOAD['prompt_params']['enable_gt_verification']}")
+    print(f"  Analysis: {PAYLOAD['prompt_params']['enable_analysis']}")
+    print(f"  Debug Viz: {PAYLOAD['prompt_params']['enable_debug_visualization']}")
+    print(f"  Dataset Export: {PAYLOAD['prompt_params']['enable_dataset_export']}")
+    print(f"  Google Drive Upload: Yes")
+    print()
+    
+    try:
+        print("⏳ Calling /generate/pdf...")
+        print("   (This will return immediately, then we'll poll for status)\n")
+        start_time = time.time()
+        
+        response = requests.post(
+            f"{BASE_URL}/generate/pdf",
+            json=PAYLOAD,
+            timeout=180,  # 3 minutes max for initial response
+            stream=True
+        )
+        response.raise_for_status()
+        
+        elapsed_time = time.time() - start_time
+        
+        # Check response headers
+        print(f"✓ Response received in {elapsed_time:.1f} seconds")
+        print("\nResponse Headers:")
+        
+        request_id = response.headers.get('X-Request-ID')
+        status_url = response.headers.get('X-Status-URL')
+        
+        if request_id:
+            print(f"  ✓ X-Request-ID: {request_id}")
+        else:
+            print(f"  ⚠ X-Request-ID: NOT SET")
+        
+        if status_url:
+            print(f"  ✓ X-Status-URL: {status_url}")
+        else:
+            print(f"  ⚠ X-Status-URL: NOT SET")
+        
+        # Verify ZIP file
+        zip_data = response.content
+        zip_size_mb = len(zip_data) / (1024 * 1024)
+        print(f"\n✓ ZIP file size: {zip_size_mb:.2f} MB")
+        
+        # Validate ZIP structure
+        try:
+            zip_buffer = io.BytesIO(zip_data)
+            with zipfile.ZipFile(zip_buffer, 'r') as zip_file:
+                file_list = zip_file.namelist()
+                print(f"✓ ZIP contains {len(file_list)} files")
+                
+                # Show directory structure
+                print("\nDataset Structure:")
+                dirs = set()
+                for filepath in file_list:
+                    parts = filepath.split('/')
+                    if len(parts) > 1:
+                        dirs.add(parts[0] + '/' + parts[1] if len(parts) > 2 else parts[0])
+                
+                for dir_name in sorted(dirs):
+                    file_count = sum(1 for f in file_list if f.startswith(dir_name + '/') and f != dir_name + '/')
+                    if file_count > 0:
+                        print(f"  📁 {dir_name}/ ({file_count} files)")
+                
+                # Check for essential files
+                if 'docgenie_documents/metadata.json' in file_list:
+                    print("\n  ✓ metadata.json present")
+                if 'docgenie_documents/README.md' in file_list:
+                    print("  ✓ README.md present")
+        
+        except zipfile.BadZipFile as e:
+            print(f"✗ Invalid ZIP file: {e}")
+            return False
+        
+        # Continuous polling if we have request_id
+        if request_id:
+            print("\n" + "=" * 80)
+            print("CONTINUOUS STATUS POLLING")
+            print("=" * 80)
+            print(f"Request ID: {request_id}")
+            print(f"Polling every {POLL_INTERVAL} seconds...\n")
+            
+            poll_count = 0
+            last_status = None
+            last_progress = None
+            
+            while True:
+                poll_count += 1
+                timestamp = time.strftime("%H:%M:%S")
+                
+                try:
+                    status_response = requests.get(
+                        f"{BASE_URL}/jobs/{request_id}/status",
+                        timeout=10
+                    )
+                    status_response.raise_for_status()
+                    status_data = status_response.json()
+                    
+                    current_status = status_data.get('status')
+                    current_progress = status_data.get('progress')
+                    
+                    # Only print if status or progress changed
+                    if current_status != last_status or current_progress != last_progress:
+                        print(f"[{timestamp}] Poll #{poll_count}: {current_status.upper()}", end="")
+                        if current_progress:
+                            print(f" - {current_progress}", end="")
+                        print()
+                        
+                        last_status = current_status
+                        last_progress = current_progress
+                    
+                    # Check for terminal states
+                    if current_status == "completed":
+                        print("\n" + "=" * 80)
+                        print("✓ JOB COMPLETED!")
+                        print("=" * 80)
+                        
+                        results = status_data.get('results', {})
+                        download_url = results.get('download_url')
+                        
+                        if download_url:
+                            print(f"  ✓ Google Drive URL: {download_url}")
+                        else:
+                            print(f"  ⏳ Google Drive upload may still be in progress")
+                        
+                        if results.get('file_size_mb'):
+                            print(f"  File Size: {results['file_size_mb']:.2f} MB")
+                        
+                        print(f"  Document Count: {results.get('document_count', 'N/A')}")
+                        print(f"  Created: {status_data.get('created_at')}")
+                        print(f"  Completed: {status_data.get('updated_at')}")
+                        
+                        break
+                    
+                    elif current_status == "failed":
+                        print("\n" + "=" * 80)
+                        print("✗ JOB FAILED!")
+                        print("=" * 80)
+                        print(f"  Error: {status_data.get('error_message', 'Unknown error')}")
+                        return False
+                    
+                    # Wait before next poll
+                    time.sleep(POLL_INTERVAL)
+                
+                except KeyboardInterrupt:
+                    print("\n\n⚠ Polling interrupted by user")
+                    print(f"You can continue polling manually:")
+                    print(f"  GET {BASE_URL}/jobs/{request_id}/status")
+                    break
+                
+                except Exception as e:
+                    print(f"\n⚠ Error polling status: {e}")
+                    time.sleep(POLL_INTERVAL)
+        
+        print("\n" + "=" * 80)
+        print("✅ TEST COMPLETED SUCCESSFULLY")
+        print("=" * 80)
+        print(f"✓ ZIP received in {elapsed_time:.1f} seconds")
+        print(f"✓ ZIP size: {zip_size_mb:.2f} MB")
+        print(f"✓ Dataset structure validated")
+        print(f"✓ Google Drive upload tracked")
+        return True
+        
+    except requests.exceptions.Timeout:
+        print(f"✗ Request timed out")
+        return False
+    except Exception as e:
+        print(f"✗ Test failed: {e}")
+        import traceback
+        traceback.print_exc()
+        return False
+
+
+def main():
+    print("\n" + "=" * 80)
+    print(" " * 15 + "SYNC PDF API TEST - FULL FEATURE SET")
+    print("=" * 80)
+    print(f"Base URL: {BASE_URL}")
+    print("=" * 80)
+    print()
+    
+    # Step 1: Health check
+    if not test_health():
+        print("\n❌ API is not accessible. Make sure the server is running.")
+        print(f"   Expected URL: {BASE_URL}")
+        sys.exit(1)
+    
+    # Step 2: Test sync endpoint
+    success = test_sync_endpoint()
+    
+    # Summary
+    print("\n" + "=" * 80)
+    print(" " * 30 + "SUMMARY")
+    print("=" * 80)
+    
+    if success:
+        print("✅ ALL TESTS PASSED!")
+        print("\nFeatures tested:")
+        print("  ✓ Handwriting insertion")
+        print("  ✓ Visual elements (5 types)")
+        print("  ✓ OCR processing")
+        print("  ✓ Ground truth verification")
+        print("  ✓ Analysis & debug visualization")
+        print("  ✓ Dataset export")
+        print("  ✓ Google Drive upload")
+        print("  ✓ Continuous status polling")
+    else:
+        print("❌ TEST FAILED")
+    
+    print("=" * 80)
+    
+    sys.exit(0 if success else 1)
+
+
+if __name__ == "__main__":
+    main()

api/worker.py

@@ -0,0 +1,804 @@
+"""
+Background worker for processing document generation jobs using batched Claude API.
+Runs as RQ worker process.
+"""
+
+import asyncio
+import io
+import json
+import os
+import pathlib
+import tempfile
+import time
+import traceback
+import zipfile
+import shutil
+import math
+from typing import Dict, Any, List, Callable
+from datetime import datetime
+
+# Add worker startup logging
+from .config import settings
+
+from .supabase_client import supabase_client
+from .google_drive import GoogleDriveClient
+from .utils import (
+    download_seed_images,
+    build_prompt,
+    extract_html_documents_from_response,
+    extract_ground_truth,
+    extract_css_from_html,
+    render_html_to_pdf,
+    extract_bboxes_from_rendered_pdf,
+    pdf_to_base64,
+    process_stage3_complete,
+    process_stage4_ocr,
+    process_stage5_complete,
+    validate_html_structure,
+    validate_pdf,
+    validate_bboxes
+)
+from docgenie.generation.pipeline_01.claude_batching import ClaudeBatchedClient
+from docgenie import ENV
+
+
+# ==================== Worker Logging Configuration ====================
+# Read from environment variable, default to False for cleaner logs
+VERBOSE_LOGGING = os.getenv('WORKER_VERBOSE_LOGGING', 'false').lower() in ('true', '1', 'yes')
+
+def log_verbose(message: str):
+    """Log message only if verbose logging is enabled"""
+    if VERBOSE_LOGGING:
+        print(message)
+
+
+# ==================== Startup Validation ====================
+def validate_worker_config():
+    """Validate worker configuration at startup"""
+    print("=" * 60)
+    print("🔧 Worker Configuration Check")
+    print("=" * 60)
+    
+    # Check Anthropic API
+    if settings.ANTHROPIC_API_KEY:
+        print("✓ ANTHROPIC_API_KEY: Set")
+    else:
+        print("✗ ANTHROPIC_API_KEY: NOT SET (REQUIRED)")
+    
+    # Check Supabase
+    if settings.SUPABASE_URL and settings.SUPABASE_KEY:
+        print(f"✓ SUPABASE: {settings.SUPABASE_URL[:30]}...")
+    else:
+        print("✗ SUPABASE: NOT SET (REQUIRED)")
+    
+    # Check Google OAuth (optional, for token refresh)
+    if settings.GOOGLE_CLIENT_ID and settings.GOOGLE_CLIENT_SECRET:
+        print(f"✓ GOOGLE_CLIENT_ID: {settings.GOOGLE_CLIENT_ID[:20]}...")
+        print("✓ GOOGLE_CLIENT_SECRET: Set")
+        print("  → Token auto-refresh: ENABLED")
+    else:
+        print("⚠ GOOGLE_CLIENT_ID/SECRET: Not set")
+        print("  → Token auto-refresh: DISABLED")
+        print("  → Users must provide fresh access tokens that don't expire during processing")
+    
+    print("=" * 60)
+
+# Run validation on module import
+validate_worker_config()
+
+
+def retry_on_network_error(func: Callable, max_retries: int = 3, delay: float = 2.0) -> Any:
+    """
+    Retry a function on network errors with exponential backoff.
+    
+    Args:
+        func: Function to execute (must be callable with no args)
+        max_retries: Maximum number of retry attempts
+        delay: Initial delay in seconds (doubles each retry)
+    
+    Returns:
+        Result of the function call
+    
+    Raises:
+        Last exception if all retries fail
+    """
+    last_exception = None
+    for attempt in range(max_retries):
+        try:
+            return func()
+        except Exception as e:
+            last_exception = e
+            error_str = str(e).lower()
+            # Retry on network/DNS errors
+            if any(err in error_str for err in ['name resolution', 'connection', 'timeout', 'network']):
+                if attempt < max_retries - 1:
+                    wait_time = delay * (2 ** attempt)
+                    print(f"[Retry {attempt + 1}/{max_retries}] Network error, retrying in {wait_time}s: {e}")
+                    time.sleep(wait_time)
+                    continue
+            # Non-network error or last attempt
+            raise
+    # All retries exhausted
+    raise last_exception
+
+
+async def process_document_generation_job_async(request_id: str, request_data: Dict[str, Any]):
+    """
+    Async background job function - processes document generation using batched Claude API.
+    
+    This function:
+    1. Creates Claude batch with single message (generates N documents)
+    2. Polls batch until completion
+    3. Processes all documents (PDFs, handwriting, etc.)
+    4. Uploads ZIP to user's Google Drive
+    5. Updates Supabase with results
+    
+    Args:
+        request_id: Document request UUID from Supabase
+        request_data: Request parameters dict containing:
+            - user_id: int
+            - seed_images: List[str] (URLs)
+            - prompt_params: Dict (language, doc_type, num_solutions, etc.)
+    
+    Raises:
+        Exception: Any error during processing (logged to Supabase)
+    """
+    user_id = request_data['user_id']
+    google_drive_token = request_data.get('google_drive_token')
+    google_drive_refresh_token = request_data.get('google_drive_refresh_token')
+    seed_image_urls = request_data['seed_images']
+    prompt_params = request_data['prompt_params']
+    
+    # Validate Google Drive credentials configuration
+    if google_drive_refresh_token:
+        if not settings.GOOGLE_CLIENT_ID or not settings.GOOGLE_CLIENT_SECRET:
+            print(f"[Job {request_id}] ⚠️ WARNING: refresh_token provided but GOOGLE_CLIENT_ID/SECRET not configured")
+            print(f"[Job {request_id}] Token auto-refresh will fail. Ensure access token remains valid.")
+    
+    # Create temporary directories for this job
+    with tempfile.TemporaryDirectory() as tmp_dir:
+        tmp_path = pathlib.Path(tmp_dir)
+        batch_dir = tmp_path / "batches"
+        message_dir = tmp_path / "messages"
+        batch_dir.mkdir(exist_ok=True)
+        message_dir.mkdir(exist_ok=True)
+        
+        # Initialize DatasetExporter for organized structure
+        from .dataset_exporter import DatasetExporter
+        exporter = DatasetExporter(tmp_path, dataset_name="docgenie_documents")
+        
+        try:
+            # ==================== Update Status: Downloading ====================
+            retry_on_network_error(lambda: supabase_client.update_request_status(request_id, "downloading"))
+            print(f"[Job {request_id}] Status: downloading (fetching seed images)")
+            
+            # ==================== Step 1: Download Seed Images ====================
+            log_verbose(f"[Job {request_id}] Downloading {len(seed_image_urls)} seed images...")
+            seed_images_base64 = download_seed_images(seed_image_urls)
+            log_verbose(f"[Job {request_id}] Downloaded {len(seed_images_base64)} images")
+            
+            # ==================== Step 2: Build Prompts (Chunked) ====================
+            prompt_template_path = ENV.PROMPT_TEMPLATES_DIR / "ClaudeRefined12" / "seed-based-json.txt"
+            if not prompt_template_path.exists():
+                raise FileNotFoundError(f"Prompt template not found: {prompt_template_path}")
+
+            num_solutions = prompt_params.get('num_solutions', 1)
+            chunk_size = settings.BATCH_PROMPT_CHUNK_SIZE
+            num_prompts = math.ceil(num_solutions / chunk_size)
+            
+            prompts = []
+            images_base64_list = []
+            image_docids_list = []
+            
+            for i in range(num_prompts):
+                # Calculate how many solutions for this specific prompt
+                current_num_solutions = min(chunk_size, num_solutions - (i * chunk_size))
+                
+                p = build_prompt(
+                    language=prompt_params.get('language', 'English'),
+                    doc_type=prompt_params.get('doc_type', 'business and administrative'),
+                    gt_type=prompt_params.get('gt_type', 'Questions and answers'),
+                    gt_format=prompt_params.get('gt_format', '{"question": "answer"}'),
+                    num_solutions=current_num_solutions,
+                    num_seed_images=len(seed_images_base64),
+                    prompt_template_path=prompt_template_path,
+                    enable_visual_elements=prompt_params.get('enable_visual_elements', False),
+                    visual_element_types=prompt_params.get('visual_element_types', [])
+                )
+                prompts.append(p)
+                images_base64_list.append(seed_images_base64)
+                image_docids_list.append(["seed"] * len(seed_images_base64))
+            
+            log_verbose(f"[Job {request_id}] Created {num_prompts} prompts (chunk size: {chunk_size})")
+            
+            # ==================== Step 3: Create Claude Batch ====================
+            log_verbose(f"[Job {request_id}] Creating Claude batch with {num_prompts} messages...")
+            
+            client = ClaudeBatchedClient(api_key=settings.ANTHROPIC_API_KEY)
+            
+            # Send batch with multiple messages (one per chunk)
+            client.send_batch(
+                model=settings.CLAUDE_MODEL,
+                prompts=prompts,
+                images_base64=images_base64_list,
+                image_docids=image_docids_list,
+                batch_data_directory=batch_dir,
+                max_tokens=16384
+            )
+            
+            print(f"[Job {request_id}] ⏳ Batch created with {num_prompts} tasks, awaiting processing...")
+            
+            # ==================== Step 4: Poll Batch Until Complete ====================
+            client.await_batches(
+                batch_data_directory=batch_dir,
+                message_data_directory=message_dir,
+                sleep_seconds_between_batch=2,
+                sleep_seconds_iteration=settings.BATCH_POLL_INTERVAL
+            )
+            
+            print(f"[Job {request_id}] ✓ Batch complete")
+            
+            # ==================== Step 5: Read Batch Results ====================
+            message_files = list(message_dir.glob("*.json"))
+            
+            if not message_files:
+                raise RuntimeError("No message results found after batch completion")
+            
+            html_documents = []
+            for msg_file in message_files:
+                try:
+                    message_data = json.loads(msg_file.read_text())
+                    if message_data.get('result_type') == 'succeeded':
+                        llm_response = message_data['response']
+                        docs = extract_html_documents_from_response(llm_response)
+                        html_documents.extend(docs)
+                        log_verbose(f"  ✓ Extracted {len(docs)} documents from task {msg_file.stem}")
+                    else:
+                        error_msg = message_data.get('error', 'Unknown error')
+                        print(f"[Job {request_id}] ⚠ Task {msg_file.stem} failed: {error_msg}")
+                except Exception as e:
+                    print(f"[Job {request_id}] ⚠ Error reading message result {msg_file.name}: {e}")
+            
+            if not html_documents:
+                raise RuntimeError("No valid HTML documents found in any batch results")
+            
+            print(f"[Job {request_id}] ✓ Combined total of {len(html_documents)} documents from all tasks")
+            
+            # ==================== Update Status: Generating ====================
+            retry_on_network_error(lambda: supabase_client.update_request_status(request_id, "generating"))
+            print(f"[Job {request_id}] Status: generating (processing documents)")
+            
+            # ==================== Step 7: Download Assets from Supabase ====================
+            assets_temp_dir = None
+            try:
+                assets_path = f"{user_id}/{request_id}/assets"
+                files = supabase_client.list_files("doc_storage", assets_path)
+                
+                # Filter out directories
+                asset_files = [f for f in files if f.get('id') is not None]
+                
+                if asset_files:
+                    assets_temp_dir = pathlib.Path(tempfile.mkdtemp())
+                    print(f"[Job {request_id}] Found {len(asset_files)} assets in storage, downloading...")
+                    
+                    for file_info in asset_files:
+                        file_name = file_info['name']
+                        try:
+                            file_content = supabase_client.download_file("doc_storage", f"{assets_path}/{file_name}")
+                            with open(assets_temp_dir / file_name, 'wb') as f:
+                                f.write(file_content)
+                            log_verbose(f"  ✓ Downloaded {file_name}")
+                        except Exception as download_err:
+                            print(f"  ⚠ Failed to download {file_name}: {download_err}")
+                else:
+                    log_verbose(f"[Job {request_id}] No assets found in {assets_path}")
+            except Exception as e:
+                print(f"[Job {request_id}] ⚠ Asset check/download failed: {e}")
+            
+            # ==================== Step 8: Process Each Document ====================
+            pdf_files = []
+            metadata = []
+            
+            for idx, html in enumerate(html_documents):
+                try:
+                    doc_id = f"document_{idx + 1}"
+                    log_verbose(f"[Job {request_id}] Processing document {idx + 1}/{len(html_documents)}")
+                    
+                    # Initialize original_pdf_path
+                    original_pdf_path = None
+                    
+                    # Validate HTML
+                    is_valid, error_msg = validate_html_structure(html)
+                    if not is_valid:
+                        print(f"[Job {request_id}] Document {idx + 1} HTML validation failed: {error_msg}")
+                        continue
+                    
+                    # Extract ground truth and CSS
+                    gt, html_clean = extract_ground_truth(html)
+                    css, _ = extract_css_from_html(html_clean)
+                    
+                    # Render to PDF
+                    pdf_path = tmp_path / f"{doc_id}.pdf"
+                    pdf_path, width_mm, height_mm, geometries = await render_html_to_pdf(
+                        html=html_clean,
+                        output_pdf_path=pdf_path
+                    )
+                    
+                    # Track original PDF
+                    original_pdf_path = pdf_path
+                    
+                    # Validate PDF
+                    is_valid, error_msg = validate_pdf(pdf_path)
+                    if not is_valid:
+                        print(f"[Job {request_id}] Document {idx + 1} PDF validation failed: {error_msg}")
+                        continue
+                    
+                    # Extract bounding boxes
+                    bboxes_raw = extract_bboxes_from_rendered_pdf(pdf_path)
+                    
+                    # Validate bboxes
+                    is_valid, error_msg = validate_bboxes(bboxes_raw, min_bbox_count=1)
+                    if not is_valid:
+                        print(f"[Job {request_id}] Document {idx + 1} BBox validation warning: {error_msg}")
+                    
+                    log_verbose(f"[Job {request_id}] Document {idx + 1}: Extracted {len(bboxes_raw)} bboxes")
+                    
+                    # Process Stage 3 (Handwriting & Visual Elements) if enabled
+                    final_image_b64 = None
+                    handwriting_regions = []
+                    visual_elements = []
+                    handwriting_images = {}
+                    visual_element_images = {}
+                    ocr_results = None
+                    pdf_with_handwriting_path = None
+                    pdf_final_path = None
+                    
+                    if prompt_params.get('enable_handwriting') or prompt_params.get('enable_visual_elements'):
+                        # Update status: Handwriting
+                        if prompt_params.get('enable_handwriting'):
+                            retry_on_network_error(lambda: supabase_client.update_request_status(request_id, "handwriting"))
+                            log_verbose(f"[Job {request_id}] Status: handwriting (generating handwritten text)")
+                        
+                        log_verbose(f"[Job {request_id}] Document {idx + 1}: Processing handwriting/visual elements...")
+                        
+                        try:
+                            final_image_b64, handwriting_regions, visual_elements, handwriting_images, visual_element_images, pdf_with_handwriting_path, pdf_final_path = await process_stage3_complete(
+                                pdf_path=pdf_path,
+                                geometries=geometries,
+                                ground_truth=gt,
+                                bboxes_raw=bboxes_raw,
+                                page_width_mm=width_mm,
+                                page_height_mm=height_mm,
+                                enable_handwriting=prompt_params.get('enable_handwriting', False),
+                                handwriting_ratio=prompt_params.get('handwriting_ratio', 0.3),
+                                enable_visual_elements=prompt_params.get('enable_visual_elements', False),
+                                visual_element_types=prompt_params.get('visual_element_types', []),
+                                seed=prompt_params.get('seed'),
+                                assets_dir=assets_temp_dir,
+                                barcode_number=prompt_params.get('barcode_number')
+                            )
+                            
+                            # Use final PDF if both modifications applied, otherwise use handwriting PDF
+                            if pdf_final_path and pdf_final_path.exists():
+                                pdf_path = pdf_final_path
+                            elif pdf_with_handwriting_path and pdf_with_handwriting_path.exists():
+                                pdf_path = pdf_with_handwriting_path
+                            
+                            log_verbose(f"[Job {request_id}] Document {idx + 1}: {len(handwriting_regions)} handwriting, {len(visual_elements)} visual elements")
+                        
+                        except Exception as e:
+                            print(f"[Job {request_id}] Document {idx + 1}: Stage 3 failed: {str(e)}")
+                    
+                    # Process Stage 4/5 (OCR) if needed
+                    if prompt_params.get('enable_ocr'):
+                        # Update status: OCR
+                        retry_on_network_error(lambda: supabase_client.update_request_status(request_id, "ocr"))
+                        log_verbose(f"[Job {request_id}] Status: ocr (running OCR on documents)")
+                        
+                        log_verbose(f"[Job {request_id}] Document {idx + 1}: Processing OCR...")
+                        
+                        try:
+                            stage4_image, ocr_results = await process_stage4_ocr(
+                                pdf_path=pdf_path,
+                                enable_ocr=True,
+                                dpi=settings.OCR_DPI
+                            )
+                            
+                            if ocr_results:
+                                log_verbose(f"[Job {request_id}] Document {idx + 1}: OCR complete - {len(ocr_results.get('words', []))} words")
+                        
+                        except Exception as e:
+                            print(f"[Job {request_id}] Document {idx + 1}: OCR failed: {str(e)}")
+                    
+                    # Process Stage 5 (Dataset packaging) if needed
+                    stage5_results = {}
+                    if any([
+                        prompt_params.get('enable_bbox_normalization'),
+                        prompt_params.get('enable_gt_verification'),
+                        prompt_params.get('enable_analysis'),
+                        prompt_params.get('enable_debug_visualization')
+                    ]):
+                        # Update status: Validation (if GT verification enabled)
+                        if prompt_params.get('enable_gt_verification'):
+                            retry_on_network_error(lambda: supabase_client.update_request_status(request_id, "validation"))
+                            log_verbose(f"[Job {request_id}] Status: validation (validating ground truth)")
+                        
+                        log_verbose(f"[Job {request_id}] Document {idx + 1}: Processing dataset packaging...")
+                        
+                        try:
+                            stage5_results = await process_stage5_complete(
+                                document_id=doc_id,
+                                pdf_path=pdf_path,
+                                image_base64=final_image_b64,
+                                ocr_results=ocr_results,
+                                ground_truth=gt,
+                                has_handwriting=prompt_params.get('enable_handwriting', False),
+                                has_visual_elements=prompt_params.get('enable_visual_elements', False),
+                                layout_elements=visual_elements,
+                                enable_bbox_normalization=prompt_params.get('enable_bbox_normalization', False),
+                                enable_gt_verification=prompt_params.get('enable_gt_verification', False),
+                                enable_analysis=prompt_params.get('enable_analysis', False),
+                                enable_debug_visualization=prompt_params.get('enable_debug_visualization', False)
+                            )
+                        
+                        except Exception as e:
+                            print(f"[Job {request_id}] Document {idx + 1}: Stage 5 failed: {str(e)}")
+                    
+                    # Track PDFs for metadata
+                    if original_pdf_path and pdf_path != original_pdf_path:
+                        pdf_files.append(original_pdf_path)
+                        pdf_files.append(pdf_path)
+                    else:
+                        pdf_files.append(pdf_path)
+                    
+                    # Extract bbox_pdf (word + char) from original PDF (ground truth positions)
+                    from .utils import extract_all_bboxes_from_pdf, extract_raw_annotations_from_geometries
+                    log_verbose(f"[Job {request_id}] Document {idx + 1}: 📦 Extracting bbox_pdf (word + char level) from original PDF...")
+                    
+                    try:
+                        bboxes_pdf = extract_all_bboxes_from_pdf(original_pdf_path if original_pdf_path else pdf_path)
+                        bbox_pdf_word = bboxes_pdf.get('word', [])
+                        bbox_pdf_char = bboxes_pdf.get('char', [])
+                        log_verbose(f"[Job {request_id}] Document {idx + 1}:   ✓ Extracted {len(bbox_pdf_word)} word bboxes, {len(bbox_pdf_char)} char bboxes from PDF")
+                    except Exception as e:
+                        print(f"[Job {request_id}] Document {idx + 1}:   ⚠ bbox_pdf extraction failed: {e}")
+                        bbox_pdf_word = bboxes_raw  # Fallback to raw bboxes
+                        bbox_pdf_char = []
+                    
+                    # Extract raw_annotations (layout boxes before normalization)
+                    raw_annotations = None
+                    if geometries:
+                        log_verbose(f"[Job {request_id}] Document {idx + 1}: 📦 Extracting raw_annotations from geometries...")
+                        try:
+                            raw_annotations = extract_raw_annotations_from_geometries(geometries)
+                            log_verbose(f"[Job {request_id}] Document {idx + 1}:   ✓ Extracted {len(raw_annotations)} layout annotations")
+                        except Exception as e:
+                            print(f"[Job {request_id}] Document {idx + 1}:   ⚠ raw_annotations extraction failed: {e}")
+                    
+                    # Decode final image to bytes
+                    final_image_bytes = None
+                    if final_image_b64:
+                        import base64
+                        final_image_bytes = base64.b64decode(final_image_b64)
+                    
+                    # Decode debug visualization
+                    debug_viz_bytes = None
+                    if stage5_results.get('debug_visualization'):
+                        import base64
+                        debug_viz_dict = stage5_results['debug_visualization']
+                        if debug_viz_dict and 'bbox_overlay_base64' in debug_viz_dict:
+                            debug_viz_b64 = debug_viz_dict['bbox_overlay_base64']
+                            debug_viz_bytes = base64.b64decode(debug_viz_b64)
+                    
+                    # Prepare token mapping if tokens exist
+                    output_detail = prompt_params.get('output_detail', 'minimal')
+                    token_mapping_data = None
+                    if output_detail in ["dataset", "complete"]:
+                        if handwriting_images or visual_element_images:
+                            from .utils import create_token_mapping_json
+                        token_mapping_data = create_token_mapping_json(
+                            handwriting_regions,
+                            handwriting_images,
+                            visual_elements,
+                            visual_element_images
+                        )
+                        log_verbose(f"[Job {request_id}] Document {idx + 1}: 📦 Output detail '{output_detail}': Prepared {len(handwriting_images)} handwriting tokens, {len(visual_element_images)} visual elements")
+                    
+                    # Extract bbox_final_word and bbox_final_segment (from OCR or PDF)
+                    bbox_final_word = None
+                    bbox_final_segment = None
+                    if ocr_results and ocr_results.get('words'):
+                        # Use OCR results as final bboxes
+                        bbox_final_word = ocr_results.get('words', [])
+                        bbox_final_segment = ocr_results.get('lines', [])
+                    else:
+                        # Fallback to PDF bboxes if no OCR
+                        bbox_final_word = bbox_pdf_word
+                        bbox_final_segment = []  # No line-level data without OCR
+                    
+                    # Read PDF bytes for exporter
+                    pdf_initial_bytes = original_pdf_path.read_bytes()
+                    
+                    # Read modified PDFs if they exist
+                    pdf_with_handwriting_bytes = None
+                    pdf_final_bytes = None
+                    pdf_with_visual_elements_bytes = None
+                    
+                    if pdf_with_handwriting_path and pdf_with_handwriting_path.exists():
+                        pdf_with_handwriting_bytes = pdf_with_handwriting_path.read_bytes()
+                    
+                    if pdf_final_path and pdf_final_path.exists():
+                        pdf_final_bytes = pdf_final_path.read_bytes()
+                    
+                    # Special case: if only visual elements (no handwriting), pdf_final is actually pdf_with_visual_elements
+                    if pdf_final_bytes and not pdf_with_handwriting_bytes:
+                        pdf_with_visual_elements_bytes = pdf_final_bytes
+                        pdf_final_bytes = None
+                    
+                    # Add document to exporter
+                    log_verbose(f"[Job {request_id}] Document {idx + 1}: 📦 Adding document to dataset exporter...")
+                    exporter.add_document(
+                        document_id=doc_id,
+                        html=html_clean,
+                        css=css,
+                        pdf_initial=pdf_initial_bytes,
+                        pdf_with_handwriting=pdf_with_handwriting_bytes,
+                        pdf_with_visual_elements=pdf_with_visual_elements_bytes,
+                        pdf_final=pdf_final_bytes,
+                        final_image=final_image_bytes,
+                        ground_truth=gt,
+                        raw_annotations=raw_annotations,
+                        bboxes_pdf_word=bbox_pdf_word,
+                        bboxes_pdf_char=bbox_pdf_char,
+                        bboxes_final_word=bbox_final_word,
+                        bboxes_final_segment=bbox_final_segment,
+                        bboxes_normalized_word=stage5_results.get('normalized_bboxes_word'),
+                        bboxes_normalized_segment=stage5_results.get('normalized_bboxes_segment'),
+                        gt_verification=stage5_results.get('gt_verification'),
+                        token_mapping=token_mapping_data,
+                        handwriting_regions=handwriting_regions,
+                        handwriting_images=handwriting_images,
+                        visual_elements=visual_elements,
+                        visual_element_images=visual_element_images,
+                        layout_elements=visual_elements,
+                        geometries=geometries,
+                        ocr_results=ocr_results,
+                        analysis_stats=stage5_results.get('analysis_stats'),
+                        debug_visualization=debug_viz_bytes
+                    )
+                    log_verbose(f"[Job {request_id}] Document {idx + 1}:   ✓ Document {doc_id} added to dataset")
+                    
+                    # Store comprehensive metadata (matching /generate/pdf format)
+                    metadata.append({
+                        "document_id": doc_id,
+                        "filename": f"{doc_id}.pdf",
+                        "bboxes": bboxes_raw,
+                        "ground_truth": gt,
+                        "geometries": geometries,
+                        "page_width_mm": width_mm,
+                        "page_height_mm": height_mm,
+                        "handwriting_regions": handwriting_regions,
+                        "visual_elements": visual_elements,
+                        "has_stage3_image": final_image_b64 is not None,
+                        "ocr_results": ocr_results,
+                        # Stage 5 results
+                        "normalized_bboxes_word": stage5_results.get('normalized_bboxes_word'),
+                        "normalized_bboxes_segment": stage5_results.get('normalized_bboxes_segment'),
+                        "gt_verification": stage5_results.get('gt_verification'),
+                        "analysis_stats": stage5_results.get('analysis_stats'),
+                        "debug_visualization_available": stage5_results.get('debug_visualization') is not None
+                    })
+                
+                except Exception as e:
+                    print(f"[Job {request_id}] Error processing document {idx + 1}: {str(e)}")
+                    traceback.print_exc()
+                    continue
+            
+            if not pdf_files:
+                raise RuntimeError("Failed to process any documents")
+            
+            log_verbose(f"[Job {request_id}] Processed {len(pdf_files)} PDF files")
+            
+            # ==================== Step 8: Finalize Dataset & Create ZIP ====================
+            log_verbose(f"[Job {request_id}] 📦 Finalizing dataset export...")
+            exporter.finalize(
+                request_id=request_id,
+                user_id=user_id,
+                prompt_params=prompt_params,
+                api_mode="async"
+            )
+            log_verbose(f"[Job {request_id}]   ✓ Dataset structure finalized at {exporter.base_path}")
+            
+            # ==================== Update Status: Zipping ====================
+            retry_on_network_error(lambda: supabase_client.update_request_status(request_id, "zipping"))
+            print(f"[Job {request_id}] Status: zipping (creating ZIP archive)")
+            
+            # Create ZIP from organized dataset
+            log_verbose(f"[Job {request_id}] 📦 Creating ZIP archive from dataset...")
+            zip_path = tmp_path / f"docgenie_{request_id}.zip"
+            
+            with zipfile.ZipFile(zip_path, 'w', zipfile.ZIP_DEFLATED) as zip_file:
+                # Add all files from exporter.base_path
+                for file_path in exporter.base_path.rglob('*'):
+                    if file_path.is_file():
+                        arcname = file_path.relative_to(exporter.base_path.parent)
+                        zip_file.write(file_path, arcname)
+            
+            zip_size_mb = zip_path.stat().st_size / (1024 * 1024)
+            log_verbose(f"[Job {request_id}]   ✓ ZIP created: {zip_size_mb:.2f} MB")
+            
+            # ==================== Update Status: Uploading ====================
+            retry_on_network_error(lambda: supabase_client.update_request_status(request_id, "uploading"))
+            print(f"[Job {request_id}] Status: uploading (uploading to Google Drive)")
+            
+            # ==================== Step 9: Upload to Google Drive ====================
+            print(f"[Job {request_id}] ⬆️  Uploading to Google Drive...")
+            
+            google_drive_url = None
+            gdrive_failed = False
+            # Check if Google Drive token provided
+            if not google_drive_token:
+                print(f"[Job {request_id}] No Google Drive token provided. Skipping Google Drive upload.")
+            else:
+                try:
+                    drive_client = GoogleDriveClient(
+                        access_token=google_drive_token,
+                        refresh_token=google_drive_refresh_token
+                    )
+                    google_drive_url = drive_client.upload_file(
+                        file_path=zip_path,
+                        filename=f"docgenie_{request_id}.zip",
+                        folder_name=settings.GOOGLE_DRIVE_FOLDER_NAME
+                    )
+                    
+                    print(f"[Job {request_id}] ✓ Uploaded to Google Drive: {google_drive_url}")
+                
+                except Exception as e:
+                    print(f"[Job {request_id}] Google Drive upload failed: {str(e)}")
+                    gdrive_failed = True
+                    # Do not raise an error, just continue so we can still save to Supabase
+            
+            # ==================== Step 10: Store Results in Supabase ====================
+            log_verbose(f"[Job {request_id}] Saving results to Supabase...")
+            log_verbose(f"[Job {request_id}]   URL: {google_drive_url}")
+            
+            # Upload ZIP to Supabase
+            zip_url = None
+            try:
+                zip_storage_path = f"{user_id}/{request_id}/generated/docgenie_{request_id}.zip"
+                supabase_client.upload_to_storage("doc_storage", zip_storage_path, zip_path.read_bytes(), "application/zip")
+                zip_url = supabase_client.get_public_url("doc_storage", zip_storage_path)
+                print(f"[Job {request_id}] ✓ Uploaded ZIP to Supabase: {zip_url}")
+            except Exception as e:
+                print(f"[Job {request_id}] ⚠ Supabase ZIP upload failed: {e}")
+
+            # ==================== Step 11: Upload Individual Documents to Supabase ====================
+            print(f"[Job {request_id}] Uploading individual documents to Supabase...")
+            for idx, doc_data in enumerate(metadata):
+                doc_id = doc_data["document_id"]
+                try:
+                    # Determine paths (matching sync endpoint structure)
+                    doc_storage_path = f"{user_id}/{request_id}/generated/{idx}_doc.pdf"
+                    gt_storage_path = f"{user_id}/{request_id}/generated/{idx}_gt.json"
+                    src_storage_path = f"{user_id}/{request_id}/generated/{idx}_src.html"
+                    bbox_storage_path = f"{user_id}/{request_id}/generated/{idx}_bbox.json"
+                    
+                    # Find files on disk
+                    doc_path = exporter.pdf_final_dir / f"{doc_id}.pdf"
+                    if not doc_path.exists():
+                        doc_path = exporter.pdf_initial_dir / f"{doc_id}.pdf"
+                        
+                    gt_path = exporter.gt_dir / f"{doc_id}.json"
+                    src_path = exporter.html_dir / f"{doc_id}.html"
+                    bbox_path = exporter.bbox_pdf_word_dir / f"{doc_id}.json"
+                    
+                    # Upload PDF
+                    if doc_path.exists():
+                        supabase_client.upload_to_storage("doc_storage", doc_storage_path, doc_path.read_bytes(), "application/pdf")
+                    
+                    # Upload Ground Truth
+                    if gt_path.exists():
+                        supabase_client.upload_to_storage("doc_storage", gt_storage_path, gt_path.read_bytes(), "application/json")
+                        
+                    # Upload HTML Source
+                    if src_path.exists():
+                        supabase_client.upload_to_storage("doc_storage", src_storage_path, src_path.read_bytes(), "text/html")
+                        
+                    # Upload Bounding Boxes
+                    if bbox_path.exists():
+                        supabase_client.upload_to_storage("doc_storage", bbox_storage_path, bbox_path.read_bytes(), "application/json")
+                    
+                    # Upload visual element images if available (parity with sync)
+                    if doc_data.get("visual_elements") and doc_data.get("visual_element_images"):
+                        for ve_id, img_b64 in doc_data["visual_element_images"].items():
+                            ve_storage_path = f"{user_id}/{request_id}/generated/{idx}_ve_{ve_id}.png"
+                            try:
+                                img_bytes = base64.b64decode(img_b64)
+                                supabase_client.upload_to_storage("doc_storage", ve_storage_path, img_bytes, "image/png")
+                            except Exception as ve_err:
+                                print(f"  ⚠ Failed to upload visual element {ve_id}: {ve_err}")
+
+                    # Create record in database (parity with sync)
+                    retry_on_network_error(lambda: supabase_client.create_generated_document(
+                        request_id=request_id,
+                        file_url=supabase_client.get_public_url("doc_storage", doc_storage_path),
+                        file_type="application/pdf",
+                        page_count=1,
+                        model_version=settings.LLM_MODEL,
+                        doc_index=idx,
+                        doc_storage_path=doc_storage_path,
+                        gt_storage_path=gt_storage_path,
+                        html_storage_path=src_storage_path,
+                        bbox_storage_path=bbox_storage_path
+                    ))
+                        
+                    log_verbose(f"  ✓ Uploaded document {idx+1} assets and created DB record")
+                except Exception as upload_err:
+                    print(f"  ⚠ Failed to upload individual assets for document {idx+1}: {upload_err}")
+
+            # Create generated document record
+            retry_on_network_error(lambda: supabase_client.create_generated_document(
+                request_id=request_id,
+                file_url=google_drive_url,
+                file_type="application/zip",
+                page_count=len(metadata),  # Using document count as page_count
+                model_version=settings.LLM_MODEL,
+                zip_url=zip_url
+            ))
+            
+            # Update request status
+            status = "completed_gdrive_failed" if gdrive_failed else "completed"
+            retry_on_network_error(lambda: supabase_client.update_request_status(request_id, status))
+            
+            # Log analytics
+            retry_on_network_error(lambda: supabase_client.log_analytics_event(
+                user_id=user_id,
+                event_type="document_generation_completed",
+                entity_id=request_id
+            ))
+            
+            print(f"[Job {request_id}] ✅ Job completed successfully!")
+        
+        except Exception as e:
+            # Update status to failed with error message
+            error_message = f"{type(e).__name__}: {str(e)}"
+            print(f"[Job {request_id}] ❌ Job failed: {error_message}")
+            traceback.print_exc()
+            
+            retry_on_network_error(lambda: supabase_client.update_request_status(
+                request_id=request_id,
+                status="failed",
+                error_message=error_message
+            ))
+            
+            # Log analytics
+            retry_on_network_error(lambda: supabase_client.log_analytics_event(
+                user_id=user_id,
+                event_type="document_generation_failed",
+                entity_id=request_id
+            ))
+            
+            raise  # Re-raise so RQ marks job as failed
+        finally:
+            # Clean up assets directory if it exists
+            if 'assets_temp_dir' in locals() and assets_temp_dir and assets_temp_dir.exists():
+                try:
+                    shutil.rmtree(assets_temp_dir, ignore_errors=True)
+                    print(f"[Job {request_id}] ✓ Cleaned up assets directory {assets_temp_dir}")
+                except:
+                    pass
+
+
+def process_document_generation_job(request_id: str, request_data: Dict[str, Any]):
+    """
+    Synchronous wrapper for RQ - calls the async function with asyncio.run().
+    
+    This is the function that RQ worker calls. It runs the async version using asyncio.
+    """
+    print(f"{'='*60}")
+    print(f"🎯 Worker picked up job: {request_id}")
+    print(f"   User ID: {request_data.get('user_id', 'N/A')}")
+    print(f"   Num documents: {request_data.get('prompt_params', {}).get('num_solutions', 'N/A')}")
+    print(f"{'='*60}")
+    
+    return asyncio.run(process_document_generation_job_async(request_id, request_data))

data/docvqa_hw/handschrift_mit_qid.jsonl

@@ -0,0 +1,83 @@
+{"name": "fykp0227_9.pdf", "question_ids": [63039]}
+{"name": "fypn0000_2.pdf", "question_ids": [52698, 52700, 52703]}
+{"name": "hkdv0228_4.pdf", "question_ids": [61298]}
+{"name": "hmmg0227_13.pdf", "question_ids": [63575, 63578]}
+{"name": "hnnp0227_33.pdf", "question_ids": [23169]}
+{"name": "hnnp0227_35.pdf", "question_ids": [21316, 21317]}
+{"name": "hznv0228_1.pdf", "question_ids": [2325, 2327]}
+{"name": "jmmg0227_1.pdf", "question_ids": [63696]}
+{"name": "jqyg0227_1.pdf", "question_ids": [63487]}
+{"name": "jrgn0226_1.pdf", "question_ids": [44904]}
+{"name": "ljgg0227_2.pdf", "question_ids": [61199]}
+{"name": "lkdv0228_13.pdf", "question_ids": [61536, 61537, 61538, 61539]}
+{"name": "lkdv0228_28.pdf", "question_ids": [61527, 61528, 61529, 61530]}
+{"name": "lrgn0226_1.pdf", "question_ids": [43050]}
+{"name": "lyph0227_1.pdf", "question_ids": [5280]}
+{"name": "mmxd0227_1.pdf", "question_ids": [38123, 38163]}
+{"name": "mzyc0227_2.pdf", "question_ids": [63782]}
+{"name": "njpf0227_2.pdf", "question_ids": [61140, 61143, 61144, 61145]}
+{"name": "nmyg0227_1.pdf", "question_ids": [62372, 62373]}
+{"name": "npnm0020_1.pdf", "question_ids": [53668, 53669]}
+{"name": "pnbv0228_1.pdf", "question_ids": [50370]}
+{"name": "rkmd0217_2.pdf", "question_ids": [64390]}
+{"name": "shwg0227_1.pdf", "question_ids": [62010]}
+{"name": "tlgw0228_1.pdf", "question_ids": [50193]}
+{"name": "txpn0095_17.pdf", "question_ids": [52200, 52202, 52204]}
+{"name": "xnbl0037_7.pdf", "question_ids": [575]}
+{"name": "xthh0077_40.pdf", "question_ids": [55068, 55069, 55073, 55076, 55077]}
+{"name": "xthh0077_41.pdf", "question_ids": [54938, 54941, 54943, 54945, 54946, 54948]}
+{"name": "yjdv0228_13.pdf", "question_ids": [61895, 61902]}
+{"name": "yqgl0228_1.pdf", "question_ids": [209]}
+{"name": "zhjl0226_1.pdf", "question_ids": [44927]}
+{"name": "znmf0227_4.pdf", "question_ids": [62529, 62530, 62532]}
+{"name": "yhxd0227_2.pdf", "question_ids": [62644]}
+{"name": "ynbm0227_3.pdf", "question_ids": [56931]}
+{"name": "ffmm0020_1.pdf", "question_ids": [53921, 53924]}
+{"name": "fkmj0226_7.pdf", "question_ids": [52474, 52475, 52476]}
+{"name": "fnkp0227_31.pdf", "question_ids": [63098, 63100, 63102]}
+{"name": "gtmj0226_7.pdf", "question_ids": [5722, 5724]}
+{"name": "gxyd0217_2.pdf", "question_ids": [35331, 35332, 35333, 35335, 35339]}
+{"name": "hhhh0224_10.pdf", "question_ids": [9769, 9770, 9771, 9772]}
+{"name": "hnnp0227_28.pdf", "question_ids": [22936, 22941, 22945, 22995]}
+{"name": "hnnp0227_80.pdf", "question_ids": [23110, 23113, 23116, 23119]}
+{"name": "hqfh0224_17.pdf", "question_ids": [5902, 5904, 5907]}
+{"name": "htwc0228_1.pdf", "question_ids": [62864, 62865]}
+{"name": "jggn0226_39.pdf", "question_ids": [45089, 45094, 45095, 45097, 45098]}
+{"name": "kfkm0081_1.pdf", "question_ids": [56535, 56537, 56539, 56540]}
+{"name": "kggn0226_20.pdf", "question_ids": [46467, 46471, 46475, 46482]}
+{"name": "kggn0226_26.pdf", "question_ids": [43354, 43357, 43376]}
+{"name": "kjnd0004_1.pdf", "question_ids": [7042, 7044, 7045, 7048, 7050]}
+{"name": "kkkp0227_21.pdf", "question_ids": [56382, 56383, 56384, 56385]}
+{"name": "klfw0081_1.pdf", "question_ids": [56916, 56920]}
+{"name": "kyvw0217_1.pdf", "question_ids": [16955, 16956, 16958]}
+{"name": "lfgn0226_29.pdf", "question_ids": [43172, 43185]}
+{"name": "lmyc0227_2.pdf", "question_ids": [40740, 40743, 40745, 40749, 40751, 40755, 40758, 40762, 40764]}
+{"name": "lnnp0227_1.pdf", "question_ids": [59669, 59670, 59671]}
+{"name": "lnwg0227_36.pdf", "question_ids": [31500, 31501, 31502, 31503, 31504]}
+{"name": "lsww0228_14.pdf", "question_ids": [50277, 50281, 50285, 50288, 50291, 50407]}
+{"name": "lxkp0227_5.pdf", "question_ids": [57793, 57794]}
+{"name": "mmkp0227_5.pdf", "question_ids": [62980, 62982]}
+{"name": "nfpw0224_1.pdf", "question_ids": [5571, 5573]}
+{"name": "nhyk0226_1.pdf", "question_ids": [60062, 60064, 60065, 60066]}
+{"name": "nngv0228_2.pdf", "question_ids": [59573]}
+{"name": "pfpw0224_10.pdf", "question_ids": [4950, 4951]}
+{"name": "ppjb0228_7.pdf", "question_ids": [49295, 49301, 49306, 49307, 49312, 49316]}
+{"name": "qllg0023_3.pdf", "question_ids": [54893, 54898]}
+{"name": "rpwx0225_9.pdf", "question_ids": [4763, 4764, 4765, 4766]}
+{"name": "rydb0228_2.pdf", "question_ids": [59517, 59519, 59521, 59523, 59525]}
+{"name": "rzyw0224_1.pdf", "question_ids": [5682, 5685, 5688, 5691, 5697]}
+{"name": "sjkg0227_2.pdf", "question_ids": [61152, 61153, 61154, 61155]}
+{"name": "thwm0227_2.pdf", "question_ids": [59272]}
+{"name": "tpwx0225_9.pdf", "question_ids": [5572, 5574, 5577]}
+{"name": "xngv0228_4.pdf", "question_ids": [59870, 59871, 59872]}
+{"name": "xxhd0227_6.pdf", "question_ids": [62613, 62615]}
+{"name": "xygx0227_9.pdf", "question_ids": [21195, 21197, 21198, 21199]}
+{"name": "xynd0004_1.pdf", "question_ids": [6688, 6689, 6690, 6691]}
+{"name": "xyyv0228_1.pdf", "question_ids": [3036, 3037, 3038]}
+{"name": "yjkg0227_2.pdf", "question_ids": [61148, 61150, 61151]}
+{"name": "ylfh0078_1.pdf", "question_ids": [56262, 56263, 56264, 56265]}
+{"name": "ylml0226_1.pdf", "question_ids": [63790, 63792, 63793]}
+{"name": "ymkm0227_5.pdf", "question_ids": [59275, 59276, 59277, 59278]}
+{"name": "ymkp0227_10.pdf", "question_ids": [61513, 61514, 61515, 61516, 61517, 61518, 61520, 61521]}
+{"name": "zrww0228_4.pdf", "question_ids": [50908, 50909, 50910]}
+{"name": "ztcn0020_11.pdf", "question_ids": [8056, 8057]}

data/docvqa_hw/zahlen_mit_qid.jsonl

@@ -0,0 +1,20 @@
+{"name": "ffdh0224_1.pdf", "question_ids": [5844, 5851]}
+{"name": "fgbd0079_5.pdf", "question_ids": [18595, 18598, 18602, 18606, 18609]}
+{"name": "ghlw0228_3.pdf", "question_ids": [50847]}
+{"name": "glfh0224_9.pdf", "question_ids": [5920, 5922, 5925, 5927, 5931]}
+{"name": "hlmd0217_2.pdf", "question_ids": [38949]}
+{"name": "hnpp0000_3.pdf", "question_ids": [5527]}
+{"name": "hrcd0003_1.pdf", "question_ids": [6844]}
+{"name": "jlmd0217_2.pdf", "question_ids": [64321]}
+{"name": "jmmd0217_2.pdf", "question_ids": [37658]}
+{"name": "jxwg0023_2.pdf", "question_ids": [53898]}
+{"name": "kmmw0228_2.pdf", "question_ids": [56444]}
+{"name": "kspw0224_2.pdf", "question_ids": [5980, 5987]}
+{"name": "lsww0228_12.pdf", "question_ids": [52170, 52172, 52174]}
+{"name": "prhm0227_3.pdf", "question_ids": [47948]}
+{"name": "pzyy0078_7.pdf", "question_ids": [18897, 18899, 18901]}
+{"name": "xfbd0003_1.pdf", "question_ids": [51512]}
+{"name": "xrcy0227_48.pdf", "question_ids": [59635]}
+{"name": "zqlp0000_10.pdf", "question_ids": [6093, 6097]}
+{"name": "zqww0228_8.pdf", "question_ids": [50854, 50855, 50856]}
+{"name": "zzyw0224_12.pdf", "question_ids": [4909, 4910, 4911]}

data/models/handwriting/cached_vae/config.json

@@ -0,0 +1,38 @@
+{
+  "_class_name": "AutoencoderKL",
+  "_diffusers_version": "0.35.2",
+  "_name_or_path": "stabilityai/sd-vae-ft-mse",
+  "act_fn": "silu",
+  "block_out_channels": [
+    128,
+    256,
+    512,
+    512
+  ],
+  "down_block_types": [
+    "DownEncoderBlock2D",
+    "DownEncoderBlock2D",
+    "DownEncoderBlock2D",
+    "DownEncoderBlock2D"
+  ],
+  "force_upcast": true,
+  "in_channels": 3,
+  "latent_channels": 4,
+  "latents_mean": null,
+  "latents_std": null,
+  "layers_per_block": 2,
+  "mid_block_add_attention": true,
+  "norm_num_groups": 32,
+  "out_channels": 3,
+  "sample_size": 256,
+  "scaling_factor": 0.18215,
+  "shift_factor": null,
+  "up_block_types": [
+    "UpDecoderBlock2D",
+    "UpDecoderBlock2D",
+    "UpDecoderBlock2D",
+    "UpDecoderBlock2D"
+  ],
+  "use_post_quant_conv": true,
+  "use_quant_conv": true
+}

data/models/handwriting/char_vocab.json

@@ -0,0 +1,89 @@
+{
+  "char_to_idx": {
+    "<PAD>": 0,
+    "<UNK>": 1,
+    "<SOS>": 2,
+    "<EOS>": 3,
+    " ": 4,
+    "!": 5,
+    "\"": 6,
+    "#": 7,
+    "&": 8,
+    "'": 9,
+    "(": 10,
+    ")": 11,
+    "*": 12,
+    "+": 13,
+    ",": 14,
+    "-": 15,
+    ".": 16,
+    "/": 17,
+    "0": 18,
+    "1": 19,
+    "2": 20,
+    "3": 21,
+    "4": 22,
+    "5": 23,
+    "6": 24,
+    "7": 25,
+    "8": 26,
+    "9": 27,
+    ":": 28,
+    ";": 29,
+    "?": 30,
+    "A": 31,
+    "B": 32,
+    "C": 33,
+    "D": 34,
+    "E": 35,
+    "F": 36,
+    "G": 37,
+    "H": 38,
+    "I": 39,
+    "J": 40,
+    "K": 41,
+    "L": 42,
+    "M": 43,
+    "N": 44,
+    "O": 45,
+    "P": 46,
+    "Q": 47,
+    "R": 48,
+    "S": 49,
+    "T": 50,
+    "U": 51,
+    "V": 52,
+    "W": 53,
+    "X": 54,
+    "Y": 55,
+    "Z": 56,
+    "a": 57,
+    "b": 58,
+    "c": 59,
+    "d": 60,
+    "e": 61,
+    "f": 62,
+    "g": 63,
+    "h": 64,
+    "i": 65,
+    "j": 66,
+    "k": 67,
+    "l": 68,
+    "m": 69,
+    "n": 70,
+    "o": 71,
+    "p": 72,
+    "q": 73,
+    "r": 74,
+    "s": 75,
+    "t": 76,
+    "u": 77,
+    "v": 78,
+    "w": 79,
+    "x": 80,
+    "y": 81,
+    "z": 82
+  },
+  "max_length": 32,
+  "vocab_size": 83
+}

data/models/handwriting/config.yaml

@@ -0,0 +1,95 @@
+data:
+  batch_size: 64
+  num_workers: 8
+  train_lmdb_path: ./iam_lmdbclear
+  vocab_path: ./char_vocab.json
+model:
+  latent_shape:
+  - 4
+  - 16
+  - 64
+  scheduler:
+    beta_end: 0.012
+    beta_schedule: linear
+    beta_start: 0.00085
+    num_train_timesteps: 1000
+    prediction_type: epsilon
+  text_encoder:
+    d_ff: 1024
+    d_model: 512
+    dropout: 0.1
+    max_length: 32
+    num_heads: 8
+    num_layers: 4
+    output_dim: 512
+  unet:
+    act_fn: silu
+    attention_head_dim: 8
+    block_out_channels:
+    - 192
+    - 384
+    - 768
+    - 768
+    cross_attention_dim: 512
+    down_block_types:
+    - DownBlock2D
+    - CrossAttnDownBlock2D
+    - CrossAttnDownBlock2D
+    - DownBlock2D
+    in_channels: 4
+    layers_per_block: 2
+    mid_block_type: UNetMidBlock2DCrossAttn
+    norm_num_groups: 32
+    num_class_embeds: 657
+    out_channels: 4
+    sample_size:
+    - 16
+    - 64
+    up_block_types:
+    - UpBlock2D
+    - CrossAttnUpBlock2D
+    - CrossAttnUpBlock2D
+    - UpBlock2D
+  vae:
+    model_name: stabilityai/sd-vae-ft-mse
+training:
+  compile_model: false
+  ema_decay: 0.999
+  ema_inv_gamma: 1.0
+  ema_min_decay: 0.0
+  ema_power: 1.0
+  gradient_accumulation_steps: 1
+  log_every_n_steps: 10
+  lr_scheduler:
+    min_lr: 1.0e-07
+    type: cosine
+    warmup_steps: 2000
+  max_grad_norm: 1.0
+  mixed_precision: bf16
+  mode: latent
+  num_epochs: 300
+  num_inference_steps: 1000
+  optimizer:
+    beta1: 0.9
+    beta2: 0.999
+    eps: 1.0e-08
+    lr: 0.0001
+    type: adamw
+    weight_decay: 0.01
+  output_dir: ./experiments/hf_conditional_latent_batch64
+  resume_from_checkpoint: null
+  run_name: hf_conditional_latent_batch64
+  sample_every_n_steps: 18000
+  save_every_n_epochs: 10
+  seed: 42
+  use_channels_last: false
+  use_ema: true
+wandb:
+  api_key:
+  entity: null
+  notes: Hugging Face UNet with EMA and latent diffusion training.
+  project: handwriting-diffusion
+  tags:
+  - hf
+  - conditional
+  - latent

data/models/handwriting/writer_id_map.json

@@ -0,0 +1,659 @@
+{
+  "0": 0,
+  "1": 1,
+  "10": 2,
+  "100": 3,
+  "102": 4,
+  "103": 5,
+  "104": 6,
+  "105": 7,
+  "106": 8,
+  "107": 9,
+  "108": 10,
+  "109": 11,
+  "11": 12,
+  "110": 13,
+  "111": 14,
+  "112": 15,
+  "113": 16,
+  "114": 17,
+  "115": 18,
+  "116": 19,
+  "117": 20,
+  "118": 21,
+  "119": 22,
+  "12": 23,
+  "120": 24,
+  "121": 25,
+  "122": 26,
+  "123": 27,
+  "124": 28,
+  "125": 29,
+  "126": 30,
+  "127": 31,
+  "128": 32,
+  "129": 33,
+  "13": 34,
+  "130": 35,
+  "131": 36,
+  "132": 37,
+  "133": 38,
+  "134": 39,
+  "135": 40,
+  "136": 41,
+  "137": 42,
+  "138": 43,
+  "139": 44,
+  "14": 45,
+  "140": 46,
+  "141": 47,
+  "142": 48,
+  "143": 49,
+  "144": 50,
+  "145": 51,
+  "146": 52,
+  "147": 53,
+  "148": 54,
+  "149": 55,
+  "15": 56,
+  "150": 57,
+  "151": 58,
+  "152": 59,
+  "153": 60,
+  "154": 61,
+  "155": 62,
+  "156": 63,
+  "157": 64,
+  "158": 65,
+  "159": 66,
+  "16": 67,
+  "160": 68,
+  "161": 69,
+  "162": 70,
+  "163": 71,
+  "164": 72,
+  "165": 73,
+  "166": 74,
+  "167": 75,
+  "168": 76,
+  "169": 77,
+  "17": 78,
+  "170": 79,
+  "171": 80,
+  "172": 81,
+  "173": 82,
+  "174": 83,
+  "175": 84,
+  "176": 85,
+  "177": 86,
+  "178": 87,
+  "179": 88,
+  "18": 89,
+  "180": 90,
+  "181": 91,
+  "182": 92,
+  "183": 93,
+  "184": 94,
+  "185": 95,
+  "186": 96,
+  "187": 97,
+  "188": 98,
+  "189": 99,
+  "19": 100,
+  "190": 101,
+  "191": 102,
+  "192": 103,
+  "193": 104,
+  "194": 105,
+  "195": 106,
+  "196": 107,
+  "197": 108,
+  "198": 109,
+  "199": 110,
+  "2": 111,
+  "20": 112,
+  "200": 113,
+  "201": 114,
+  "202": 115,
+  "203": 116,
+  "204": 117,
+  "205": 118,
+  "206": 119,
+  "207": 120,
+  "208": 121,
+  "209": 122,
+  "21": 123,
+  "210": 124,
+  "211": 125,
+  "212": 126,
+  "213": 127,
+  "214": 128,
+  "215": 129,
+  "216": 130,
+  "217": 131,
+  "218": 132,
+  "219": 133,
+  "22": 134,
+  "220": 135,
+  "221": 136,
+  "222": 137,
+  "223": 138,
+  "224": 139,
+  "225": 140,
+  "226": 141,
+  "227": 142,
+  "228": 143,
+  "229": 144,
+  "23": 145,
+  "230": 146,
+  "231": 147,
+  "232": 148,
+  "233": 149,
+  "234": 150,
+  "235": 151,
+  "236": 152,
+  "237": 153,
+  "238": 154,
+  "239": 155,
+  "24": 156,
+  "240": 157,
+  "241": 158,
+  "242": 159,
+  "243": 160,
+  "244": 161,
+  "245": 162,
+  "246": 163,
+  "247": 164,
+  "248": 165,
+  "249": 166,
+  "25": 167,
+  "250": 168,
+  "251": 169,
+  "252": 170,
+  "253": 171,
+  "254": 172,
+  "255": 173,
+  "256": 174,
+  "257": 175,
+  "258": 176,
+  "259": 177,
+  "26": 178,
+  "260": 179,
+  "261": 180,
+  "262": 181,
+  "263": 182,
+  "264": 183,
+  "265": 184,
+  "266": 185,
+  "267": 186,
+  "268": 187,
+  "269": 188,
+  "27": 189,
+  "270": 190,
+  "272": 191,
+  "273": 192,
+  "274": 193,
+  "275": 194,
+  "276": 195,
+  "277": 196,
+  "278": 197,
+  "279": 198,
+  "28": 199,
+  "280": 200,
+  "281": 201,
+  "282": 202,
+  "283": 203,
+  "285": 204,
+  "286": 205,
+  "287": 206,
+  "288": 207,
+  "289": 208,
+  "29": 209,
+  "290": 210,
+  "291": 211,
+  "292": 212,
+  "293": 213,
+  "294": 214,
+  "295": 215,
+  "296": 216,
+  "297": 217,
+  "298": 218,
+  "299": 219,
+  "3": 220,
+  "30": 221,
+  "300": 222,
+  "301": 223,
+  "302": 224,
+  "303": 225,
+  "304": 226,
+  "305": 227,
+  "307": 228,
+  "308": 229,
+  "309": 230,
+  "31": 231,
+  "310": 232,
+  "312": 233,
+  "313": 234,
+  "314": 235,
+  "315": 236,
+  "316": 237,
+  "317": 238,
+  "318": 239,
+  "319": 240,
+  "32": 241,
+  "320": 242,
+  "321": 243,
+  "322": 244,
+  "323": 245,
+  "324": 246,
+  "325": 247,
+  "326": 248,
+  "327": 249,
+  "328": 250,
+  "329": 251,
+  "33": 252,
+  "330": 253,
+  "331": 254,
+  "332": 255,
+  "333": 256,
+  "334": 257,
+  "335": 258,
+  "336": 259,
+  "337": 260,
+  "338": 261,
+  "339": 262,
+  "34": 263,
+  "340": 264,
+  "341": 265,
+  "342": 266,
+  "343": 267,
+  "344": 268,
+  "345": 269,
+  "346": 270,
+  "347": 271,
+  "348": 272,
+  "349": 273,
+  "35": 274,
+  "350": 275,
+  "351": 276,
+  "352": 277,
+  "353": 278,
+  "354": 279,
+  "355": 280,
+  "356": 281,
+  "357": 282,
+  "359": 283,
+  "36": 284,
+  "360": 285,
+  "361": 286,
+  "362": 287,
+  "363": 288,
+  "364": 289,
+  "365": 290,
+  "366": 291,
+  "367": 292,
+  "368": 293,
+  "369": 294,
+  "37": 295,
+  "370": 296,
+  "371": 297,
+  "372": 298,
+  "373": 299,
+  "375": 300,
+  "376": 301,
+  "377": 302,
+  "378": 303,
+  "379": 304,
+  "38": 305,
+  "380": 306,
+  "382": 307,
+  "383": 308,
+  "384": 309,
+  "385": 310,
+  "386": 311,
+  "387": 312,
+  "388": 313,
+  "389": 314,
+  "39": 315,
+  "390": 316,
+  "391": 317,
+  "392": 318,
+  "393": 319,
+  "394": 320,
+  "395": 321,
+  "396": 322,
+  "397": 323,
+  "398": 324,
+  "399": 325,
+  "4": 326,
+  "40": 327,
+  "400": 328,
+  "401": 329,
+  "402": 330,
+  "403": 331,
+  "404": 332,
+  "405": 333,
+  "406": 334,
+  "407": 335,
+  "408": 336,
+  "409": 337,
+  "41": 338,
+  "410": 339,
+  "411": 340,
+  "412": 341,
+  "413": 342,
+  "414": 343,
+  "415": 344,
+  "416": 345,
+  "417": 346,
+  "418": 347,
+  "419": 348,
+  "42": 349,
+  "420": 350,
+  "421": 351,
+  "422": 352,
+  "423": 353,
+  "424": 354,
+  "425": 355,
+  "426": 356,
+  "427": 357,
+  "428": 358,
+  "429": 359,
+  "43": 360,
+  "430": 361,
+  "431": 362,
+  "432": 363,
+  "433": 364,
+  "434": 365,
+  "435": 366,
+  "436": 367,
+  "439": 368,
+  "44": 369,
+  "440": 370,
+  "441": 371,
+  "442": 372,
+  "443": 373,
+  "444": 374,
+  "445": 375,
+  "446": 376,
+  "447": 377,
+  "448": 378,
+  "449": 379,
+  "45": 380,
+  "450": 381,
+  "451": 382,
+  "452": 383,
+  "453": 384,
+  "454": 385,
+  "455": 386,
+  "456": 387,
+  "457": 388,
+  "458": 389,
+  "459": 390,
+  "46": 391,
+  "460": 392,
+  "461": 393,
+  "462": 394,
+  "463": 395,
+  "464": 396,
+  "465": 397,
+  "466": 398,
+  "467": 399,
+  "468": 400,
+  "469": 401,
+  "47": 402,
+  "470": 403,
+  "471": 404,
+  "472": 405,
+  "473": 406,
+  "474": 407,
+  "475": 408,
+  "476": 409,
+  "477": 410,
+  "478": 411,
+  "479": 412,
+  "48": 413,
+  "480": 414,
+  "481": 415,
+  "482": 416,
+  "483": 417,
+  "484": 418,
+  "485": 419,
+  "486": 420,
+  "487": 421,
+  "488": 422,
+  "489": 423,
+  "49": 424,
+  "490": 425,
+  "491": 426,
+  "492": 427,
+  "493": 428,
+  "494": 429,
+  "495": 430,
+  "496": 431,
+  "497": 432,
+  "498": 433,
+  "499": 434,
+  "5": 435,
+  "50": 436,
+  "500": 437,
+  "501": 438,
+  "502": 439,
+  "503": 440,
+  "504": 441,
+  "505": 442,
+  "506": 443,
+  "508": 444,
+  "509": 445,
+  "51": 446,
+  "510": 447,
+  "511": 448,
+  "512": 449,
+  "513": 450,
+  "514": 451,
+  "515": 452,
+  "516": 453,
+  "517": 454,
+  "518": 455,
+  "519": 456,
+  "52": 457,
+  "520": 458,
+  "521": 459,
+  "522": 460,
+  "523": 461,
+  "524": 462,
+  "525": 463,
+  "526": 464,
+  "527": 465,
+  "528": 466,
+  "529": 467,
+  "53": 468,
+  "530": 469,
+  "531": 470,
+  "532": 471,
+  "533": 472,
+  "534": 473,
+  "535": 474,
+  "536": 475,
+  "537": 476,
+  "538": 477,
+  "539": 478,
+  "54": 479,
+  "540": 480,
+  "541": 481,
+  "542": 482,
+  "543": 483,
+  "544": 484,
+  "545": 485,
+  "546": 486,
+  "547": 487,
+  "548": 488,
+  "549": 489,
+  "55": 490,
+  "550": 491,
+  "551": 492,
+  "552": 493,
+  "553": 494,
+  "554": 495,
+  "555": 496,
+  "556": 497,
+  "557": 498,
+  "558": 499,
+  "559": 500,
+  "56": 501,
+  "560": 502,
+  "561": 503,
+  "562": 504,
+  "563": 505,
+  "564": 506,
+  "565": 507,
+  "566": 508,
+  "567": 509,
+  "568": 510,
+  "569": 511,
+  "570": 512,
+  "571": 513,
+  "572": 514,
+  "573": 515,
+  "574": 516,
+  "575": 517,
+  "576": 518,
+  "577": 519,
+  "578": 520,
+  "579": 521,
+  "58": 522,
+  "580": 523,
+  "581": 524,
+  "582": 525,
+  "583": 526,
+  "584": 527,
+  "585": 528,
+  "586": 529,
+  "587": 530,
+  "588": 531,
+  "589": 532,
+  "59": 533,
+  "590": 534,
+  "591": 535,
+  "592": 536,
+  "593": 537,
+  "594": 538,
+  "595": 539,
+  "596": 540,
+  "597": 541,
+  "598": 542,
+  "599": 543,
+  "6": 544,
+  "60": 545,
+  "600": 546,
+  "601": 547,
+  "602": 548,
+  "603": 549,
+  "604": 550,
+  "605": 551,
+  "606": 552,
+  "607": 553,
+  "608": 554,
+  "609": 555,
+  "61": 556,
+  "610": 557,
+  "611": 558,
+  "612": 559,
+  "613": 560,
+  "614": 561,
+  "615": 562,
+  "616": 563,
+  "617": 564,
+  "618": 565,
+  "619": 566,
+  "62": 567,
+  "620": 568,
+  "621": 569,
+  "622": 570,
+  "623": 571,
+  "624": 572,
+  "625": 573,
+  "626": 574,
+  "627": 575,
+  "628": 576,
+  "629": 577,
+  "63": 578,
+  "630": 579,
+  "631": 580,
+  "632": 581,
+  "633": 582,
+  "634": 583,
+  "635": 584,
+  "636": 585,
+  "637": 586,
+  "638": 587,
+  "639": 588,
+  "64": 589,
+  "640": 590,
+  "641": 591,
+  "642": 592,
+  "643": 593,
+  "644": 594,
+  "645": 595,
+  "647": 596,
+  "648": 597,
+  "649": 598,
+  "65": 599,
+  "650": 600,
+  "651": 601,
+  "652": 602,
+  "653": 603,
+  "654": 604,
+  "655": 605,
+  "658": 606,
+  "659": 607,
+  "66": 608,
+  "660": 609,
+  "661": 610,
+  "662": 611,
+  "663": 612,
+  "664": 613,
+  "665": 614,
+  "666": 615,
+  "667": 616,
+  "668": 617,
+  "669": 618,
+  "67": 619,
+  "670": 620,
+  "671": 621,
+  "68": 622,
+  "69": 623,
+  "7": 624,
+  "70": 625,
+  "71": 626,
+  "72": 627,
+  "73": 628,
+  "74": 629,
+  "75": 630,
+  "76": 631,
+  "77": 632,
+  "78": 633,
+  "79": 634,
+  "8": 635,
+  "80": 636,
+  "81": 637,
+  "82": 638,
+  "83": 639,
+  "84": 640,
+  "85": 641,
+  "86": 642,
+  "87": 643,
+  "88": 644,
+  "89": 645,
+  "9": 646,
+  "90": 647,
+  "91": 648,
+  "92": 649,
+  "93": 650,
+  "94": 651,
+  "95": 652,
+  "96": 653,
+  "97": 654,
+  "98": 655,
+  "99": 656
+}

data/prompt_templates/Adaptation_GT/seed-based.txt

@@ -0,0 +1,40 @@
+You are an AI specialized in generating unique HTML
+documents based on multiple scanned images of realworld examples. You have been provided with distinct
+sample images, each from a different cultural or regional
+background. You have been provided seed images of
+{doc type}, each originating from different cultural or regional contexts. For example, some might feature:
+• Local languages or regional disclaimers
+• Different date formats (e.g., dd/mm/yyyy vs. mm/dd/yyyy)
+• Unique currency or numbering formats
+• Varying layout norms (positions of key fields, disclaimers, official stamps, etc.)
+Now, please generate {num solutions} unique HTML
+documents that:
+1. Strictly reflect the overall style, layout, and cultural
+cues found in these samples, but do NOT copy any text,
+disclaimers, or layout verbatim from the samples.
+2. Include any essential mandatory fields: {sections}.
+3. Maintain an A4 size format for printing (using @page
+{{ size: A4; }} or similar CSS).
+4. Maintain a {background requirements}.
+5. Avoid copy-pasting or reusing large chunks of HTML,
+CSS, or disclaimers—each document must be at least
+70% different in code and text than the others.
+6. Strictly wrap each new document in
+<HTML>...</HTML> tags, for example:
+1. <HTML>...Solution #1...</HTML>
+2. <HTML>...Solution #2...</HTML>
+...
+{num solutions}. <HTML>...Solution
+#{num solutions}...</HTML>
+Additional Requirements: {user descriptions}
+Include the {gt type} as JSON in the document via <script type="application/json" id="GT">...</script> in the following format: {gt example}
+Notes:
+• Pay close attention to cultural/regional differences seen
+in the seed images (e.g., language, format, disclaimers).
+• Feel free to creatively adapt or combine stylistic cues
+from the seeds, as long as the end result looks authentic
+for that cultural context.
+• Do NOT directly copy-paste text or entire code blocks
+from any single seed image or across these new solutions.
+Now please generate the {num solutions} distinct
+{doc type} documents.

data/prompt_templates/Adaptation_GT/seed-free.txt

@@ -0,0 +1,25 @@
+You are an AI specialized in generating multiple unique
+HTML documents in one response. Please create
+{num solutions} unique HTML documents representing
+{doc type}.
+Each solution must:
+1. Include all mandatory fields: {sections}.
+2. Be formatted so it could print on A4 (e.g., use @page
+{{ size: A4; }} in your CSS).
+3. Show a significantly different layout, styling, and textual content from every other solution.
+4. Maintain a {background requirements}.
+5. Avoid copy-pasting or reusing large chunks of HTML,
+CSS, or disclaimers—each document must be at least
+70% different in code and text than the others.
+6. Wrap each complete document between <HTML>
+and </HTML> tags, labeled as:
+1. <HTML>...Solution #1...</HTML>
+2. <HTML>...Solution #2...</HTML>
+...
+{num solutions}. <HTML>...Solution
+#{num solutions}...</HTML>
+Include the {gt type} as JSON in the document via <script type="application/json" id="GT">...</script> in the following format: {gt example}
+Do not provide additional commentary or references to the
+other solutions within each HTML.
+Now generate the {num solutions} distinct {doc type}
+documents.

data/prompt_templates/ClaudeRefined1/seed-based.txt

@@ -0,0 +1,78 @@
+# HTML Document Generation Prompt (Refined)
+
+You are an AI specialized in creating culturally authentic HTML documents based on visual analysis of real-world examples. You have been provided with {num_seed_images} seed images of **{doc_type}** documents from different cultural and regional contexts.
+
+## Cultural Variations (If Present)
+The seed images may demonstrate regional differences such as:
+- Language variations and local terminology
+- Date formatting conventions (DD/MM/YYYY, MM/DD/YYYY, etc.)
+- Currency symbols and number formatting
+- Layout preferences (field positioning, official elements, cultural design patterns)
+- Regional legal disclaimers and regulatory requirements
+- Typography and visual hierarchy standards
+
+## Task Requirements
+Generate **{num_solutions}** unique HTML documents that meet these specifications:
+
+### Core Requirements
+1. **Cultural Authenticity**: If cultural/regional variations are present in the seed images, reflect those stylistic elements without directly copying any text, disclaimers, or layouts verbatim
+2. **Required Content**: Include all essential fields: {required_sections}
+3. **Single Page Format**: Design as single-page documents with dimensions appropriate to the document type (receipts: narrow format, forms: standard width, etc.)
+4. **Language**: Generate all content in {language}
+5. **Background**: {background_requirements}
+6. **Uniqueness**: Each document must be at least 70% different in code structure, styling, and content from others
+
+## Ground Truth Generation
+Generate appropriate ground truth data for each document: {gt_type}.
+Include the ground truth as JSON inside each document in a `<script type="application/json" id="GT">...</script>` tag.
+The ground truth must follow the format: {gt_format}
+
+### Technical Specifications
+- Wrap each solution in `<HTML>...</HTML>` tags numbered sequentially
+- Include the ground truth JSON in `<script type="application/json" id="GT">...</script>` as specified above
+- Implement static CSS appropriate for the document type and single-page layout (no animations, transitions, or dynamic effects)
+
+## Additional Requirements
+{user_descriptions}
+
+### Content Guidelines
+- **DO**: Adapt any cultural/regional stylistic elements present in the seed images
+- **DO**: Create authentic-feeling content appropriate to each cultural context
+- **DO**: Vary layout structures, color schemes, and typographic choices
+- **DO**: Use static styling only (no animations, hover effects, or transitions)
+- **DON'T**: Copy-paste text, code blocks, or entire sections between solutions
+- **DON'T**: Reuse identical disclaimers, headers, or formatting patterns
+- **DON'T**: Include any dynamic effects, animations, or interactive elements
+
+## Additional Requirements
+{user_descriptions}
+
+## Output Format
+Structure your response as:
+
+```
+1. <HTML>
+   <!-- Solution #1 with cultural context A -->
+   ...complete HTML document...
+</HTML>
+
+2. <HTML>
+   <!-- Solution #2 with cultural context B -->
+   ...complete HTML document...
+</HTML>
+
+...continue for all {num_solutions} solutions
+```
+
+## Quality Checklist
+Before generating, ensure each document:
+- [ ] Reflects any authentic cultural/regional characteristics present in seed images
+- [ ] Contains all required sections: {required_sections}
+- [ ] Uses static styling only (no animations or dynamic effects)
+- [ ] Uses appropriate single-page formatting for the document type
+- [ ] All content is in English
+- [ ] Includes the specified ground truth in proper JSON format
+- [ ] Maintains 70%+ uniqueness from other solutions
+- [ ] Follows semantic HTML best practices
+
+Now generate the **{num_solutions}** distinct **{doc_type}** documents.

data/prompt_templates/ClaudeRefined10/seed-based.txt

@@ -0,0 +1,57 @@
+You are an AI creating authentic HTML representations of documents based on seed images.
+Analyze the seed images for structural and semantic content and generate authentic variations.
+The generated documents will be printed.
+
+## Requirements
+1. **Authenticity**: Reflect stylistic elements from seed images without copying text/layouts verbatim
+2. **Format**: Single-page documents with dimensions appropriate to the document type
+3. **Language**: {language}
+4. **Static Only**: No animations, transitions, or dynamic effects
+
+## Technical
+- Wrap each document in `<HTML>...</HTML>` tags, numbered sequentially
+- Static CSS only for single-page layout
+- Generate only minified CSS, HTML, JS.
+
+## Content Guidelines
+**DO**: Adapt cultural elements, vary layouts/colors/typography, use static styling
+**DON'T**: Copy text/code blocks, reuse identical sections, include dynamic effects
+
+## Handwritten Fields (if document type requires)
+- Mark with class 'handwritten'
+- Apply generously increased size to 'handwritten', in line with realistic handwriting
+- Assign author ID via class ('author1', 'author2', etc.) to distinguish different people
+- Never include signatures as handwriting
+
+## Visual Placeholders (if document type requires)
+- Insert `<div data-placeholder="type" style="...">` for non-text elements at appropiate positions
+- Valid types are: signature, stamp, logo, barcode, photo, chart
+- Add data-content attribute with actual content description
+- For signatures, add author class ('author1', 'author2', etc.) to distinguish different people and ensure the author is semantically coherent with the document content
+- For stamps, use `position:absolute;z-index:10;` and specify 'top' and 'right'
+- Dimensions in mm/cm, e.g. `width:30mm;height:20mm;`
+- Example: `<div data-placeholder="signature" data-content="john" class="author1" style="width:50mm;height:15mm;"></div>`
+- Example: `<div data-placeholder="stamp" data-content="APPROVED 2024-03-15" style="position:absolute;top:50mm;right:20mm;width:35mm;height:35mm;z-index:10;"></div>`
+- Example: `<div data-placeholder="logo" data-content="ACME Corp Logo" style="width:150mm;height:100mm;"></div>`
+
+## Output Format
+Generate minified HTML like this:
+```
+1. <HTML><!DOCTYPE html><html ... document 1 ... </html></HTML>
+2. <HTML><!DOCTYPE html><html ... document 2 ... </html></HTML>
+...
+```
+## Ground Truth
+Generate ground truth as JSON in `<script type="application/json" id="GT">...</script>` tag.
+Ground truth specification: {gt_type}
+Ground truth must follow the format: {gt_format}
+
+## Quality Checklist
+- [ ] Authentic variations without verbatim copying from seed images
+- [ ] Static styling only (no animations or dynamic effects)
+- [ ] Single-page format with minified HTML/CSS/JS
+- [ ] Content in {language}
+- [ ] GT JSON present and correctly formatted
+- [ ] Visual elements are semantically coherent
+
+Generate {num_solutions} distinct {doc_type} documents based on {num_seed_images} seed images.

data/prompt_templates/ClaudeRefined11/seed-based.txt

@@ -0,0 +1,55 @@
+You are an AI creating authentic HTML representations of documents based on seed images.
+Analyze the seed images for structural and semantic content and generate authentic variations.
+The generated documents will be printed.
+
+## Requirements
+1. **Authenticity**: Reflect stylistic elements from seed images without copying text/layouts verbatim
+2. **Format**: Single-page documents with dimensions appropriate to the document type
+3. **Language**: {language}
+4. **Static Only**: No animations, transitions, or dynamic effects
+
+## Technical
+- Wrap each document in `<HTML>...</HTML>` tags, numbered sequentially
+- Static CSS only for single-page layout
+- Generate only minified CSS, HTML, JS.
+
+## Content Guidelines
+**DO**: Adapt cultural elements, vary layouts/colors/typography, use static styling
+**DON'T**: Copy text/code blocks, reuse identical sections, include dynamic effects
+
+## Handwritten Fields (if document type requires)
+- Mark with class 'handwritten' and use regular text
+- Apply no special styles to 'handwritten', except generously increased size, in line with realistic handwriting
+- Assign author ID via class ('author1', 'author2', etc.) to distinguish different people
+- If the handwriting represents a signature mark it additionally with class 'signature'
+
+## Visual Placeholders (if document type requires)
+- Insert `<div data-placeholder="type" style="...">` for non-text elements at appropriate positions
+- Valid types are: stamp, logo, barcode, photo, chart
+- Add data-content attribute with actual content description
+- For stamps, use `position:absolute;z-index:10;` and specify 'top' and 'right'
+- Always provide dimensions in mm/cm, e.g. `width:30mm;height:20mm;`
+- Example: `<div data-placeholder="stamp" data-content="APPROVED 2024-03-15" style="position:absolute;top:50mm;right:20mm;width:35mm;height:35mm;z-index:10;"></div>`
+- Example: `<div data-placeholder="logo" data-content="ACME Corp Logo" style="width:150mm;height:100mm;"></div>`
+
+## Output Format
+Generate minified HTML like this:
+```
+1. <HTML><!DOCTYPE html><html ... document 1 ... </html></HTML>
+2. <HTML><!DOCTYPE html><html ... document 2 ... </html></HTML>
+...
+```
+## Ground Truth
+Generate ground truth as JSON in `<script type="application/json" id="GT">...</script>` tag.
+Ground truth specification: {gt_type}
+Ground truth must follow the format: {gt_format}
+
+## Quality Checklist
+- [ ] Authentic variations without verbatim copying from seed images
+- [ ] Static styling only (no animations or dynamic effects)
+- [ ] Single-page format with minified HTML/CSS/JS
+- [ ] Content in {language}
+- [ ] GT JSON present and correctly formatted
+- [ ] Visual elements are semantically coherent
+
+Generate {num_solutions} distinct {doc_type} documents based on {num_seed_images} seed images.

data/prompt_templates/ClaudeRefined12/seed-based-annotation.txt

@@ -0,0 +1,55 @@
+You are an AI creating authentic HTML representations of documents based on seed images.
+Analyze the seed images for structural and semantic content and generate authentic variations.
+The generated documents will be printed.
+
+## Requirements
+1. **Authenticity**: Reflect stylistic elements from seed images without copying text/layouts verbatim
+2. **Format**: Single-page documents with dimensions appropriate to the document type
+3. **Language**: {language}
+4. **Static Only**: No animations, transitions, or dynamic effects
+
+## Technical
+- Wrap each document in `<HTML>...</HTML>` tags, numbered sequentially
+- Static CSS only for single-page layout
+- Generate only minified CSS, HTML, JS.
+
+## Content Guidelines
+**DO**: Adapt cultural elements, vary layouts/colors/typography, use static styling
+**DON'T**: Copy text/code blocks, reuse identical sections, include dynamic effects
+
+## Handwritten Fields (if document type requires)
+- Mark with class 'handwritten' and use regular text
+- Apply no special styles to 'handwritten', except generously increased size, in line with realistic handwriting
+- Assign author ID via class ('author1', 'author2', etc.) to distinguish different people
+- If the handwriting represents a signature mark it additionally with class 'signature'
+
+## Visual Placeholders (if document type requires)
+- Insert `<div data-placeholder="type" style="...">` for non-text elements at appropriate positions
+- Valid types are: stamp, logo, figure, barcode, photo
+- Add data-content attribute with actual content description
+- For stamps, use `position:absolute;z-index:10;` and specify 'top' and 'right'
+- Always provide appropiate dimensions
+- Example: `<div data-placeholder="stamp" data-content="APPROVED 2024-03-15" style="position:absolute;top:50mm;right:20mm;width:35mm;height:35mm;z-index:10;"></div>`
+- Example: `<div data-placeholder="logo" data-content="ACME Corp Logo" style="width:150mm;height:100mm;"></div>`
+
+## Output Format
+Generate minified HTML like this:
+```
+1. <HTML><!DOCTYPE html><html ... document 1 ... </html></HTML>
+2. <HTML><!DOCTYPE html><html ... document 2 ... </html></HTML>
+...
+```
+## Ground Truth
+Generate ground truth by assigning each applicable element in HTML a class from the list below to uniquely identify its label:
+{gt_type}
+{gt_format}
+
+## Quality Checklist
+- [ ] Authentic variations without verbatim copying from seed images
+- [ ] Static styling only (no animations or dynamic effects)
+- [ ] Single-page format with minified HTML/CSS
+- [ ] Content in {language}
+- [ ] GT labels via class annotations are present and assigned to correct elements
+- [ ] Visual elements are semantically coherent
+
+Generate {num_solutions} distinct {doc_type} documents based on {num_seed_images} seed images.

data/prompt_templates/ClaudeRefined12/seed-based-json.txt

@@ -0,0 +1,55 @@
+You are an AI creating authentic HTML representations of documents based on seed images.
+Analyze the seed images for structural and semantic content and generate authentic variations.
+The generated documents will be printed.
+
+## Requirements
+1. **Authenticity**: Reflect stylistic elements from seed images without copying text/layouts verbatim
+2. **Format**: Single-page documents with dimensions appropriate to the document type
+3. **Language**: {language}
+4. **Static Only**: No animations, transitions, or dynamic effects
+
+## Technical
+- Wrap each document in `<HTML>...</HTML>` tags, numbered sequentially
+- Static CSS only for single-page layout
+- Generate only minified CSS, HTML, JS.
+
+## Content Guidelines
+**DO**: Adapt cultural elements, vary layouts/colors/typography, use static styling
+**DON'T**: Copy text/code blocks, reuse identical sections, include dynamic effects
+
+## Handwritten Fields (if document type requires)
+- Mark with class 'handwritten' and use regular text
+- Apply no special styles to 'handwritten', except generously increased size, in line with realistic handwriting
+- Assign author ID via class ('author1', 'author2', etc.) to distinguish different people
+- If the handwriting represents a signature mark it additionally with class 'signature'
+
+## Visual Placeholders (if document type requires)
+- Insert `<div data-placeholder="type" style="...">` for non-text elements at appropriate positions
+- Valid types are: stamp, logo, figure, barcode, photo
+- Add data-content attribute with actual content description
+- For stamps, use `position:absolute;z-index:10;` and specify 'top' and 'right'
+- Always provide appropiate dimensions
+- Example: `<div data-placeholder="stamp" data-content="APPROVED 2024-03-15" style="position:absolute;top:50mm;right:20mm;width:35mm;height:35mm;z-index:10;"></div>`
+- Example: `<div data-placeholder="logo" data-content="ACME Corp Logo" style="width:150mm;height:100mm;"></div>`
+
+## Output Format
+Generate minified HTML like this:
+```
+1. <HTML><!DOCTYPE html><html ... document 1 ... </html></HTML>
+2. <HTML><!DOCTYPE html><html ... document 2 ... </html></HTML>
+...
+```
+## Ground Truth
+Generate ground truth as JSON in `<script type="application/json" id="GT">...</script>` tag.
+Ground truth specification: {gt_type}
+Ground truth must follow the format: {gt_format}
+
+## Quality Checklist
+- [ ] Authentic variations without verbatim copying from seed images
+- [ ] Static styling only (no animations or dynamic effects)
+- [ ] Single-page format with minified HTML/CSS
+- [ ] Content in {language}
+- [ ] GT JSON present, correctly formatted and semantically coherent
+- [ ] Visual elements are semantically coherent
+
+Generate {num_solutions} distinct {doc_type} documents based on {num_seed_images} seed images.