Update app.py

app.py

@@ -1,30 +1,35 @@
 # app.py
 """
 Elderly HealthWatch AI Backend (FastAPI)
-This variant uses:
-- facenet-pytorch or mtcnn if available
-- otherwise falls back to OpenCV Haar cascades (fast, CPU-only, lightweight)
-- integrates a remote VLM via gradio_client to get JSON feature vectors
+Pipeline:
+ - receive images
+ - run VLM (remote gradio / chat_fn) -> JSON feature vector
+ - run LLM (remote gradio /chat) -> structured risk JSON (per requested schema)
+ - continue rest of processing and store results
+Notes:
+ - Add gradio_client==1.13.2 (or another compatible 1.x) to requirements.txt
+ - If VLM/LLM Spaces are private, set HF_TOKEN in the environment for authentication.
 """
 
 import io
+import os
 import uuid
+import json
 import asyncio
+import logging
+import traceback
 from typing import Dict, Any, Optional
 from datetime import datetime
+
 from fastapi import FastAPI, UploadFile, File, BackgroundTasks, HTTPException
 from fastapi.middleware.cors import CORSMiddleware
 from PIL import Image
 import numpy as np
-import os
-import traceback
 import cv2  # opencv-python-headless expected installed
-import json
-import logging
 
-# Optional gradio client import (for VLM)
+# Optional gradio client (for VLM + LLM calls)
 try:
-    from gradio_client import Client, handle_file
+    from gradio_client import Client, handle_file  # type: ignore
     GRADIO_AVAILABLE = True
 except Exception:
     GRADIO_AVAILABLE = False
@@ -32,41 +37,40 @@ except Exception:
 # Configure logging
 logging.basicConfig(level=logging.INFO)
 
-# Configuration for remote VLM (change to your target Space)
-GRADIO_SPACE = os.getenv("GRADIO_SPACE", "developer0hye/Qwen3-VL-8B-Instruct")
-# If your space is private, set HF_TOKEN as a secret / env var in Spaces
+# Configuration for remote VLM and LLM spaces (change to your target Space names)
+GRADIO_VLM_SPACE = os.getenv("GRADIO_SPACE", "developer0hye/Qwen3-VL-8B-Instruct")
+LLM_GRADIO_SPACE = os.getenv("LLM_GRADIO_SPACE", "Tonic/med-gpt-oss-20b-demo")
 HF_TOKEN = os.getenv("HF_TOKEN", None)
+
+# Default VLM prompt
 DEFAULT_VLM_PROMPT = (
     "From the provided face/eye images, compute the required screening features "
     "(pallor, sclera yellowness, redness, mobility metrics, quality checks) "
     "and output a clean JSON feature vector only."
 )
 
-# Attempt to import facenet-pytorch MTCNN first (recommended)
+# Default LLM prompts / metadata
+LLM_MODEL_IDENTITY = os.getenv("LLM_MODEL_IDENTITY", "You are GPT-Tonic, a large language model trained by TonicAI for clinical reasoning.")
+LLM_SYSTEM_PROMPT = os.getenv("LLM_SYSTEM_PROMPT", "You are GPT-Tonic, a medically-oriented assistant. Answer concisely and provide structured JSON only.")
+LLM_DEVELOPER_PROMPT = os.getenv("LLM_DEVELOPER_PROMPT", "Provide structured JSON with keys: risk_score, jaundice_probability, anemia_probability, hydration_issue_probability, neurological_issue_probability, summary, recommendation, confidence. Output JSON only.")
+
+# Try MTCNN libs; fallback to OpenCV haar cascades
+_MTCNN_IMPL = None
 try:
-    from facenet_pytorch import MTCNN as FacenetMTCNN
+    from facenet_pytorch import MTCNN as FacenetMTCNN  # type: ignore
     _MTCNN_IMPL = "facenet_pytorch"
 except Exception:
     FacenetMTCNN = None
     _MTCNN_IMPL = None
 
-# Fallback to the classic mtcnn package
 if _MTCNN_IMPL is None:
     try:
-        from mtcnn import MTCNN as ClassicMTCNN
+        from mtcnn import MTCNN as ClassicMTCNN  # type: ignore
         _MTCNN_IMPL = "mtcnn"
     except Exception:
         ClassicMTCNN = None
 
-# We'll create a fallback "opencv" detector if neither is present.
 def create_mtcnn_or_fallback():
-    """
-    Return:
-     - facenet_pytorch.MTCNN instance if available
-     - classic mtcnn instance if available
-     - dict with OpenCV cascade detector if neither available
-     - None if something unexpected happened
-    """
     if _MTCNN_IMPL == "facenet_pytorch" and FacenetMTCNN is not None:
         try:
             return FacenetMTCNN(keep_all=False, device="cpu")
