Update app/fastapi_server.py

Reverted previous working version

app/fastapi_server.py

@@ -1,5 +1,4 @@
-# Add missing import
-import os
+import json
 import time
 import joblib
 import logging
@@ -24,59 +23,12 @@ from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
 from fastapi import FastAPI, HTTPException, Depends, Request, BackgroundTasks, status
 
 
-# =============================================================================
-# CENTRALIZED PATH CONFIGURATION - FIXES THE CRITICAL BUG
-# =============================================================================
-class PathConfig:
-    """Centralized path management to ensure consistency across all components"""
-    
-    # Environment detection
-    if os.getenv("HF_SPACES_BUILD") == "1" or os.getenv("SPACE_ID"):
-        BASE_DIR = Path("/app/persistent")
-        ENVIRONMENT = "huggingface_spaces"
-    else:
-        BASE_DIR = Path("/tmp")
-        ENVIRONMENT = "local"
-    
-    # Base directories
-    DATA_DIR = BASE_DIR / "data"  
-    MODEL_DIR = BASE_DIR / "model"
-    LOGS_DIR = BASE_DIR / "logs"
-    
-    # Model files - CONSISTENT PATHS (matches train.py)
-    MODEL_FILE = MODEL_DIR / "model.pkl"           # ✅ /tmp/model/model.pkl
-    VECTORIZER_FILE = MODEL_DIR / "vectorizer.pkl" # ✅ /tmp/model/vectorizer.pkl
-    PIPELINE_FILE = MODEL_DIR / "pipeline.pkl"     # ✅ /tmp/model/pipeline.pkl
-    METADATA_FILE = BASE_DIR / "metadata.json"     # ✅ /tmp/metadata.json
-    
-    # Log files
-    SERVER_LOG = LOGS_DIR / "fastapi_server.log"
-    PREDICTION_LOG = LOGS_DIR / "prediction_log.json"
-    
-    @classmethod
-    def ensure_directories(cls):
-        """Create all required directories with proper permissions"""
-        for attr_name in dir(cls):
-            attr = getattr(cls, attr_name)
-            if isinstance(attr, Path) and attr_name.endswith('_DIR'):
-                attr.mkdir(parents=True, exist_ok=True, mode=0o755)
-                
-        # Ensure log directory exists
-        cls.LOGS_DIR.mkdir(parents=True, exist_ok=True, mode=0o755)
-
-
-# Initialize directories at startup
-PathConfig.ensure_directories()
-
-
-# =============================================================================
-# ENHANCED LOGGING CONFIGURATION
-# =============================================================================
+# Configure logging
 logging.basicConfig(
     level=logging.INFO,
-    format='%(asctime)s - %(levelname)s - %(name)s - %(message)s',
+    format='%(asctime)s - %(levelname)s - %(message)s',
     handlers=[
-        logging.FileHandler(PathConfig.SERVER_LOG),
+        logging.FileHandler('/tmp/fastapi_server.log'),
         logging.StreamHandler()
     ]
 )
@@ -89,57 +41,8 @@ security = HTTPBearer(auto_error=False)
 rate_limit_storage = defaultdict(list)
 
 
-# =============================================================================
-# CIRCUIT BREAKER FOR RESILIENCE
-# =============================================================================
-class CircuitBreaker:
-    """Circuit breaker pattern for model operations"""
-    
-    def __init__(self, failure_threshold: int = 5, recovery_timeout: int = 60):
-        self.failure_threshold = failure_threshold
-        self.recovery_timeout = recovery_timeout
-        self.failure_count = 0
-        self.last_failure_time = None
-        self.state = 'CLOSED'  # CLOSED, OPEN, HALF_OPEN
-        
-    def call(self, func, *args, **kwargs):
-        """Execute function with circuit breaker protection"""
-        if self.state == 'OPEN':
-            if time.time() - self.last_failure_time > self.recovery_timeout:
-                self.state = 'HALF_OPEN'
-                logger.info("Circuit breaker transitioning to HALF_OPEN")
-            else:
-                raise Exception("Circuit breaker is OPEN - service unavailable")
-                
-        try:
-            result = func(*args, **kwargs)
-            self.on_success()
-            return result
-        except Exception as e:
-            self.on_failure()
-            raise
-            
-    def on_success(self):
-        """Reset circuit breaker on successful operation"""
-        self.failure_count = 0
-        if self.state == 'HALF_OPEN':
-            self.state = 'CLOSED'
-            logger.info("Circuit breaker reset to CLOSED")
-            
-    def on_failure(self):
-        """Handle failure and potentially open circuit"""
-        self.failure_count += 1
-        self.last_failure_time = time.time()
-        if self.failure_count >= self.failure_threshold:
-            self.state = 'OPEN'
-            logger.error(f"Circuit breaker OPENED after {self.failure_count} failures")
-
-
-# =============================================================================
-# ENHANCED MODEL MANAGER WITH FIXED PATHS
-# =============================================================================
 class ModelManager:
