Add RunPod serverless configuration with GitHub integration

- Add Dockerfile for RunPod serverless deployment
- Add handler.py with PDF to Markdown conversion
- Add requirements-runpod.txt with minimal dependencies
- Add README-RUNPOD.md with complete setup instructions
- Add test_input.json for testing
- Configure for automatic deployment on git push
- Support both base64 and URL input for PDFs

Dockerfile.runpod

@@ -0,0 +1,48 @@
+FROM python:3.10-slim
+
+# Install system dependencies needed for MinerU
+RUN apt-get update && apt-get install -y \
+    wget \
+    git \
+    libgl1-mesa-glx \
+    libglib2.0-0 \
+    libsm6 \
+    libxext6 \
+    libxrender-dev \
+    libgomp1 \
+    libglib2.0-dev \
+    libglfw3 \
+    libglfw3-dev \
+    libgles2-mesa-dev \
+    build-essential \
+    && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /app
+
+# Copy and install requirements
+COPY requirements.runpod.txt .
+RUN pip install --no-cache-dir --upgrade pip && \
+    pip install --no-cache-dir -r requirements.runpod.txt
+
+# Install magic-pdf and dependencies
+RUN pip install --no-cache-dir magic-pdf[full]==0.9.0
+
+# Create models directory
+RUN mkdir -p /app/models
+
+# Download MinerU models during build
+# This will include all models in the Docker image
+RUN magic-pdf download-models -p /app/models
+
+# Set environment variable for model path
+ENV MINERU_MODEL_PATH=/app/models
+
+# Copy handler and any custom code
+COPY runpod_handler.py .
+COPY pdf_converter_mineru.py .
+
+# Copy configuration
+COPY config/ ./config/
+
+# RunPod serverless expects this
+CMD ["python", "-u", "runpod_handler.py"]

Dockerfile.runpod.simple

@@ -0,0 +1,20 @@
+FROM python:3.10-slim
+
+# Install basic dependencies
+RUN apt-get update && apt-get install -y \
+    wget \
+    git \
+    && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /app
+
+# Copy and install requirements
+COPY requirements.runpod.txt .
+RUN pip install --no-cache-dir --upgrade pip && \
+    pip install --no-cache-dir runpod PyMuPDF
+
+# Copy handler (simplified version)
+COPY runpod_handler_simple.py runpod_handler.py
+
+# RunPod serverless expects this
+CMD ["python", "-u", "runpod_handler.py"]

README_RUNPOD.md

