✅ Application imports successfully ✅ App instance creates without errors ✅ All agents initialize properly ✅ Routes register correctly ✅ No memory leaks or hanging operations

app.py

@@ -43,31 +43,16 @@ os.environ.setdefault("MKL_NUM_THREADS", "1")
 # Create a robust app instance with multiple fallback strategies
 app = None
 
-# Strategy 1: Try to import from ai_med_extract package
+# Simplified import strategy with better error handling
 try:
     logging.info("Attempting to import from ai_med_extract package...")
     logging.info(f"Python path: {sys.path[:3]}")
     logging.info(f"Current working directory: {os.getcwd()}")
     logging.info(f"Files in current directory: {os.listdir('.')}")
     
-    # Import with explicit path handling for better linter support
-    
-    # Try to load the module dynamically to avoid linter warnings
-    ai_med_extract_app_path = os.path.join(src_dir, "ai_med_extract", "app.py")
-    if os.path.exists(ai_med_extract_app_path):
-        spec = importlib.util.spec_from_file_location("ai_med_extract.app", ai_med_extract_app_path)
-        if spec and spec.loader:
-            ai_med_extract_app = importlib.util.module_from_spec(spec)
-            spec.loader.exec_module(ai_med_extract_app)
-            create_app = ai_med_extract_app.create_app
-            initialize_agents = ai_med_extract_app.initialize_agents
-            logging.info("Successfully imported create_app and initialize_agents via dynamic import")
-        else:
-            raise ImportError("Could not load ai_med_extract.app module")
-    else:
-        # Fallback to regular import
-        from ai_med_extract.app import create_app, initialize_agents  # type: ignore
-        logging.info("Successfully imported create_app and initialize_agents")
+    # Direct import approach - simpler and more reliable
+    from ai_med_extract.app import create_app, initialize_agents  # type: ignore
+    logging.info("Successfully imported create_app and initialize_agents")
     
     # Create the app instance
     try:
@@ -104,69 +89,30 @@ except Exception as e:
     import traceback
     logging.error(f"Full traceback: {traceback.format_exc()}")
     
-    # Strategy 2: Try direct import from the nested structure
-    try:
-        logging.info("Attempting direct import from nested structure...")
-        # Add the specific path to ai_med_extract
-        ai_med_extract_path = os.path.join(src_dir, "ai_med_extract")
-        if ai_med_extract_path not in sys.path:
-            sys.path.insert(0, ai_med_extract_path)
-        
-        logging.info(f"Added ai_med_extract_path to sys.path: {ai_med_extract_path}")
-        logging.info(f"Files in ai_med_extract directory: {os.listdir(ai_med_extract_path) if os.path.exists(ai_med_extract_path) else 'Directory not found'}")
-        
-        # Try dynamic import for the nested structure as well
-        ai_med_extract_app_path = os.path.join(ai_med_extract_path, "app.py")
-        if os.path.exists(ai_med_extract_app_path):
-            spec = importlib.util.spec_from_file_location("ai_med_extract.app", ai_med_extract_app_path)
-            if spec and spec.loader:
-                ai_med_extract_app = importlib.util.module_from_spec(spec)
-                spec.loader.exec_module(ai_med_extract_app)
-                create_app = ai_med_extract_app.create_app
-                initialize_agents = ai_med_extract_app.initialize_agents
-                logging.info("Successfully imported via dynamic import from nested structure")
-            else:
-                from ai_med_extract.app import create_app, initialize_agents  # type: ignore
-        else:
-            from ai_med_extract.app import create_app, initialize_agents  # type: ignore
-        
-        app = create_app()
-        
-        try:
-            initialize_agents(app, preload_small_models=False)
-            logging.info("Agents initialized successfully via direct import")
-        except Exception as e:
-            logging.warning(f"Agent initialization failed via direct import: {e}")
-            
-    except Exception as e:
-        logging.error(f"Direct import also failed: {e}")
-        import traceback
-        logging.error(f"Direct import traceback: {traceback.format_exc()}")
-        
-        # Strategy 3: Create a minimal FastAPI app as final fallback
-        logging.info("Creating 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),
-                "status": "degraded"
-            }
-        
-        @app.get("/health")
-        async def health():
-            return {"status": "degraded", "message": "Fallback mode active"}
-        
-        @app.get("/docs")
-        async def docs():
-            return {"message": "API documentation not available in fallback mode"}
-        
-        @app.get("/redoc")
-        async def redoc():
-            return {"message": "ReDoc not available in fallback mode"}
+    # Create a minimal FastAPI app as fallback
+    logging.info("Creating 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),
+            "status": "degraded"
+        }
+    
+    @app.get("/health")
+    async def health():
+        return {"status": "degraded", "message": "Fallback mode active"}
+    
+    @app.get("/docs")
+    async def docs():
+        return {"message": "API documentation not available in fallback mode"}
+    
+    @app.get("/redoc")
+    async def redoc():
+        return {"message": "ReDoc not available in fallback mode"}
 
 # Ensure we have an app instance
 if app is None:

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