-    """Enhanced model manager with circuit breaker and proper path handling"""
+    """Manages model loading and health checks"""
 
     def __init__(self):
         self.model = None
@@ -148,139 +51,68 @@ class ModelManager:
         self.model_metadata = {}
         self.last_health_check = None
         self.health_status = "unknown"
-        self.circuit_breaker = CircuitBreaker()
         self.load_model()
 
     def load_model(self):
-        """Load model with FIXED PATHS and comprehensive error handling"""
+        """Load model with comprehensive error handling"""
         try:
-            logger.info("Loading ML model with corrected paths...")
-            
-            # FIXED: Use correct paths that match train.py
-            pipeline_path = PathConfig.PIPELINE_FILE      # ✅ /tmp/model/pipeline.pkl
-            model_path = PathConfig.MODEL_FILE           # ✅ /tmp/model/model.pkl
-            vectorizer_path = PathConfig.VECTORIZER_FILE # ✅ /tmp/model/vectorizer.pkl
-            metadata_path = PathConfig.METADATA_FILE     # ✅ /tmp/metadata.json
-
-            logger.info(f"Looking for pipeline at: {pipeline_path}")
-            logger.info(f"Looking for model at: {model_path}")
-            logger.info(f"Looking for vectorizer at: {vectorizer_path}")
-
-            # Try to load pipeline first (preferred method)
+            logger.info("Loading ML model...")
+
+            # Try to load pipeline first (preferred)
+            # pipeline_path = Path("/tmp/model/pipeline.pkl")
+            pipeline_path = Path("/tmp/pipeline.pkl")
             if pipeline_path.exists():
-                logger.info("✅ Found pipeline file, loading...")
                 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('vectorize')
-                    logger.info("✅ Extracted model and vectorizer from pipeline")
-                else:
-                    # Pipeline might be the complete model
-                    logger.info("✅ Pipeline loaded as complete model")
-                    
-                logger.info("✅ Loaded model pipeline successfully")
-                
-            elif model_path.exists() and vectorizer_path.exists():
-                # Fallback to individual components
-                logger.info("📦 Loading individual model components...")
-                self.model = joblib.load(model_path)
-                self.vectorizer = joblib.load(vectorizer_path)
-                logger.info("✅ Loaded individual model components successfully")
-                
+                self.model = self.pipeline.named_steps.get('model')
+                self.vectorizer = self.pipeline.named_steps.get('vectorize')
+                logger.info("Loaded model pipeline successfully")
             else:
-                # Detailed error message for debugging
-                available_files = []
-                for path in [pipeline_path, model_path, vectorizer_path]:
-                    if path.exists():
-                        available_files.append(str(path))
-                        
-                error_msg = f"No model files found at expected paths. Available files: {available_files}"
-                logger.error(error_msg)
-                raise FileNotFoundError(error_msg)
-
-            # Load metadata if available
+                # Fallback to individual components
+                model_path = Path("/tmp/model.pkl")
+                vectorizer_path = Path("/tmp/vectorizer.pkl")
+
+                if model_path.exists() and vectorizer_path.exists():
+                    self.model = joblib.load(model_path)
+                    self.vectorizer = joblib.load(vectorizer_path)
+                    logger.info("Loaded model components successfully")
+                else:
+                    raise FileNotFoundError("No model files found")
+
+            # Load metadata
+            metadata_path = Path("/tmp/metadata.json")
             if metadata_path.exists():
