Upload 11 files

src/social_sphere_llm/api_service.py

@@ -0,0 +1,287 @@
+"""
+Social Media Analysis API Service
+
+A FastAPI web service for serving MLflow-trained social media analysis models.
+"""
+
+from fastapi import FastAPI, HTTPException, BackgroundTasks
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel, Field
+from typing import List, Dict, Optional, Any
+import uvicorn
+import json
+import logging
+from datetime import datetime
+import pandas as pd
+
+from .prediction_service import SocialMediaPredictionService
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Initialize FastAPI app
+app = FastAPI(
+    title="Social Media Analysis API",
+    description="API for predicting social media addiction using MLflow models",
+    version="1.0.0",
+    docs_url="/docs",
+    redoc_url="/redoc"
+)
+
+# Add CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Global prediction service
+prediction_service = None
+
+
+class PredictionRequest(BaseModel):
+    """Request model for single prediction."""
+    data: Dict[str, Any] = Field(..., description="Input features for prediction")
+    
+    class Config:
+        schema_extra = {
+            "example": {
+                "data": {
+                    "feature1": 0.5,
+                    "feature2": -0.2,
+                    "feature3": 1.0
+                }
+            }
+        }
+
+
+class BatchPredictionRequest(BaseModel):
+    """Request model for batch predictions."""
+    data: List[Dict[str, Any]] = Field(..., description="List of input features for predictions")
+    
+    class Config:
+        schema_extra = {
+            "example": {
+                "data": [
+                    {"feature1": 0.5, "feature2": -0.2, "feature3": 1.0},
+                    {"feature1": -0.1, "feature2": 0.8, "feature3": -0.5}
+                ]
+            }
+        }
+
+
+class PredictionResponse(BaseModel):
+    """Response model for predictions."""
+    prediction: int = Field(..., description="Predicted class (0: Low Risk, 1: High Risk)")
+    probability: List[float] = Field(..., description="Class probabilities")
+    confidence: float = Field(..., description="Confidence score")
+    prediction_class: str = Field(..., description="Human-readable prediction class")
+    model_name: str = Field(..., description="Name of the model used")
+    model_version: str = Field(..., description="Version of the model used")
+    timestamp: str = Field(..., description="Prediction timestamp")
+
+
+class BatchPredictionResponse(BaseModel):
+    """Response model for batch predictions."""
+    predictions: List[int] = Field(..., description="List of predicted classes")
+    probabilities: List[List[float]] = Field(..., description="List of class probabilities")
+    confidence_scores: List[float] = Field(..., description="List of confidence scores")
+    prediction_classes: List[str] = Field(..., description="List of human-readable prediction classes")
+    model_name: str = Field(..., description="Name of the model used")
+    model_version: str = Field(..., description="Version of the model used")
+    timestamp: str = Field(..., description="Prediction timestamp")
+    total_predictions: int = Field(..., description="Total number of predictions made")
+
+
+class ModelInfoResponse(BaseModel):
+    """Response model for model information."""
+    model_name: str = Field(..., description="Name of the model")
+    model_version: str = Field(..., description="Version of the model")
+    model_loaded: bool = Field(..., description="Whether the model is loaded")
+    feature_columns: Optional[List[str]] = Field(None, description="Required feature columns")
+    model_type: Optional[str] = Field(None, description="Type of the model")
+    metadata: Optional[Dict[str, Any]] = Field(None, description="Model metadata")
+
+
+class HealthResponse(BaseModel):
+    """Response model for health check."""
+    status: str = Field(..., description="Service status")
+    timestamp: str = Field(..., description="Current timestamp")
+    model_loaded: bool = Field(..., description="Whether the model is loaded")
+    uptime: str = Field(..., description="Service uptime")
+
+
+# Startup and shutdown events
+@app.on_event("startup")
+async def startup_event():
+    """Initialize the prediction service on startup."""
+    global prediction_service
+    try:
+        prediction_service = SocialMediaPredictionService()
+        logger.info("✅ Prediction service initialized successfully")
+    except Exception as e:
+        logger.error(f"❌ Failed to initialize prediction service: {e}")
+        prediction_service = None
+
+
+@app.on_event("shutdown")
+async def shutdown_event():
+    """Cleanup on shutdown."""
+    logger.info("🔄 Shutting down Social Media Analysis API")
+
+
+# Health check endpoint
+@app.get("/health", response_model=HealthResponse, tags=["Health"])
+async def health_check():
+    """Check the health status of the API service."""
+    return HealthResponse(
+        status="healthy" if prediction_service and prediction_service.model else "unhealthy",
+        timestamp=datetime.now().isoformat(),
+        model_loaded=prediction_service is not None and prediction_service.model is not None,
+        uptime="running"
+    )
+
+
+# Model information endpoint
+@app.get("/model/info", response_model=ModelInfoResponse, tags=["Model"])
+async def get_model_info():
+    """Get information about the loaded model."""
+    if not prediction_service:
+        raise HTTPException(status_code=503, detail="Prediction service not available")
+    
+    try:
+        model_info = prediction_service.get_model_info()
+        return ModelInfoResponse(**model_info)
+    except Exception as e:
+        logger.error(f"❌ Failed to get model info: {e}")
+        raise HTTPException(status_code=500, detail=f"Failed to get model info: {str(e)}")
+
+
+# Single prediction endpoint
+@app.post("/predict", response_model=PredictionResponse, tags=["Prediction"])
+async def predict_single(request: PredictionRequest):
+    """Make a prediction for a single data point."""
+    if not prediction_service:
+        raise HTTPException(status_code=503, detail="Prediction service not available")
+    
+    try:
+        # Make prediction
+        result = prediction_service.predict_single(request.data)
+        
+        # Add timestamp
+        result['timestamp'] = datetime.now().isoformat()
+        
+        return PredictionResponse(**result)
+        
+    except Exception as e:
+        logger.error(f"❌ Prediction failed: {e}")
+        raise HTTPException(status_code=500, detail=f"Prediction failed: {str(e)}")
+
+
+# Batch prediction endpoint
+@app.post("/predict/batch", response_model=BatchPredictionResponse, tags=["Prediction"])
+async def predict_batch(request: BatchPredictionRequest):
+    """Make predictions for multiple data points."""
+    if not prediction_service:
+        raise HTTPException(status_code=503, detail="Prediction service not available")
+    
+    try:
+        # Make batch predictions
+        results = prediction_service.predict(request.data)
+        
+        # Add timestamp and total count
+        results['timestamp'] = datetime.now().isoformat()
+        results['total_predictions'] = len(results['predictions'])
+        
+        return BatchPredictionResponse(**results)
+        
+    except Exception as e:
+        logger.error(f"❌ Batch prediction failed: {e}")
+        raise HTTPException(status_code=500, detail=f"Batch prediction failed: {str(e)}")
+
+
+# Model reload endpoint
+@app.post("/model/reload", tags=["Model"])
+async def reload_model(background_tasks: BackgroundTasks):
+    """Reload the model in the background."""
+    if not prediction_service:
+        raise HTTPException(status_code=503, detail="Prediction service not available")
+    
+    def reload_model_task():
+        """Background task to reload the model."""
+        global prediction_service
+        try:
+            prediction_service = SocialMediaPredictionService()
+            logger.info("✅ Model reloaded successfully")
+        except Exception as e:
+            logger.error(f"❌ Failed to reload model: {e}")
+    
+    background_tasks.add_task(reload_model_task)
+    
+    return {
+        "message": "Model reload initiated",
+        "timestamp": datetime.now().isoformat()
+    }
+
+
+# Root endpoint
+@app.get("/", tags=["Root"])
+async def root():
+    """Root endpoint with API information."""
+    return {
+        "message": "Social Media Analysis API",
+        "version": "1.0.0",
+        "docs": "/docs",
+        "health": "/health",
+        "model_info": "/model/info",
+        "predict": "/predict",
+        "batch_predict": "/predict/batch"
+    }
+
+
+# Error handlers
+@app.exception_handler(404)
+async def not_found_handler(request, exc):
+    """Handle 404 errors."""
+    return {
+        "error": "Not found",
+        "message": "The requested resource was not found",
+        "timestamp": datetime.now().isoformat()
+    }
+
+
+@app.exception_handler(500)
+async def internal_error_handler(request, exc):
+    """Handle 500 errors."""
+    return {
+        "error": "Internal server error",
+        "message": "An internal server error occurred",
+        "timestamp": datetime.now().isoformat()
+    }
+
+
+def start_api_server(host: str = "0.0.0.0", port: int = 8000, reload: bool = False):
+    """
+    Start the FastAPI server.
+    
+    Args:
+        host: Host to bind the server to
+        port: Port to bind the server to
+        reload: Whether to enable auto-reload
+    """
+    uvicorn.run(
+        "social_sphere_llm.api_service:app",
+        host=host,
+        port=port,
+        reload=reload,
+        log_level="info"
+    )
+
+
+if __name__ == "__main__":
+    # Start the API server
+    print("🚀 Starting Social Media Analysis API...")
+    start_api_server(host="0.0.0.0", port=8000, reload=True) 