@@ -77,29 +81,23 @@ def create_mtcnn_or_fallback():
             return ClassicMTCNN()
         except Exception:
             pass
-
-    # OpenCV fallback: use Haar cascades (bundled with cv2)
+    # OpenCV Haar fallback
     try:
         face_cascade_path = os.path.join(cv2.data.haarcascades, "haarcascade_frontalface_default.xml")
         eye_cascade_path = os.path.join(cv2.data.haarcascades, "haarcascade_eye.xml")
         if os.path.exists(face_cascade_path) and os.path.exists(eye_cascade_path):
-            face_cascade = cv2.CascadeClassifier(face_cascade_path)
-            eye_cascade = cv2.CascadeClassifier(eye_cascade_path)
-            return {"impl": "opencv", "face_cascade": face_cascade, "eye_cascade": eye_cascade}
+            return {
+                "impl": "opencv",
+                "face_cascade": cv2.CascadeClassifier(face_cascade_path),
+                "eye_cascade": cv2.CascadeClassifier(eye_cascade_path)
+            }
     except Exception:
         pass
-
     return None
 
 mtcnn = create_mtcnn_or_fallback()
-# mtcnn may now be:
-# - FacenetMTCNN instance (facenet_pytorch)
-# - ClassicMTCNN instance (mtcnn)
-# - dict {"impl":"opencv", "face_cascade":..., "eye_cascade":...}
-# - None
 
 app = FastAPI(title="Elderly HealthWatch AI Backend")