-                try:
-                    with open(metadata_path, 'r') as f:
-                        self.model_metadata = json.load(f)
-                    logger.info(f"✅ Loaded model metadata: {self.model_metadata.get('model_version', 'Unknown')}")
-                except Exception as e:
-                    logger.warning(f"Could not load metadata: {e}")
-                    self.model_metadata = {"model_version": "unknown"}
-            else:
-                logger.warning(f"Metadata file not found at {metadata_path}")
-                self.model_metadata = {"model_version": "unknown"}
+                with open(metadata_path, 'r') as f:
+                    self.model_metadata = json.load(f)
+                logger.info(
+                    f"Loaded model metadata: {self.model_metadata.get('model_version', 'Unknown')}")
 
-            # Verify model is functional
-            self._verify_model_functionality()
-            
             self.health_status = "healthy"
             self.last_health_check = datetime.now()
-            logger.info("🎉 Model loaded successfully and is functional!")
 
         except Exception as e:
-            logger.error(f"❌ Failed to load model: {str(e)}")
-            logger.error(f"❌ Exception details: {traceback.format_exc()}")
+            logger.error(f"Failed to load model: {e}")
             self.health_status = "unhealthy"
             self.model = None
             self.vectorizer = None
             self.pipeline = None
-            
-    def _verify_model_functionality(self):
-        """Verify that the loaded model can make predictions"""
-        test_text = "This is a test article for verification purposes."
-        
-        try:
-            if self.pipeline:
-                # Test pipeline prediction
-                prediction = self.pipeline.predict([test_text])
-                probabilities = self.pipeline.predict_proba([test_text])
-                logger.info("✅ Pipeline prediction test successful")
-            elif self.model and self.vectorizer:
-                # Test individual components
-                X = self.vectorizer.transform([test_text])
-                prediction = self.model.predict(X)
-                probabilities = self.model.predict_proba(X)
-                logger.info("✅ Individual components prediction test successful")
-            else:
-                raise ValueError("No functional model components available")
-                
-        except Exception as e:
-            logger.error(f"❌ Model functionality verification failed: {e}")
-            raise
 
     def predict(self, text: str) -> tuple[str, float]:
-        """Make prediction with circuit breaker protection"""
-        return self.circuit_breaker.call(self._predict_internal, text)
-        
-    def _predict_internal(self, text: str) -> tuple[str, float]:
-        """Internal prediction method"""
+        """Make prediction with error handling"""
         try:
             if self.pipeline:
                 # Use pipeline for prediction
                 prediction = self.pipeline.predict([text])[0]
                 probabilities = self.pipeline.predict_proba([text])[0]
-                logger.debug("Used pipeline for prediction")
-                
             elif self.model and self.vectorizer:
                 # Use individual components
                 X = self.vectorizer.transform([text])
                 prediction = self.model.predict(X)[0]
                 probabilities = self.model.predict_proba(X)[0]
-                logger.debug("Used individual components for prediction")
-                
             else:
                 raise ValueError("No model available for prediction")
 
-            # Get confidence score (handle both binary and probability outputs)
-            if isinstance(probabilities, (list, np.ndarray)) and len(probabilities) > 1:
-                # Multi-class probabilities
-                confidence = float(np.max(probabilities))
-            else:
-                # Binary classification
-                confidence = float(probabilities[1] if len(probabilities) > 1 else probabilities[0])
+            # Get confidence score
+            confidence = float(probabilities[prediction])
 
             # Convert prediction to readable format
             label = "Fake" if prediction == 1 else "Real"
@@ -288,14 +120,14 @@ class ModelManager:
             return label, confidence
 
         except Exception as e:
-            logger.error(f"❌ Prediction failed: {str(e)}")
+            logger.error(f"Prediction failed: {e}")
             raise HTTPException(
                 status_code=500,
                 detail=f"Prediction failed: {str(e)}"
             )
 
     def health_check(self) -> Dict[str, Any]:
-        """Comprehensive health check with circuit breaker status"""
+        """Perform health check"""
         try:
             # Test prediction with sample text
             test_text = "This is a test article for health check purposes."
@@ -310,15 +142,7 @@ class ModelManager:
                 "model_available": self.model is not None,
                 "vectorizer_available": self.vectorizer is not None,
                 "pipeline_available": self.pipeline is not None,
-                "circuit_breaker_state": self.circuit_breaker.state,
-                "circuit_breaker_failures": self.circuit_breaker.failure_count,
-                "test_prediction": {"label": label, "confidence": confidence},
-                "model_paths": {
-                    "pipeline_exists": PathConfig.PIPELINE_FILE.exists(),
-                    "model_exists": PathConfig.MODEL_FILE.exists(),
-                    "vectorizer_exists": PathConfig.VECTORIZER_FILE.exists(),
-                    "metadata_exists": PathConfig.METADATA_FILE.exists()
-                }
+                "test_prediction": {"label": label, "confidence": confidence}
             }
 
         except Exception as e:
@@ -331,15 +155,7 @@ class ModelManager:
                 "error": str(e),
                 "model_available": self.model is not None,
                 "vectorizer_available": self.vectorizer is not None,
-                "pipeline_available": self.pipeline is not None,
-                "circuit_breaker_state": self.circuit_breaker.state,
-                "circuit_breaker_failures": self.circuit_breaker.failure_count,
-                "model_paths": {
-                    "pipeline_exists": PathConfig.PIPELINE_FILE.exists(),
-                    "model_exists": PathConfig.MODEL_FILE.exists(),
-                    "vectorizer_exists": PathConfig.VECTORIZER_FILE.exists(),
-                    "metadata_exists": PathConfig.METADATA_FILE.exists()
-                }
+                "pipeline_available": self.pipeline is not None
             }
 
 
@@ -347,17 +163,11 @@ class ModelManager:
 model_manager = ModelManager()
 
 
-# =============================================================================
-# FASTAPI APPLICATION SETUP
-# =============================================================================
 @asynccontextmanager
 async def lifespan(app: FastAPI):
-    """Manage application lifespan with enhanced startup"""
-    logger.info("🚀 Starting FastAPI application...")
+    """Manage application lifespan"""
+    logger.info("Starting FastAPI application...")
 
-    # Ensure directories exist
-    PathConfig.ensure_directories()
-    
     # Startup tasks
     model_manager.load_model()
 
@@ -367,14 +177,13 @@ async def lifespan(app: FastAPI):
     yield
 
     # Shutdown tasks
-    logger.info("🛑 Shutting down FastAPI application...")
-
+    logger.info("Shutting down FastAPI application...")
 
 # Create FastAPI app
 app = FastAPI(
     title="Fake News Detection API",
-    description="Production-ready API for fake news detection with fixed path management and comprehensive monitoring",
-    version="2.1.0",
+    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
@@ -394,10 +203,9 @@ app.add_middleware(
     allowed_hosts=["*"]  # Configure appropriately for production
 )
 
+# Request/Response models
+
 
-# =============================================================================
-# REQUEST/RESPONSE MODELS (UNCHANGED)
-# =============================================================================
 class PredictionRequest(BaseModel):
     text: str = Field(..., min_length=1, max_length=10000,
                       description="Text to analyze for fake news detection")
@@ -464,10 +272,9 @@ class HealthResponse(BaseModel):
     system_health: Dict[str, Any]
     api_health: Dict[str, Any]
 
+# Rate limiting
+
 
-# =============================================================================
-# MIDDLEWARE AND RATE LIMITING (UNCHANGED)
-# =============================================================================
 async def rate_limit_check(request: Request):
     """Check rate limits"""
     client_ip = request.client.host
@@ -489,6 +296,8 @@ async def rate_limit_check(request: Request):
     # Add current request
     rate_limit_storage[client_ip].append(current_time)
 
+# Logging middleware
+
 
 @app.middleware("http")
 async def log_requests(request: Request, call_next):
@@ -512,10 +321,9 @@ async def log_requests(request: Request, call_next):
 
     return response
 
+# Error handlers
+
 
-# =============================================================================
-# ERROR HANDLERS (UNCHANGED)
-# =============================================================================
 @app.exception_handler(HTTPException)
 async def http_exception_handler(request: Request, exc: HTTPException):
     """Handle HTTP exceptions"""
@@ -552,42 +360,35 @@ async def general_exception_handler(request: Request, exc: Exception):
         content=error_data
     )
 
+# Background tasks
+
 
-# =============================================================================
-# BACKGROUND TASKS
-# =============================================================================
 async def periodic_health_check():
