feat(api): Implement FastAPI endpoints and ML service

Dockerfile

@@ -0,0 +1,23 @@
+FROM python:3.10-slim
+
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    libpq-dev \
+    && rm -rf /var/lib/apt/lists/*
+
+# Install python dependencies
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy application code
+COPY . .
+
+# Expose port
+EXPOSE 7860
+
+# Command to run the application
+# Using 7860 for Hugging Face Spaces compatibility
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "7860"]

app/main.py

@@ -0,0 +1,19 @@
+from fastapi import FastAPI
+from app.routers import prediction
+from app.core.database import engine, Base
+
+# Create tables on startup (for simplicity in this POC, though usually done via migration scripts)
+# Base.metadata.create_all(bind=engine) 
+# We will use a separate script for DB creation as requested.
+
+app = FastAPI(
+    title="ML Prediction API",
+    description="API for XGBoost Model Predictions",
+    version="1.0.0"
+)
+
+app.include_router(prediction.router)
+
+@app.get("/")
+def root():
+    return {"message": "Welcome to the ML Prediction API. Visit /docs for documentation."}

app/routers/prediction.py

@@ -0,0 +1,56 @@
+from fastapi import APIRouter, Depends, HTTPException, Header, status
+from sqlalchemy.orm import Session
+from app.core.database import get_db
+from app.models.schemas import InputSchema, PredictionOutput
+from app.models.models import PredictionLog
+from app.services.ml_service import ml_service
+from app.core.config import settings
+
+router = APIRouter()
+
+def verify_api_key(x_api_key: str = Header(...)):
+    if x_api_key != settings.API_KEY:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Invalid API Key",
+        )
+    return x_api_key
+
+@router.post("/predict", response_model=PredictionOutput)
+def predict(input_data: InputSchema, db: Session = Depends(get_db), api_key: str = Depends(verify_api_key)):
+    # Convert Pydantic model to dict
+    data_dict = input_data.dict()
+    
+    try:
+        # Make prediction
+        prediction, probability = ml_service.predict(data_dict)
+        
+        # Log to Database
+        db_log = PredictionLog(
+            **data_dict,
+            prediction=prediction,
+            probability=probability
+        )
+        db.add(db_log)
+        db.commit()
+        db.refresh(db_log)
+        
+        return PredictionOutput(prediction=prediction, probability=probability)
+        
+    except Exception as e:
+        print(f"Error during prediction: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.get("/health")
+def health_check():
+    return {"status": "healthy"}
+
+@router.get("/model/info")
+def model_info(api_key: str = Depends(verify_api_key)):
+    model = ml_service.model
+    if not model:
+        return {"status": "Model not loaded"}
+    return {
+        "type": str(type(model)),
+        "params": model.get_params() if hasattr(model, "get_params") else "Unknown"
+    }

app/services/ml_service.py

@@ -0,0 +1,67 @@
+import pickle
+import pandas as pd
+import os
+from app.core.config import settings
+
+class MLService:
+    def __init__(self):
+        self.model = None
+        self.expected_features = None
+        self.load_model()
+
+    def load_model(self):
+        model_path = settings.MODEL_PATH
+        if not os.path.exists(model_path):
+            print(f"Warning: Model file not found at {model_path}")
+            return
+            
+        print(f"Loading model from {model_path}...")
+        with open(model_path, 'rb') as f:
+            self.model = pickle.load(f)
+        
+        if hasattr(self.model, "feature_names_in_"):
+            self.expected_features = self.model.feature_names_in_
+            print(f"Model expects {len(self.expected_features)} features.")
+        else:
+            print("Warning: Model does not have feature_names_in_. Preprocessing might fail.")
+        
+        print("Model loaded successfully.")
+
+    def predict(self, input_data: dict):
+        if not self.model:
+            raise RuntimeError("Model is not loaded")
+        
+        # Convert input dict to DataFrame
+        df = pd.DataFrame([input_data])
+        
+        # Preprocessing: One-Hot Encoding
+        # We use pd.get_dummies to encode categorical variables
+        # Then we align with expected features
+        
+        df_encoded = pd.get_dummies(df)
+        
+        if self.expected_features is not None:
+            # Add missing columns with 0
+            # Remove extra columns (if any, though unlikely with single row input unless new category appears)
+            # Reorder columns to match model expectation
+            
+            # This reindex handles both adding missing cols (filling with 0) and reordering
+            df_final = df_encoded.reindex(columns=self.expected_features, fill_value=0)
+        else:
+            df_final = df_encoded
+        
+        # Predict
+        prediction = self.model.predict(df_final)[0]
+        
+        # Try to get probability if available
+        probability = None
+        if hasattr(self.model, "predict_proba"):
+            try:
+                probs = self.model.predict_proba(df_final)
+                probability = float(probs[0][1]) # Assuming binary classification
+            except Exception as e:
+                print(f"Could not get probability: {e}")
+        
+        return int(prediction), probability
+
+ml_service = MLService()