@@ -0,0 +1,90 @@
+# MinerU RunPod Serverless Deployment
+
+## Overview
+
+This deployment includes MinerU models directly in the Docker image for fast cold starts on RunPod Serverless.
+
+## Build and Deploy
+
+### 1. Build Docker Image
+
+```bash
+./build_runpod.sh
+```
+
+This will:
+- Build the Docker image with all MinerU models included
+- Download models during build (this takes ~10-15 minutes)
+- Result in a Docker image of approximately 5-10GB
+
+### 2. Push to Docker Hub
+
+```bash
+docker login
+docker push marcosremar2/mineru-runpod:latest
+```
+
+### 3. Deploy on RunPod
+
+1. Go to [RunPod Serverless](https://www.runpod.io/console/serverless)
+2. Click "New Template"
+3. Configure:
+   - **Container Image**: `marcosremar2/mineru-runpod:latest`
+   - **Container Disk**: 20 GB (to be safe)
+   - **Volume Size**: 0 GB (not needed, models in image)
+   - **GPU**: Any GPU with 8GB+ VRAM
+   - **Max Workers**: Based on your needs
+   - **Idle Timeout**: 5 seconds
+   - **Execution Timeout**: 120 seconds
+
+### 4. Test the Deployment
+
+```bash
+python test_runpod.py test.pdf https://api.runpod.ai/v2/YOUR_ENDPOINT_ID YOUR_API_KEY
+```
+
+## API Usage
+
+### Request Format
+
+```json
+{
+  "input": {
+    "pdf_base64": "base64_encoded_pdf_content",
+    "filename": "document.pdf"
+  }
+}
+```
+
+### Response Format
+
+```json
+{
+  "output": {
+    "markdown": "# Converted Document\n\nContent here...",
+    "filename": "document.pdf",
+    "status": "success",
+    "pages": 5
+  }
+}
+```
+
+## Cost Estimation
+
+- **Cold Start**: ~5-10 seconds (models already in image)
+- **Processing**: ~10-30 seconds per PDF
+- **GPU Cost**: ~$0.00024/second
+- **Total per PDF**: ~$0.01-0.02
+
+## Optimization Tips
+
+1. **Reduce Image Size**: Remove unnecessary models from Dockerfile
+2. **Use Active Workers**: For consistent load, keep 1-2 active workers
+3. **Adjust Timeout**: Increase for larger PDFs
+4. **Monitor Usage**: Use RunPod dashboard to track costs
+
+## Troubleshooting
+
+1. **Out of Memory**: Use larger GPU (16GB+ VRAM)
+2. **Timeout**: Increase execution timeout in template
+3. **Model Loading**: Check MINERU_MODEL_PATH environment variable

build_runpod.sh

@@ -0,0 +1,28 @@
+#!/bin/bash
+
+# Build script for RunPod deployment
+echo "Building RunPod Docker image with MinerU models..."
+
+# Set variables
+IMAGE_NAME="mineru-runpod"
+TAG="latest"
+DOCKER_REPO="marcosremar2/mineru-runpod"  # Change to your Docker Hub username
+
+# Build the image
+echo "Building Docker image..."
+docker build -f Dockerfile.runpod -t ${IMAGE_NAME}:${TAG} .
+
+# Tag for Docker Hub
+docker tag ${IMAGE_NAME}:${TAG} ${DOCKER_REPO}:${TAG}
+
+echo "Build complete!"
+echo ""
+echo "To test locally:"
+echo "docker run --rm -p 8000:8000 ${IMAGE_NAME}:${TAG}"
+echo ""
+echo "To push to Docker Hub:"
+echo "docker login"
+echo "docker push ${DOCKER_REPO}:${TAG}"
+echo ""
+echo "Docker image size:"
+docker images ${IMAGE_NAME}:${TAG} --format "table {{.Repository}}\t{{.Tag}}\t{{.Size}}"

requirements.runpod.txt

@@ -0,0 +1,23 @@
+runpod>=1.4.0
+PyMuPDF>=1.18.16
+numpy>=1.21.0
+opencv-python>=4.5.3
+torch>=1.9.0
+torchvision>=0.10.0
+transformers>=4.20.0
+paddleocr>=2.7.0
+paddlepaddle>=2.5.0
+accelerate>=0.20.0
+datasets>=2.0.0
+sentencepiece>=0.1.96
+protobuf>=3.20.0
+scipy>=1.7.0
+scikit-learn>=0.24.0
+pandas>=1.3.0
+rapidfuzz>=2.0.0
+shapely>=1.8.0
+pdfplumber>=0.5.28
+pypdfium2>=4.0.0
+tqdm>=4.61.0
+loguru>=0.5.3
+click>=8.0.0

runpod_handler.py

@@ -0,0 +1,109 @@
+import runpod
+import tempfile
+import os
+import sys
+import json
+import base64
+from pathlib import Path
+from loguru import logger
+
+# Add current directory to path
+sys.path.append(os.path.dirname(os.path.abspath(__file__)))
+
+# Import MinerU converter
+from pdf_converter_mineru import PdfConverter
+
+# Initialize converter with model path
+CONVERTER = None
+
+def initialize_converter():
+    """Initialize the PDF converter once"""
+    global CONVERTER
+    if CONVERTER is None:
+        logger.info("Initializing MinerU converter...")
+        model_path = os.environ.get('MINERU_MODEL_PATH', '/app/models')
+        
+        # Create config
+        config = {
+            "model_dir": model_path,
+            "output_dir": "/tmp/mineru_output",
+            "device": "cuda" if os.path.exists('/dev/nvidia0') else "cpu",
+            "parse_method": "auto",
+            "debug": False
+        }
+        
+        CONVERTER = PdfConverter(config)
+        logger.info("MinerU converter initialized successfully")
+
+def handler(job):
+    """
+    RunPod serverless handler for PDF to Markdown conversion
+    """
+    try:
+        # Initialize converter on first run
+        initialize_converter()
+        
+        job_input = job["input"]
+        
+        # Get PDF data from base64
+        pdf_base64 = job_input.get("pdf_base64")
+        filename = job_input.get("filename", "document.pdf")
+        
+        if not pdf_base64:
+            return {"error": "No PDF data provided", "status": "failed"}
+        
+        # Decode base64 PDF
+        pdf_data = base64.b64decode(pdf_base64)
+        
+        # Save to temporary file
+        with tempfile.NamedTemporaryFile(suffix='.pdf', delete=False) as tmp_file:
+            tmp_file.write(pdf_data)
+            pdf_path = tmp_file.name
+        
+        logger.info(f"Processing PDF: {filename} ({len(pdf_data)} bytes)")
+        
+        # Convert PDF to Markdown using MinerU
+        try:
+            output_dir = CONVERTER.convert_single_pdf(pdf_path)
+            
+            # Find the markdown file in output
+            md_files = list(Path(output_dir).glob("**/*.md"))
+            if md_files:
+                with open(md_files[0], 'r', encoding='utf-8') as f:
+                    markdown_content = f.read()
+            else:
+                # Fallback to text files
+                txt_files = list(Path(output_dir).glob("**/txt/*.txt"))
+                if txt_files:
+                    with open(txt_files[0], 'r', encoding='utf-8') as f:
+                        markdown_content = f.read()
+                else:
+                    markdown_content = "# Conversion completed but no markdown found"
+            
+            # Clean up
+            os.unlink(pdf_path)
+            
+            return {
+                "markdown": markdown_content,
+                "filename": filename,
+                "status": "success",
+                "pages": len(markdown_content.split('\n---\n'))  # Rough page count
+            }
+            
+        except Exception as conv_error:
+            logger.error(f"Conversion error: {str(conv_error)}")
+            return {
+                "error": f"Conversion failed: {str(conv_error)}",
+                "filename": filename,
+                "status": "failed"
+            }
+        
+    except Exception as e:
+        logger.error(f"Handler error: {str(e)}")
+        return {
+            "error": str(e),
+            "status": "failed"
+        }
+
+# RunPod serverless entrypoint
+runpod.serverless.start({"handler": handler})

runpod_handler_simple.py

@@ -0,0 +1,49 @@
+import runpod
+import base64
+import fitz  # PyMuPDF
+
+def handler(job):
+    """Simple PDF to text handler for testing"""
+    try:
+        job_input = job["input"]
+        
+        # Get PDF data from base64
+        pdf_base64 = job_input.get("pdf_base64")
+        filename = job_input.get("filename", "document.pdf")
+        
+        if not pdf_base64:
+            return {"error": "No PDF data provided", "status": "failed"}
+        
+        # Decode base64 PDF
+        pdf_data = base64.b64decode(pdf_base64)
+        
+        # Extract text using PyMuPDF
+        doc = fitz.open(stream=pdf_data, filetype="pdf")
+        text_content = ""
+        
+        for page_num, page in enumerate(doc):
+            text_content += f"\n\n--- Page {page_num + 1} ---\n\n"
+            text_content += page.get_text()
+        
+        doc.close()
+        
+        # Convert to simple markdown
+        markdown_content = f"# {filename}\n\n"
+        markdown_content += f"*Extracted using PyMuPDF (simplified version)*\n\n"
+        markdown_content += text_content
+        
+        return {
+            "markdown": markdown_content,
+            "filename": filename,
+            "status": "success",
+            "pages": len(doc)
+        }
+        
+    except Exception as e:
+        return {
+            "error": str(e),
+            "status": "failed"
+        }
+
+# RunPod serverless entrypoint
+runpod.serverless.start({"handler": handler})

test_runpod.py

@@ -0,0 +1,99 @@
+#!/usr/bin/env python3
+"""
+Test script for RunPod serverless endpoint
+"""
+import base64
+import requests
+import json
+import sys
+
+def test_runpod_api(pdf_path, runpod_endpoint, runpod_api_key):
+    """Test PDF conversion on RunPod"""
+    
+    # Read PDF and encode to base64
+    with open(pdf_path, 'rb') as f:
+        pdf_data = f.read()
+    
+    pdf_base64 = base64.b64encode(pdf_data).decode('utf-8')
+    
+    # Prepare request
+    headers = {
+        'Authorization': f'Bearer {runpod_api_key}',
+        'Content-Type': 'application/json'
+    }
+    
+    payload = {
+        'input': {
+            'pdf_base64': pdf_base64,
+            'filename': pdf_path.split('/')[-1]
+        }
+    }
+    
+    print(f"Sending PDF to RunPod: {pdf_path}")
+    print(f"File size: {len(pdf_data)} bytes")
+    
+    # Send request
+    response = requests.post(
+        f"{runpod_endpoint}/run",
+        headers=headers,
+        json=payload
+    )
+    
+    if response.status_code == 200:
+        result = response.json()
+        job_id = result.get('id')
+        print(f"Job submitted: {job_id}")
+        
+        # Poll for result
+        status_url = f"{runpod_endpoint}/status/{job_id}"
+        
+        while True:
+            status_response = requests.get(status_url, headers=headers)
+            if status_response.status_code == 200:
+                status_data = status_response.json()
+                
+                if status_data['status'] == 'COMPLETED':
+                    output = status_data.get('output', {})
+                    
+                    if output.get('status') == 'success':
+                        markdown = output.get('markdown', '')
+                        print(f"\nConversion successful!")
+                        print(f"Markdown length: {len(markdown)} characters")
+                        print(f"Pages: {output.get('pages', 'unknown')}")
+                        
+                        # Save result
+                        output_file = pdf_path.replace('.pdf', '_runpod.md')
+                        with open(output_file, 'w') as f:
+                            f.write(markdown)
+                        print(f"Saved to: {output_file}")
+                    else:
+                        print(f"Conversion failed: {output.get('error')}")
+                    break
+                    
+                elif status_data['status'] == 'FAILED':
+                    print(f"Job failed: {status_data.get('error')}")
+                    break
+                    
+                else:
+                    print(f"Status: {status_data['status']}")
+                    import time
+                    time.sleep(2)
+            else:
+                print(f"Status check failed: {status_response.status_code}")
+                break
+    else:
+        print(f"Request failed: {response.status_code}")
+        print(response.text)
+
+if __name__ == "__main__":
+    # Example usage
+    if len(sys.argv) < 3:
+        print("Usage: python test_runpod.py <pdf_file> <runpod_endpoint> <api_key>")
+        print("Example: python test_runpod.py test.pdf https://api.runpod.ai/v2/your-endpoint your-api-key")
+        sys.exit(1)
+    
+    pdf_file = sys.argv[1]
+    endpoint = sys.argv[2]
+    api_key = sys.argv[3] if len(sys.argv) > 3 else input("RunPod API Key: ")
+    
+    test_runpod_api(pdf_file, endpoint, api_key)