-
 app.add_middleware(
     CORSMiddleware,
     allow_origins=["*"],
@@ -108,16 +106,16 @@ app.add_middleware(
     allow_headers=["*"],
 )
 
+# In-memory DB for demo
 screenings_db: Dict[str, Dict[str, Any]] = {}
 
+# -----------------------
+# Utility helpers
+# -----------------------
 def load_image_from_bytes(bytes_data: bytes) -> Image.Image:
     return Image.open(io.BytesIO(bytes_data)).convert("RGB")
 
 def estimate_eye_openness_from_detection(confidence: float) -> float:
-    """
-    Simple mapping from detection confidence to an "eye_openness" heuristic in [0,1].
-    (Used by facenet/mtcnn flows)
-    """
     try:
         conf = float(confidence)
         openness = min(max((conf * 1.15), 0.0), 1.0)
@@ -125,70 +123,59 @@ def estimate_eye_openness_from_detection(confidence: float) -> float:
     except Exception:
         return 0.0
 
-# --------------------------
-# VLM client helper
-# --------------------------
-def get_gradio_client():
-    """Return a configured gradio Client or raise if not available."""
+# -----------------------
+# Gradio / VLM helper
+# -----------------------
+def get_gradio_client_for_space(space: str) -> Client:
     if not GRADIO_AVAILABLE:
-        raise RuntimeError("gradio_client not installed in this environment.")
+        raise RuntimeError("gradio_client not installed in this environment. Add gradio_client to requirements.txt.")
     if HF_TOKEN:
-        return Client(GRADIO_SPACE, hf_token=HF_TOKEN)
-    return Client(GRADIO_SPACE)
+        return Client(space, hf_token=HF_TOKEN)
+    return Client(space)
 
 def run_vlm_and_get_features(face_path: str, eye_path: str, prompt: Optional[str] = None) -> Dict[str, Any]:
     """
-    Synchronous call to the remote VLM (gradio / chat_fn).
-    Expects the VLM to return a JSON string only (we parse it).
-    On success returns a dict (parsed JSON).
-    On failure raises RuntimeError or ValueError.
+    Synchronous call to remote VLM (gradio /chat_fn). Expects a JSON feature vector in response.
+    Returns parsed dict or raises.
     """
     prompt = prompt or DEFAULT_VLM_PROMPT
-
     if not os.path.exists(face_path) or not os.path.exists(eye_path):
         raise FileNotFoundError("Face or eye image path missing for VLM call.")
-
     if not GRADIO_AVAILABLE:
-        raise RuntimeError("gradio_client is not available in this environment.")
-
-    client = get_gradio_client()
+        raise RuntimeError("gradio_client not available in this environment.")
 
-    message = {
-        "text": prompt,
-        "files": [handle_file(face_path), handle_file(eye_path)]
-    }
+    client = get_gradio_client_for_space(GRADIO_VLM_SPACE)
+    message = {"text": prompt, "files": [handle_file(face_path), handle_file(eye_path)]}
 
-    # Call the remote API
     try:
-        logging.info("Calling remote VLM at %s", GRADIO_SPACE)
-        # result is typically a tuple: (output_dict, new_history)
+        logging.info("Calling VLM Space %s", GRADIO_VLM_SPACE)
         result = client.predict(message=message, history=[], api_name="/chat_fn")
     except Exception as e:
         logging.exception("VLM call failed")
         raise RuntimeError(f"VLM call failed: {e}")
 
-    # Extract text output
-    if not result or not isinstance(result, (list, tuple)):
-        # some spaces return just a dict too
-        if isinstance(result, dict):
-            out = result
-        else:
-            raise RuntimeError("Unexpected VLM response shape")
-    else:
+    # Normalize result
+    if not result:
+        raise RuntimeError("Empty response from VLM")
+
+    if isinstance(result, (list, tuple)):
         out = result[0]
+    elif isinstance(result, dict):
+        out = result
+    else:
+        out = {"text": str(result)}
 
     if not isinstance(out, dict):
         raise RuntimeError("Unexpected VLM output format (expected dict with 'text' key)")
 
     text_out = out.get("text") or out.get("output") or None
     if not text_out:
-        raise RuntimeError("VLM returned empty text output")
+        text_out = json.dumps(out)
 
-    # The model was instructed to return JSON only. Try to parse it.
+    # Parse JSON, forgiving extraction if needed
     try:
         features = json.loads(text_out)
     except Exception:
-        # attempt a forgiving extraction: find the first { ... } block
         try:
             s = text_out
             first = s.find("{")
@@ -207,10 +194,150 @@ def run_vlm_and_get_features(face_path: str, eye_path: str, prompt: Optional[str
 
     return features
 
-# --------------------------
-# End VLM helper
-# --------------------------
+# -----------------------
+# Gradio / LLM helper (always prompts with VLM output + strict instruction)
+# -----------------------
+def run_llm_on_vlm(vlm_features: Dict[str, Any],
+                   max_new_tokens: int = 1024,
+                   temperature: float = 0.0,
+                   reasoning_effort: str = "medium",
+                   model_identity: Optional[str] = None,
+                   system_prompt: Optional[str] = None,
+                   developer_prompt: Optional[str] = None) -> Dict[str, Any]:
+    """
+    Call the remote LLM Space's /chat endpoint with vlm_features embedded in the prompt.
+    The LLM is ALWAYS prompted with the vlm JSON followed by the exact instruction:
+    "{vlm_ioutput},Generate a JSON with risk_score, jaundice_probability, anemia_probability, hydration_issue_probability, neurological_issue_probability, summary, recommendation, confidence.   
+    Base probabilities logically on the input features.  
+    Do NOT mention any disease names in summary or recommendation; use neutral wording only."
+    Returns parsed dict with normalized numeric fields.
+    """
+    if not GRADIO_AVAILABLE:
+        raise RuntimeError("gradio_client not installed. Add gradio_client to requirements.txt")
+
+    client = get_gradio_client_for_space(LLM_GRADIO_SPACE)
+
+    model_identity = model_identity or LLM_MODEL_IDENTITY
+    system_prompt = system_prompt or LLM_SYSTEM_PROMPT
+    developer_prompt = developer_prompt or LLM_DEVELOPER_PROMPT
+
+    # Prepare the exact combined prompt
+    vlm_json_str = json.dumps(vlm_features, default=str)
+    instruction = (
+        ",Generate a JSON with risk_score, jaundice_probability, anemia_probability, "
+        "hydration_issue_probability, neurological_issue_probability, summary, recommendation, confidence.   \n"
+        "Base probabilities logically on the input features.  \n"
+        "Do NOT mention any disease names in summary or recommendation; use neutral wording only."
+    )
+    input_payload_str = vlm_json_str + instruction
+
+    try:
+        logging.info("Calling LLM Space %s with strict schema prompt", LLM_GRADIO_SPACE)
+        result = client.predict(
+            input_data=input_payload_str,
+            max_new_tokens=float(max_new_tokens),
+            model_identity=model_identity,
+            system_prompt=system_prompt,
+            developer_prompt=developer_prompt,
+            reasoning_effort=reasoning_effort,
+            temperature=float(temperature),
+            top_p=0.9,
+            top_k=50,
+            repetition_penalty=1.0,
+            api_name="/chat"
+        )
+    except Exception as e:
+        logging.exception("LLM call failed")
+        raise RuntimeError(f"LLM call failed: {e}")
+
+    # Normalize result to string
+    if isinstance(result, (dict, list)):
+        text_out = json.dumps(result)
+    else:
+        text_out = str(result)
+
+    if not text_out or len(text_out.strip()) == 0:
+        raise RuntimeError("LLM returned empty response")
+
+    # Parse JSON (forgiving extraction)
+    try:
+        parsed = json.loads(text_out)
+    except Exception:
+        try:
+            s = text_out
+            first = s.find("{")
+            last = s.rfind("}")
+            if first != -1 and last != -1 and last > first:
+                maybe = s[first:last+1]
+                parsed = json.loads(maybe)
+            else:
+                raise ValueError("No JSON object found in LLM output")
+        except Exception as e:
+            logging.exception("Failed to parse JSON from LLM output")
+            raise ValueError(f"Failed to parse JSON from LLM output: {e}\nRaw output: {text_out}")
+
+    if not isinstance(parsed, dict):
+        raise ValueError("Parsed LLM output is not a JSON object/dict")
+
+    # Validate and coerce expected probability fields to floats between 0..1 and risk_score 0..100
+    def safe_prob(val):
+        try:
+            v = float(val)
+            if v > 1:
+                # if model returned 0-100 percentage, convert
+                if v <= 100:
+                    v = v / 100.0
+            return max(0.0, min(1.0, v))
+        except Exception:
+            return None
+
+    expected_prob_keys = [
+        "jaundice_probability",
+        "anemia_probability",
+        "hydration_issue_probability",
+        "neurological_issue_probability",
+    ]
+    for k in expected_prob_keys:
+        if k in parsed:
+            parsed[k] = safe_prob(parsed[k])
+        else:
+            parsed[k] = None
+
+    # risk_score: coerce to 0..100
+    if "risk_score" in parsed:
+        try:
+            rs = float(parsed["risk_score"])
+            if rs <= 1:
+                rs = rs * 100.0
+            parsed["risk_score"] = round(max(0.0, min(100.0, rs)), 2)
+        except Exception:
+            parsed["risk_score"] = None
+    else:
+        # derive a simple aggregated risk_score if missing
+        probs = [p for p in (parsed.get(k) for k in expected_prob_keys) if isinstance(p, (int, float))]
+        parsed["risk_score"] = round((sum(probs) / len(probs) * 100.0) if probs else 0.0, 2)
+
+    # Ensure confidence exists and is 0..1
+    if "confidence" in parsed:
+        try:
+            c = float(parsed["confidence"])
+            if c > 1 and c <= 100:
+                c = c / 100.0
+            parsed["confidence"] = max(0.0, min(1.0, c))
+        except Exception:
+            parsed["confidence"] = None
+    else:
+        parsed["confidence"] = None
+
+    # summary and recommendation must be strings (neutral wording)
+    parsed["summary"] = str(parsed.get("summary", "")).strip()
+    parsed["recommendation"] = str(parsed.get("recommendation", "")).strip()
+
+    return parsed
 
+# -----------------------
+# API endpoints
+# -----------------------
 @app.get("/")
 async def read_root():
     return {"message": "Elderly HealthWatch AI Backend"}
@@ -224,16 +351,21 @@ async def health_check():
         impl = "opencv_haar_fallback"
     else:
         impl = _MTCNN_IMPL
-    return {"status": "healthy", "detector": impl, "vlm_available": GRADIO_AVAILABLE}
+    return {
+        "status": "healthy",
+        "detector": impl,
+        "vlm_available": GRADIO_AVAILABLE,
+        "vlm_space": GRADIO_VLM_SPACE,
+        "llm_space": LLM_GRADIO_SPACE
+    }
 
 @app.post("/api/v1/validate-eye-photo")
 async def validate_eye_photo(image: UploadFile = File(...)):
     """
-    Validate an eye photo: detects a face and returns eye_openness_score & landmarks.
-    Uses facenet/mtcnn if available; otherwise OpenCV haar cascades.
+    Lightweight validation endpoint. Uses available detector (facenet/mtcnn/opencv) to check face/eye detection.
+    For full pipeline, use /api/v1/upload which invokes VLM+LLM in background.
     """
     if mtcnn is None:
-        # No detector at all
         raise HTTPException(status_code=500, detail="No face detector available in this deployment.")
 
     try:
@@ -248,13 +380,9 @@ async def validate_eye_photo(image: UploadFile = File(...)):
             try:
                 boxes, probs, landmarks = mtcnn.detect(pil_img, landmarks=True)
                 if boxes is None or len(boxes) == 0:
-                    return {
-                        "valid": False,
-                        "face_detected": False,
-                        "eye_openness_score": 0.0,
-                        "message_english": "No face detected. Please ensure your face is clearly visible in the frame.",
-                        "message_hindi": "कोई चेहरा नहीं मिला। कृपया सुनिश्चित करें कि आपका चेहरा फ्रेम में स्पष्ट रूप से दिखाई दे रहा है।"
-                    }
+                    return {"valid": False, "face_detected": False, "eye_openness_score": 0.0,
+                            "message_english": "No face detected. Please ensure your face is clearly visible in the frame.",
+                            "message_hindi": "कोई चेहरा नहीं मिला। कृपया सुनिश्चित करें कि आपका चेहरा फ्रेम में स्पष्ट रूप से दिखाई दे रहा है।"}
                 prob = float(probs[0]) if probs is not None else 0.0
                 lm = landmarks[0] if landmarks is not None else None
                 if lm is not None and len(lm) >= 2:
@@ -264,14 +392,10 @@ async def validate_eye_photo(image: UploadFile = File(...)):
                     left_eye = right_eye = None
                 eye_openness_score = estimate_eye_openness_from_detection(prob)
                 is_valid = eye_openness_score >= 0.3
-                return {
-                    "valid": bool(is_valid),
-                    "face_detected": True,
-                    "eye_openness_score": round(eye_openness_score, 2),
-                    "message_english": "Photo looks good! Eyes are properly open." if is_valid else "Eyes appear to be closed or partially closed. Please open your eyes wide and try again.",
-                    "message_hindi": "फोटो अच्छी है! आंखें ठीक से खुली हैं।" if is_valid else "आंखें बंद या आंशिक रूप से बंद दिखाई दे रही हैं। कृपया अपनी आंखें चौड़ी खोलें और पुनः प्रयास करें।",
-                    "eye_landmarks": {"left_eye": left_eye, "right_eye": right_eye}
-                }
+                return {"valid": bool(is_valid), "face_detected": True, "eye_openness_score": round(eye_openness_score, 2),
+                        "message_english": "Photo looks good! Eyes are properly open." if is_valid else "Eyes appear to be closed or partially closed. Please open your eyes wide and try again.",
+                        "message_hindi": "फोटो अच्छी है! आंखें ठीक से खुली हैं।" if is_valid else "आंखें बंद या आंशिक रूप से बंद दिखाई दे रही हैं। कृपया अपनी आंखें चौड़ी खोलें और पुनः प्रयास करें।",
+                        "eye_landmarks": {"left_eye": left_eye, "right_eye": right_eye}}
             except Exception:
                 traceback.print_exc()
                 raise HTTPException(status_code=500, detail="Face detector failed during inference.")
@@ -283,13 +407,9 @@ async def validate_eye_photo(image: UploadFile = File(...)):
             except Exception:
                 detections = mtcnn.detect_faces(pil_img)
             if not detections:
-                return {
-                    "valid": False,
-                    "face_detected": False,
-                    "eye_openness_score": 0.0,
-                    "message_english": "No face detected. Please ensure your face is clearly visible in the frame.",
-                    "message_hindi": "कोई चेहरा नहीं मिला। कृपया सुनिश्चित करें कि आपका चेहरा फ्रेम में स्पष्ट रूप से दिखाई दे रहा है।"
-                }
+                return {"valid": False, "face_detected": False, "eye_openness_score": 0.0,
+                        "message_english": "No face detected. Please ensure your face is clearly visible in the frame.",
+                        "message_hindi": "कोई चेहरा नहीं मिला। कृपया सुनिश्चित करें कि आपका चेहरा फ्रेम में स्पष्ट रूप से दिखाई दे रहा है।"}
             face = detections[0]
             keypoints = face.get("keypoints", {})
             left_eye = keypoints.get("left_eye")
@@ -297,14 +417,10 @@ async def validate_eye_photo(image: UploadFile = File(...)):
             confidence = float(face.get("confidence", 0.0))
             eye_openness_score = estimate_eye_openness_from_detection(confidence)
             is_valid = eye_openness_score >= 0.3
-            return {
-                "valid": bool(is_valid),
-                "face_detected": True,
-                "eye_openness_score": round(eye_openness_score, 2),
-                "message_english": "Photo looks good! Eyes are properly open." if is_valid else "Eyes appear to be closed or partially closed. Please open your eyes wide and try again.",
-                "message_hindi": "फोटो अच्छी है! आंखें ठीक से खुली हैं।" if is_valid else "आंखें बंद या आंशिक रूप से बंद दिखाई दे रही हैं। कृपया अपनी आंखें चौड़ी खोलें और पुनः प्रयास करें।",
-                "eye_landmarks": {"left_eye": left_eye, "right_eye": right_eye}
-            }
+            return {"valid": bool(is_valid), "face_detected": True, "eye_openness_score": round(eye_openness_score, 2),
+                    "message_english": "Photo looks good! Eyes are properly open." if is_valid else "Eyes appear to be closed or partially closed. Please open your eyes wide and try again.",
+                    "message_hindi": "फोटो अच्छी है! आंखें ठीक से खुली हैं।" if is_valid else "आंखें बंद या आंशिक रूप से बंद दिखाई दे रही हैं। कृपया अपनी आंखें चौड़ी खोलें और पुनः प्रयास करें।",
+                    "eye_landmarks": {"left_eye": left_eye, "right_eye": right_eye}}
 
         # OpenCV Haar cascade fallback
         if isinstance(mtcnn, dict) and mtcnn.get("impl") == "opencv":
@@ -314,54 +430,38 @@ async def validate_eye_photo(image: UploadFile = File(...)):
                 eye_cascade = mtcnn["eye_cascade"]
                 faces = face_cascade.detectMultiScale(gray, scaleFactor=1.1, minNeighbors=4, minSize=(60, 60))
                 if len(faces) == 0:
-                    return {
-                        "valid": False,
-                        "face_detected": False,
-                        "eye_openness_score": 0.0,
-                        "message_english": "No face detected. Please ensure your face is clearly visible in the frame.",
-                        "message_hindi": "कोई चेहरा नहीं मिला। कृपया सुनिश्चित करें कि आपका चेहरा फ्रेम में स्पष्ट रूप से दिखाई दे रहा है।"
-                    }
-                # Use first face
+                    return {"valid": False, "face_detected": False, "eye_openness_score": 0.0,
+                            "message_english": "No face detected. Please ensure your face is clearly visible in the frame.",
+                            "message_hindi": "कोई चेहरा नहीं मिला। कृपया सुनिश्चित करें कि आपका चेहरा फ्रेम में स्पष्ट रूप से दिखाई दे रहा है।"}
                 (x, y, w, h) = faces[0]
                 roi_gray = gray[y:y+h, x:x+w]
                 eyes = eye_cascade.detectMultiScale(roi_gray, scaleFactor=1.1, minNeighbors=5, minSize=(20, 10))
-                # Heuristic openness: if eyes detected => open
                 eye_openness_score = 1.0 if len(eyes) >= 1 else 0.0
                 is_valid = eye_openness_score >= 0.3
-                # estimate coordinates relative to full image
                 left_eye = None
                 right_eye = None
                 if len(eyes) >= 1:
                     ex, ey, ew, eh = eyes[0]
-                    # convert to image coords center
                     cx = float(x + ex + ew/2)
                     cy = float(y + ey + eh/2)
                     left_eye = {"x": cx, "y": cy}
-                return {
-                    "valid": bool(is_valid),
-                    "face_detected": True,
-                    "eye_openness_score": round(eye_openness_score, 2),
-                    "message_english": "Photo looks good! Eyes are detected." if is_valid else "Eyes not detected. Please open your eyes wide and try again.",
-                    "message_hindi": "फोटो अच्छी है! आंखें मिलीं।" if is_valid else "आंखें नहीं मिलीं। कृपया अपनी आंखें चौड़ी खोलें और पुनः प्रयास करें।",
-                    "eye_landmarks": {"left_eye": left_eye, "right_eye": right_eye}
-                }
+                return {"valid": bool(is_valid), "face_detected": True, "eye_openness_score": round(eye_openness_score, 2),
+                        "message_english": "Photo looks good! Eyes are detected." if is_valid else "Eyes not detected. Please open your eyes wide and try again.",
+                        "message_hindi": "फोटो अच्छी है! आंखें मिलीं।" if is_valid else "आंखें नहीं मिलीं। कृपया अपनी आंखें चौड़ी खोलें और पुनः प्रयास करें।",
+                        "eye_landmarks": {"left_eye": left_eye, "right_eye": right_eye}}
             except Exception:
                 traceback.print_exc()
                 raise HTTPException(status_code=500, detail="OpenCV fallback detector failed.")
-        # Should not reach here
+
         raise HTTPException(status_code=500, detail="Invalid detector configuration.")
     except HTTPException:
         raise
     except Exception as e:
         traceback.print_exc()
-        return {
-            "valid": False,
-            "face_detected": False,
-            "eye_openness_score": 0.0,
-            "message_english": "Error processing image. Please try again.",
-            "message_hindi": "छवि प्रोसेस करने में त्रुटि। कृपया पुनः प्रयास करें।",
-            "error": str(e)
-        }
+        return {"valid": False, "face_detected": False, "eye_openness_score": 0.0,
+                "message_english": "Error processing image. Please try again.",
+                "message_hindi": "छवि प्रोसेस करने में त्रुटि। कृपया पुनः प्रयास करें।",
+                "error": str(e)}
 
 @app.post("/api/v1/upload")
 async def upload_images(
@@ -369,6 +469,9 @@ async def upload_images(
     face_image: UploadFile = File(...),
     eye_image: UploadFile = File(...)
 ):
+    """
+    Save images and enqueue background processing. VLM -> LLM runs inside process_screening.
+    """
     try:
         screening_id = str(uuid.uuid4())
         now = datetime.utcnow().isoformat() + "Z"
@@ -428,30 +531,43 @@ async def get_history(user_id: str):
     history = [s for s in screenings_db.values() if s.get("user_id") == user_id]
     return {"screenings": history}
 
+# -----------------------
+# Main processing pipeline
+# -----------------------
 async def process_screening(screening_id: str):
+    """
+    Main pipeline:
+     - load images
+     - quick detector-based quality metrics
+     - run VLM -> vlm_features
+     - run LLM on vlm_features -> structured risk JSON
+     - merge results into ai_results and finish
+    """
     try:
         if screening_id not in screenings_db:
-            print(f"[process_screening] screening {screening_id} not found")
+            logging.error("[process_screening] screening %s not found", screening_id)
             return
         screenings_db[screening_id]["status"] = "processing"
-        print(f"[process_screening] Starting {screening_id}")
+        logging.info("[process_screening] Starting %s", screening_id)
+
         entry = screenings_db[screening_id]
         face_path = entry.get("face_image_path")
         eye_path = entry.get("eye_image_path")
+
         if not (face_path and os.path.exists(face_path)):
             raise RuntimeError("Face image missing")
         if not (eye_path and os.path.exists(eye_path)):
             raise RuntimeError("Eye image missing")
+
         face_img = Image.open(face_path).convert("RGB")
         eye_img = Image.open(eye_path).convert("RGB")
 
-        # Basic detection using whichever detector is available; populate quality_metrics
+        # Basic detection + quality metrics (facenet/mtcnn/opencv)
         face_detected = False
         face_confidence = 0.0
         left_eye_coord = right_eye_coord = None
 
-        # facenet/mtcnn path
-        if not isinstance(mtcnn, dict) and (_MTCNN_IMPL == "facenet_pytorch" or _MTCNN_IMPL == "mtcnn"):
+        if mtcnn is not None and not isinstance(mtcnn, dict) and (_MTCNN_IMPL == "facenet_pytorch" or _MTCNN_IMPL == "mtcnn"):
             try:
                 if _MTCNN_IMPL == "facenet_pytorch":
                     boxes, probs, landmarks = mtcnn.detect(face_img, landmarks=True)
@@ -475,7 +591,6 @@ async def process_screening(screening_id: str):
             except Exception:
                 traceback.print_exc()
 
-        # OpenCV fallback path
         if isinstance(mtcnn, dict) and mtcnn.get("impl") == "opencv":
             try:
                 arr = np.asarray(face_img)
@@ -485,7 +600,6 @@ async def process_screening(screening_id: str):
                 faces = face_cascade.detectMultiScale(gray, scaleFactor=1.1, minNeighbors=4, minSize=(60, 60))
                 if len(faces) > 0:
                     face_detected = True
-                    # crude confidence proxy by face size ratio
                     (x, y, w, h) = faces[0]
                     face_confidence = min(1.0, (w*h) / (arr.shape[0]*arr.shape[1]) * 4.0)
                     roi_gray = gray[y:y+h, x:x+w]
@@ -507,74 +621,86 @@ async def process_screening(screening_id: str):
         }
         screenings_db[screening_id]["quality_metrics"] = quality_metrics
 
-        # Attempt VLM call to compute multimodal features (pallor, sclera yellowness, etc.)
+        # --------------------------
+        # RUN VLM -> get vlm_features
+        # --------------------------
+        vlm_features = None
         try:
             vlm_features = run_vlm_and_get_features(face_path, eye_path)
-            # attach under ai_results
             screenings_db[screening_id].setdefault("ai_results", {})
-            screenings_db[screening_id]["ai_results"].update({
-                "vlm_features": vlm_features
-            })
+            screenings_db[screening_id]["ai_results"].update({"vlm_features": vlm_features})
         except Exception as e:
-            # Don't fail the entire pipeline for VLM errors; record them
             logging.exception("VLM feature extraction failed")
             screenings_db[screening_id].setdefault("ai_results", {})
-            screenings_db[screening_id]["ai_results"].update({
-                "vlm_error": str(e)
-            })
-
-        # Simulate Medical model steps (kept short)
-        await asyncio.sleep(1)
-        vlm_face_desc = "Patient appears to have normal facial tone; no severe jaundice visible."
-        vlm_eye_desc = "Sclera shows mild yellowing."
-
-        await asyncio.sleep(1)
-        medical_insights = {
-            "hemoglobin_estimate": 11.2,
-            "bilirubin_estimate": 1.8,
-            "anemia_indicators": ["pale skin"],
-            "jaundice_indicators": ["mild scleral yellowing"],
-            "confidence": 0.82
-        }
+            screenings_db[screening_id]["ai_results"].update({"vlm_error": str(e)})
+            vlm_features = None
 
-        hem = medical_insights["hemoglobin_estimate"]
-        bil = medical_insights["bilirubin_estimate"]
-
-        ai_results = {
-            "hemoglobin_g_dl": hem,
-            "anemia_status": "Mild Anemia" if hem < 12 else "Normal",
-            "anemia_confidence": medical_insights["confidence"],
-            "bilirubin_mg_dl": bil,
-            "jaundice_status": "Normal" if bil < 2.5 else "Elevated",
-            "jaundice_confidence": medical_insights["confidence"],
-            "vlm_face_description": vlm_face_desc,
-            "vlm_eye_description": vlm_eye_desc,
-            "medical_insights": medical_insights,
-            "processing_time_ms": 1200
-        }
-        # Merge ai_results while preserving vlm_features if present
+        # --------------------------
+        # RUN LLM on vlm_features -> structured risk JSON
+        # --------------------------
+        structured_risk = None
+        try:
+            if vlm_features:
+                structured_risk = run_llm_on_vlm(vlm_features)
+            else:
+                # Fallback if VLM failed: produce conservative defaults
+                structured_risk = {
+                    "risk_score": 0.0,
+                    "jaundice_probability": 0.0,
+                    "anemia_probability": 0.0,
+                    "hydration_issue_probability": 0.0,
+                    "neurological_issue_probability": 0.0,
+                    "summary": "",
+                    "recommendation": "",
+                    "confidence": 0.0
+                }
+            screenings_db[screening_id].setdefault("ai_results", {})
+            screenings_db[screening_id]["ai_results"].update({"structured_risk": structured_risk})
+        except Exception as e:
+            logging.exception("LLM processing failed")
+            screenings_db[screening_id].setdefault("ai_results", {})
+            screenings_db[screening_id]["ai_results"].update({"llm_error": str(e)})
+            structured_risk = {
+                "risk_score": 0.0,
+                "jaundice_probability": 0.0,
+                "anemia_probability": 0.0,
+                "hydration_issue_probability": 0.0,
+                "neurological_issue_probability": 0.0,
+                "summary": "",
+                "recommendation": "",
+                "confidence": 0.0
+            }
+
+        # Use structured_risk for summary recommendations & simple disease inference placeholders
+        hem = screenings_db[screening_id]["ai_results"].get("medical_insights", {}).get("hemoglobin_estimate", None)
+        bil = screenings_db[screening_id]["ai_results"].get("medical_insights", {}).get("bilirubin_estimate", None)
+
+        # Keep older ai_results shape for backward compatibility (if you want)
         screenings_db[screening_id].setdefault("ai_results", {})
-        screenings_db[screening_id]["ai_results"].update(ai_results)
+        screenings_db[screening_id]["ai_results"].update({
+            "processing_time_ms": 1200
+        })
 
+        # disease_predictions & recommendations can be built from structured_risk if needed
         disease_predictions = [
             {
-                "condition": "Iron Deficiency Anemia",
-                "risk_level": "Medium" if hem < 12 else "Low",
-                "probability": 0.76 if hem < 12 else 0.23,
-                "confidence": medical_insights["confidence"]
+                "condition": "Anemia-like-signs",  # internal tag (not surfaced in LLM summary)
+                "risk_level": "Medium" if structured_risk.get("anemia_probability", 0.0) > 0.5 else "Low",
+                "probability": structured_risk.get("anemia_probability", 0.0),
+                "confidence": structured_risk.get("confidence", 0.0)
             },
             {
-                "condition": "Jaundice",
-                "risk_level": "Low" if bil < 2.5 else "Medium",
-                "probability": 0.23 if bil < 2.5 else 0.45,
-                "confidence": medical_insights["confidence"]
+                "condition": "Jaundice-like-signs",
+                "risk_level": "Medium" if structured_risk.get("jaundice_probability", 0.0) > 0.5 else "Low",
+                "probability": structured_risk.get("jaundice_probability", 0.0),
+                "confidence": structured_risk.get("confidence", 0.0)
             }
         ]
 
         recommendations = {
-            "action_needed": "consult" if hem < 12 else "monitor",
-            "message_english": f"Your hemoglobin is {hem} g/dL. Please consult a doctor within 2 weeks for blood tests.",
-            "message_hindi": f"आपका हीमोग्लोबिन {hem} g/dL है। कृपया 2 सप्ताह में डॉक्टर से परामर्श करें।"
+            "action_needed": "consult" if structured_risk.get("risk_score", 0.0) > 30.0 else "monitor",
+            "message_english": structured_risk.get("recommendation", "") or f"Please follow up with a health professional if concerns persist.",
+            "message_hindi": ""  # could be auto-translated if desired
         }
 
         screenings_db[screening_id].update({
@@ -583,15 +709,18 @@ async def process_screening(screening_id: str):
             "recommendations": recommendations
         })
 
-        print(f"[process_screening] Completed {screening_id}")
+        logging.info("[process_screening] Completed %s", screening_id)
     except Exception as e:
         traceback.print_exc()
         if screening_id in screenings_db:
             screenings_db[screening_id]["status"] = "failed"
             screenings_db[screening_id]["error"] = str(e)
         else:
-            print(f"[process_screening] Failed for unknown screening {screening_id}: {e}")
+            logging.error("[process_screening] Failed for unknown screening %s: %s", screening_id, str(e))
 
+# -----------------------
+# Run server (for local debugging)
+# -----------------------
 if __name__ == "__main__":
     import uvicorn
     uvicorn.run("app:app", host="0.0.0.0", port=7860, reload=False)