src/social_sphere_llm/prediction_service.py

@@ -0,0 +1,278 @@
+"""
+Social Media Analysis Prediction Service
+
+This module provides a production-ready service for making predictions
+using MLflow-trained models for social media addiction analysis.
+"""
+
+import mlflow
+import pandas as pd
+import numpy as np
+import json
+import logging
+from typing import Dict, List, Union, Optional
+from pathlib import Path
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+class SocialMediaPredictionService:
+    """
+    A service class for making predictions on social media data using MLflow models.
+    """
+    
+    def __init__(self, model_name: str = "social_media_best_model", model_version: str = "latest"):
+        """
+        Initialize the prediction service.
+        
+        Args:
+            model_name: Name of the registered MLflow model
+            model_version: Version of the model to load (default: "latest")
+        """
+        self.model_name = model_name
+        self.model_version = model_version
+        self.model = None
+        self.model_metadata = None
+        self.feature_columns = None
+        
+        # Set MLflow tracking URI
+        mlflow.set_tracking_uri("file:./mlruns")
+        
+        # Load the model
+        self._load_model()
+    
+    def _load_model(self):
+        """Load the MLflow model and metadata."""
+        try:
+            # Load the model
+            model_uri = f"models:/{self.model_name}/{self.model_version}"
+            self.model = mlflow.sklearn.load_model(model_uri)
+            logger.info(f"✅ Model loaded successfully: {model_uri}")
+            
+            # Try to load model metadata
+            self._load_metadata()
+            
+        except Exception as e:
+            logger.error(f"❌ Failed to load model: {e}")
+            raise
+    
+    def _load_metadata(self):
+        """Load model metadata if available."""
+        try:
+            # Look for metadata in the model artifacts
+            client = mlflow.tracking.MlflowClient()
+            model_versions = client.search_model_versions(f"name='{self.model_name}'")
+            
+            if model_versions:
+                latest_version = max(model_versions, key=lambda x: x.version)
+                run_id = latest_version.run_id
+                
+                # Try to load metadata from the run
+                run = client.get_run(run_id)
+                if run.data.artifacts:
+                    # Look for metadata file
+                    for artifact in run.data.artifacts:
+                        if artifact.path.endswith('model_metadata.json'):
+                            metadata_path = f"mlruns/{run.info.experiment_id}/{run_id}/artifacts/{artifact.path}"
+                            if Path(metadata_path).exists():
+                                with open(metadata_path, 'r') as f:
+                                    self.model_metadata = json.load(f)
+                                self.feature_columns = self.model_metadata.get('feature_columns', [])
+                                logger.info("✅ Model metadata loaded successfully")
+                                break
+                                
+        except Exception as e:
+            logger.warning(f"⚠️ Could not load model metadata: {e}")
+    
+    def preprocess_data(self, data: Union[pd.DataFrame, Dict, List[Dict]]) -> pd.DataFrame:
+        """
+        Preprocess input data to match the model's expected format.
+        
+        Args:
+            data: Input data in various formats
+            
+        Returns:
+            Preprocessed DataFrame
+        """
+        # Convert to DataFrame if needed
+        if isinstance(data, dict):
+            data = pd.DataFrame([data])
+        elif isinstance(data, list):
+            data = pd.DataFrame(data)
+        elif not isinstance(data, pd.DataFrame):
+            raise ValueError("Data must be a DataFrame, dict, or list of dicts")
+        
+        # Make a copy to avoid modifying original data
+        df = data.copy()
+        
+        # Handle missing columns
+        if self.feature_columns:
+            missing_cols = set(self.feature_columns) - set(df.columns)
+            if missing_cols:
+                logger.warning(f"⚠️ Missing columns: {missing_cols}")
+                # Fill missing columns with 0 or appropriate defaults
+                for col in missing_cols:
+                    df[col] = 0
+        
+        # Select only the required features
+        if self.feature_columns:
+            available_cols = [col for col in self.feature_columns if col in df.columns]
+            df = df[available_cols]
+        
+        # Handle categorical variables (basic encoding)
+        categorical_cols = df.select_dtypes(include=['object', 'category']).columns
+        for col in categorical_cols:
+            if col in df.columns:
+                df[col] = df[col].astype(str).astype('category').cat.codes
+        
+        # Fill missing values
+        df = df.fillna(0)
+        
+        logger.info(f"✅ Data preprocessed: {df.shape}")
+        return df
+    
+    def predict(self, data: Union[pd.DataFrame, Dict, List[Dict]]) -> Dict:
+        """
+        Make predictions on the input data.
+        
+        Args:
+            data: Input data to predict on
+            
+        Returns:
+            Dictionary containing prediction results
+        """
+        if self.model is None:
+            raise ValueError("Model not loaded. Please initialize the service properly.")
+        
+        try:
+            # Preprocess the data
+            processed_data = self.preprocess_data(data)
+            
+            # Make predictions
+            predictions = self.model.predict(processed_data)
+            probabilities = self.model.predict_proba(processed_data)
+            
+            # Prepare results
+            results = {
+                'predictions': predictions.tolist(),
+                'probabilities': probabilities.tolist(),
+                'model_name': self.model_name,
+                'model_version': self.model_version,
+                'confidence_scores': np.max(probabilities, axis=1).tolist(),
+                'prediction_classes': ['Low Risk' if p == 0 else 'High Risk' for p in predictions],
+                'data_shape': processed_data.shape
+            }
+            
+            # Add metadata if available
+            if self.model_metadata:
+                results['model_metadata'] = {
+                    'training_date': self.model_metadata.get('training_date'),
+                    'model_type': self.model_metadata.get('model_type'),
+                    'performance_metrics': self.model_metadata.get('performance_metrics', {})
+                }
+            
+            logger.info(f"✅ Predictions completed for {len(predictions)} samples")
+            return results
+            
+        except Exception as e:
+            logger.error(f"❌ Prediction failed: {e}")
+            raise
+    
+    def predict_single(self, data: Dict) -> Dict:
+        """
+        Make a prediction for a single data point.
+        
+        Args:
+            data: Single data point as a dictionary
+            
+        Returns:
+            Dictionary containing single prediction result
+        """
+        results = self.predict(data)
+        
+        # Return single prediction result
+        return {
+            'prediction': results['predictions'][0],
+            'probability': results['probabilities'][0],
+            'confidence': results['confidence_scores'][0],
+            'prediction_class': results['prediction_classes'][0],
+            'model_name': results['model_name'],
+            'model_version': results['model_version']
+        }
+    
+    def get_model_info(self) -> Dict:
+        """
+        Get information about the loaded model.
+        
+        Returns:
+            Dictionary containing model information
+        """
+        info = {
+            'model_name': self.model_name,
+            'model_version': self.model_version,
+            'model_loaded': self.model is not None,
+            'feature_columns': self.feature_columns,
+            'model_type': type(self.model.named_steps['classifier']).__name__ if self.model else None
+        }
+        
+        if self.model_metadata:
+            info['metadata'] = self.model_metadata
+        
+        return info
+
+
+def create_prediction_service(model_name: str = "social_media_best_model") -> SocialMediaPredictionService:
+    """
+    Factory function to create a prediction service.
+    
+    Args:
+        model_name: Name of the MLflow model to load
+        
+    Returns:
+        Initialized prediction service
+    """
+    return SocialMediaPredictionService(model_name=model_name)
+
+
+# Example usage and testing functions
+def test_prediction_service():
+    """Test the prediction service with sample data."""
+    try:
+        # Create prediction service
+        service = create_prediction_service()
+        
+        # Get model info
+        model_info = service.get_model_info()
+        print("📊 Model Information:")
+        print(json.dumps(model_info, indent=2))
+        
+        # Create sample data (adjust based on your actual features)
+        sample_data = {
+            'feature1': 0.5,
+            'feature2': -0.2,
+            'feature3': 1.0
+        }
+        
+        # Make prediction
+        result = service.predict_single(sample_data)
+        print("\n🎯 Prediction Result:")
+        print(json.dumps(result, indent=2))
+        
+        return True
+        
+    except Exception as e:
+        print(f"❌ Test failed: {e}")
+        return False
+
+
+if __name__ == "__main__":
+    # Run test if script is executed directly
+    print("🧪 Testing Social Media Prediction Service...")
+    success = test_prediction_service()
+    
+    if success:
+        print("✅ Prediction service test completed successfully!")
+    else:
+        print("❌ Prediction service test failed!") 

src/social_sphere_llm/unified_api_service.py

@@ -0,0 +1,375 @@
+"""
+Unified Social Media Analysis API Service
+
+A FastAPI web service for serving all three MLflow-trained social media analysis models:
+1. Conflicts Prediction (Notebook 07)
+2. Addicted Score Regression (Notebook 08) 
+3. Clustering Analysis (Notebook 09)
+"""
+
+from fastapi import FastAPI, HTTPException, BackgroundTasks
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel, Field
+from typing import List, Dict, Optional, Any
+import uvicorn
+import json
+import logging
+from datetime import datetime
+import pandas as pd
+
+from .unified_prediction_service import UnifiedSocialMediaPredictionService
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Initialize FastAPI app
+app = FastAPI(
+    title="Unified Social Media Analysis API",
+    description="API for predicting social media addiction, conflicts, and clustering using MLflow models",
+    version="2.0.0",
+    docs_url="/docs",
+    redoc_url="/redoc"
+)
+
+# Add CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Global prediction service
+prediction_service = None
+
+
+class StudentDataRequest(BaseModel):
+    """Request model for student data."""
+    age: int = Field(..., ge=10, le=100, description="Student age")
+    gender: str = Field(..., description="Student gender (Male/Female)")
+    academic_level: str = Field(..., description="Academic level (High School/Undergraduate/Graduate)")
+    avg_daily_usage_hours: float = Field(..., ge=0, le=24, description="Average daily social media usage hours")
+    sleep_hours_per_night: float = Field(..., ge=0, le=24, description="Sleep hours per night")
+    mental_health_score: int = Field(..., ge=1, le=10, description="Mental health score (1-10)")
+    conflicts_over_social_media: int = Field(..., ge=0, le=10, description="Number of conflicts over social media")
+    addicted_score: int = Field(..., ge=1, le=10, description="Addiction score (1-10)")
+    relationship_status: str = Field(..., description="Relationship status")
+    affects_academic_performance: str = Field(..., description="Whether social media affects academic performance")
+    most_used_platform: str = Field(..., description="Most used social media platform")
+    
+    class Config:
+        schema_extra = {
+            "example": {
+                "age": 20,
+                "gender": "Female",
+                "academic_level": "Undergraduate",
+                "avg_daily_usage_hours": 6.5,
+                "sleep_hours_per_night": 7.0,
+                "mental_health_score": 7,
+                "conflicts_over_social_media": 2,
+                "addicted_score": 6,
+                "relationship_status": "Single",
+                "affects_academic_performance": "Yes",
+                "most_used_platform": "Instagram"
+            }
+        }
+
+
+class ConflictsPredictionResponse(BaseModel):
+    """Response model for conflicts predictions."""
+    predicted_conflicts: int = Field(..., description="Predicted conflicts (0: Low, 1: High)")
+    conflict_level: str = Field(..., description="Conflict risk level")
+    recommendation: str = Field(..., description="Intervention recommendation")
+    confidence: float = Field(..., description="Prediction confidence")
+    timestamp: str = Field(..., description="Prediction timestamp")
+    model_type: str = Field(..., description="Model type")
+
+
+class AddictedScoreResponse(BaseModel):
+    """Response model for addicted score predictions."""
+    predicted_score: float = Field(..., description="Predicted addiction score")
+    addiction_level: str = Field(..., description="Addiction level category")
+    confidence: float = Field(..., description="Prediction confidence")
+    timestamp: str = Field(..., description="Prediction timestamp")
+    model_type: str = Field(..., description="Model type")
+
+
+class ClusteringResponse(BaseModel):
+    """Response model for clustering predictions."""
+    cluster_id: int = Field(..., description="Assigned cluster ID")
+    cluster_label: str = Field(..., description="Cluster label")
+    risk_level: str = Field(..., description="Risk level")
+    recommendation: str = Field(..., description="Intervention recommendation")
+    confidence: float = Field(..., description="Prediction confidence")
+    timestamp: str = Field(..., description="Prediction timestamp")
+    model_type: str = Field(..., description="Model type")
+
+
+class UnifiedPredictionResponse(BaseModel):
+    """Response model for unified predictions."""
+    conflicts_prediction: ConflictsPredictionResponse = Field(..., description="Conflicts prediction results")
+    addicted_score_prediction: AddictedScoreResponse = Field(..., description="Addicted score prediction results")
+    clustering_prediction: ClusteringResponse = Field(..., description="Clustering prediction results")
+    timestamp: str = Field(..., description="Prediction timestamp")
+    student_data: Dict[str, Any] = Field(..., description="Input student data")
+
+
+class ModelStatusResponse(BaseModel):
+    """Response model for model status."""
+    conflicts_model_loaded: bool = Field(..., description="Whether conflicts model is loaded")
+    addicted_model_loaded: bool = Field(..., description="Whether addicted model is loaded")
+    clustering_model_loaded: bool = Field(..., description="Whether clustering model is loaded")
+    conflicts_scaler_loaded: bool = Field(..., description="Whether conflicts scaler is loaded")
+    addicted_scaler_loaded: bool = Field(..., description="Whether addicted scaler is loaded")
+    clustering_scaler_loaded: bool = Field(..., description="Whether clustering scaler is loaded")
+    cluster_labels_loaded: bool = Field(..., description="Whether cluster labels are loaded")
+    feature_names_loaded: bool = Field(..., description="Whether feature names are loaded")
+    timestamp: str = Field(..., description="Status timestamp")
+
+
+class HealthResponse(BaseModel):
+    """Response model for health check."""
+    status: str = Field(..., description="Service status")
+    timestamp: str = Field(..., description="Current timestamp")
+    models_loaded: bool = Field(..., description="Whether all models are loaded")
+    uptime: str = Field(..., description="Service uptime")
+
+
+# Startup and shutdown events
+@app.on_event("startup")
+async def startup_event():
+    """Initialize the unified prediction service on startup."""
+    global prediction_service
+    try:
+        prediction_service = UnifiedSocialMediaPredictionService()
+        logger.info("✅ Unified prediction service initialized successfully")
+    except Exception as e:
+        logger.error(f"❌ Failed to initialize unified prediction service: {e}")
+        prediction_service = None
+
+
+@app.on_event("shutdown")
+async def shutdown_event():
+    """Cleanup on shutdown."""
+    logger.info("🔄 Shutting down Unified Social Media Analysis API")
+
+
+# Health check endpoint
+@app.get("/health", response_model=HealthResponse, tags=["Health"])
+async def health_check():
+    """Check the health status of the API service."""
+    models_loaded = (
+        prediction_service and 
+        prediction_service.conflicts_model and 
+        prediction_service.addicted_model and 
+        prediction_service.clustering_model
+    )
+    
+    return HealthResponse(
+        status="healthy" if models_loaded else "unhealthy",
+        timestamp=datetime.now().isoformat(),
+        models_loaded=models_loaded,
+        uptime="running"
+    )
+
+
+# Model status endpoint
+@app.get("/models/status", response_model=ModelStatusResponse, tags=["Models"])
+async def get_model_status():
+    """Get status of all models."""
+    if not prediction_service:
+        raise HTTPException(status_code=503, detail="Prediction service not available")
+    
+    try:
+        status = prediction_service.get_model_status()
+        return ModelStatusResponse(**status)
+    except Exception as e:
+        logger.error(f"❌ Failed to get model status: {e}")
+        raise HTTPException(status_code=500, detail=f"Failed to get model status: {str(e)}")
+
+
+# Conflicts prediction endpoint
+@app.post("/predict/conflicts", response_model=ConflictsPredictionResponse, tags=["Predictions"])
+async def predict_conflicts(request: StudentDataRequest):
+    """Make a conflicts prediction for student data."""
+    if not prediction_service:
+        raise HTTPException(status_code=503, detail="Prediction service not available")
+    
+    try:
+        # Convert request to dictionary
+        data = request.dict()
+        
+        # Make prediction
+        result = prediction_service.predict_conflicts(data)
+        
+        if 'error' in result:
+            raise HTTPException(status_code=500, detail=result['error'])
+        
+        return ConflictsPredictionResponse(**result)
+        
+    except Exception as e:
+        logger.error(f"❌ Conflicts prediction failed: {e}")
+        raise HTTPException(status_code=500, detail=f"Conflicts prediction failed: {str(e)}")
+
+
+# Addicted score prediction endpoint
+@app.post("/predict/addicted-score", response_model=AddictedScoreResponse, tags=["Predictions"])
+async def predict_addicted_score(request: StudentDataRequest):
+    """Make an addicted score prediction for student data."""
+    if not prediction_service:
+        raise HTTPException(status_code=503, detail="Prediction service not available")
+    
+    try:
+        # Convert request to dictionary
+        data = request.dict()
+        
+        # Make prediction
+        result = prediction_service.predict_addicted_score(data)
+        
+        if 'error' in result:
+            raise HTTPException(status_code=500, detail=result['error'])
+        
+        return AddictedScoreResponse(**result)
+        
+    except Exception as e:
+        logger.error(f"❌ Addicted score prediction failed: {e}")
+        raise HTTPException(status_code=500, detail=f"Addicted score prediction failed: {str(e)}")
+
+
+# Clustering prediction endpoint
+@app.post("/predict/clustering", response_model=ClusteringResponse, tags=["Predictions"])
+async def predict_clustering(request: StudentDataRequest):
+    """Make a clustering prediction for student data."""
+    if not prediction_service:
+        raise HTTPException(status_code=503, detail="Prediction service not available")
+    
+    try:
+        # Convert request to dictionary
+        data = request.dict()
+        
+        # Make prediction
+        result = prediction_service.predict_cluster(data)
+        
+        if 'error' in result:
+            raise HTTPException(status_code=500, detail=result['error'])
+        
+        return ClusteringResponse(**result)
+        
+    except Exception as e:
+        logger.error(f"❌ Clustering prediction failed: {e}")
+        raise HTTPException(status_code=500, detail=f"Clustering prediction failed: {str(e)}")
+
+
+# Unified prediction endpoint
+@app.post("/predict/all", response_model=UnifiedPredictionResponse, tags=["Predictions"])
+async def predict_all(request: StudentDataRequest):
+    """Make predictions using all three models."""
+    if not prediction_service:
+        raise HTTPException(status_code=503, detail="Prediction service not available")
+    
+    try:
+        # Convert request to dictionary
+        data = request.dict()
+        
+        # Make all predictions
+        results = prediction_service.predict_all(data)
+        
+        # Check for errors in any prediction
+        for key, result in results.items():
+            if isinstance(result, dict) and 'error' in result:
+                raise HTTPException(status_code=500, detail=f"{key} failed: {result['error']}")
+        
+        return UnifiedPredictionResponse(**results)
+        
+    except Exception as e:
+        logger.error(f"❌ Unified prediction failed: {e}")
+        raise HTTPException(status_code=500, detail=f"Unified prediction failed: {str(e)}")
+
+
+# Model reload endpoint
+@app.post("/models/reload", tags=["Models"])
+async def reload_models(background_tasks: BackgroundTasks):
+    """Reload all models in the background."""
+    if not prediction_service:
+        raise HTTPException(status_code=503, detail="Prediction service not available")
+    
+    def reload_models_task():
+        """Background task to reload all models."""
+        global prediction_service
+        try:
+            prediction_service = UnifiedSocialMediaPredictionService()
+            logger.info("✅ All models reloaded successfully")
+        except Exception as e:
+            logger.error(f"❌ Failed to reload models: {e}")
+    
+    background_tasks.add_task(reload_models_task)
+    
+    return {
+        "message": "Model reload initiated",
+        "timestamp": datetime.now().isoformat()
+    }
+
+
+# Root endpoint
+@app.get("/", tags=["Root"])
+async def root():
+    """Root endpoint with API information."""
+    return {
+        "message": "Unified Social Media Analysis API",
+        "version": "2.0.0",
+        "description": "API for predicting social media addiction, conflicts, and clustering",
+        "docs": "/docs",
+        "health": "/health",
+        "model_status": "/models/status",
+        "endpoints": {
+            "conflicts_prediction": "/predict/conflicts",
+            "addicted_score_prediction": "/predict/addicted-score",
+            "clustering_prediction": "/predict/clustering",
+            "unified_prediction": "/predict/all"
+        }
+    }
+
+
+# Error handlers
+@app.exception_handler(404)
+async def not_found_handler(request, exc):
+    """Handle 404 errors."""
+    return {
+        "error": "Not found",
+        "message": "The requested endpoint does not exist",
+        "timestamp": datetime.now().isoformat()
+    }
+
+
+@app.exception_handler(500)
+async def internal_error_handler(request, exc):
+    """Handle 500 errors."""
+    return {
+        "error": "Internal server error",
+        "message": "An unexpected error occurred",
+        "timestamp": datetime.now().isoformat()
+    }
+
+
+def start_unified_api_server(host: str = "0.0.0.0", port: int = 8000, reload: bool = False):
+    """
+    Start the unified API server.
+    
+    Args:
+        host: Host to bind to
+        port: Port to bind to
+        reload: Whether to enable auto-reload
+    """
+    uvicorn.run(
+        "src.social_sphere_llm.unified_api_service:app",
+        host=host,
+        port=port,
+        reload=reload,
+        log_level="info"
+    )
+
+
+if __name__ == "__main__":
+    start_unified_api_server() 

src/social_sphere_llm/unified_prediction_service.py

@@ -0,0 +1,641 @@
+"""
+Unified Social Media Analysis Prediction Service
+
+This module provides a production-ready service for making predictions
+using all three MLflow-trained models:
+1. Conflicts Prediction (Notebook 07)
+2. Addicted Score Regression (Notebook 08) 
+3. Clustering Analysis (Notebook 09)
+"""
+
+import mlflow
+import pandas as pd
+import numpy as np
+import json
+import logging
+import joblib
+from typing import Dict, List, Union, Optional
+from pathlib import Path
+from datetime import datetime
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+class UnifiedSocialMediaPredictionService:
+    """
+    A unified service class for making predictions on social media data using all three models.
+    """
+    
+    def __init__(self):
+        """
+        Initialize the unified prediction service with all three models.
+        """
+        self.conflicts_model = None
+        self.addicted_model = None
+        self.clustering_model = None
+        self.conflicts_scaler = None
+        self.addicted_scaler = None
+        self.clustering_scaler = None
+        self.cluster_labels = None
+        self.feature_names = {}
+        
+        # Set MLflow tracking URI
+        mlflow.set_tracking_uri("file:./mlruns")
+        
+        # Load all models
+        self._load_all_models()
+    
+    def _load_all_models(self):
+        """Load all three models and their associated files."""
+        try:
+            # Load Conflicts Prediction Model (Notebook 07)
+            self._load_conflicts_model()
+            
+            # Load Addicted Score Model (Notebook 08)
+            self._load_addicted_model()
+            
+            # Load Clustering Model (Notebook 09)
+            self._load_clustering_model()
+            
+            logger.info("✅ All models loaded successfully!")
+            
+        except Exception as e:
+            logger.error(f"❌ Failed to load models: {e}")
+            raise
+    
+    def _load_conflicts_model(self):
+        """Load the conflicts prediction model from Notebook 07."""
+        try:
+            # Try to load from different paths
+            model_paths = [
+                'models/conflicts_classifier_rf.joblib',
+                '../models/conflicts_classifier_rf.joblib',
+                'notebooks/models/conflicts_classifier_rf.joblib'
+            ]
+            
+            for path in model_paths:
+                try:
+                    self.conflicts_model = joblib.load(path)
+                    logger.info(f"✅ Loaded conflicts model from: {path}")
+                    break
+                except:
+                    continue
+            
+            # Load scaler
+            scaler_paths = [
+                'models/conflicts_scaler.joblib',
+                '../models/conflicts_scaler.joblib',
+                'notebooks/models/conflicts_scaler.joblib'
+            ]
+            
+            for path in scaler_paths:
+                try:
+                    self.conflicts_scaler = joblib.load(path)
+                    logger.info(f"✅ Loaded conflicts scaler from: {path}")
+                    break
+                except:
+                    continue
+            
+            # Load feature names
+            feature_paths = [
+                'models/conflicts_feature_names.joblib',
+                '../models/conflicts_feature_names.joblib',
+                'notebooks/models/conflicts_feature_names.joblib'
+            ]
+            
+            for path in feature_paths:
+                try:
+                    self.feature_names['conflicts'] = joblib.load(path)
+                    logger.info(f"✅ Loaded conflicts feature names from: {path}")
+                    break
+                except:
+                    continue
+                    
+        except Exception as e:
+            logger.warning(f"⚠️ Could not load conflicts model: {e}")
+    
+    def _load_addicted_model(self):
+        """Load the addicted score regression model from Notebook 08."""
+        try:
+            # Try to load from MLflow first
+            try:
+                model_uri = "models:/addicted_score_regressor/latest"
+                self.addicted_model = mlflow.sklearn.load_model(model_uri)
+                logger.info(f"✅ Loaded addicted model from MLflow: {model_uri}")
+            except:
+                # Try local paths
+                model_paths = [
+                    'models/addicted_score_model.joblib',
+                    '../models/addicted_score_model.joblib',
+                    'notebooks/models/addicted_score_model.joblib'
+                ]
+                
+                for path in model_paths:
+                    try:
+                        self.addicted_model = joblib.load(path)
+                        logger.info(f"✅ Loaded addicted model from: {path}")
+                        break
+                    except:
+                        continue
+            
+            # Load scaler
+            scaler_paths = [
+                'models/addicted_score_scaler.joblib',
+                '../models/addicted_score_scaler.joblib',
+                'notebooks/models/addicted_score_scaler.joblib'
+            ]
+            
+            for path in scaler_paths:
+                try:
+                    self.addicted_scaler = joblib.load(path)
+                    logger.info(f"✅ Loaded addicted scaler from: {path}")
+                    break
+                except:
+                    continue
+                    
+        except Exception as e:
+            logger.warning(f"⚠️ Could not load addicted model: {e}")
+    
+    def _load_clustering_model(self):
+        """Load the clustering model from Notebook 09."""
+        try:
+            # Try to load from different paths
+            model_paths = [
+                'models/clustering_model.joblib',
+                '../models/clustering_model.joblib',
+                'notebooks/models/clustering_model.joblib'
+            ]
+            
+            for path in model_paths:
+                try:
+                    self.clustering_model = joblib.load(path)
+                    logger.info(f"✅ Loaded clustering model from: {path}")
+                    break
+                except:
+                    continue
+            
+            # Load scaler
+            scaler_paths = [
+                'models/clustering_scaler.joblib',
+                '../models/clustering_scaler.joblib',
+                'notebooks/models/clustering_scaler.joblib'
+            ]
+            
+            for path in scaler_paths:
+                try:
+                    self.clustering_scaler = joblib.load(path)
+                    logger.info(f"✅ Loaded clustering scaler from: {path}")
+                    break
+                except:
+                    continue
+            
+            # Load cluster labels
+            labels_paths = [
+                'models/cluster_labels.joblib',
+                '../models/cluster_labels.joblib',
+                'notebooks/models/cluster_labels.joblib'
+            ]
+            
+            for path in labels_paths:
+                try:
+                    self.cluster_labels = joblib.load(path)
+                    logger.info(f"✅ Loaded cluster labels from: {path}")
+                    break
+                except:
+                    continue
+            
+            # Load feature names
+            feature_paths = [
+                'models/clustering_feature_names.joblib',
+                '../models/clustering_feature_names.joblib',
+                'notebooks/models/clustering_feature_names.joblib'
+            ]
+            
+            for path in feature_paths:
+                try:
+                    self.feature_names['clustering'] = joblib.load(path)
+                    logger.info(f"✅ Loaded clustering feature names from: {path}")
+                    break
+                except:
+                    continue
+                    
+        except Exception as e:
+            logger.warning(f"⚠️ Could not load clustering model: {e}")
+    
+    def predict_conflicts(self, data: Dict) -> Dict:
+        """
+        Predict conflicts over social media using Notebook 07 model.
+        
+        Args:
+            data: Dictionary containing student data
+            
+        Returns:
+            Dictionary containing conflicts prediction results
+        """
+        if self.conflicts_model is None or self.conflicts_scaler is None:
+            return {
+                "error": "Conflicts model not loaded. Please run notebook 07 first.",
+                "timestamp": datetime.now().isoformat()
+            }
+        
+        try:
+            # Prepare features for conflicts model (only 4 features needed)
+            features = {}
+            
+            # Extract required features for conflicts model
+            if 'Mental_Health_Score' in data:
+                features['Mental_Health_Score'] = float(data['Mental_Health_Score'])
+            if 'Age' in data:
+                features['Age'] = float(data['Age'])
+            
+            # Handle gender encoding
+            if 'Gender' in data:
+                gender = data['Gender'].lower()
+                if gender in ['male', 'm']:
+                    features['Gender_Male'] = 1
+                    features['Gender_Female'] = 0
+                elif gender in ['female', 'f']:
+                    features['Gender_Male'] = 0
+                    features['Gender_Female'] = 1
+                else:
+                    features['Gender_Male'] = 0
+                    features['Gender_Female'] = 0
+            
+            # Create feature vector for scaler (2 features)
+            scaler_features = ['Mental_Health_Score', 'Age']
+            feature_vector = []
+            for feature in scaler_features:
+                if feature in features:
+                    feature_vector.append(features[feature])
+                else:
+                    feature_vector.append(0)
+            
+            # Scale the features
+            feature_vector_scaled = self.conflicts_scaler.transform([feature_vector])
+            
+            # Create full feature vector for model (4 features)
+            model_features = ['Mental_Health_Score', 'Age', 'Gender_Female', 'Gender_Male']
+            full_feature_vector = []
+            for feature in model_features:
+                if feature in features:
+                    full_feature_vector.append(features[feature])
+                else:
+                    full_feature_vector.append(0)
+            
+            # Combine scaled features with categorical features
+            final_vector = list(feature_vector_scaled[0]) + full_feature_vector[2:]  # Use scaled first 2, raw last 2
+            
+            # Make prediction
+            prediction = self.conflicts_model.predict([final_vector])[0]
+            probability = self.conflicts_model.predict_proba([final_vector])[0]
+            
+            # Determine conflict level
+            if prediction == 1:
+                conflict_level = 'High Risk'
+                recommendation = 'Immediate intervention needed: Conflict resolution training, communication skills'
+            else:
+                conflict_level = 'Low Risk'
+                recommendation = 'Monitor and provide resources: Healthy communication guidelines'
+            
+            # Calculate confidence
+            confidence = max(probability)
+            
+            return {
+                'predicted_conflicts': int(prediction),
+                'conflict_level': conflict_level,
+                'recommendation': recommendation,
+                'confidence': float(confidence),
+                'timestamp': datetime.now().isoformat(),
+                'model_type': 'conflicts_prediction'
+            }
+            
+        except Exception as e:
+            return {
+                'error': str(e),
+                'timestamp': datetime.now().isoformat()
+            }
+    
+    def predict_addicted_score(self, data: Dict) -> Dict:
+        """
+        Predict addicted score using Notebook 08 model.
+        
+        Args:
+            data: Dictionary containing student data
+            
+        Returns:
+            Dictionary containing addicted score prediction results
+        """
+        if self.addicted_model is None or self.addicted_scaler is None:
+            return {
+                "error": "Addicted score model not loaded. Please run notebook 08 first.",
+                "timestamp": datetime.now().isoformat()
+            }
+        
+        try:
+            # Prepare features for addicted score model (3 features needed)
+            features = {}
+            
+            # Extract required features for addicted score model
+            if 'Age' in data:
+                features['Age'] = float(data['Age'])
+            if 'Mental_Health_Score' in data:
+                features['Mental_Health_Score'] = float(data['Mental_Health_Score'])
+                # Add squared feature
+                features['mental_health_squared'] = features['Mental_Health_Score'] ** 2
+            if 'Conflicts_Over_Social_Media' in data:
+                features['Conflicts_Over_Social_Media'] = float(data['Conflicts_Over_Social_Media'])
+            
+            # Handle gender encoding
+            if 'Gender' in data:
+                gender = data['Gender'].lower()
+                if gender in ['male', 'm']:
+                    features['Gender_Male'] = 1
+                    features['Gender_Female'] = 0
+                elif gender in ['female', 'f']:
+                    features['Gender_Male'] = 0
+                    features['Gender_Female'] = 1
+                else:
+                    features['Gender_Male'] = 0
+                    features['Gender_Female'] = 0
+            
+            # Create feature vector for scaler (3 features)
+            scaler_features = ['Mental_Health_Score', 'Age', 'Conflicts_Over_Social_Media']
+            feature_vector = []
+            for feature in scaler_features:
+                if feature in features:
+                    feature_vector.append(features[feature])
+                else:
+                    feature_vector.append(0)
+            
+            # Scale the features
+            feature_vector_scaled = self.addicted_scaler.transform([feature_vector])
+            
+            # Create full feature vector for model (6 features)
+            model_features = ['Mental_Health_Score', 'Age', 'Conflicts_Over_Social_Media', 'mental_health_squared', 'Gender_Female', 'Gender_Male']
+            full_feature_vector = []
+            for feature in model_features:
+                if feature in features:
+                    full_feature_vector.append(features[feature])
+                else:
+                    full_feature_vector.append(0)
+            
+            # Combine scaled features with additional features
+            final_vector = list(feature_vector_scaled[0]) + full_feature_vector[3:]  # Use scaled first 3, raw last 3
+            
+            # Make prediction
+            prediction = self.addicted_model.predict([final_vector])[0]
+            
+            # Determine addiction level
+            if prediction >= 8:
+                addiction_level = 'Very High'
+            elif prediction >= 6:
+                addiction_level = 'High'
+            elif prediction >= 4:
+                addiction_level = 'Moderate'
+            else:
+                addiction_level = 'Low'
+            
+            # Calculate confidence (simplified)
+            confidence = 0.8  # Default confidence
+            
+            return {
+                'predicted_score': float(prediction),
+                'addiction_level': addiction_level,
+                'confidence': float(confidence),
+                'timestamp': datetime.now().isoformat(),
+                'model_type': 'addicted_score_regression'
+            }
+            
+        except Exception as e:
+            return {
+                'error': str(e),
+                'timestamp': datetime.now().isoformat()
+            }
+    
+    def predict_cluster(self, data: Dict) -> Dict:
+        """
+        Predict cluster assignment using Notebook 09 model.
+        
+        Args:
+            data: Dictionary containing student data
+            
+        Returns:
+            Dictionary containing cluster prediction results
+        """
+        if self.clustering_model is None or self.clustering_scaler is None:
+            return {
+                "error": "Clustering model not loaded. Please run notebook 09 first.",
+                "timestamp": datetime.now().isoformat()
+            }
+        
+        try:
+            # Prepare features
+            features = {}
+            
+            # Extract numeric features
+            if 'Age' in data:
+                features['Age'] = float(data['Age'])
+            if 'Avg_Daily_Usage_Hours' in data:
+                features['Avg_Daily_Usage_Hours'] = float(data['Avg_Daily_Usage_Hours'])
+            if 'Sleep_Hours_Per_Night' in data:
+                features['Sleep_Hours_Per_Night'] = float(data['Sleep_Hours_Per_Night'])
+            if 'Mental_Health_Score' in data:
+                features['Mental_Health_Score'] = float(data['Mental_Health_Score'])
+            if 'Conflicts_Over_Social_Media' in data:
+                features['Conflicts_Over_Social_Media'] = float(data['Conflicts_Over_Social_Media'])
+            if 'Addicted_Score' in data:
+                features['Addicted_Score'] = float(data['Addicted_Score'])
+            
+            # Handle categorical features
+            if 'Gender' in data:
+                gender = data['Gender'].lower()
+                if gender in ['male', 'm']:
+                    features['Is_Female'] = 0
+                elif gender in ['female', 'f']:
+                    features['Is_Female'] = 1
+                else:
+                    features['Is_Female'] = 0
+            
+            if 'Academic_Level' in data:
+                level = data['Academic_Level'].lower()
+                if 'undergraduate' in level:
+                    features['Is_Undergraduate'] = 1
+                    features['Is_Graduate'] = 0
+                    features['Is_High_School'] = 0
+                elif 'graduate' in level:
+                    features['Is_Undergraduate'] = 0
+                    features['Is_Graduate'] = 1
+                    features['Is_High_School'] = 0
+                elif 'high school' in level:
+                    features['Is_Undergraduate'] = 0
+                    features['Is_Graduate'] = 0
+                    features['Is_High_School'] = 1
+                else:
+                    features['Is_Undergraduate'] = 0
+                    features['Is_Graduate'] = 0
+                    features['Is_High_School'] = 0
+            
+            # Create behavioral features
+            if 'Avg_Daily_Usage_Hours' in features:
+                features['High_Usage'] = 1 if features['Avg_Daily_Usage_Hours'] >= 6 else 0
+            if 'Sleep_Hours_Per_Night' in features:
+                features['Low_Sleep'] = 1 if features['Sleep_Hours_Per_Night'] <= 6 else 0
+            if 'Mental_Health_Score' in features:
+                features['Poor_Mental_Health'] = 1 if features['Mental_Health_Score'] <= 5 else 0
+            if 'Conflicts_Over_Social_Media' in features:
+                features['High_Conflict'] = 1 if features['Conflicts_Over_Social_Media'] >= 3 else 0
+            if 'Addicted_Score' in features:
+                features['High_Addiction'] = 1 if features['Addicted_Score'] >= 7 else 0
+            
+            # Create interaction features
+            if 'Avg_Daily_Usage_Hours' in features and 'Sleep_Hours_Per_Night' in features:
+                features['Usage_Sleep_Ratio'] = features['Avg_Daily_Usage_Hours'] / features['Sleep_Hours_Per_Night']
+            if 'Mental_Health_Score' in features and 'Avg_Daily_Usage_Hours' in features:
+                features['Mental_Health_Usage_Ratio'] = features['Mental_Health_Score'] / features['Avg_Daily_Usage_Hours']
+            
+            # Create feature vector in the correct order
+            feature_vector = []
+            for feature in self.feature_names.get('clustering', []):
+                if feature in features:
+                    feature_vector.append(features[feature])
+                else:
+                    feature_vector.append(0)
+            
+            # Scale the features
+            feature_vector_scaled = self.clustering_scaler.transform([feature_vector])
+            
+            # Make prediction
+            cluster_prediction = self.clustering_model.predict(feature_vector_scaled)[0]
+            
+            # Get cluster label
+            cluster_label = self.cluster_labels.get(cluster_prediction, f'Cluster_{cluster_prediction}') if self.cluster_labels else f'Cluster_{cluster_prediction}'
+            
+            # Determine risk level based on cluster characteristics
+            if 'High-Usage' in cluster_label and 'High-Addiction' in cluster_label:
+                risk_level = 'High Risk'
+                recommendation = 'Intensive intervention needed: Digital detox programs, counseling, parental monitoring'
+            elif 'High-Usage' in cluster_label or 'Poor-Health' in cluster_label:
+                risk_level = 'Moderate Risk'
+                recommendation = 'Targeted intervention recommended: Screen time limits, mental health support, sleep hygiene'
+            else:
+                risk_level = 'Low Risk'
+                recommendation = 'Monitor and provide resources: Educational materials, healthy usage guidelines'
+            
+            # Calculate confidence based on distance to cluster center
+            try:
+                cluster_center = self.clustering_model.cluster_centers_[cluster_prediction]
+                distance = np.linalg.norm(feature_vector_scaled[0] - cluster_center)
+                confidence = max(0.1, 1 - distance/10)  # Normalize distance to confidence
+            except:
+                confidence = 0.8  # Default confidence
+            
+            return {
+                'cluster_id': int(cluster_prediction),
+                'cluster_label': cluster_label,
+                'risk_level': risk_level,
+                'recommendation': recommendation,
+                'confidence': float(confidence),
+                'timestamp': datetime.now().isoformat(),
+                'model_type': 'clustering_analysis'
+            }
+            
+        except Exception as e:
+            return {
+                'error': str(e),
+                'timestamp': datetime.now().isoformat()
+            }
+    
+    def predict_all(self, data: Dict) -> Dict:
+        """
+        Make predictions using all three models.
+        
+        Args:
+            data: Dictionary containing student data
+            
+        Returns:
+            Dictionary containing all prediction results
+        """
+        results = {
+            'conflicts_prediction': self.predict_conflicts(data),
+            'addicted_score_prediction': self.predict_addicted_score(data),
+            'clustering_prediction': self.predict_cluster(data),
+            'timestamp': datetime.now().isoformat(),
+            'student_data': data
+        }
+        
+        return results
+    
+    def get_model_status(self) -> Dict:
+        """
+        Get status of all models.
+        
+        Returns:
+            Dictionary containing model status information
+        """
+        return {
+            'conflicts_model_loaded': self.conflicts_model is not None,
+            'addicted_model_loaded': self.addicted_model is not None,
+            'clustering_model_loaded': self.clustering_model is not None,
+            'conflicts_scaler_loaded': self.conflicts_scaler is not None,
+            'addicted_scaler_loaded': self.addicted_scaler is not None,
+            'clustering_scaler_loaded': self.clustering_scaler is not None,
+            'cluster_labels_loaded': self.cluster_labels is not None,
+            'feature_names_loaded': len(self.feature_names) > 0,
+            'timestamp': datetime.now().isoformat()
+        }
+
+
+def create_unified_prediction_service() -> UnifiedSocialMediaPredictionService:
+    """
+    Factory function to create a unified prediction service.
+    
+    Returns:
+        Initialized unified prediction service
+    """
+    return UnifiedSocialMediaPredictionService()
+
+
+# Example usage and testing functions
+def test_unified_prediction_service():
+    """Test the unified prediction service with sample data."""
+    try:
+        # Create prediction service
+        service = create_unified_prediction_service()
+        
+        # Get model status
+        status = service.get_model_status()
+        print("📊 Model Status:")
+        print(json.dumps(status, indent=2))
+        
+        # Test with sample data
+        sample_data = {
+            'Age': 20,
+            'Gender': 'Female',
+            'Academic_Level': 'Undergraduate',
+            'Avg_Daily_Usage_Hours': 6.5,
+            'Sleep_Hours_Per_Night': 7.0,
+            'Mental_Health_Score': 7,
+            'Conflicts_Over_Social_Media': 2,
+            'Addicted_Score': 6,
+            'Relationship_Status': 'Single',
+            'Affects_Academic_Performance': 'Yes',
+            'Most_Used_Platform': 'Instagram'
+        }
+        
+        # Make all predictions
+        results = service.predict_all(sample_data)
+        
+        print("\n📊 Unified Prediction Results:")
+        print(json.dumps(results, indent=2))
+        
+        return results
+        
+    except Exception as e:
+        print(f"❌ Test failed: {e}")
+        return None
+
+
+if __name__ == "__main__":
+    test_unified_prediction_service()