Update app.py

app.py

@@ -1,6 +1,6 @@
 """
 Elderly HealthWatch AI Backend (FastAPI) - Refactored with Qwen2.5-VL
-Updated to use mrdbourke/Qwen2.5-VL-Instruct-Demo instead of Qwen3-VL
+Updated to use Qwen2.5-VL with multiple space options and fallback
 """
 
 import io
@@ -32,8 +32,23 @@ except Exception:
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger("elderly_healthwatch")
 
-# Updated VLM space to use Qwen2.5-VL
-GRADIO_VLM_SPACE = os.getenv("GRADIO_SPACE", "mrdbourke/Qwen2.5-VL-Instruct-Demo")
+# Multiple VLM options - will try in order until one works
+VLM_SPACES = [
+    {
+        "space": "Qwen/Qwen2.5-VL-7B-Instruct",
+        "model_id": "Qwen/Qwen2.5-VL-7B-Instruct",
+        "api_name": "/model_chat",
+        "type": "official"
+    },
+    {
+        "space": "mrdbourke/Qwen2.5-VL-Instruct-Demo",
+        "model_id": "Qwen/Qwen2.5-VL-7B-Instruct",
+        "api_name": "/run_example",
+        "type": "demo"
+    }
+]
+
+GRADIO_VLM_SPACE = os.getenv("GRADIO_SPACE", VLM_SPACES[0]["space"])
 VLM_MODEL_ID = os.getenv("VLM_MODEL_ID", "Qwen/Qwen2.5-VL-7B-Instruct")
 LLM_GRADIO_SPACE = os.getenv("LLM_GRADIO_SPACE", "Tonic/med-gpt-oss-20b-demo")
 HF_TOKEN = os.getenv("HF_TOKEN", None)
@@ -67,26 +82,26 @@ os.makedirs(TMP_DIR, exist_ok=True)
 # In-memory database
 screenings_db: Dict[str, Dict[str, Any]] = {}
 
+# Track which VLM space is working
+active_vlm_config = None
+
 # ============================================================================
 # Face Detection Setup
 # ============================================================================
 def setup_face_detector():
     """Initialize face detector (MTCNN or OpenCV fallback)"""
-    # Try facenet-pytorch MTCNN
     try:
         from facenet_pytorch import MTCNN
         return MTCNN(keep_all=False, device="cpu"), "facenet_pytorch"
     except Exception:
         pass
     
-    # Try classic MTCNN
     try:
         from mtcnn import MTCNN
         return MTCNN(), "mtcnn"
     except Exception:
         pass
     
-    # OpenCV Haar cascade fallback
     try:
         face_path = os.path.join(cv2.data.haarcascades, "haarcascade_frontalface_default.xml")
         eye_path = os.path.join(cv2.data.haarcascades, "haarcascade_eye.xml")
@@ -143,7 +158,6 @@ def detect_face_and_eyes(pil_img: Image.Image) -> Dict[str, Any]:
     
     img_arr = np.asarray(pil_img)
     
-    # Facenet-pytorch MTCNN
     if detector_type == "facenet_pytorch":
         try:
             boxes, probs, landmarks = face_detector.detect(pil_img, landmarks=True)
@@ -171,7 +185,6 @@ def detect_face_and_eyes(pil_img: Image.Image) -> Dict[str, Any]:
             return {"face_detected": False, "face_confidence": 0.0, "eye_openness_score": 0.0,
                     "left_eye": None, "right_eye": None}
     
-    # Classic MTCNN
     elif detector_type == "mtcnn":
         try:
             detections = face_detector.detect_faces(img_arr)
@@ -195,7 +208,6 @@ def detect_face_and_eyes(pil_img: Image.Image) -> Dict[str, Any]:
             return {"face_detected": False, "face_confidence": 0.0, "eye_openness_score": 0.0,
                     "left_eye": None, "right_eye": None}
     
-    # OpenCV fallback
     elif detector_type == "opencv":
         try:
             gray = cv2.cvtColor(img_arr, cv2.COLOR_RGB2GRAY)
@@ -287,7 +299,7 @@ def extract_json_from_llm_output(raw_text: str) -> Dict[str, Any]:
     }
 
 # ============================================================================