@@ -50,16 +50,18 @@ async def lifespan(app: FastAPI):
     redis_client = None
     db_audit_logger = None
     service_mesh = None
+    monitoring = None
 
     try:
-        # Initialize Redis (optional)
+        # Initialize Redis (optional) - with timeout to prevent hanging
         redis_url = os.getenv('REDIS_URL', 'redis://localhost:6379/0')
         redis_client = None
 
         try:
-            redis_client = redis.from_url(redis_url, decode_responses=True)
-            # Test Redis connection
-            await redis_client.ping()
+            import asyncio
+            redis_client = redis.from_url(redis_url, decode_responses=True, socket_timeout=5, socket_connect_timeout=5)
+            # Test Redis connection with timeout
+            await asyncio.wait_for(redis_client.ping(), timeout=5.0)
             logging.info("Redis connected successfully")
         except Exception as redis_error:
             logging.warning(f"Redis connection failed: {redis_error}")
@@ -205,10 +207,20 @@ def create_app(config: dict = None, initialize: bool = True) -> FastAPI:
         os.environ.setdefault(env_var, path)
         os.makedirs(path, exist_ok=True)
 
-    # Global exception handler
+    # Global exception handler with memory cleanup
     @app.exception_handler(Exception)
     async def global_exception_handler(request, exc):
         logging.error(f"Unhandled error: {str(exc)}", exc_info=True)
+        
+        # Clean up memory on errors
+        try:
+            import gc
+            gc.collect()
+            if torch.cuda.is_available():
+                torch.cuda.empty_cache()
+        except Exception:
+            pass
+        
         return JSONResponse(
             status_code=500,
             content={"error": str(exc), "status": "error"}
@@ -494,12 +506,17 @@ def initialize_agents(app: FastAPI, *, preload_small_models: bool = True):
             summ_loader = model_manager.get_model_loader(_mc.get_default_model("summarization"), "summarization")
             summarizer_agent = SummarizerAgent(summ_loader)
             logging.info("SummarizerAgent initialized with bart-base")
-        except Exception:
+        except Exception as e:
+            logging.warning(f"Failed to load summarization model: {e}")
             from .utils.model_loader_gguf import create_fallback_pipeline
 
             class FallbackSummarizer:
                 def generate(self, text, **kwargs):
-                    return create_fallback_pipeline().generate_full_summary(text)
+                    try:
+                        return create_fallback_pipeline().generate_full_summary(text)
+                    except Exception as fallback_error:
+                        logging.error(f"Fallback summarizer failed: {fallback_error}")
+                        return f"Summarization failed: {str(fallback_error)}"
 
             summarizer_agent = SummarizerAgent(FallbackSummarizer())
 
@@ -508,12 +525,17 @@ def initialize_agents(app: FastAPI, *, preload_small_models: bool = True):
             med_generator = med_loader.load()
             medical_data_extractor_agent = MedicalDataExtractorAgent(med_generator)
             logging.info("MedicalDataExtractorAgent initialized with distilgpt2")
-        except Exception:
+        except Exception as e:
+            logging.warning(f"Failed to load medical extraction model: {e}")
             from .utils.model_loader_gguf import create_fallback_pipeline
 
             class FallbackExtractor:
                 def generate(self, prompt, **kwargs):
-                    return create_fallback_pipeline().generate(prompt)
+                    try:
+                        return create_fallback_pipeline().generate(prompt)
+                    except Exception as fallback_error:
+                        logging.error(f"Fallback extractor failed: {fallback_error}")
+                        return f"Medical extraction failed: {str(fallback_error)}"
 
             medical_data_extractor_agent = MedicalDataExtractorAgent(FallbackExtractor())
 
@@ -619,6 +641,9 @@ def initialize_agents(app: FastAPI, *, preload_small_models: bool = True):
         logging.info("Agents initialized and routes registered")
     except Exception as e:
         logging.error(f"Failed to register routes: {e}")
+        import traceback
+        logging.error(f"Route registration traceback: {traceback.format_exc()}")
+        
         # Add basic health endpoint as fallback
         @app.get("/health")
         async def basic_health():
@@ -627,6 +652,14 @@ def initialize_agents(app: FastAPI, *, preload_small_models: bool = True):
         @app.get("/")
         async def root():
             return {"message": "Medical AI Service - Limited functionality", "status": "degraded"}
+        
+        @app.get("/docs")
+        async def docs():
+            return {"message": "API documentation not available in degraded mode"}
+        
+        @app.get("/redoc")
+        async def redoc():
+            return {"message": "ReDoc not available in degraded mode"}
     
     # Mark the app as ready for readiness checks
     try: