app.py

app.py

@@ -70,8 +70,22 @@ try:
         logging.info("Successfully imported create_app and initialize_agents")
     
     # Create the app instance
-    app = create_app()
-    logging.info("App instance created successfully")
+    try:
+        app = create_app()
+        logging.info("App instance created successfully")
+    except Exception as e:
+        logging.error(f"Failed to create app: {e}")
+        # Create minimal fallback app
+        from fastapi import FastAPI
+        app = FastAPI(title="Medical AI Service (fallback)")
+        
+        @app.get("/")
+        async def root():
+            return {"message": "Medical AI Service - Fallback mode", "error": str(e)}
+        
+        @app.get("/health")
+        async def health():
+            return {"status": "degraded", "message": "App creation failed", "error": str(e)}
     
     # Initialize agents with minimal preloading for Hugging Face Spaces
     try:
@@ -178,3 +192,17 @@ if app is None:
 
 # Export the app for Hugging Face Spaces
 __all__ = ["app"]
+
+# Ensure the app is available at module level
+if 'app' not in locals():
+    logging.error("No app instance created, creating emergency fallback...")
+    from fastapi import FastAPI
+    app = FastAPI(title="Medical AI Service (emergency fallback)")
+    
+    @app.get("/")
+    async def root():
+        return {"message": "Emergency fallback mode", "status": "error"}
+    
+    @app.get("/health")
+    async def health():
+        return {"status": "error", "message": "Emergency fallback mode"}

services/ai-service/src/ai_med_extract/app.py

@@ -14,7 +14,19 @@ from .api_middleware import SecurityHeadersMiddleware
 from .scalable_service_mesh import ScalableServiceMesh, initialize_scalable_mesh, scalable_lifespan
 from .database_audit import initialize_db_audit_logger
 from .monitoring_observability import initialize_monitoring
-from .utils.model_manager import model_manager
+
+# Import model_manager with error handling
+try:
+    from .utils.model_manager import model_manager
+except ImportError as e:
+    logging.warning(f"Failed to import model_manager: {e}")
+    # Create a fallback model manager
+    class FallbackModelManager:
+        def get_model_loader(self, *args, **kwargs):
+            return None
+        def generate_text(self, *args, **kwargs):
+            return "Model not available"
+    model_manager = FallbackModelManager()
 
 # Ensure reasonable default for thread usage
 torch.set_num_threads(1)
@@ -71,11 +83,16 @@ async def lifespan(app: FastAPI):
         service_mesh = None
         if redis_client:
             try:
-                service_mesh = await initialize_scalable_mesh(model_manager, redis_client, {
-                    'database_url': database_url,
-                    'audit_logger': db_audit_logger
-                })
-                logging.info("Scalable service mesh initialized successfully")
+                # Check if model_manager is available before using it
+                if hasattr(model_manager, 'get_model_loader'):
+                    service_mesh = await initialize_scalable_mesh(model_manager, redis_client, {
+                        'database_url': database_url,
+                        'audit_logger': db_audit_logger
+                    })
+                    logging.info("Scalable service mesh initialized successfully")
+                else:
+                    logging.warning("Model manager not available, skipping service mesh initialization")
+                    service_mesh = None
             except Exception as e:
                 logging.warning(f"Scalable service mesh initialization failed: {e}")
                 service_mesh = None
@@ -403,13 +420,62 @@ def initialize_agents(app: FastAPI, *, preload_small_models: bool = True):
 
     If preload_small_models is False, agents will be created using lazy/fallback loaders only.
     """
-    # Local imports to avoid heavy work at module import time
-    from .agents.text_extractor import TextExtractorAgent
-    from .agents.phi_scrubber import PHIScrubberAgent
-    from .agents.summarizer import SummarizerAgent
-    from .agents.medical_data_extractor import MedicalDataExtractorAgent
-    from .agents.patient_summary_agent import PatientSummarizerAgent
-    from .utils.model_manager import model_manager
+    try:
+        # Local imports to avoid heavy work at module import time
+        from .agents.text_extractor import TextExtractorAgent
+        from .agents.phi_scrubber import PHIScrubberAgent
+        from .agents.summarizer import SummarizerAgent
+        from .agents.medical_data_extractor import MedicalDataExtractorAgent
+        from .agents.patient_summary_agent import PatientSummarizerAgent
+        
+        # Import model_manager with error handling
+        try:
+            from .utils.model_manager import model_manager
+        except ImportError as e:
+            logging.warning(f"Failed to import model_manager in initialize_agents: {e}")
+            # Create a fallback model manager
+            class FallbackModelManager:
+                def get_model_loader(self, *args, **kwargs):
+                    return None
+                def generate_text(self, *args, **kwargs):
+                    return "Model not available"
+            model_manager = FallbackModelManager()
+    except Exception as e:
+        logging.error(f"Failed to import agents: {e}")
+        # Create minimal fallback agents
+        class MinimalTextExtractor:
+            def extract_text(self, *args, **kwargs):
+                return "Text extraction not available"
+        
+        class MinimalPHIScrubber:
+            def scrub_phi(self, *args, **kwargs):
+                return "PHI scrubbing not available"
+        
+        class MinimalSummarizer:
+            def generate(self, *args, **kwargs):
+                return "Summarization not available"
+        
+        class MinimalMedicalExtractor:
+            def generate(self, *args, **kwargs):
+                return "Medical extraction not available"
+        
+        class MinimalPatientSummarizer:
+            def generate(self, *args, **kwargs):
+                return "Patient summarization not available"
+        
+        class FallbackModelManager:
+            def get_model_loader(self, *args, **kwargs):
+                return None
+            def generate_text(self, *args, **kwargs):
+                return "Model not available"
+        
+        # Use fallback classes
+        TextExtractorAgent = MinimalTextExtractor
+        PHIScrubberAgent = MinimalPHIScrubber
+        SummarizerAgent = MinimalSummarizer
+        MedicalDataExtractorAgent = MinimalMedicalExtractor
+        PatientSummarizerAgent = MinimalPatientSummarizer
+        model_manager = FallbackModelManager()
 
     # Initialize lightweight agents
     text_extractor_agent = TextExtractorAgent()
@@ -543,13 +609,25 @@ def initialize_agents(app: FastAPI, *, preload_small_models: bool = True):
             print(f"[GGUF] Preload failed (non-fatal): {e}")
 
     # Register routes only after agents are prepared
-    from .api.routes_fastapi import register_routes
-    from .health_endpoints import router as health_router
+    try:
+        from .api.routes_fastapi import register_routes
+        from .health_endpoints import router as health_router
 
-    register_routes(app, agents)
-    app.include_router(health_router, prefix="/health")
+        register_routes(app, agents)
+        app.include_router(health_router, prefix="/health")
 
-    logging.info("Agents initialized and routes registered")
+        logging.info("Agents initialized and routes registered")
+    except Exception as e:
+        logging.error(f"Failed to register routes: {e}")
+        # Add basic health endpoint as fallback
+        @app.get("/health")
+        async def basic_health():
+            return {"status": "degraded", "message": "Routes not fully registered", "error": str(e)}
+        
+        @app.get("/")
+        async def root():
+            return {"message": "Medical AI Service - Limited functionality", "status": "degraded"}
+    
     # Mark the app as ready for readiness checks
     try:
         app._is_ready = True