-# VLM & LLM Integration - UPDATED FOR QWEN2.5-VL
+# VLM & LLM Integration - UPDATED FOR QWEN2.5-VL with Fallback
 # ============================================================================
 def get_gradio_client(space: str) -> Client:
     """Get Gradio client with optional auth"""
@@ -295,11 +307,42 @@ def get_gradio_client(space: str) -> Client:
         raise RuntimeError("gradio_client not installed")
     return Client(space, hf_token=HF_TOKEN) if HF_TOKEN else Client(space)
 
+def call_vlm_single_image(client: Client, image_path: str, prompt: str, config: Dict) -> str:
+    """Call VLM with a single image using appropriate API"""
+    try:
+        if config["type"] == "demo":
+            # mrdbourke style API
+            result = client.predict(
+                image=handle_file(image_path),
+                text_input=prompt,
+                model_id=config["model_id"],
+                api_name=config["api_name"]
+            )
+            # Extract text from tuple response
+            if isinstance(result, (list, tuple)) and len(result) > 0:
+                return str(result[0])
+            return str(result)
+        else:
+            # Try official Qwen space API (if it exists)
+            result = client.predict(
+                query=prompt,
+                image=handle_file(image_path),
+                api_name=config["api_name"]
+            )
+            if isinstance(result, (list, tuple)) and len(result) > 0:
+                return str(result[0])
+            return str(result)
+    except Exception as e:
+        logger.error("VLM single image call failed with config %s: %s", config, str(e))
+        raise
+
 def call_vlm(face_path: str, eye_path: str, prompt: Optional[str] = None) -> Tuple[Optional[Dict], str]:
     """
     Call Qwen2.5-VL and return (parsed_features, raw_text)
-    Updated to use mrdbourke/Qwen2.5-VL-Instruct-Demo API
+    Tries multiple VLM spaces until one works
     """
+    global active_vlm_config
+    
     prompt = prompt or DEFAULT_VLM_PROMPT
     
     if not os.path.exists(face_path) or not os.path.exists(eye_path):
@@ -311,85 +354,85 @@ def call_vlm(face_path: str, eye_path: str, prompt: Optional[str] = None) -> Tup
                 eye_path, os.path.exists(eye_path), os.path.getsize(eye_path))
     logger.info("VLM Prompt: %s", prompt[:100])
     
-    client = get_gradio_client(GRADIO_VLM_SPACE)
+    # Try active config first if we have one that worked before
+    configs_to_try = []
+    if active_vlm_config:
+        configs_to_try.append(active_vlm_config)
+    configs_to_try.extend([c for c in VLM_SPACES if c != active_vlm_config])
     
-    try:
-        logger.info("Calling Qwen2.5-VL Space: %s with api_name=/run_example", GRADIO_VLM_SPACE)
-        
-        # First call with face image
-        result_face = client.predict(
-            image=handle_file(face_path),
-            text_input=prompt + " Focus on the face and overall skin condition.",
-            model_id=VLM_MODEL_ID,
-            api_name="/run_example"
-        )
-        
-        # Second call with eye image
-        result_eye = client.predict(
-            image=handle_file(eye_path),
-            text_input=prompt + " Focus on the eyes, sclera color, and eye health.",
-            model_id=VLM_MODEL_ID,
-            api_name="/run_example"
-        )
-        
-        logger.info("VLM Face result type: %s", type(result_face))
-        logger.info("VLM Eye result type: %s", type(result_eye))
-        
-        # Extract text from tuple results (returns tuple of 2 elements)
-        face_text = result_face[0] if isinstance(result_face, (list, tuple)) and len(result_face) > 0 else str(result_face)
-        eye_text = result_eye[0] if isinstance(result_eye, (list, tuple)) and len(result_eye) > 0 else str(result_eye)
-        
-        # Combine both analyses
-        combined_text = f"Face Analysis:\n{face_text}\n\nEye Analysis:\n{eye_text}"
-        
-        logger.info("VLM combined text (first 500 chars): %s", combined_text[:500])
-        
-    except Exception as e:
-        logger.exception("VLM call failed")
-        raise RuntimeError(f"VLM call failed: {e}")
-    
-    # Try to parse JSON from the combined text
-    parsed = None
-    try:
-        # Try direct JSON parse first
-        parsed = json.loads(combined_text)
-        if not isinstance(parsed, dict):
-            logger.warning("VLM JSON parsed but not a dict: %s", type(parsed))
-            parsed = None
-        else:
-            logger.info("VLM successfully parsed JSON with keys: %s", list(parsed.keys()))
-    except Exception:
-        # Try to extract JSON block
+    last_error = None
+    for config in configs_to_try:
         try:
-            first = combined_text.find("{")
-            last = combined_text.rfind("}")
-            if first != -1 and last != -1 and last > first:
-                json_str = combined_text[first:last+1]
-                parsed = json.loads(json_str)
+            logger.info("Trying VLM Space: %s with api_name=%s", config["space"], config["api_name"])
+            client = get_gradio_client(config["space"])
+            
+            # Call VLM twice - once for face, once for eyes
+            face_text = call_vlm_single_image(
+                client, face_path, 
+                prompt + " Focus on the face and overall skin condition.",
+                config
+            )
+            
+            eye_text = call_vlm_single_image(
+                client, eye_path,
+                prompt + " Focus on the eyes, sclera color, and eye health.",
+                config
+            )
+            
+            # Success! Save this config
+            active_vlm_config = config
+            
+            # Combine both analyses
+            combined_text = f"Face Analysis:\n{face_text}\n\nEye Analysis:\n{eye_text}"
+            logger.info("VLM combined text (first 500 chars): %s", combined_text[:500])
+            
+            # Try to parse JSON
+            parsed = None
+            try:
+                parsed = json.loads(combined_text)
                 if not isinstance(parsed, dict):
                     parsed = None
                 else:
-                    logger.info("Successfully extracted JSON from text with keys: %s", list(parsed.keys()))
-        except Exception as extract_err:
-            logger.warning("Could not extract JSON from VLM text: %s", str(extract_err))
-            parsed = None
-    
-    # If no JSON found, create structured data from text
-    if parsed is None:
-        logger.info("No JSON found, creating structured data from text analysis")
-        parsed = {
-            "face_analysis": face_text[:500],
-            "eye_analysis": eye_text[:500],
-            "combined_analysis": combined_text[:1000]
-        }
+                    logger.info("VLM successfully parsed JSON with keys: %s", list(parsed.keys()))
+            except Exception:
+                try:
+                    first = combined_text.find("{")
+                    last = combined_text.rfind("}")
+                    if first != -1 and last != -1 and last > first:
+                        json_str = combined_text[first:last+1]
+                        parsed = json.loads(json_str)
+                        if not isinstance(parsed, dict):
+                            parsed = None
+                        else:
+                            logger.info("Successfully extracted JSON from text with keys: %s", list(parsed.keys()))
+                except Exception as extract_err:
+                    logger.warning("Could not extract JSON from VLM text: %s", str(extract_err))
+                    parsed = None
+            
+            # If no JSON found, create structured data from text
+            if parsed is None:
+                logger.info("No JSON found, creating structured data from text analysis")
+                parsed = {
+                    "face_analysis": face_text[:500],
+                    "eye_analysis": eye_text[:500],
+                    "combined_analysis": combined_text[:1000]
+                }
+            
+            return parsed, combined_text
+            
+        except Exception as e:
+            logger.warning("VLM space %s failed: %s", config["space"], str(e))
+            last_error = e
+            continue
     
-    return parsed, combined_text
+    # All configs failed
+    logger.error("All VLM spaces failed. Last error: %s", str(last_error))
+    raise RuntimeError(f"All VLM spaces failed. Last error: {last_error}")
 
 def get_fallback_risk_assessment(vlm_output: Any, reason: str = "LLM unavailable") -> Dict[str, Any]:
     """Generate basic risk assessment from VLM output when LLM is unavailable"""
     logger.warning("Using fallback risk assessment: %s", reason)
     
-    # Try to extract basic info from VLM output
     vlm_dict = {}
     if isinstance(vlm_output, dict):
         vlm_dict = vlm_output
@@ -399,7 +442,6 @@ def get_fallback_risk_assessment(vlm_output: Any, reason: str = "LLM unavailable
         except Exception:
             pass
     
-    # Check if VLM data is empty/invalid
     has_data = bool(vlm_dict and any(vlm_dict.values()))
     
     if not has_data:
@@ -417,14 +459,13 @@ def get_fallback_risk_assessment(vlm_output: Any, reason: str = "LLM unavailable
             "fallback_reason": "no_vlm_data"
         }
     
-    # Basic heuristic risk scoring based on VLM features
-    risk_score = 20.0  # Conservative default
+    # Basic heuristic risk scoring
+    risk_score = 20.0
     jaundice_prob = 0.0
     anemia_prob = 0.0
     hydration_prob = 0.0
     neuro_prob = 0.0
     
-    # Extract VLM features if available
     sclera_yellow = vlm_dict.get("sclera_yellowness", 0)
     pallor = vlm_dict.get("pallor_score", 0)
     redness = vlm_dict.get("redness", 0)
@@ -461,17 +502,14 @@ def call_llm(vlm_output: Any, use_fallback_on_error: bool = True) -> Dict[str, A
             return get_fallback_risk_assessment(vlm_output, reason="gradio_not_available")
         raise RuntimeError("gradio_client not installed")
     
-    # Check if VLM output is empty/useless
     vlm_text = vlm_output if isinstance(vlm_output, str) else json.dumps(vlm_output, default=str)
     
-    # Detect empty or minimal VLM output
     if not vlm_text or vlm_text.strip() in ["{}", "[]", ""]:
         logger.warning("VLM output is empty, using fallback assessment")
         if use_fallback_on_error:
             return get_fallback_risk_assessment(vlm_output, reason="empty_vlm_output")
         raise RuntimeError("VLM output is empty")
     
-    # Prepare input
     instruction = (
         "\n\nSTRICT INSTRUCTIONS:\n"
         "1) OUTPUT ONLY a single valid JSON object — no prose, no code fences.\n"
@@ -483,7 +521,6 @@ def call_llm(vlm_output: Any, use_fallback_on_error: bool = True) -> Dict[str, A
         "VLM Output:\n" + vlm_text + "\n"
     )
     
-    # Call with safe defaults
     try:
         client = get_gradio_client(LLM_GRADIO_SPACE)
         logger.info("Calling LLM Space: %s", LLM_GRADIO_SPACE)
@@ -508,7 +545,6 @@ def call_llm(vlm_output: Any, use_fallback_on_error: bool = True) -> Dict[str, A
         parsed = extract_json_from_llm_output(text_out)
         logger.info("LLM parsed JSON:\n%s", json.dumps(parsed, indent=2))
         
-        # Check if LLM returned essentially empty results
         all_zero = all(
             parsed.get(k, 0) == 0 
             for k in ["jaundice_probability", "anemia_probability", 
@@ -516,7 +552,7 @@ def call_llm(vlm_output: Any, use_fallback_on_error: bool = True) -> Dict[str, A
         )
         
         if all_zero and parsed.get("risk_score", 0) == 0:
-            logger.warning("LLM returned all-zero assessment, likely due to poor VLM input")
+            logger.warning("LLM returned all-zero assessment")
             parsed["summary"] = "Image analysis incomplete. Please ensure photos are clear and well-lit."
             parsed["recommendation"] = "Retake photos with face clearly visible and eyes open."
             parsed["confidence"] = 0.1
@@ -555,7 +591,6 @@ async def process_screening(screening_id: str):
         face_path = entry["face_image_path"]
         eye_path = entry["eye_image_path"]
         
-        # Load images and get quality metrics
         face_img = Image.open(face_path).convert("RGB")
         detection_result = detect_face_and_eyes(face_img)
         
@@ -579,7 +614,6 @@ async def process_screening(screening_id: str):
         llm_input = vlm_raw if vlm_raw else (vlm_features if vlm_features else "{}")
         structured_risk = await asyncio.to_thread(call_llm, llm_input, use_fallback_on_error=True)
         
-        # Store results
         screenings_db[screening_id]["ai_results"] = {
             "vlm_features": vlm_features,
             "vlm_raw": vlm_raw,
@@ -587,7 +621,6 @@ async def process_screening(screening_id: str):
             "processing_time_ms": 1200
         }
         
-        # Build disease predictions
         disease_predictions = [
             {
                 "condition": "Anemia-like-signs",
@@ -624,7 +657,7 @@ async def process_screening(screening_id: str):
             screenings_db[screening_id]["error"] = str(e)
 
 # ============================================================================
-# FastAPI App & Routes
+# FastAPI App & Routes (REST OF THE CODE REMAINS THE SAME)
 # ============================================================================
 app = FastAPI(title="Elderly HealthWatch AI Backend")
 app.add_middleware(
@@ -637,7 +670,11 @@ app.add_middleware(
 
 @app.get("/")
 async def read_root():
-    return {"message": "Elderly HealthWatch AI Backend - Using Qwen2.5-VL"}
+    return {
+        "message": "Elderly HealthWatch AI Backend - Using Qwen2.5-VL",
+        "active_vlm": active_vlm_config["space"] if active_vlm_config else "Not yet determined",
+        "available_vlm_spaces": [c["space"] for c in VLM_SPACES]
+    }
 
 @app.get("/health")
 async def health_check():
@@ -665,8 +702,8 @@ async def health_check():
         "status": "healthy",
         "detector": detector_type or "none",
         "vlm_available": GRADIO_AVAILABLE,
-        "vlm_space": GRADIO_VLM_SPACE,
-        "vlm_model": VLM_MODEL_ID,
+        "active_vlm_space": active_vlm_config["space"] if active_vlm_config else "Not yet determined",
+        "available_vlm_spaces": [c["space"] for c in VLM_SPACES],
         "llm_space": LLM_GRADIO_SPACE,
         "llm_status": llm_status,
         "llm_message": llm_message,
@@ -797,21 +834,25 @@ async def get_history(user_id: str):
 async def debug_spaces():
     """Debug endpoint to test VLM and LLM spaces"""
     results = {
-        "vlm": {"available": False, "error": None},
+        "vlm_spaces": [],
         "llm": {"available": False, "error": None}
     }
     
+    # Test each VLM space
     if GRADIO_AVAILABLE:
-        try:
-            client = get_gradio_client(GRADIO_VLM_SPACE)
-            results["vlm"]["available"] = True
-            results["vlm"]["space"] = GRADIO_VLM_SPACE
-            results["vlm"]["model"] = VLM_MODEL_ID
-        except Exception as e:
-            results["vlm"]["error"] = str(e)
+        for config in VLM_SPACES:
+            space_result = {"space": config["space"], "available": False, "error": None}
+            try:
+                client = get_gradio_client(config["space"])
+                space_result["available"] = True
+                space_result["config"] = config
+            except Exception as e:
+                space_result["error"] = str(e)
+            results["vlm_spaces"].append(space_result)
     else:
-        results["vlm"]["error"] = "Gradio not installed"
+        results["vlm_error"] = "Gradio not installed"
     
+    # Test LLM
     if GRADIO_AVAILABLE:
         try:
             client = get_gradio_client(LLM_GRADIO_SPACE)
@@ -822,6 +863,7 @@ async def debug_spaces():
     else:
         results["llm"]["error"] = "Gradio not installed"
     
+    results["active_vlm"] = active_vlm_config
     return results
 
 @app.post("/api/v1/get-vitals")
@@ -857,7 +899,8 @@ async def get_vitals_from_upload(
             "vlm_features": vlm_features,
             "vlm_raw": vlm_raw,
             "structured_risk": structured_risk,
-            "using_fallback": structured_risk.get("fallback_mode", False)
+            "using_fallback": structured_risk.get("fallback_mode", False),
+            "vlm_space_used": active_vlm_config["space"] if active_vlm_config else "unknown"
         }
         
     except Exception as e:
@@ -898,7 +941,8 @@ async def get_vitals_for_screening(screening_id: str):
             "vlm_raw": vlm_raw,
             "structured_risk": structured_risk,
             "last_vitals_run": datetime.utcnow().isoformat() + "Z",
-            "using_fallback": structured_risk.get("fallback_mode", False)
+            "using_fallback": structured_risk.get("fallback_mode", False),
+            "vlm_space_used": active_vlm_config["space"] if active_vlm_config else "unknown"
         })
         
         return {
@@ -906,7 +950,8 @@ async def get_vitals_for_screening(screening_id: str):
             "vlm_features": vlm_features,
             "vlm_raw": vlm_raw,
             "structured_risk": structured_risk,
-            "using_fallback": structured_risk.get("fallback_mode", False)
+            "using_fallback": structured_risk.get("fallback_mode", False),
+            "vlm_space_used": active_vlm_config["space"] if active_vlm_config else "unknown"
         }
         
     except Exception as e: