Upload app.py with huggingface_hub

app.py

@@ -4,14 +4,29 @@ Main Gradio Application for MedGemma Impact Challenge
 
 This application demonstrates a multi-agent system for chest X-ray analysis
 using Google's Health AI Developer Foundations (HAI-DEF) models.
+
+Now with REAL MedGemma inference via MLX (local) or ZeroGPU (HuggingFace).
 """
 
+import os
 import gradio as gr
 from PIL import Image
 import time
 from typing import Optional, Tuple, List, Dict
 import json
 
+# Try to import spaces for ZeroGPU on HuggingFace
+try:
+    import spaces
+    SPACES_AVAILABLE = True
+except ImportError:
+    SPACES_AVAILABLE = False
+    # Create a dummy decorator
+    class spaces:
+        @staticmethod
+        def GPU(func):
+            return func
+
 # Import our modules
 from orchestrator import RadioFlowOrchestrator, WorkflowResult, create_orchestrator
 from utils.visualization import (
@@ -21,18 +36,49 @@ from utils.visualization import (
     create_timeline_chart
 )
 
+# Check if we're on HuggingFace Spaces with ZeroGPU
+IS_SPACES = os.environ.get("SPACE_ID") is not None
+USE_ZEROGPU = IS_SPACES and os.environ.get("ZEROGPU_ENABLED") == "true"
+
+# Determine if we should use demo mode
+# - Local with MLX: Use real model (demo_mode=False)
+# - HuggingFace without GPU: Use demo mode (demo_mode=True) 
+# - HuggingFace with ZeroGPU: Use real model (demo_mode=False)
+FORCE_DEMO_MODE = os.environ.get("FORCE_DEMO_MODE", "false").lower() == "true"
+
 # Global orchestrator instance
 orchestrator: Optional[RadioFlowOrchestrator] = None
+engine_status = "Not initialized"
 
 
 def initialize_system():
-    """Initialize the RadioFlow system."""
-    global orchestrator
+    """Initialize the RadioFlow system with real MedGemma."""
+    global orchestrator, engine_status
+    
     if orchestrator is None:
-        orchestrator = create_orchestrator(demo_mode=True)
-    return "✅ RadioFlow System Initialized"
+        # Try to use real model, fall back to demo if needed
+        demo_mode = FORCE_DEMO_MODE
+        
+        try:
+            # Try to load the MedGemma engine first
+            from agents.medgemma_engine import get_engine
+            engine = get_engine(force_demo=demo_mode)
+            engine_status = f"MedGemma: {engine.backend}"
+            
+            # Only use demo mode if engine is in demo mode
+            if engine.backend == "demo":
+                demo_mode = True
+        except Exception as e:
+            print(f"Could not initialize MedGemma engine: {e}")
+            engine_status = "Demo mode (engine failed)"
+            demo_mode = True
+        
+        orchestrator = create_orchestrator(demo_mode=demo_mode)
+        
+    return f"✅ RadioFlow System Initialized ({engine_status})"
 
 
+@spaces.GPU(duration=120)  # Request GPU for up to 2 minutes per inference
 def process_xray(
     image: Optional[Image.Image],
     clinical_history: str,
@@ -42,6 +88,7 @@ def process_xray(
 ) -> Tuple[str, str, str, str, str, dict, dict, dict]:
     """
     Process a chest X-ray through the RadioFlow pipeline.
+    Uses real MedGemma inference with GPU acceleration.
     
     Returns:
         Tuple of (report, priority_html, findings_json, metrics, status,