Fix: Multi-service Dockerfile + missing API endpoints

- Dockerfile: python:3.11-slim base with Ollama installed via curl
(was: ollama/ollama base with no Python - FastAPI never started)
- app.py v3.0: Added /api/generate (for cloud_llm_adapter.py)
and /tools/analyze_report (for trigger_cloud.py)
- start.sh: Dual-service startup (Ollama bg + FastAPI fg)
- Model pull moved to runtime to avoid build timeout
- Added python-multipart for file upload support

Co-authored-by: Cursor <cursoragent@cursor.com>

Dockerfile

@@ -1,8 +1,31 @@
-FROM ollama/ollama:latest
+# Moltbot Hybrid Engine - Multi-service Dockerfile
+# Runs: FastAPI (port 7860) + Ollama (port 11434, background)
+# Build: 2026-02-06
+FROM python:3.11-slim
+
+# Install system dependencies + Ollama
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    curl \
+    procps \
+    && curl -fsSL https://ollama.com/install.sh | sh \
+    && apt-get clean \
+    && rm -rf /var/lib/apt/lists/*
+
+# Set environment
 ENV OLLAMA_HOST=0.0.0.0
-RUN ollama serve & \
-    sleep 5 && \
-    ollama pull qwen2.5:7b && \
-    killall ollama
+ENV OLLAMA_MODELS=/app/models
+WORKDIR /app
+
+# Copy and install Python dependencies first (Docker layer caching)
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy application files
+COPY app.py start.sh ./
+RUN chmod +x start.sh
+
+# Expose HF Spaces port
 EXPOSE 7860
-ENTRYPOINT ["ollama", "serve"]
+
+# Start both services via start.sh
+CMD ["bash", "start.sh"]

app.py

@@ -1,33 +1,53 @@
 """
-Moltbot Hybrid Engine - SAFE DEPLOYMENT v2.0.0
-Brain only - NO file access, NO local filesystem access
-Runs on Hugging Face Spaces in isolated container
-Build: 2026-01-31
+Moltbot Hybrid Engine - Production v3.0.0
+Multi-service: FastAPI endpoints + Ollama LLM integration
+Runs on Hugging Face Spaces
+Build: 2026-02-06
+
+Endpoints:
+  GET  /              - Health check
+  GET  /health        - Detailed health status
+  GET  /security      - Security posture info
+  POST /api/generate  - LLM text generation via Ollama (called by cloud_llm_adapter.py)
+  POST /api/search    - Fuzzy file matching (called by file resolution)
+  POST /api/analyze   - Report analysis (JSON body)
+  POST /api/extract_date - Date extraction from filenames
+  POST /tools/analyze_report - Report analysis via file upload (called by trigger_cloud.py)
 """
 import os
 import re
 import json
-from fastapi import FastAPI, HTTPException, Header
+import subprocess
+import logging
+from fastapi import FastAPI, HTTPException, Header, UploadFile, File
 from pydantic import BaseModel
 from typing import List, Optional, Dict, Any
 
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger("moltbot-engine")
+
 # Initialize App
 app = FastAPI(
     title="Moltbot Hybrid Engine",
-    description="Safe AI agent for file matching - brain only, no file access",
-    version="2.0.0"
+    description="AI agent for legal document processing - LLM + file matching + analysis",
+    version="3.0.0"
 )
 
 # API Key for authentication
 API_KEY = os.environ.get("MOLTBOT_API_KEY", "default_insecure_key")
 if API_KEY == "default_insecure_key":
-    print("WARNING: MOLTBOT_API_KEY not set. Using insecure default.")
+    logger.warning("MOLTBOT_API_KEY not set. Using insecure default.")
 
 
 # ============================================================
 # DATA MODELS
 # ============================================================
 
+class GenerateRequest(BaseModel):
+    model: str = "qwen2.5:7b"
+    prompt: str
+    stream: bool = False
+
 class FileSearchRequest(BaseModel):
     missing_filename: str
     available_files: List[str]
@@ -50,10 +70,11 @@ class AnalysisResponse(BaseModel):
 
 
 # ============================================================
-# HELPER FUNCTIONS (Pure logic, no file access)
+# HELPER FUNCTIONS
 # ============================================================
 
 def tokenize(text: str) -> set:
+    """Tokenize a filename for fuzzy matching."""
     clean = re.sub(r'[_\-\.\(\)\[\]]', ' ', text.lower())
     tokens = set(clean.split())
     junk = {'pdf', 'mp4', 'jpg', 'jpeg', 'png', 'gif', 'doc', 'docx',
@@ -61,16 +82,18 @@ def tokenize(text: str) -> set:
     return tokens - junk
 
 def calculate_match_score(wanted: set, found: set) -> float:
+    """Calculate token overlap score between two sets."""
     if not wanted:
         return 0.0
     common = wanted.intersection(found)
     return len(common) / len(wanted)
 
 def find_best_matches(missing_filename: str, available_files: List[str], max_results: int = 5) -> List[Dict[str, Any]]:
+    """Find best fuzzy matches for a missing filename."""
     wanted_tokens = tokenize(missing_filename)
     if not wanted_tokens:
         return []
-    
+
     matches = []
     for filename in available_files:
         if filename == missing_filename:
@@ -83,10 +106,58 @@ def find_best_matches(missing_filename: str, available_files: List[str], max_res
         score = calculate_match_score(wanted_tokens, found_tokens)
         if score >= 0.5:
             matches.append({"filename": filename, "score": round(score, 3), "match_type": "token_match"})
-    
+
     matches.sort(key=lambda x: x["score"], reverse=True)
     return matches[:max_results]
 
+def check_ollama_status() -> dict:
+    """Check if Ollama is running and responsive."""
+    try:
+        result = subprocess.run(
+            ["ollama", "list"],
+            capture_output=True, text=True, timeout=10
+        )
+        if result.returncode == 0:
+            models = [line.split()[0] for line in result.stdout.strip().split('\n')[1:] if line.strip()]
+            return {"running": True, "models": models}
+        return {"running": False, "error": result.stderr.strip()}
+    except FileNotFoundError:
+        return {"running": False, "error": "ollama binary not found"}
+    except subprocess.TimeoutExpired:
+        return {"running": False, "error": "ollama list timed out"}
+    except Exception as e:
+        return {"running": False, "error": str(e)}
+
+def analyze_report_data(data: dict) -> dict:
+    """Analyze a verification report and return findings."""
+    suggestions = []
+    missing_files = data.get("missing_total", 0)
+    structure_issues = data.get("page_structure_analysis", {}).get("bundles_with_structure_issues", 0)
+    blank_pages = data.get("blank_placeholder_pages", 0)
+
+    if missing_files > 0:
+        suggestions.append(f"{missing_files} files missing - check paths in proven_paths_index.json")
+    if structure_issues > 0:
+        suggestions.append(f"{structure_issues} bundles have page structure problems - check embedding logic")
+    if blank_pages > 0:
+        suggestions.append(f"{blank_pages} blank placeholder pages found - files listed in TOC but not embedded")
+
+    # Check per-bundle issues
+    bundles = data.get("bundles", {})
+    for bundle_name, bundle_data in bundles.items():
+        if isinstance(bundle_data, dict):
+            bundle_missing = bundle_data.get("missing_count", 0)
+            if bundle_missing > 0:
+                suggestions.append(f"Bundle {bundle_name}: {bundle_missing} files missing")
+
+    critical_count = missing_files + structure_issues + blank_pages
+    return {
+        "status": "success",
+        "critical_issues": critical_count,
+        "suggestions": suggestions if suggestions else ["No critical issues found"],
+        "summary": f"Analyzed report: {critical_count} critical issues across {len(bundles)} bundles"
+    }
+
 
 # ============================================================
 # API ENDPOINTS
@@ -94,85 +165,199 @@ def find_best_matches(missing_filename: str, available_files: List[str], max_res
 
 @app.get("/")
 def health_check():
+    """Basic health check."""
+    ollama = check_ollama_status()
     return {
         "status": "running",
         "service": "Moltbot Hybrid Engine",
-        "version": "2.0.0",
-        "mode": "SAFE - Brain only, no file access"
+        "version": "3.0.0",
+        "ollama": ollama
+    }
+
+@app.get("/health")
+def detailed_health():
+    """Detailed health check with Ollama status."""
+    ollama = check_ollama_status()
+    return {
+        "status": "healthy",
+        "service": "moltbot-hybrid-engine",
+        "version": "3.0.0",
+        "ollama_running": ollama.get("running", False),
+        "ollama_models": ollama.get("models", []),
+        "endpoints": ["/", "/health", "/api/generate", "/api/search",
+                      "/api/analyze", "/api/extract_date", "/tools/analyze_report"]
     }
 
 @app.get("/security")
 def security_info():
+    """Report security posture."""
     return {
         "file_access": False,
         "network_access": "API only",
         "isolation": "Hugging Face container",
-        "cannot_do": ["Read files", "Write files", "Delete files", "Access filesystem", "Execute commands"]
+        "cannot_do": ["Read local files", "Write local files", "Delete files",
+                      "Access host filesystem", "Execute arbitrary commands"]
     }
 
+
+# --- LLM Generation (called by cloud_llm_adapter.py) ---
+
+@app.post("/api/generate")
+async def generate(request: GenerateRequest, x_api_key: str = Header(None)):
+    """Generate text using Ollama. Called by cloud_llm_adapter.py."""
+    if not x_api_key or x_api_key != API_KEY:
+        raise HTTPException(status_code=401, detail="Invalid or missing API Key")
+
+    logger.info(f"[GENERATE] model={request.model}, prompt_len={len(request.prompt)}")
+
+    # Check Ollama availability first
+    ollama_status = check_ollama_status()
+    if not ollama_status.get("running"):
+        raise HTTPException(
+            status_code=503,
+            detail=f"Ollama not available: {ollama_status.get('error', 'unknown')}"
+        )
+
+    try:
+        result = subprocess.run(
+            ["ollama", "run", request.model, request.prompt],
+            capture_output=True,
+            text=True,
+            timeout=120
+        )
+
+        if result.returncode != 0:
+            logger.error(f"[GENERATE] Ollama error: {result.stderr}")
+            raise HTTPException(
+                status_code=500,
+                detail=f"Ollama error: {result.stderr.strip()}"
+            )
+
+        response_text = result.stdout.strip()
+        logger.info(f"[GENERATE] Success, response_len={len(response_text)}")
+
+        return {
+            "model": request.model,
+            "response": response_text,
+            "done": True
+        }
+
+    except subprocess.TimeoutExpired:
+        logger.error("[GENERATE] Ollama timeout after 120s")
+        raise HTTPException(status_code=504, detail="Ollama request timed out after 120s")
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"[GENERATE] Unexpected error: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+# --- File Search (called by file resolution) ---
+
 @app.post("/api/search", response_model=FileSearchResponse)
 async def search_file(request: FileSearchRequest, x_api_key: str = Header(None)):
+    """Fuzzy file matching for missing evidence files."""
     if not x_api_key or x_api_key != API_KEY:
         raise HTTPException(status_code=401, detail="Invalid or missing API Key")
-    
+
     if len(request.missing_filename) > 200:
         return FileSearchResponse(
             status="error", missing_filename=request.missing_filename[:50] + "...",
             suggestions=[], confidence=0.0,
             reasoning="Filename too long - likely concatenated filenames"
         )
-    
+
     matches = find_best_matches(request.missing_filename, request.available_files)
     confidence = matches[0]["score"] if matches else 0.0
-    
+
     if not matches:
         reasoning = f"No matches found in {len(request.available_files)} files"
     elif matches[0]["match_type"] == "exact":
         reasoning = f"Exact match: {matches[0]['filename']}"
     else:
         reasoning = f"Token match with {int(confidence * 100)}% similarity"
-    
+
     return FileSearchResponse(
         status="success", missing_filename=request.missing_filename,
         suggestions=matches, confidence=confidence, reasoning=reasoning
     )
 
+
+# --- Report Analysis via JSON body ---
+
 @app.post("/api/analyze", response_model=AnalysisResponse)
-async def analyze_report(request: AnalysisRequest, x_api_key: str = Header(None)):
+async def analyze_report_json(request: AnalysisRequest, x_api_key: str = Header(None)):
+    """Analyze a verification report (JSON body). Called by API clients."""
     if not x_api_key or x_api_key != API_KEY:
         raise HTTPException(status_code=401, detail="Invalid or missing API Key")
-    
-    data = request.report_data
-    suggestions = []
-    missing_files = data.get("missing_total", 0)
-    structure_issues = data.get("page_structure_analysis", {}).get("bundles_with_structure_issues", 0)
-    
-    if missing_files > 0:
-        suggestions.append(f"{missing_files} files missing - check paths")
-    if structure_issues > 0:
-        suggestions.append(f"{structure_issues} bundles have structure problems")
-    
+
+    result = analyze_report_data(request.report_data)
     return AnalysisResponse(
-        status="success", critical_issues=missing_files + structure_issues, suggestions=suggestions
+        status=result["status"],
+        critical_issues=result["critical_issues"],
+        suggestions=result["suggestions"]
     )
 
+
+# --- Report Analysis via file upload (called by trigger_cloud.py) ---
+
+@app.post("/tools/analyze_report")
+async def analyze_report_upload(
+    report_file: UploadFile = File(...),
+    x_api_key: str = Header(None)
+):
+    """Analyze a verification report uploaded as a file.
+    Called by trigger_cloud.py and generate_bundles_final_corrected.py cloud reporting.
+    """
+    if not x_api_key or x_api_key != API_KEY:
+        raise HTTPException(status_code=401, detail="Invalid or missing API Key")
+
+    logger.info(f"[ANALYZE_REPORT] Received file: {report_file.filename}")
+
+    try:
+        content = await report_file.read()
+        data = json.loads(content)
+    except json.JSONDecodeError:
+        raise HTTPException(status_code=400, detail="Invalid JSON in uploaded file")
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=f"Error reading file: {str(e)}")
+
+    result = analyze_report_data(data)
+    logger.info(f"[ANALYZE_REPORT] Found {result['critical_issues']} critical issues")
+
+    return result
+
+
+# --- Date Extraction ---
+
 @app.post("/api/extract_date")
 async def extract_date(filename: str, x_api_key: str = Header(None)):
+    """Extract date from a filename string."""
     if not x_api_key or x_api_key != API_KEY:
         raise HTTPException(status_code=401, detail="Invalid or missing API Key")
-    
+
     patterns = [
         (r'(\d{4})-(\d{2})-(\d{2})', 'ISO'),
         (r'(\d{4})_(\d{2})_(\d{2})', 'underscore'),
+        (r'(\d{1,2})-(\d{1,2})-(\d{2,4})', 'UK_dash'),
         (r'(\d{4})(\d{2})(\d{2})', 'compact'),
     ]
     for pattern, fmt in patterns:
         match = re.search(pattern, filename)
         if match:
-            year, month, day = match.groups()
-            return {"status": "found", "date": f"{year}-{int(month):02d}-{int(day):02d}"}
+            groups = match.groups()
+            if fmt == 'UK_dash':
+                day, month, year = groups
+                if len(year) == 2:
+                    year = f"20{year}"
+                return {"status": "found", "date": f"{year}-{int(month):02d}-{int(day):02d}", "format": fmt}
+            else:
+                year, month, day = groups
+                return {"status": "found", "date": f"{year}-{int(month):02d}-{int(day):02d}", "format": fmt}
+
     return {"status": "not_found", "date": None}
 
+
 if __name__ == "__main__":
     import uvicorn
     uvicorn.run(app, host="0.0.0.0", port=7860)

requirements.txt

@@ -1,4 +1,5 @@
-# Moltbot Hybrid Engine - Safe Deployment
+# Moltbot Hybrid Engine - Dependencies
 fastapi>=0.104.0
 uvicorn>=0.24.0
 pydantic>=2.0.0
+python-multipart>=0.0.6

start.sh

@@ -1,9 +1,49 @@
 #!/bin/bash
-# Moltbot Safe Startup - Simple version
-echo "🚀 Starting Moltbot Hybrid Engine (Safe Mode)..."
-echo "   Version: 2.0.0"
-echo "   Mode: Brain only, no file access"
-echo "=================================="
+# Moltbot Hybrid Engine - Multi-service Startup
+# Starts: Ollama (background) + FastAPI/uvicorn (foreground on port 7860)
+# Build: 2026-02-06
 
-# Start uvicorn directly (HF handles process management)
+echo "============================================================"
+echo "  Moltbot Hybrid Engine v3.0.0 - Starting..."
+echo "============================================================"
+echo "  Timestamp: $(date '+%Y-%m-%d %H:%M:%S')"
+echo ""
+
+# 1. Start Ollama in background
+echo "[1/3] Starting Ollama server..."
+ollama serve &
+OLLAMA_PID=$!
+echo "  Ollama PID: $OLLAMA_PID"
+
+# 2. Wait for Ollama to be ready (up to 30 seconds)
+echo "[2/3] Waiting for Ollama to be ready..."
+MAX_WAIT=30
+WAITED=0
+while [ $WAITED -lt $MAX_WAIT ]; do
+    if ollama list > /dev/null 2>&1; then
+        echo "  Ollama ready after ${WAITED}s"
+        break
+    fi
+    sleep 2
+    WAITED=$((WAITED + 2))
+done
+
+if [ $WAITED -ge $MAX_WAIT ]; then
+    echo "  WARNING: Ollama not ready after ${MAX_WAIT}s - FastAPI will start anyway"
+    echo "  LLM endpoints will return 503 until Ollama is available"
+else
+    # Try to pull model (non-blocking, in background)
+    echo "  Checking for qwen2.5:7b model..."
+    if ! ollama list 2>/dev/null | grep -q "qwen2.5"; then
+        echo "  Model not found, pulling in background..."
+        ollama pull qwen2.5:7b &
+    else
+        echo "  Model already available"
+    fi
+fi
+
+# 3. Start FastAPI (foreground - this keeps the container alive)
+echo "[3/3] Starting FastAPI on port 7860..."
+echo "============================================================"
+echo ""
 exec python -m uvicorn app:app --host 0.0.0.0 --port 7860