Update app/fastapi_server.py

Restoring previous working version

app/fastapi_server.py

@@ -1,5 +1,3 @@
-# Enhanced app/fastapi_server.py with LightGBM ensemble support
-
 import json
 import time
 import joblib
@@ -26,13 +24,6 @@ from fastapi.middleware.trustedhost import TrustedHostMiddleware
 from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
 from fastapi import FastAPI, HTTPException, Depends, Request, BackgroundTasks, status
 
-# LightGBM availability check
-try:
-    import lightgbm as lgb
-    LIGHTGBM_AVAILABLE = True
-except ImportError:
-    LIGHTGBM_AVAILABLE = False
-
 from data.data_validator import (
     DataValidationPipeline, validate_text, validate_articles_list, 
     get_validation_stats, generate_quality_report
@@ -48,10 +39,12 @@ from deployment.traffic_router import TrafficRouter
 from deployment.model_registry import ModelRegistry
 from deployment.blue_green_manager import BlueGreenDeploymentManager
 
-# Import the path manager
+
+# Import the new path manager
 try:
     from path_config import path_manager
 except ImportError:
+    # Fallback for development environments
     import sys
     import os
     sys.path.append(os.path.dirname(os.path.abspath(__file__)))
@@ -60,21 +53,26 @@ except ImportError:
 # Configure logging with fallback for permission issues
 def setup_logging():
     """Setup logging with fallback for environments with restricted file access"""
-    handlers = [logging.StreamHandler()]
+    handlers = [logging.StreamHandler()]  # Always include console output
     
     try:
+        # Try to create log file in the logs directory
         log_file_path = path_manager.get_logs_path('fastapi_server.log')
         log_file_path.parent.mkdir(parents=True, exist_ok=True)
         
+        # Test if we can write to the file
         test_handler = logging.FileHandler(log_file_path)
         test_handler.close()
         
+        # If successful, add file handler
         handlers.append(logging.FileHandler(log_file_path))
-        print(f"Logging to file: {log_file_path}")
+        print(f"Logging to file: {log_file_path}")  # Use print instead of logger
         
     except (PermissionError, OSError) as e:
+        # If file logging fails, just use console logging
         print(f"Cannot create log file, using console only: {e}")
         
+        # Try alternative locations for file logging
         try:
             import tempfile
             temp_log = tempfile.NamedTemporaryFile(mode='w', suffix='.log', delete=False, prefix='fastapi_')
@@ -86,7 +84,7 @@ def setup_logging():
     
     return handlers
 
-# Setup logging
+# Setup logging with error handling
 logging.basicConfig(
     level=logging.INFO,
     format='%(asctime)s - %(levelname)s - %(message)s',
@@ -94,7 +92,7 @@ logging.basicConfig(
 )
 logger = logging.getLogger(__name__)
 
-# Log environment info
+# Now that logger is defined, log the environment info
 try:
     path_manager.log_environment_info()
 except Exception as e:
@@ -107,86 +105,49 @@ security = HTTPBearer(auto_error=False)
 rate_limit_storage = defaultdict(list)
 
 
-class EnhancedModelManager:
-    """Enhanced model manager with LightGBM ensemble support"""
+class ModelManager:
+    """Manages model loading and health checks with dynamic paths"""
 
     def __init__(self):
         self.model = None
         self.vectorizer = None
         self.pipeline = None
-        self.ensemble = None
         self.model_metadata = {}
-        self.ensemble_metadata = {}
         self.last_health_check = None
         self.health_status = "unknown"
-        self.model_type = "unknown"
-        self.is_ensemble = False
         self.load_model()
 
     def load_model(self):
-        """Load model with comprehensive error handling and ensemble support"""
+        """Load model with comprehensive error handling and dynamic paths"""
         try:
-            logger.info("Loading ML model with ensemble support...")
+            logger.info("Loading ML model...")
 
             # Initialize all to None first
             self.model = None
             self.vectorizer = None
             self.pipeline = None
-            self.ensemble = None
-            self.is_ensemble = False
 
-            # Check for ensemble model first
-            ensemble_path = Path("/tmp/ensemble.pkl")
-            ensemble_metadata_path = Path("/tmp/ensemble_metadata.json")
+            # Try to load pipeline first (preferred)
+            pipeline_path = path_manager.get_pipeline_path()
+            logger.info(f"Checking for pipeline at: {pipeline_path}")
             
-            if ensemble_path.exists():
+            if pipeline_path.exists():
                 try:
-                    self.ensemble = joblib.load(ensemble_path)
-                    self.pipeline = self.ensemble  # Use ensemble as pipeline
-                    self.model_type = "ensemble"
-                    self.is_ensemble = True
-                    
-                    # Load ensemble metadata
-                    if ensemble_metadata_path.exists():
-                        with open(ensemble_metadata_path, 'r') as f:
-                            self.ensemble_metadata = json.load(f)
-                        logger.info(f"Loaded ensemble metadata: {self.ensemble_metadata.get('ensemble_type', 'unknown')}")
-                    
-                    logger.info("Loaded ensemble model successfully")
-                    logger.info(f"Ensemble type: {self.ensemble_metadata.get('ensemble_type', 'voting_classifier')}")
-                    logger.info(f"Component models: {self.ensemble_metadata.get('component_models', [])}")
-                    
+                    self.pipeline = joblib.load(pipeline_path)
+                    # Extract components from pipeline
+                    if hasattr(self.pipeline, 'named_steps'):
+                        self.model = self.pipeline.named_steps.get('model')
+                        self.vectorizer = (self.pipeline.named_steps.get('vectorizer') or 
+                                         self.pipeline.named_steps.get('vectorize'))
+                    logger.info("Loaded model pipeline successfully")
+                    logger.info(f"Pipeline steps: {list(self.pipeline.named_steps.keys()) if hasattr(self.pipeline, 'named_steps') else 'No named_steps'}")
                 except Exception as e:
-                    logger.warning(f"Failed to load ensemble model: {e}, falling back to individual pipeline")
-                    self.ensemble = None
-
-            # Try to load pipeline if ensemble not available
-            if self.pipeline is None:
-                pipeline_path = path_manager.get_pipeline_path()
-                logger.info(f"Checking for pipeline at: {pipeline_path}")
-                
-                if pipeline_path.exists():
-                    try:
-                        self.pipeline = joblib.load(pipeline_path)
-                        # Extract components from pipeline
-                        if hasattr(self.pipeline, 'named_steps'):
-                            self.model = self.pipeline.named_steps.get('model')
-                            self.vectorizer = (self.pipeline.named_steps.get('vectorizer') or 
-                                             self.pipeline.named_steps.get('vectorize'))
-                            
-                            # Check if this is actually an ensemble pipeline
-                            if 'ensemble' in self.pipeline.named_steps:
-                                self.model_type = "ensemble_pipeline"
-                                self.is_ensemble = True
-                                logger.info("Detected ensemble within pipeline")
-                            
-                        logger.info("Loaded model pipeline successfully")
-                        logger.info(f"Pipeline steps: {list(self.pipeline.named_steps.keys()) if hasattr(self.pipeline, 'named_steps') else 'No named_steps'}")
-                    except Exception as e:
-                        logger.warning(f"Failed to load pipeline: {e}, falling back to individual components")
-                        self.pipeline = None
+                    logger.warning(f"Failed to load pipeline: {e}, falling back to individual components")
+                    self.pipeline = None
+            else:
+                logger.info(f"Pipeline file not found at {pipeline_path}")
 
-            # If pipeline loading failed, load individual components
+            # If pipeline loading failed or doesn't exist, load individual components
             if self.pipeline is None:
                 model_path = path_manager.get_model_file_path()
                 vectorizer_path = path_manager.get_vectorizer_path()
@@ -198,52 +159,35 @@ class EnhancedModelManager:
                     try:
                         self.model = joblib.load(model_path)
                         self.vectorizer = joblib.load(vectorizer_path)
-                        self.model_type = "individual_components"
                         logger.info("Loaded model components successfully")
                     except Exception as e:
                         logger.error(f"Failed to load individual components: {e}")
                         raise e
                 else:
-                    raise FileNotFoundError(f"No model files found")
+                    raise FileNotFoundError(f"No model files found. Checked:\n- {pipeline_path}\n- {model_path}\n- {vectorizer_path}")
+
+            # Verify we have what we need for predictions
+            if self.pipeline is None and (self.model is None or self.vectorizer is None):
+                raise ValueError("Neither complete pipeline nor individual model components are available")
 
             # Load metadata
             metadata_path = path_manager.get_metadata_path()
             if metadata_path.exists():
                 with open(metadata_path, 'r') as f:
                     self.model_metadata = json.load(f)
-                
-                # Update model type and ensemble status from metadata
-                if self.model_metadata.get('is_ensemble', False):
-                    self.is_ensemble = True
-                    if not self.model_type.startswith('ensemble'):
-                        self.model_type = "ensemble_from_metadata"
-                
                 logger.info(f"Loaded model metadata: {self.model_metadata.get('model_version', 'Unknown')}")
-                logger.info(f"Model type from metadata: {self.model_metadata.get('model_type', 'unknown')}")
-                logger.info(f"Is ensemble: {self.is_ensemble}")
-                
-                if self.is_ensemble and 'ensemble_details' in self.model_metadata:
-                    ensemble_details = self.model_metadata['ensemble_details']
-                    logger.info(f"Ensemble details: {ensemble_details}")
             else:
                 logger.warning(f"Metadata file not found at: {metadata_path}")
                 self.model_metadata = {"model_version": "unknown"}
 
-            # Verify we have what we need for predictions
-            if self.pipeline is None and (self.model is None or self.vectorizer is None):
-                raise ValueError("Neither complete pipeline nor individual model components are available")
-
             self.health_status = "healthy"
             self.last_health_check = datetime.now()
 
             # Log what was successfully loaded
             logger.info(f"Model loading summary:")
             logger.info(f"  Pipeline available: {self.pipeline is not None}")
-            logger.info(f"  Individual model available: {self.model is not None}")
+            logger.info(f"  Model available: {self.model is not None}")
             logger.info(f"  Vectorizer available: {self.vectorizer is not None}")
-            logger.info(f"  Ensemble available: {self.ensemble is not None}")
-            logger.info(f"  Model type: {self.model_type}")
-            logger.info(f"  Is ensemble: {self.is_ensemble}")
 
         except Exception as e:
             logger.error(f"Failed to load model: {e}")
@@ -252,21 +196,15 @@ class EnhancedModelManager:
             self.model = None
             self.vectorizer = None
             self.pipeline = None
-            self.ensemble = None
 
     def predict(self, text: str) -> tuple[str, float]:
-        """Make prediction with enhanced ensemble support"""
+        """Make prediction with error handling"""
         try:
             if self.pipeline:
-                # Use pipeline for prediction (works for both ensemble and individual models)
+                # Use pipeline for prediction
                 prediction = self.pipeline.predict([text])[0]
                 probabilities = self.pipeline.predict_proba([text])[0]
-                
-                if self.is_ensemble:
-                    logger.debug("Used ensemble pipeline for prediction")
-                else:
-                    logger.debug("Used individual model pipeline for prediction")
-                    
+                logger.debug("Used pipeline for prediction")
             elif self.model and self.vectorizer:
                 # Use individual components
                 X = self.vectorizer.transform([text])
@@ -293,7 +231,7 @@ class EnhancedModelManager:
             )
 
     def health_check(self) -> Dict[str, Any]:
-        """Perform health check with ensemble information"""
+        """Perform health check"""
         try:
             # Test prediction with sample text
             test_text = "This is a test article for health check purposes."
@@ -302,44 +240,26 @@ class EnhancedModelManager:
             self.health_status = "healthy"
             self.last_health_check = datetime.now()
 
-            health_info = {
+            return {
                 "status": "healthy",
                 "last_check": self.last_health_check.isoformat(),
                 "model_available": self.model is not None,
                 "vectorizer_available": self.vectorizer is not None,
                 "pipeline_available": self.pipeline is not None,
-                "ensemble_available": self.ensemble is not None,
-                "model_type": self.model_type,
-                "is_ensemble": self.is_ensemble,
                 "test_prediction": {"label": label, "confidence": confidence},
                 "environment": path_manager.environment,
-                "lightgbm_available": LIGHTGBM_AVAILABLE,
-                "model_paths": {
-                    "pipeline": str(path_manager.get_pipeline_path()),
-                    "ensemble": "/tmp/ensemble.pkl",
-                    "model": str(path_manager.get_model_file_path()),
-                    "vectorizer": str(path_manager.get_vectorizer_path())
-                },
+                "model_path": str(path_manager.get_model_file_path()),
+                "vectorizer_path": str(path_manager.get_vectorizer_path()),
+                "pipeline_path": str(path_manager.get_pipeline_path()),
+                "data_path": str(path_manager.get_data_path()),
                 "file_exists": {
-                    "pipeline": path_manager.get_pipeline_path().exists(),
-                    "ensemble": Path("/tmp/ensemble.pkl").exists(),
                     "model": path_manager.get_model_file_path().exists(),
                     "vectorizer": path_manager.get_vectorizer_path().exists(),
-                    "metadata": path_manager.get_metadata_path().exists(),
-                    "ensemble_metadata": Path("/tmp/ensemble_metadata.json").exists()
+                    "pipeline": path_manager.get_pipeline_path().exists(),
+                    "metadata": path_manager.get_metadata_path().exists()
                 }
             }
 
-            # Add ensemble-specific information
-            if self.is_ensemble:
-                health_info["ensemble_info"] = {
-                    "ensemble_type": self.ensemble_metadata.get('ensemble_type', 'unknown'),
-                    "component_models": self.ensemble_metadata.get('component_models', []),
-                    "voting_type": self.model_metadata.get('ensemble_details', {}).get('voting_type', 'unknown')
-                }
-
-            return health_info
-
         except Exception as e:
             self.health_status = "unhealthy"
             self.last_health_check = datetime.now()
@@ -351,15 +271,21 @@ class EnhancedModelManager:
                 "model_available": self.model is not None,
                 "vectorizer_available": self.vectorizer is not None,
                 "pipeline_available": self.pipeline is not None,
-                "ensemble_available": self.ensemble is not None,
-                "model_type": self.model_type,
-                "is_ensemble": self.is_ensemble,
                 "environment": path_manager.environment,
-                "lightgbm_available": LIGHTGBM_AVAILABLE
+                "model_path": str(path_manager.get_model_file_path()),
+                "vectorizer_path": str(path_manager.get_vectorizer_path()),
+                "pipeline_path": str(path_manager.get_pipeline_path()),
+                "data_path": str(path_manager.get_data_path()),
+                "file_exists": {
+                    "model": path_manager.get_model_file_path().exists(),
+                    "vectorizer": path_manager.get_vectorizer_path().exists(),
+                    "pipeline": path_manager.get_pipeline_path().exists(),
+                    "metadata": path_manager.get_metadata_path().exists()
+                }
             }
 
 
-# Background task functions remain the same...
+# Background task functions
 async def log_prediction(text: str, prediction: str, confidence: float, client_ip: str, processing_time: float):
     """Log prediction details with error handling for file access"""
     try:
@@ -370,9 +296,7 @@ async def log_prediction(text: str, prediction: str, confidence: float, client_i
             "prediction": prediction,
             "confidence": confidence,
             "processing_time": processing_time,
-            "text_hash": hashlib.md5(text.encode()).hexdigest(),
-            "model_type": model_manager.model_type,
-            "is_ensemble": model_manager.is_ensemble
+            "text_hash": hashlib.md5(text.encode()).hexdigest()
         }
 
         # Try to save to log file
@@ -401,6 +325,7 @@ async def log_prediction(text: str, prediction: str, confidence: float, client_i
                 await f.write(json.dumps(logs, indent=2))
                 
         except (PermissionError, OSError) as e:
+            # If file logging fails, just log to console
             logger.warning(f"Cannot write prediction log to file: {e}")
             logger.info(f"Prediction logged: {json.dumps(log_entry)}")
 
@@ -408,8 +333,27 @@ async def log_prediction(text: str, prediction: str, confidence: float, client_i
         logger.error(f"Failed to log prediction: {e}")
 
 
+async def log_batch_prediction(total_texts: int, successful_predictions: int, client_ip: str, processing_time: float):
+    """Log batch prediction details"""
+    try:
+        log_entry = {
+            "timestamp": datetime.now().isoformat(),
+            "type": "batch_prediction",
+            "client_ip": client_ip,
+            "total_texts": total_texts,
+            "successful_predictions": successful_predictions,
+            "processing_time": processing_time,
+            "success_rate": successful_predictions / total_texts if total_texts > 0 else 0
+        }
+
+        logger.info(f"Batch prediction logged: {json.dumps(log_entry)}")
+
+    except Exception as e:
+        logger.error(f"Failed to log batch prediction: {e}")
+
+
 # Global variables
-model_manager = EnhancedModelManager()
+model_manager = ModelManager()
 
 # Initialize automation manager
 automation_manager = None
@@ -419,21 +363,17 @@ deployment_manager = None
 traffic_router = None
 model_registry = None
 
+
 @asynccontextmanager
 async def lifespan(app: FastAPI):
-    """Manage application lifespan with enhanced model support"""
+    """Manage application lifespan with deployment system"""
     global deployment_manager, traffic_router, model_registry
     
-    logger.info("Starting Enhanced FastAPI application with ensemble support...")
+    logger.info("Starting FastAPI application...")
     
     # Startup tasks
     model_manager.load_model()
     
-    # Log model information
-    logger.info(f"Model loaded: {model_manager.model_type}")
-    logger.info(f"Ensemble support: {model_manager.is_ensemble}")
-    logger.info(f"LightGBM available: {LIGHTGBM_AVAILABLE}")
-    
     # Initialize deployment components
     try:
         deployment_manager = BlueGreenDeploymentManager()
@@ -443,37 +383,72 @@ async def lifespan(app: FastAPI):
     except Exception as e:
         logger.error(f"Failed to initialize deployment system: {e}")
     
-    # Initialize monitoring
-    try:
-        prediction_monitor = PredictionMonitor(base_dir=Path("/tmp"))
-        metrics_collector = MetricsCollector(base_dir=Path("/tmp"))
-        alert_system = AlertSystem(base_dir=Path("/tmp"))
-        
-        prediction_monitor.start_monitoring()
-        alert_system.add_notification_handler("console", console_notification_handler)
-        logger.info("Monitoring system initialized")
-    except Exception as e:
-        logger.error(f"Failed to initialize monitoring: {e}")
+    # Initialize monitoring and automation...
     
     yield
     
     # Shutdown tasks
-    logger.info("Shutting down Enhanced FastAPI application...")
+    logger.info("Shutting down FastAPI application...")
+
+# Initialize monitoring components
+prediction_monitor = PredictionMonitor(base_dir=Path("/tmp"))
+metrics_collector = MetricsCollector(base_dir=Path("/tmp"))
+alert_system = AlertSystem(base_dir=Path("/tmp"))
+
+# Start monitoring
+prediction_monitor.start_monitoring()
+
+alert_system.add_notification_handler("console", console_notification_handler)
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    """Manage application lifespan"""
+    logger.info("Starting FastAPI application...")
+
+    # Startup tasks
+    model_manager.load_model()
+
+    # Schedule periodic health checks
+    asyncio.create_task(periodic_health_check())
+
+    yield
+
+    # Shutdown tasks
+    logger.info("Shutting down FastAPI application...")
+
+
+# Background tasks
+async def periodic_health_check():
+    """Periodic health check"""
+    while True:
+        try:
+            await asyncio.sleep(300)  # Check every 5 minutes
+            health_status = model_manager.health_check()
+
+            if health_status["status"] == "unhealthy":
+                logger.warning(
+                    "Model health check failed, attempting to reload...")
+                model_manager.load_model()
+
+        except Exception as e:
+            logger.error(f"Periodic health check failed: {e}")
+
 
 # Create FastAPI app
 app = FastAPI(
-    title="Enhanced Fake News Detection API with Ensemble Support",
-    description="Production-ready API for fake news detection with LightGBM ensemble support and comprehensive monitoring",
-    version="2.1.0",
+    title="Fake News Detection API",
+    description="Production-ready API for fake news detection with comprehensive monitoring and security features",
+    version="2.0.0",
     docs_url="/docs",
     redoc_url="/redoc",
     lifespan=lifespan
 )
 
-# Add middleware (same as before)
+# Add middleware
 app.add_middleware(
     CORSMiddleware,
-    allow_origins=["*"],
+    allow_origins=["*"],  # Configure appropriately for production
     allow_credentials=True,
     allow_methods=["*"],
     allow_headers=["*"],
@@ -481,31 +456,38 @@ app.add_middleware(
 
 app.add_middleware(
     TrustedHostMiddleware,
-    allowed_hosts=["*"]
+    allowed_hosts=["*"]  # Configure appropriately for production
 )
 
-# Enhanced prediction response model
-class EnhancedPredictionResponse(BaseModel):
-    prediction: str = Field(..., description="Prediction result: 'Real' or 'Fake'")
-    confidence: float = Field(..., ge=0.0, le=1.0, description="Confidence score between 0 and 1")
-    model_version: str = Field(..., description="Version of the model used for prediction")
-    model_type: str = Field(..., description="Type of model: individual, ensemble, etc.")
-    is_ensemble: bool = Field(..., description="Whether an ensemble model was used")
-    ensemble_info: Optional[Dict[str, Any]] = Field(None, description="Ensemble-specific information")
-    timestamp: str = Field(..., description="Timestamp of the prediction")
-    processing_time: float = Field(..., description="Time taken for processing in seconds")
+# Custom OpenAPI setup - RIGHT AFTER app creation
+def custom_openapi():
+    if app.openapi_schema:
+        return app.openapi_schema
+
+    openapi_schema = get_openapi(
+        title="Fake News Detection API",
+        version="2.0.0",
+        description="Production-ready API for fake news detection with comprehensive monitoring and security features",
+        routes=app.routes,
+    )
+
+    # Add security definitions
+    openapi_schema["components"]["securitySchemes"] = {
+        "Bearer": {
+            "type": "http",
+            "scheme": "bearer",
+            "bearerFormat": "JWT",
+        }
+    }
 
-# Enhanced health response model
-class EnhancedHealthResponse(BaseModel):
-    status: str
-    timestamp: str
-    model_health: Dict[str, Any]
-    system_health: Dict[str, Any]
-    api_health: Dict[str, Any]
-    environment_info: Dict[str, Any]
-    ensemble_info: Optional[Dict[str, Any]] = None
+    app.openapi_schema = openapi_schema
+    return app.openapi_schema
+
+# Set the custom OpenAPI function
+app.openapi = custom_openapi
 
-# Request models remain the same...
+
+# Request/Response models
 class PredictionRequest(BaseModel):
     text: str = Field(..., min_length=1, max_length=10000,
                       description="Text to analyze for fake news detection")
@@ -514,15 +496,67 @@ class PredictionRequest(BaseModel):
     def validate_text(cls, v):
         if not v or not v.strip():
             raise ValueError('Text cannot be empty')
+
+        # Basic content validation
         if len(v.strip()) < 10:
             raise ValueError('Text must be at least 10 characters long')
+
+        # Check for suspicious patterns
         suspicious_patterns = ['<script', 'javascript:', 'data:']
         if any(pattern in v.lower() for pattern in suspicious_patterns):
             raise ValueError('Text contains suspicious content')
+
         return v.strip()
 
 
-# Rate limiting and error handlers remain the same...
+class PredictionResponse(BaseModel):
+    prediction: str = Field(...,
+                            description="Prediction result: 'Real' or 'Fake'")
+    confidence: float = Field(..., ge=0.0, le=1.0,
+                              description="Confidence score between 0 and 1")
+    model_version: str = Field(...,
+                               description="Version of the model used for prediction")
+    timestamp: str = Field(..., description="Timestamp of the prediction")
+    processing_time: float = Field(...,
+                                   description="Time taken for processing in seconds")
+
+
+class BatchPredictionRequest(BaseModel):
+    texts: List[str] = Field(..., min_items=1, max_items=10,
+                             description="List of texts to analyze")
+
+    @validator('texts')
+    def validate_texts(cls, v):
+        if not v:
+            raise ValueError('Texts list cannot be empty')
+
+        for text in v:
+            if not text or not text.strip():
+                raise ValueError('All texts must be non-empty')
+
+            if len(text.strip()) < 10:
+                raise ValueError(
+                    'All texts must be at least 10 characters long')
+
+        return [text.strip() for text in v]
+
+
+class BatchPredictionResponse(BaseModel):
+    predictions: List[PredictionResponse]
+    total_count: int
+    processing_time: float
+
+
+class HealthResponse(BaseModel):
+    status: str
+    timestamp: str
+    model_health: Dict[str, Any]
+    system_health: Dict[str, Any]
+    api_health: Dict[str, Any]
+    environment_info: Dict[str, Any]
+
+
+# Rate limiting
 async def rate_limit_check(request: Request):
     """Check rate limits"""
     client_ip = request.client.host
@@ -531,7 +565,7 @@ async def rate_limit_check(request: Request):
     # Clean old entries
     rate_limit_storage[client_ip] = [
         timestamp for timestamp in rate_limit_storage[client_ip]
-        if current_time - timestamp < 3600
+        if current_time - timestamp < 3600  # 1 hour window
     ]
 
     # Check rate limit (100 requests per hour)
@@ -545,11 +579,14 @@ async def rate_limit_check(request: Request):
     rate_limit_storage[client_ip].append(current_time)
 
 
+# Logging middleware
 @app.middleware("http")
 async def log_requests(request: Request, call_next):
-    """Log all requests with ensemble information"""
+    """Log all requests"""
     start_time = time.time()
+
     response = await call_next(request)
+
     process_time = time.time() - start_time
 
     log_data = {
@@ -558,42 +595,76 @@ async def log_requests(request: Request, call_next):
         "client_ip": request.client.host,
         "status_code": response.status_code,
         "process_time": process_time,
-        "timestamp": datetime.now().isoformat(),
-        "model_type": model_manager.model_type,
-        "is_ensemble": model_manager.is_ensemble
+        "timestamp": datetime.now().isoformat()
     }
 
     logger.info(f"Request: {json.dumps(log_data)}")
+
     return response
 
 
-# Enhanced API Routes
-@app.get("/")
+# Error handlers
+@app.exception_handler(HTTPException)
+async def http_exception_handler(request: Request, exc: HTTPException):
+    """Handle HTTP exceptions"""
+    error_data = {
+        "error": True,
+        "message": exc.detail,
+        "status_code": exc.status_code,
+        "timestamp": datetime.now().isoformat(),
+        "path": request.url.path
+    }
+
+    logger.error(f"HTTP Exception: {json.dumps(error_data)}")
+
+    return JSONResponse(
+        status_code=exc.status_code,
+        content=error_data
+    )
+
+
+@app.exception_handler(Exception)
+async def general_exception_handler(request: Request, exc: Exception):
+    """Handle general exceptions"""
+    error_data = {
+        "error": True,
+        "message": "Internal server error",
+        "timestamp": datetime.now().isoformat(),
+        "path": request.url.path
+    }
+
+    logger.error(f"General Exception: {str(exc)}\n{traceback.format_exc()}")
+
+    return JSONResponse(
+        status_code=500,
+        content=error_data
+    )
+
+
+# API Routes
+@app.get("/", response_model=Dict[str, str])
 async def root():
-    """Root endpoint with ensemble information"""
+    """Root endpoint"""
     return {
-        "message": "Enhanced Fake News Detection API with Ensemble Support",
-        "version": "2.1.0",
+        "message": "Fake News Detection API",
+        "version": "2.0.0",
         "environment": path_manager.environment,
-        "model_type": model_manager.model_type,
-        "ensemble_support": model_manager.is_ensemble,
-        "lightgbm_available": LIGHTGBM_AVAILABLE,
         "documentation": "/docs",
         "health_check": "/health"
     }
 
 
-@app.post("/predict", response_model=EnhancedPredictionResponse)
+@app.post("/predict", response_model=PredictionResponse)
 async def predict(
     request: PredictionRequest,
     background_tasks: BackgroundTasks,
     http_request: Request,
     _: None = Depends(rate_limit_check)
-):
+    ):
     """
-    Enhanced prediction with ensemble model support
+    Predict whether a news article is fake or real using blue-green deployment routing
     - **text**: The news article text to analyze
-    - **returns**: Enhanced prediction result with ensemble information
+    - **returns**: Prediction result with confidence score
     """
     start_time = time.time()
     client_ip = http_request.client.host
@@ -607,49 +678,62 @@ async def predict(
                 detail="Model is not available. Please try again later."
             )
 
-        # Make prediction using enhanced model manager
-        label, confidence = model_manager.predict(request.text)
-        processing_time = time.time() - start_time
-
-        # Prepare ensemble information
-        ensemble_info = None
-        if model_manager.is_ensemble:
-            ensemble_info = {
-                "ensemble_type": model_manager.ensemble_metadata.get('ensemble_type', 'unknown'),
-                "component_models": model_manager.ensemble_metadata.get('component_models', []),
-                "voting_type": model_manager.model_metadata.get('ensemble_details', {}).get('voting_type', 'soft')
-            }
+        # Prepare request data for routing
+        request_data = {
+            'client_id': client_ip,
+            'user_agent': user_agent,
+            'timestamp': datetime.now().isoformat()
+        }
+        
+        # Use traffic router if available, otherwise fallback to model manager
+        if traffic_router and (traffic_router.blue_model or traffic_router.green_model):
+            try:
+                environment, result = traffic_router.make_prediction(request.text, request_data)
+                
+                # Extract results from traffic router response
+                label = result['prediction']
+                confidence = result['confidence']
+                processing_time = result['processing_time']
+                
+                logger.debug(f"Used {environment} environment for prediction")
+                
+            except Exception as e:
+                logger.warning(f"Traffic router failed, falling back to model manager: {e}")
+                # Fallback to original model manager
+                label, confidence = model_manager.predict(request.text)
+                processing_time = time.time() - start_time
+                environment = "blue"  # Default fallback
+        else:
+            # Fallback to original model manager
+            label, confidence = model_manager.predict(request.text)
+            processing_time = time.time() - start_time
+            environment = "blue"  # Default when no traffic router
 
         # Record prediction for monitoring
-        if 'prediction_monitor' in globals():
-            prediction_monitor.record_prediction(
-                prediction=label,
-                confidence=confidence,
-                processing_time=processing_time,
-                text=request.text,
-                model_version=model_manager.model_metadata.get('model_version', 'unknown'),
-                client_id=client_ip,
-                user_agent=user_agent
-            )
+        prediction_monitor.record_prediction(
+            prediction=label,
+            confidence=confidence,
+            processing_time=processing_time,
+            text=request.text,
+            model_version=model_manager.model_metadata.get('model_version', 'unknown'),
+            client_id=client_ip,
+            user_agent=user_agent
+        )
 
         # Record API request metrics
-        if 'metrics_collector' in globals():
-            metrics_collector.record_api_request(
-                endpoint="/predict",
-                method="POST",
-                response_time=processing_time,
-                status_code=200,
-                client_ip=client_ip
-            )
+        metrics_collector.record_api_request(
+            endpoint="/predict",
+            method="POST",
+            response_time=processing_time,
+            status_code=200,
+            client_ip=client_ip
+        )
 
-        # Create enhanced response
-        response = EnhancedPredictionResponse(
+        # Create response
+        response = PredictionResponse(
             prediction=label,
             confidence=confidence,
             model_version=model_manager.model_metadata.get('model_version', 'unknown'),
-            model_type=model_manager.model_type,
-            is_ensemble=model_manager.is_ensemble,
-            ensemble_info=ensemble_info,
             timestamp=datetime.now().isoformat(),
             processing_time=processing_time
         )
@@ -669,40 +753,36 @@ async def predict(
     except HTTPException:
         # Record error for failed requests
         processing_time = time.time() - start_time
-        if 'prediction_monitor' in globals():
-            prediction_monitor.record_error(
-                error_type="http_error",
-                error_message="Service unavailable",
-                context={"status_code": 503}
-            )
-        if 'metrics_collector' in globals():
-            metrics_collector.record_api_request(
-                endpoint="/predict",
-                method="POST",
-                response_time=processing_time,
-                status_code=503,
-                client_ip=client_ip
-            )
+        prediction_monitor.record_error(
+            error_type="http_error",
+            error_message="Service unavailable",
+            context={"status_code": 503}
+        )
+        metrics_collector.record_api_request(
+            endpoint="/predict",
+            method="POST",
+            response_time=processing_time,
+            status_code=503,
+            client_ip=client_ip
+        )
         raise
     except Exception as e:
         processing_time = time.time() - start_time
         
         # Record error
-        if 'prediction_monitor' in globals():
-            prediction_monitor.record_error(
-                error_type="prediction_error",
-                error_message=str(e),
-                context={"text_length": len(request.text)}
-            )
+        prediction_monitor.record_error(
+            error_type="prediction_error",
+            error_message=str(e),
+            context={"text_length": len(request.text)}
+        )
         
-        if 'metrics_collector' in globals():
-            metrics_collector.record_api_request(
-                endpoint="/predict",
-                method="POST",
-                response_time=processing_time,
-                status_code=500,
-                client_ip=client_ip
-            )
+        metrics_collector.record_api_request(
+            endpoint="/predict",
+            method="POST",
+            response_time=processing_time,
+            status_code=500,
+            client_ip=client_ip
+        )
         
         logger.error(f"Prediction failed: {e}")
         raise HTTPException(
@@ -711,11 +791,90 @@ async def predict(
         )
 
 
-@app.get("/health", response_model=EnhancedHealthResponse)
+@app.post("/predict/batch", response_model=BatchPredictionResponse)
+async def predict_batch(
+    request: BatchPredictionRequest,
+    background_tasks: BackgroundTasks,
+    http_request: Request,
+    _: None = Depends(rate_limit_check)
+):
+    """
+    Predict multiple news articles in batch
+    - **texts**: List of news article texts to analyze
+    - **returns**: List of prediction results
+    """
+    start_time = time.time()
+
+    try:
+        # Check model health
+        if model_manager.health_status != "healthy":
+            raise HTTPException(
+                status_code=503,
+                detail="Model is not available. Please try again later."
+            )
+
+        predictions = []
+
+        for text in request.texts:
+            try:
+                label, confidence = model_manager.predict(text)
+
+                prediction = PredictionResponse(
+                    prediction=label,
+                    confidence=confidence,
+                    model_version=model_manager.model_metadata.get(
+                        'model_version', 'unknown'),
+                    timestamp=datetime.now().isoformat(),
+                    processing_time=0.0  # Will be updated with total time
+                )
+
+                predictions.append(prediction)
+
+            except Exception as e:
+                logger.error(f"Batch prediction failed for text: {e}")
+                # Continue with other texts
+                continue
+
+        # Calculate total processing time
+        total_processing_time = time.time() - start_time
+
+        # Update processing time for all predictions
+        for prediction in predictions:
+            prediction.processing_time = total_processing_time / \
+                len(predictions)
+
+        response = BatchPredictionResponse(
+            predictions=predictions,
+            total_count=len(predictions),
+            processing_time=total_processing_time
+        )
+
+        # Log batch prediction (background task)
+        background_tasks.add_task(
+            log_batch_prediction,
+            len(request.texts),
+            len(predictions),
+            http_request.client.host,
+            total_processing_time
+        )
+
+        return response
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Batch prediction failed: {e}")
+        raise HTTPException(
+            status_code=500,
+            detail=f"Batch prediction failed: {str(e)}"
+        )
+
+
+@app.get("/health", response_model=HealthResponse)
 async def health_check():
     """
-    Enhanced health check endpoint with ensemble information
-    - **returns**: Detailed health status including ensemble information
+    Comprehensive health check endpoint
+    - **returns**: Detailed health status of the API and model
     """
     try:
         # Model health
@@ -738,193 +897,843 @@ async def health_check():
 
         # Environment info
         environment_info = path_manager.get_environment_info()
-        environment_info["lightgbm_available"] = LIGHTGBM_AVAILABLE
-
-        # Ensemble information
-        ensemble_info = None
-        if model_manager.is_ensemble:
-            ensemble_info = {
-                "is_ensemble": True,
-                "ensemble_type": model_manager.ensemble_metadata.get('ensemble_type', 'unknown'),
-                "component_models": model_manager.ensemble_metadata.get('component_models', []),
-                "ensemble_health": model_health.get('ensemble_info', {}),
-                "ensemble_metadata_available": Path("/tmp/ensemble_metadata.json").exists()
-            }
 
         # Overall status
         overall_status = "healthy" if model_health["status"] == "healthy" else "unhealthy"
 
-        return EnhancedHealthResponse(
+        return HealthResponse(
             status=overall_status,
             timestamp=datetime.now().isoformat(),
             model_health=model_health,
             system_health=system_health,
             api_health=api_health,
-            environment_info=environment_info,
-            ensemble_info=ensemble_info
+            environment_info=environment_info
         )
 
     except Exception as e:
         logger.error(f"Health check failed: {e}")
-        return EnhancedHealthResponse(
+        return HealthResponse(
             status="unhealthy",
             timestamp=datetime.now().isoformat(),
             model_health={"status": "unhealthy", "error": str(e)},
             system_health={"error": str(e)},
             api_health={"error": str(e)},
-            environment_info={"error": str(e)},
-            ensemble_info={"error": str(e)} if model_manager.is_ensemble else None
+            environment_info={"error": str(e)}
         )
 
 
-@app.get("/model/info")
-async def get_model_info():
+@app.get("/health/detailed")
+async def detailed_health_check():
     """
-    Get detailed model information including ensemble details
-    - **returns**: Comprehensive model information
+    Detailed health check endpoint with comprehensive CV results
+    - **returns**: Detailed health status including cross-validation metrics
     """
     try:
-        model_info = {
-            "model_version": model_manager.model_metadata.get('model_version', 'unknown'),
-            "model_type": model_manager.model_type,
-            "is_ensemble": model_manager.is_ensemble,
-            "lightgbm_available": LIGHTGBM_AVAILABLE,
-            "training_method": model_manager.model_metadata.get('training_method', 'unknown'),
-            "timestamp": model_manager.model_metadata.get('timestamp', 'unknown'),
-            "performance_metrics": {
-                "test_accuracy": model_manager.model_metadata.get('test_accuracy', 'unknown'),
-                "test_f1": model_manager.model_metadata.get('test_f1', 'unknown'),
-                "cv_f1_mean": model_manager.model_metadata.get('cv_f1_mean', 'unknown'),
-                "cv_f1_std": model_manager.model_metadata.get('cv_f1_std', 'unknown')
+        # Get basic health information
+        basic_health = await health_check()
+        
+        # Load metadata to get CV results
+        metadata_path = path_manager.get_metadata_path()
+        cv_details = {}
+        
+        if metadata_path.exists():
+            try:
+                with open(metadata_path, 'r') as f:
+                    metadata = json.load(f)
+                
+                # Extract cross-validation information
+                cv_info = metadata.get('cross_validation', {})
+                if cv_info:
+                    cv_details = {
+                        'cross_validation_available': True,
+                        'n_splits': cv_info.get('n_splits', 'Unknown'),
+                        'test_scores': cv_info.get('test_scores', {}),
+                        'train_scores': cv_info.get('train_scores', {}),
+                        'overfitting_score': cv_info.get('overfitting_score', 'Unknown'),
+                        'stability_score': cv_info.get('stability_score', 'Unknown'),
+                        'individual_fold_results': cv_info.get('individual_fold_results', [])
+                    }
+                    
+                    # Add summary statistics
+                    test_scores = cv_info.get('test_scores', {})
+                    if 'f1' in test_scores:
+                        cv_details['cv_f1_summary'] = {
+                            'mean': test_scores['f1'].get('mean', 'Unknown'),
+                            'std': test_scores['f1'].get('std', 'Unknown'),
+                            'min': test_scores['f1'].get('min', 'Unknown'),
+                            'max': test_scores['f1'].get('max', 'Unknown'),
+                            'scores': test_scores['f1'].get('scores', [])
+                        }
+                    
+                    if 'accuracy' in test_scores:
+                        cv_details['cv_accuracy_summary'] = {
+                            'mean': test_scores['accuracy'].get('mean', 'Unknown'),
+                            'std': test_scores['accuracy'].get('std', 'Unknown'),
+                            'min': test_scores['accuracy'].get('min', 'Unknown'),
+                            'max': test_scores['accuracy'].get('max', 'Unknown'),
+                            'scores': test_scores['accuracy'].get('scores', [])
+                        }
+                
+                # Add model comparison results if available
+                statistical_validation = metadata.get('statistical_validation', {})
+                if statistical_validation:
+                    cv_details['statistical_validation'] = statistical_validation
+                
+                promotion_validation = metadata.get('promotion_validation', {})
+                if promotion_validation:
+                    cv_details['promotion_validation'] = promotion_validation
+                
+                # Add model version and training info
+                cv_details['model_info'] = {
+                    'model_version': metadata.get('model_version', 'Unknown'),
+                    'model_type': metadata.get('model_type', 'Unknown'),
+                    'training_timestamp': metadata.get('timestamp', 'Unknown'),
+                    'promotion_timestamp': metadata.get('promotion_timestamp'),
+                    'cv_f1_mean': metadata.get('cv_f1_mean'),
+                    'cv_f1_std': metadata.get('cv_f1_std'),
+                    'cv_accuracy_mean': metadata.get('cv_accuracy_mean'),
+                    'cv_accuracy_std': metadata.get('cv_accuracy_std')
+                }
+            
+            except Exception as e:
+                cv_details = {
+                    'cross_validation_available': False,
+                    'error': f"Failed to load CV details: {str(e)}"
+                }
+        else:
+            cv_details = {
+                'cross_validation_available': False,
+                'error': "No metadata file found"
+            }
+        
+        # Combine basic health with detailed CV information
+        detailed_response = {
+            'basic_health': basic_health,
+            'cross_validation_details': cv_details,
+            'detailed_check_timestamp': datetime.now().isoformat()
+        }
+        
+        return detailed_response
+        
+    except Exception as e:
+        logger.error(f"Detailed health check failed: {e}")
+        return {
+            'basic_health': {'status': 'unhealthy', 'error': str(e)},
+            'cross_validation_details': {
+                'cross_validation_available': False,
+                'error': f"Detailed health check failed: {str(e)}"
             },
-            "feature_engineering": model_manager.model_metadata.get('feature_engineering', {}),
-            "training_config": model_manager.model_metadata.get('training_config', {})
+            'detailed_check_timestamp': datetime.now().isoformat()
         }
 
-        # Add ensemble-specific information
-        if model_manager.is_ensemble:
-            ensemble_details = model_manager.model_metadata.get('ensemble_details', {})
-            model_info["ensemble_details"] = {
-                "ensemble_type": ensemble_details.get('ensemble_type', 'unknown'),
-                "component_models": ensemble_details.get('component_models', []),
-                "voting_type": ensemble_details.get('voting_type', 'soft'),
-                "component_performance": model_manager.model_metadata.get('component_performance', {})
-            }
-            
-            # Add ensemble metadata if available
-            if model_manager.ensemble_metadata:
-                model_info["ensemble_metadata"] = model_manager.ensemble_metadata
-
-        return model_info
 
+@app.get("/cv/results")
+async def get_cv_results():
+    """
+    Get detailed cross-validation results for the current model
+    - **returns**: Comprehensive CV metrics and fold-by-fold results
+    """
+    try:
+        metadata_path = path_manager.get_metadata_path()
+        
+        if not metadata_path.exists():
+            raise HTTPException(
+                status_code=404,
+                detail="Model metadata not found. Train a model first."
+            )
+        
+        with open(metadata_path, 'r') as f:
+            metadata = json.load(f)
+        
+        cv_info = metadata.get('cross_validation', {})
+        
+        if not cv_info:
+            raise HTTPException(
+                status_code=404,
+                detail="No cross-validation results found. Model may not have been trained with CV."
+            )
+        
+        # Structure the CV results for API response
+        cv_response = {
+            'model_version': metadata.get('model_version', 'Unknown'),
+            'model_type': metadata.get('model_type', 'Unknown'),
+            'training_timestamp': metadata.get('timestamp', 'Unknown'),
+            'cross_validation': {
+                'methodology': {
+                    'n_splits': cv_info.get('n_splits', 'Unknown'),
+                    'cv_type': 'StratifiedKFold',
+                    'random_state': 42
+                },
+                'test_scores': cv_info.get('test_scores', {}),
+                'train_scores': cv_info.get('train_scores', {}),
+                'performance_indicators': {
+                    'overfitting_score': cv_info.get('overfitting_score', 'Unknown'),
+                    'stability_score': cv_info.get('stability_score', 'Unknown')
+                },
+                'individual_fold_results': cv_info.get('individual_fold_results', [])
+            },
+            'statistical_validation': metadata.get('statistical_validation', {}),
+            'promotion_validation': metadata.get('promotion_validation', {}),
+            'summary_statistics': {
+                'cv_f1_mean': metadata.get('cv_f1_mean'),
+                'cv_f1_std': metadata.get('cv_f1_std'),
+                'cv_accuracy_mean': metadata.get('cv_accuracy_mean'),
+                'cv_accuracy_std': metadata.get('cv_accuracy_std')
+            }
+        }
+        
+        return cv_response
+        
+    except HTTPException:
+        raise
     except Exception as e:
-        logger.error(f"Model info retrieval failed: {e}")
+        logger.error(f"CV results retrieval failed: {e}")
         raise HTTPException(
             status_code=500,
-            detail=f"Failed to retrieve model info: {str(e)}"
+            detail=f"Failed to retrieve CV results: {str(e)}"
         )
 
 
-@app.get("/model/performance")
-async def get_model_performance():
+@app.get("/cv/comparison")
+async def get_model_comparison_results():
     """
-    Get detailed model performance metrics including ensemble comparison
-    - **returns**: Performance metrics and comparisons
+    Get latest model comparison results from retraining
+    - **returns**: Statistical comparison results between models
     """
     try:
-        performance_info = {
-            "current_model": {
-                "model_type": model_manager.model_type,
-                "is_ensemble": model_manager.is_ensemble,
-                "test_metrics": {
-                    "accuracy": model_manager.model_metadata.get('test_accuracy', 'unknown'),
-                    "f1": model_manager.model_metadata.get('test_f1', 'unknown'),
-                    "precision": model_manager.model_metadata.get('test_precision', 'unknown'),
-                    "recall": model_manager.model_metadata.get('test_recall', 'unknown'),
-                    "roc_auc": model_manager.model_metadata.get('test_roc_auc', 'unknown')
-                },
-                "cross_validation": model_manager.model_metadata.get('cross_validation', {})
+        # Load comparison logs
+        comparison_log_path = path_manager.get_logs_path("model_comparison.json")
+        
+        if not comparison_log_path.exists():
+            raise HTTPException(
+                status_code=404,
+                detail="No model comparison results found."
+            )
+        
+        with open(comparison_log_path, 'r') as f:
+            comparison_logs = json.load(f)
+        
+        if not comparison_logs:
+            raise HTTPException(
+                status_code=404,
+                detail="No comparison entries found."
+            )
+        
+        # Get the most recent comparison
+        latest_comparison = comparison_logs[-1]
+        comparison_details = latest_comparison.get('comparison_details', {})
+        
+        # Structure the response
+        comparison_response = {
+            'comparison_timestamp': latest_comparison.get('timestamp', 'Unknown'),
+            'session_id': latest_comparison.get('session_id', 'Unknown'),
+            'models_compared': {
+                'model1_name': comparison_details.get('model1_name', 'Production'),
+                'model2_name': comparison_details.get('model2_name', 'Candidate')
+            },
+            'cv_methodology': {
+                'cv_folds': comparison_details.get('cv_folds', 'Unknown')
+            },
+            'model_performance': {
+                'production_model': comparison_details.get('model1_cv_results', {}),
+                'candidate_model': comparison_details.get('model2_cv_results', {})
             },
-            "training_info": {
-                "training_method": model_manager.model_metadata.get('training_method', 'unknown'),
-                "lightgbm_used": model_manager.model_metadata.get('lightgbm_used', False),
-                "enhanced_features": model_manager.model_metadata.get('feature_engineering', {}).get('enhanced_features_used', False)
+            'metric_comparisons': comparison_details.get('metric_comparisons', {}),
+            'statistical_tests': comparison_details.get('statistical_tests', {}),
+            'promotion_decision': comparison_details.get('promotion_decision', {}),
+            'summary': {
+                'decision': comparison_details.get('promotion_decision', {}).get('promote_candidate', False),
+                'reason': comparison_details.get('promotion_decision', {}).get('reason', 'Unknown'),
+                'confidence': comparison_details.get('promotion_decision', {}).get('confidence', 0)
             }
         }
+        
+        return comparison_response
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Model comparison results retrieval failed: {e}")
+        raise HTTPException(
+            status_code=500,
+            detail=f"Failed to retrieve model comparison results: {str(e)}"
+        )
+        
 
-        # Add ensemble-specific performance information
-        if model_manager.is_ensemble:
-            component_performance = model_manager.model_metadata.get('component_performance', {})
-            if component_performance:
-                performance_info["component_comparison"] = component_performance
+@app.get("/metrics")
+async def get_metrics():
+    """
+    Get comprehensive API metrics including CV results
+    - **returns**: Usage statistics, performance metrics, and CV information
+    """
+    try:
+        # Calculate metrics from rate limiting storage
+        total_requests = sum(len(requests)
+                             for requests in rate_limit_storage.values())
+        unique_clients = len(rate_limit_storage)
+
+        # Load metadata for CV information
+        metadata_path = path_manager.get_metadata_path()
+        cv_summary = {}
+        
+        if metadata_path.exists():
+            try:
+                with open(metadata_path, 'r') as f:
+                    metadata = json.load(f)
                 
-                # Calculate ensemble advantage
-                ensemble_f1 = model_manager.model_metadata.get('test_f1', 0)
-                if isinstance(ensemble_f1, (int, float)):
-                    best_individual_f1 = max([comp.get('f1', 0) for comp in component_performance.values()], default=0)
-                    if best_individual_f1 > 0:
-                        ensemble_advantage = ensemble_f1 - best_individual_f1
-                        performance_info["ensemble_advantage"] = {
-                            "f1_improvement": ensemble_advantage,
-                            "relative_improvement": (ensemble_advantage / best_individual_f1) * 100 if best_individual_f1 > 0 else 0
-                        }
+                # Extract CV summary
+                cv_info = metadata.get('cross_validation', {})
+                if cv_info:
+                    test_scores = cv_info.get('test_scores', {})
+                    cv_summary = {
+                        'cv_available': True,
+                        'cv_folds': cv_info.get('n_splits', 'Unknown'),
+                        'cv_f1_mean': test_scores.get('f1', {}).get('mean'),
+                        'cv_f1_std': test_scores.get('f1', {}).get('std'),
+                        'cv_accuracy_mean': test_scores.get('accuracy', {}).get('mean'),
+                        'cv_accuracy_std': test_scores.get('accuracy', {}).get('std'),
+                        'overfitting_score': cv_info.get('overfitting_score'),
+                        'stability_score': cv_info.get('stability_score')
+                    }
+                else:
+                    cv_summary = {'cv_available': False}
+                    
+            except Exception as e:
+                cv_summary = {'cv_available': False, 'cv_error': str(e)}
+        else:
+            cv_summary = {'cv_available': False, 'cv_error': 'No metadata file'}
+
+        metrics = {
+            'api_metrics': {
+                'total_requests': total_requests,
+                'unique_clients': unique_clients,
+                'timestamp': datetime.now().isoformat()
+            },
+            'model_info': {
+                'model_version': model_manager.model_metadata.get('model_version', 'unknown'),
+                'model_health': model_manager.health_status,
+                'last_health_check': model_manager.last_health_check.isoformat() if model_manager.last_health_check else None
+            },
+            'cross_validation_summary': cv_summary,
+            'environment_info': {
+                'environment': path_manager.environment,
+                'available_datasets': path_manager.list_available_datasets(),
+                'available_models': path_manager.list_available_models()
+            }
+        }
+
+        return metrics
+
+    except Exception as e:
+        logger.error(f"Metrics retrieval failed: {e}")
+        raise HTTPException(
+            status_code=500,
+            detail=f"Metrics retrieval failed: {str(e)}"
+        )
 
-        return performance_info
+@app.get("/validation/statistics")
+async def get_validation_statistics():
+    """Get comprehensive validation statistics"""
+    try:
+        stats = get_validation_stats()
+        
+        if not stats:
+            return {
+                'statistics_available': False,
+                'message': 'No validation statistics available yet',
+                'timestamp': datetime.now().isoformat()
+            }
+        
+        enhanced_stats = {
+            'statistics_available': True,
+            'last_updated': stats.get('last_updated'),
+            'overall_metrics': {
+                'total_validations': stats.get('total_validations', 0),
+                'total_articles_processed': stats.get('total_articles', 0),
+                'overall_success_rate': (stats.get('total_valid_articles', 0) / 
+                                       max(stats.get('total_articles', 1), 1)),
+                'average_quality_score': stats.get('average_quality_score', 0.0)
+            },
+            'source_breakdown': stats.get('source_statistics', {}),
+            'recent_performance': {
+                'validation_history': stats.get('validation_history', [])[-10:],
+                'quality_trends': stats.get('quality_trends', [])[-10:]
+            },
+            'timestamp': datetime.now().isoformat()
+        }
+        
+        return enhanced_stats
+        
+    except Exception as e:
+        logger.error(f"Failed to get validation statistics: {e}")
+        raise HTTPException(
+            status_code=500,
+            detail=f"Failed to retrieve validation statistics: {str(e)}"
+        )
 
+@app.get("/validation/quality-report")
+async def get_quality_report():
+    """Get comprehensive data quality report"""
+    try:
+        report = generate_quality_report()
+        
+        if 'error' in report:
+            raise HTTPException(
+                status_code=404,
+                detail=report['error']
+            )
+        
+        return report
+        
+    except HTTPException:
+        raise
     except Exception as e:
-        logger.error(f"Performance info retrieval failed: {e}")
+        logger.error(f"Failed to generate quality report: {e}")
         raise HTTPException(
             status_code=500,
-            detail=f"Failed to retrieve performance info: {str(e)}"
+            detail=f"Failed to generate quality report: {str(e)}"
+        )
+
+@app.get("/validation/health")
+async def get_validation_health():
+    """Get validation system health status"""
+    try:
+        stats = get_validation_stats()
+        
+        health_indicators = {
+            'validation_system_active': True,
+            'statistics_available': bool(stats),
+            'recent_activity': False,
+            'quality_status': 'unknown'
+        }
+        
+        if stats:
+            last_updated = stats.get('last_updated')
+            if last_updated:
+                try:
+                    last_update_time = datetime.fromisoformat(last_updated)
+                    hours_since_update = (datetime.now() - last_update_time).total_seconds() / 3600
+                    health_indicators['recent_activity'] = hours_since_update <= 24
+                    health_indicators['hours_since_last_validation'] = hours_since_update
+                except:
+                    pass
+            
+            avg_quality = stats.get('average_quality_score', 0)
+            success_rate = stats.get('total_valid_articles', 0) / max(stats.get('total_articles', 1), 1)
+            
+            if avg_quality >= 0.7 and success_rate >= 0.8:
+                health_indicators['quality_status'] = 'excellent'
+            elif avg_quality >= 0.5 and success_rate >= 0.6:
+                health_indicators['quality_status'] = 'good'
+            elif avg_quality >= 0.3 and success_rate >= 0.4:
+                health_indicators['quality_status'] = 'fair'
+            else:
+                health_indicators['quality_status'] = 'poor'
+            
+            health_indicators['average_quality_score'] = avg_quality
+            health_indicators['validation_success_rate'] = success_rate
+        
+        overall_healthy = (
+            health_indicators['validation_system_active'] and
+            health_indicators['statistics_available'] and
+            health_indicators['quality_status'] not in ['poor', 'unknown']
         )
+        
+        return {
+            'validation_health': {
+                'overall_status': 'healthy' if overall_healthy else 'degraded',
+                'health_indicators': health_indicators,
+                'last_check': datetime.now().isoformat()
+            }
+        }
+        
+    except Exception as e:
+        logger.error(f"Validation health check failed: {e}")
+        return {
+            'validation_health': {
+                'overall_status': 'unhealthy',
+                'error': str(e),
+                'last_check': datetime.now().isoformat()
+            }
+        }
+
+
+# New monitoring endpoints
+@app.get("/monitor/metrics/current")
+async def get_current_metrics():
+    """Get current real-time metrics"""
+    try:
+        prediction_metrics = prediction_monitor.get_current_metrics()
+        system_metrics = metrics_collector.collect_system_metrics()
+        api_metrics = metrics_collector.collect_api_metrics()
+        
+        return {
+            "timestamp": datetime.now().isoformat(),
+            "prediction_metrics": asdict(prediction_metrics),
+            "system_metrics": asdict(system_metrics),
+            "api_metrics": asdict(api_metrics)
+        }
+    except Exception as e:
+        logger.error(f"Failed to get current metrics: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
 
+@app.get("/monitor/metrics/historical")
+async def get_historical_metrics(hours: int = 24):
+    """Get historical metrics"""
+    try:
+        return {
+            "prediction_metrics": [asdict(m) for m in prediction_monitor.get_historical_metrics(hours)],
+            "aggregated_metrics": metrics_collector.get_aggregated_metrics(hours)
+        }
+    except Exception as e:
+        logger.error(f"Failed to get historical metrics: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
 
-# Keep all other existing endpoints (cv/results, metrics, etc.) but enhance them with ensemble information where relevant
+@app.get("/monitor/alerts")
+async def get_alerts():
+    """Get active alerts and statistics"""
+    try:
+        return {
+            "active_alerts": [asdict(alert) for alert in alert_system.get_active_alerts()],
+            "alert_statistics": alert_system.get_alert_statistics()
+        }
+    except Exception as e:
+        logger.error(f"Failed to get alerts: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
 
-@app.get("/ensemble/status")
-async def get_ensemble_status():
-    """
-    Get ensemble-specific status information
-    - **returns**: Ensemble status and configuration
-    """
+@app.get("/monitor/health")
+async def get_monitoring_health():
+    """Get monitoring system health"""
     try:
-        if not model_manager.is_ensemble:
+        dashboard_data = metrics_collector.get_real_time_dashboard_data()
+        confidence_analysis = prediction_monitor.get_confidence_analysis()
+        
+        return {
+            "monitoring_status": "active",
+            "dashboard_data": dashboard_data,
+            "confidence_analysis": confidence_analysis,
+            "total_predictions": prediction_monitor.total_predictions
+        }
+    except Exception as e:
+        logger.error(f"Failed to get monitoring health: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.get("/monitor/patterns")
+async def get_prediction_patterns(hours: int = 24):
+    """Get prediction patterns and anomaly analysis"""
+    try:
+        return prediction_monitor.get_prediction_patterns(hours)
+    except Exception as e:
+        logger.error(f"Failed to get prediction patterns: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.post("/monitor/alerts/{alert_id}/acknowledge")
+async def acknowledge_alert(alert_id: str):
+    """Acknowledge an alert"""
+    try:
+        success = alert_system.acknowledge_alert(alert_id, "api_user")
+        if success:
+            return {"message": f"Alert {alert_id} acknowledged"}
+        else:
+            raise HTTPException(status_code=404, detail="Alert not found")
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Failed to acknowledge alert: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.post("/monitor/alerts/{alert_id}/resolve")
+async def resolve_alert(alert_id: str, resolution_note: str = ""):
+    """Resolve an alert"""
+    try:
+        success = alert_system.resolve_alert(alert_id, "api_user", resolution_note)
+        if success:
+            return {"message": f"Alert {alert_id} resolved"}
+        else:
+            raise HTTPException(status_code=404, detail="Alert not found")
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Failed to resolve alert: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.get("/automation/status")
+async def get_automation_status():
+    """Get automation system status"""
+    try:
+        if automation_manager is None:
+            raise HTTPException(status_code=503, detail="Automation system not available")
+        
+        # Get automation status
+        automation_status = automation_manager.get_automation_status()
+        
+        # Get drift monitoring status
+        drift_status = automation_manager.drift_monitor.get_automation_status()
+        
+        return {
+            "timestamp": datetime.now().isoformat(),
+            "automation_system": automation_status,
+            "drift_monitoring": drift_status,
+            "system_health": "active" if automation_manager.retraining_active else "inactive"
+        }
+        
+    except Exception as e:
+        logger.error(f"Failed to get automation status: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.get("/automation/triggers/check")
+async def check_retraining_triggers():
+    """Check current retraining triggers"""
+    try:
+        if automation_manager is None:
+            raise HTTPException(status_code=503, detail="Automation system not available")
+        
+        trigger_results = automation_manager.drift_monitor.check_retraining_triggers()
+        
+        return {
+            "timestamp": datetime.now().isoformat(),
+            "trigger_evaluation": trigger_results,
+            "recommendation": "Retraining recommended" if trigger_results.get('should_retrain') else "No retraining needed"
+        }
+        
+    except Exception as e:
+        logger.error(f"Failed to check triggers: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.post("/automation/retrain/trigger")
+async def trigger_manual_retraining(reason: str = "manual_api_trigger"):
+    """Manually trigger retraining"""
+    try:
+        if automation_manager is None:
+            raise HTTPException(status_code=503, detail="Automation system not available")
+        
+        result = automation_manager.trigger_manual_retraining(reason)
+        
+        if result['success']:
             return {
-                "ensemble_active": False,
-                "message": "Current model is not an ensemble",
-                "model_type": model_manager.model_type,
-                "lightgbm_available": LIGHTGBM_AVAILABLE
+                "message": "Retraining triggered successfully",
+                "timestamp": datetime.now().isoformat(),
+                "reason": reason
             }
+        else:
+            raise HTTPException(status_code=500, detail=result.get('error', 'Unknown error'))
+            
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Failed to trigger retraining: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.get("/automation/queue")
+async def get_retraining_queue():
+    """Get current retraining queue"""
+    try:
+        if automation_manager is None:
+            raise HTTPException(status_code=503, detail="Automation system not available")
+        
+        queue = automation_manager.load_retraining_queue()
+        recent_logs = automation_manager.get_recent_automation_logs(hours=24)
+        
+        return {
+            "timestamp": datetime.now().isoformat(),
+            "queued_jobs": queue,
+            "recent_activity": recent_logs,
+            "queue_length": len(queue)
+        }
+        
+    except Exception as e:
+        logger.error(f"Failed to get retraining queue: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
 
-        ensemble_status = {
-            "ensemble_active": True,
-            "ensemble_type": model_manager.ensemble_metadata.get('ensemble_type', 'unknown'),
-            "component_models": model_manager.ensemble_metadata.get('component_models', []),
-            "ensemble_health": model_manager.health_status,
-            "lightgbm_available": LIGHTGBM_AVAILABLE,
-            "lightgbm_used": 'lightgbm' in model_manager.ensemble_metadata.get('component_models', []),
-            "voting_type": model_manager.model_metadata.get('ensemble_details', {}).get('voting_type', 'unknown'),
-            "model_version": model_manager.model_metadata.get('model_version', 'unknown'),
-            "training_timestamp": model_manager.model_metadata.get('timestamp', 'unknown')
+@app.get("/automation/drift/status")
+async def get_drift_monitoring_status():
+    """Get drift monitoring status"""
+    try:
+        if automation_manager is None:
+            raise HTTPException(status_code=503, detail="Automation system not available")
+        
+        # Get recent drift results
+        drift_logs = automation_manager.get_recent_automation_logs(hours=48)
+        drift_checks = [log for log in drift_logs if 'drift' in log.get('event', '')]
+        
+        # Get current drift status
+        drift_status = automation_manager.drift_monitor.get_automation_status()
+        
+        return {
+            "timestamp": datetime.now().isoformat(),
+            "drift_monitoring_active": True,
+            "recent_drift_checks": drift_checks[-10:],  # Last 10 checks
+            "drift_status": drift_status
         }
+        
+    except Exception as e:
+        logger.error(f"Failed to get drift status: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
 
-        # Add performance comparison if available
-        component_performance = model_manager.model_metadata.get('component_performance', {})
-        if component_performance:
-            ensemble_status["component_performance"] = component_performance
+@app.post("/automation/settings/update")
+async def update_automation_settings(settings: Dict[str, Any]):
+    """Update automation settings"""
+    try:
+        if automation_manager is None:
+            raise HTTPException(status_code=503, detail="Automation system not available")
+        
+        # Update settings
+        automation_manager.automation_config.update(settings)
+        automation_manager.save_automation_config()
+        
+        return {
+            "message": "Automation settings updated",
+            "timestamp": datetime.now().isoformat(),
+            "updated_settings": settings
+        }
+        
+    except Exception as e:
+        logger.error(f"Failed to update automation settings: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+# Deployment endpoints
+@app.get("/deployment/status")
+async def get_deployment_status():
+    """Get deployment system status"""
+    try:
+        if not deployment_manager:
+            raise HTTPException(status_code=503, detail="Deployment system not available")
+        
+        return deployment_manager.get_deployment_status()
+        
+    except Exception as e:
+        logger.error(f"Failed to get deployment status: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.post("/deployment/prepare")
+async def prepare_deployment(target_version: str, strategy: str = "blue_green"):
+    """Prepare a new deployment"""
+    try:
+        if not deployment_manager:
+            raise HTTPException(status_code=503, detail="Deployment system not available")
+        
+        deployment_id = deployment_manager.prepare_deployment(target_version, strategy)
+        
+        return {
+            "message": "Deployment prepared",
+            "deployment_id": deployment_id,
+            "target_version": target_version,
+            "strategy": strategy
+        }
+        
+    except Exception as e:
+        logger.error(f"Failed to prepare deployment: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.post("/deployment/start/{deployment_id}")
+async def start_deployment(deployment_id: str):
+    """Start a prepared deployment"""
+    try:
+        if not deployment_manager:
+            raise HTTPException(status_code=503, detail="Deployment system not available")
+        
+        success = deployment_manager.start_deployment(deployment_id)
+        
+        if success:
+            return {"message": "Deployment started successfully", "deployment_id": deployment_id}
+        else:
+            raise HTTPException(status_code=500, detail="Deployment failed to start")
+            
+    except Exception as e:
+        logger.error(f"Failed to start deployment: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.post("/deployment/rollback")
+async def rollback_deployment(reason: str = "Manual rollback"):
+    """Rollback current deployment"""
+    try:
+        if not deployment_manager:
+            raise HTTPException(status_code=503, detail="Deployment system not available")
+        
+        success = deployment_manager.initiate_rollback(reason)
+        
+        if success:
+            return {"message": "Rollback initiated successfully", "reason": reason}
+        else:
+            raise HTTPException(status_code=500, detail="Rollback failed")
             
-            # Calculate which model would have been best individually
-            best_individual = max(component_performance.items(), key=lambda x: x[1].get('f1', 0), default=('none', {'f1': 0}))
-            ensemble_status["best_individual_model"] = {
-                "name": best_individual[0],
-                "f1_score": best_individual[1].get('f1', 0)
+    except Exception as e:
+        logger.error(f"Failed to rollback deployment: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.get("/deployment/traffic")
+async def get_traffic_status():
+    """Get traffic routing status"""
+    try:
+        if not traffic_router:
+            raise HTTPException(status_code=503, detail="Traffic router not available")
+        
+        return traffic_router.get_routing_status()
+        
+    except Exception as e:
+        logger.error(f"Failed to get traffic status: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.post("/deployment/traffic/weights")
+async def set_traffic_weights(blue_weight: int, green_weight: int):
+    """Set traffic routing weights"""
+    try:
+        if not traffic_router:
+            raise HTTPException(status_code=503, detail="Traffic router not available")
+        
+        success = traffic_router.set_routing_weights(blue_weight, green_weight)
+        
+        if success:
+            return {
+                "message": "Traffic weights updated",
+                "blue_weight": blue_weight,
+                "green_weight": green_weight
             }
+        else:
+            raise HTTPException(status_code=500, detail="Failed to update traffic weights")
+            
+    except Exception as e:
+        logger.error(f"Failed to set traffic weights: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
 
-        return ensemble_status
+@app.get("/deployment/performance")
+async def get_deployment_performance(window_minutes: int = 60):
+    """Get deployment performance comparison"""
+    try:
+        if not traffic_router:
+            raise HTTPException(status_code=503, detail="Traffic router not available")
+        
+        return traffic_router.compare_environment_performance(window_minutes)
+        
+    except Exception as e:
+        logger.error(f"Failed to get deployment performance: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
 
+@app.get("/registry/models")
+async def list_registry_models(status: str = None, limit: int = 10):
+    """List models in registry"""
+    try:
+        if not model_registry:
+            raise HTTPException(status_code=503, detail="Model registry not available")
+        
+        models = model_registry.list_models(status=status, limit=limit)
+        return {"models": [asdict(model) for model in models]}
+        
     except Exception as e:
-        logger.error(f"Ensemble status retrieval failed: {e}")
-        raise HTTPException(
-            status_code=500,
-            detail=f"Failed to retrieve ensemble status: {str(e)}"
-        )
+        logger.error(f"Failed to list registry models: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.get("/registry/stats")
+async def get_registry_stats():
+    """Get model registry statistics"""
+    try:
+        if not model_registry:
+            raise HTTPException(status_code=503, detail="Model registry not available")
+        
+        return model_registry.get_registry_stats()
+        
+    except Exception as e:
+        logger.error(f"Failed to get registry stats: {e}")
+        raise HTTPException(status_code=500, detail=str(e))