-    """Enhanced 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...")
+                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}")
+            logger.error(f"Periodic health check failed: {e}")
+
+# API Routes
 
 
-# =============================================================================
-# API ROUTES (ENHANCED WITH BETTER ERROR HANDLING)
-# =============================================================================
 @app.get("/", response_model=Dict[str, str])
 async def root():
-    """Root endpoint with path diagnostics"""
+    """Root endpoint"""
     return {
-        "message": "Fake News Detection API - FIXED VERSION",
-        "version": "2.1.0",
-        "status": "Path management issues resolved",
+        "message": "Fake News Detection API",
+        "version": "2.0.0",
         "documentation": "/docs",
-        "health_check": "/health",
-        "model_path_info": {
-            "pipeline_path": str(PathConfig.PIPELINE_FILE),
-            "model_path": str(PathConfig.MODEL_FILE),
-            "vectorizer_path": str(PathConfig.VECTORIZER_FILE)
-        }
+        "health_check": "/health"
     }
 
 
@@ -645,7 +446,7 @@ async def predict(
     except HTTPException:
         raise
     except Exception as e:
-        logger.error(f"❌ Prediction failed: {e}")
+        logger.error(f"Prediction failed: {e}")
         raise HTTPException(
             status_code=500,
             detail=f"Prediction failed: {str(e)}"
@@ -693,7 +494,7 @@ async def predict_batch(
                 predictions.append(prediction)
 
             except Exception as e:
-                logger.error(f"❌ Batch prediction failed for text: {e}")
+                logger.error(f"Batch prediction failed for text: {e}")
                 # Continue with other texts
                 continue
 
@@ -725,7 +526,7 @@ async def predict_batch(
     except HTTPException:
         raise
     except Exception as e:
-        logger.error(f"❌ Batch prediction failed: {e}")
+        logger.error(f"Batch prediction failed: {e}")
         raise HTTPException(
             status_code=500,
             detail=f"Batch prediction failed: {str(e)}"
@@ -735,7 +536,7 @@ async def predict_batch(
 @app.get("/health", response_model=HealthResponse)
 async def health_check():
     """
-    Enhanced health check endpoint with path diagnostics
+    Comprehensive health check endpoint
 
     - **returns**: Detailed health status of the API and model
     """
@@ -770,7 +571,7 @@ async def health_check():
         )
 
     except Exception as e:
-        logger.error(f"❌ Health check failed: {e}")
+        logger.error(f"Health check failed: {e}")
         return HealthResponse(
             status="unhealthy",
             timestamp=datetime.now().isoformat(),
@@ -783,7 +584,7 @@ async def health_check():
 @app.get("/metrics")
 async def get_metrics():
     """
-    Get API metrics with enhanced path information
+    Get API metrics
 
     - **returns**: Usage statistics and performance metrics
     """
@@ -799,23 +600,13 @@ async def get_metrics():
             "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,
-            "circuit_breaker": {
-                "state": model_manager.circuit_breaker.state,
-                "failure_count": model_manager.circuit_breaker.failure_count
-            },
-            "path_status": {
-                "pipeline_exists": PathConfig.PIPELINE_FILE.exists(),
-                "model_exists": PathConfig.MODEL_FILE.exists(),
-                "vectorizer_exists": PathConfig.VECTORIZER_FILE.exists(),
-                "metadata_exists": PathConfig.METADATA_FILE.exists()
-            },
             "timestamp": datetime.now().isoformat()
         }
 
         return metrics
 
     except Exception as e:
-        logger.error(f"❌ Metrics retrieval failed: {e}")
+        logger.error(f"Metrics retrieval failed: {e}")
         raise HTTPException(
             status_code=500,
             detail=f"Metrics retrieval failed: {str(e)}"
@@ -825,12 +616,12 @@ async def get_metrics():
 @app.post("/model/reload")
 async def reload_model():
     """
-    Reload the ML model with enhanced feedback
+    Reload the ML model
 
     - **returns**: Status of model reload operation
     """
     try:
-        logger.info("🔄 Manual model reload requested")
+        logger.info("Manual model reload requested")
         model_manager.load_model()
 
         return {
@@ -838,29 +629,21 @@ async def reload_model():
             "message": "Model reloaded successfully",
             "model_health": model_manager.health_status,
             "model_version": model_manager.model_metadata.get('model_version', 'unknown'),
-            "circuit_breaker_reset": model_manager.circuit_breaker.state,
-            "path_verification": {
-                "pipeline_exists": PathConfig.PIPELINE_FILE.exists(),
-                "model_exists": PathConfig.MODEL_FILE.exists(),
-                "vectorizer_exists": PathConfig.VECTORIZER_FILE.exists(),
-                "metadata_exists": PathConfig.METADATA_FILE.exists()
-            },
             "timestamp": datetime.now().isoformat()
         }
 
     except Exception as e:
-        logger.error(f"❌ Model reload failed: {e}")
+        logger.error(f"Model reload failed: {e}")
         raise HTTPException(
             status_code=500,
             detail=f"Model reload failed: {str(e)}"
         )
 
+# Background task functions
+
 
-# =============================================================================
-# BACKGROUND TASK FUNCTIONS (ENHANCED)
-# =============================================================================
 async def log_prediction(text: str, prediction: str, confidence: float, client_ip: str, processing_time: float):
-    """Log prediction details to structured log file"""
+    """Log prediction details"""
     try:
         log_entry = {
             "timestamp": datetime.now().isoformat(),
@@ -872,8 +655,8 @@ async def log_prediction(text: str, prediction: str, confidence: float, client_i
             "text_hash": hashlib.md5(text.encode()).hexdigest()
         }
 
-        # Save to log file with proper path
-        log_file = PathConfig.PREDICTION_LOG
+        # Save to log file
+        log_file = Path("/tmp/prediction_log.json")
 
         # Load existing logs
         logs = []
@@ -897,7 +680,7 @@ async def log_prediction(text: str, prediction: str, confidence: float, client_i
             await f.write(json.dumps(logs, indent=2))
 
     except Exception as e:
-        logger.error(f"❌ Failed to log prediction: {e}")
+        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):
@@ -913,114 +696,22 @@ async def log_batch_prediction(total_texts: int, successful_predictions: int, cl
             "success_rate": successful_predictions / total_texts if total_texts > 0 else 0
         }
 
-        logger.info(f"📊 Batch prediction logged: {json.dumps(log_entry)}")
+        logger.info(f"Batch prediction logged: {json.dumps(log_entry)}")
 
     except Exception as e:
-        logger.error(f"❌ Failed to log batch prediction: {e}")
+        logger.error(f"Failed to log batch prediction: {e}")
 
-
-# =============================================================================
-# ENHANCED PATH DIAGNOSTICS ENDPOINT
-# =============================================================================
-@app.get("/debug/paths")
-async def debug_paths():
-    """
-    Debug endpoint to check all file paths and their existence
-    
-    - **returns**: Detailed path information for troubleshooting
-    """
-    try:
-        path_info = {
-            "base_directories": {
-                "BASE_DIR": {
-                    "path": str(PathConfig.BASE_DIR),
-                    "exists": PathConfig.BASE_DIR.exists(),
-                    "is_dir": PathConfig.BASE_DIR.is_dir() if PathConfig.BASE_DIR.exists() else False
-                },
-                "MODEL_DIR": {
-                    "path": str(PathConfig.MODEL_DIR),
-                    "exists": PathConfig.MODEL_DIR.exists(),
-                    "is_dir": PathConfig.MODEL_DIR.is_dir() if PathConfig.MODEL_DIR.exists() else False
-                },
-                "DATA_DIR": {
-                    "path": str(PathConfig.DATA_DIR),
-                    "exists": PathConfig.DATA_DIR.exists(),
-                    "is_dir": PathConfig.DATA_DIR.is_dir() if PathConfig.DATA_DIR.exists() else False
-                },
-                "LOGS_DIR": {
-                    "path": str(PathConfig.LOGS_DIR),
-                    "exists": PathConfig.LOGS_DIR.exists(),
-                    "is_dir": PathConfig.LOGS_DIR.is_dir() if PathConfig.LOGS_DIR.exists() else False
-                }
-            },
-            "model_files": {
-                "PIPELINE_FILE": {
-                    "path": str(PathConfig.PIPELINE_FILE),
-                    "exists": PathConfig.PIPELINE_FILE.exists(),
-                    "size": PathConfig.PIPELINE_FILE.stat().st_size if PathConfig.PIPELINE_FILE.exists() else None
-                },
-                "MODEL_FILE": {
-                    "path": str(PathConfig.MODEL_FILE),
-                    "exists": PathConfig.MODEL_FILE.exists(),
-                    "size": PathConfig.MODEL_FILE.stat().st_size if PathConfig.MODEL_FILE.exists() else None
-                },
-                "VECTORIZER_FILE": {
-                    "path": str(PathConfig.VECTORIZER_FILE),
-                    "exists": PathConfig.VECTORIZER_FILE.exists(),
-                    "size": PathConfig.VECTORIZER_FILE.stat().st_size if PathConfig.VECTORIZER_FILE.exists() else None
-                },
-                "METADATA_FILE": {
-                    "path": str(PathConfig.METADATA_FILE),
-                    "exists": PathConfig.METADATA_FILE.exists(),
-                    "size": PathConfig.METADATA_FILE.stat().st_size if PathConfig.METADATA_FILE.exists() else None
-                }
-            },
-            "model_manager_status": {
-                "model_loaded": model_manager.model is not None,
-                "vectorizer_loaded": model_manager.vectorizer is not None,
-                "pipeline_loaded": model_manager.pipeline is not None,
-                "health_status": model_manager.health_status,
-                "circuit_breaker_state": model_manager.circuit_breaker.state
-            },
-            "directory_contents": {
-                "base_dir_files": [str(f) for f in PathConfig.BASE_DIR.iterdir()] if PathConfig.BASE_DIR.exists() else [],
-                "model_dir_files": [str(f) for f in PathConfig.MODEL_DIR.iterdir()] if PathConfig.MODEL_DIR.exists() else []
-            }
-        }
-        
-        return path_info
-        
-    except Exception as e:
-        logger.error(f"❌ Path debug failed: {e}")
-        return {
-            "error": str(e),
-            "timestamp": datetime.now().isoformat()
-        }
+# Custom OpenAPI
 
 
-# =============================================================================
-# CUSTOM OPENAPI CONFIGURATION
-# =============================================================================
 def custom_openapi():
     if app.openapi_schema:
         return app.openapi_schema
 
     openapi_schema = get_openapi(
-        title="Fake News Detection API - FIXED VERSION",
-        version="2.1.0",
-        description="""
-        Production-ready API for fake news detection with FIXED path management.
-        
-        **Key Fixes:**
-        - ✅ Centralized path configuration
-        - ✅ Circuit breaker pattern for resilience  
-        - ✅ Enhanced error handling and logging
-        - ✅ Path diagnostics endpoints for debugging
-        
-        **Critical Bug Fix:**
-        The previous version had inconsistent paths between FastAPI server and training components.
-        This version uses consistent paths that match the training pipeline.
-        """,
+        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,
     )
 
@@ -1039,33 +730,12 @@ def custom_openapi():
 
 app.openapi = custom_openapi
 
-
-# =============================================================================
-# APPLICATION STARTUP
-# =============================================================================
 if __name__ == "__main__":
-    # Final path verification before starting
-    logger.info("🔍 Performing final path verification...")
-    
-    PathConfig.ensure_directories()
-    
-    logger.info(f"📁 Model directory: {PathConfig.MODEL_DIR}")
-    logger.info(f"📁 Pipeline file path: {PathConfig.PIPELINE_FILE}")
-    logger.info(f"📁 Model file path: {PathConfig.MODEL_FILE}")
-    logger.info(f"📁 Vectorizer file path: {PathConfig.VECTORIZER_FILE}")
-    
-    if PathConfig.MODEL_DIR.exists():
-        logger.info(f"✅ Model directory exists with {len(list(PathConfig.MODEL_DIR.iterdir()))} files")
-        for file in PathConfig.MODEL_DIR.iterdir():
-            logger.info(f"   📄 {file.name} ({file.stat().st_size} bytes)")
-    else:
-        logger.warning(f"⚠️ Model directory does not exist: {PathConfig.MODEL_DIR}")
-    
     uvicorn.run(
         "fastapi_server:app",
-        host="0.0.0.0",  # Changed to 0.0.0.0 for containerized environments
+        host="127.0.0.1",
         port=8000,
         log_level="info",
         reload=False,
         access_log=True
-    )
+    )