Update app.py

app.py

@@ -1,14 +1,12 @@
 # ============================================
 # YORK CHILLER OPTIMIZER API
-# Random Forest Model with 12 Operational Features
-# Includes MCP (Model Card + Performance + Capabilities) Output
+# Random Forest Model - Compatible with existing models
 # ============================================
 
 import numpy as np
 import joblib
-import pandas as pd
 import os
-import sys
+import json
 from fastapi import FastAPI, HTTPException
 from pydantic import BaseModel, Field
 from typing import List, Optional, Dict, Any
@@ -16,227 +14,168 @@ from datetime import datetime
 import warnings
 warnings.filterwarnings('ignore')
 
-# Create FastAPI app
 app = FastAPI(
     title="York Chiller Energy Optimizer",
-    description="Random Forest Model for Chiller Energy Efficiency Prediction with MCP Documentation",
+    description="Random Forest Model for Chiller Energy Efficiency",
     version="2.0.0"
 )
 
 # ============================================
-# LOAD MODEL AND PREPROCESSORS
+# LOAD MODEL AND DETECT FEATURES
 # ============================================
 
-# Try different possible filenames
-MODEL_PATHS = ["production_model.pkl", "model.pkl", "random_forest_model.pkl"]
-SCALER_PATHS = ["scaler.pkl", "standard_scaler.pkl"]
-FEATURES_PATHS = ["features.pkl", "feature.pkl", "feature_names.pkl"]  # Fixed: includes 'feature.pkl'
-
 model = None
 scaler = None
-feature_names = None
+model_features = None
+is_demo_model = False
 
-def load_model():
-    """Load the trained Random Forest model and preprocessors"""
-    global model, scaler, feature_names
-    
-    # Try to load model
-    model_loaded = False
-    for model_path in MODEL_PATHS:
-        try:
-            if os.path.exists(model_path):
-                model = joblib.load(model_path)
-                print(f"✅ Loaded model from {model_path}")
-                print(f"   Type: {type(model).__name__}")
-                if hasattr(model, 'n_estimators'):
-                    print(f"   Trees: {model.n_estimators}")
-                model_loaded = True
-                break
-        except Exception as e:
-            print(f"⚠️ Failed to load {model_path}: {e}")
+def load_model_with_auto_detection():
+    """Load model and automatically detect what features it expects"""
+    global model, scaler, model_features, is_demo_model
     
-    if not model_loaded:
-        print("❌ No model file found. Please check model files.")
+    # Load model
+    try:
+        if os.path.exists("production_model.pkl"):
+            model = joblib.load("production_model.pkl")
+            print(f"✅ Loaded model: {type(model).__name__}")
+            
+            # Check if it's the demo model by looking at feature count
+            if hasattr(model, 'n_features_in_'):
+                n_features = model.n_features_in_
+                print(f"   Model expects {n_features} features")
+                
+                if n_features == 8:
+                    is_demo_model = True
+                    model_features = [
+                        'PLANT_TONAGE', 'WET_BULB_TEMP_C', 'CHW_SUPPLY_TEMP_C',
+                        'CHW_RETURN_TEMP_C', 'HOUR', 'MONTH', 'IS_WEEKEND', 'CHILLERS_RUNNING'
+                    ]
+                    print("   ✅ Detected: Demo model (8 features)")
+                elif n_features == 12:
+                    is_demo_model = False
+                    model_features = [
+                        'total_building_load_rt', 'avg_chilled_water_rate_lps',
+                        'avg_cooling_water_temp_c', 'avg_outside_temp_f',
+                        'avg_dew_point_f', 'avg_humidity_pct', 'avg_wind_speed_mph',
+                        'avg_pressure_in', 'hour', 'day_of_week', 'month', 'day_of_year'
+                    ]
+                    print("   ✅ Detected: Full model (12 features)")
+                else:
+                    print(f"   ⚠️ Unknown feature count: {n_features}")
+                    model_features = [f'feature_{i}' for i in range(n_features)]
+            else:
+                print("   ⚠️ Model has no n_features_in_ attribute")
+                model_features = ['feature_0', 'feature_1', 'feature_2', 'feature_3', 
+                                 'feature_4', 'feature_5', 'feature_6', 'feature_7']
+                is_demo_model = True
+        else:
+            print("❌ production_model.pkl not found")
+            return False
+    except Exception as e:
+        print(f"❌ Error loading model: {e}")
         return False
     
-    # Try to load scaler
-    scaler_loaded = False
-    for scaler_path in SCALER_PATHS:
-        try:
-            if os.path.exists(scaler_path):
-                scaler = joblib.load(scaler_path)
-                print(f"✅ Loaded scaler from {scaler_path}")
-                scaler_loaded = True
-                break
-        except Exception as e:
-            print(f"⚠️ Failed to load {scaler_path}: {e}")
+    # Load scaler
+    try:
+        if os.path.exists("scaler.pkl"):
+            scaler = joblib.load("scaler.pkl")
+            print("✅ Loaded scaler")
+    except Exception as e:
+        print(f"⚠️ Scaler not loaded: {e}")
+        scaler = None
     
-    # Try to load feature names
-    features_loaded = False
-    for features_path in FEATURES_PATHS:
-        try:
-            if os.path.exists(features_path):
-                feature_names = joblib.load(features_path)
-                print(f"✅ Loaded feature names from {features_path}")
-                print(f"   Features: {feature_names}")
-                features_loaded = True
-                break
-        except Exception as e:
-            print(f"⚠️ Failed to load {features_path}: {e}")
+    return True
+
+def transform_to_model_format(input_data) -> np.ndarray:
+    """Transform 12-feature input to whatever format the model expects"""
+    global is_demo_model
     
-    # If no feature names file, check if model has feature_names attribute
-    if not features_loaded and hasattr(model, 'feature_names_in_'):
-        feature_names = list(model.feature_names_in_)
-        print(f"✅ Using feature names from model: {feature_names}")
-        features_loaded = True
+    if is_demo_model:
+        # Demo model expects 8 features: 
+        # ['PLANT_TONAGE', 'WET_BULB_TEMP_C', 'CHW_SUPPLY_TEMP_C', 
+        #  'CHW_RETURN_TEMP_C', 'HOUR', 'MONTH', 'IS_WEEKEND', 'CHILLERS_RUNNING']
+        
+        # Calculate wet bulb from temperature and humidity (simplified)
+        wet_bulb = input_data.avg_outside_temp_f * 0.5556  # Rough estimate
+        if input_data.avg_humidity_pct > 50:
+            wet_bulb = wet_bulb * 0.9
+        
+        features = np.array([
+            input_data.total_building_load_rt,           # PLANT_TONAGE
+            wet_bulb,                                     # WET_BULB_TEMP_C
+            8.0,                                          # CHW_SUPPLY_TEMP_C (default)
+            13.5,                                         # CHW_RETURN_TEMP_C (default)
+            input_data.hour,                              # HOUR
+            input_data.month,                             # MONTH
+            1 if input_data.day_of_week >= 5 else 0,     # IS_WEEKEND (Sat/Sun)
+            2                                             # CHILLERS_RUNNING (default)
+        ]).reshape(1, -1)
+        
+        print(f"   Transformed to {len(features[0])} features for demo model")
+    else:
+        # Full 12-feature model
+        features = np.array([
+            input_data.total_building_load_rt,
+            input_data.avg_chilled_water_rate_lps,
+            input_data.avg_cooling_water_temp_c,
+            input_data.avg_outside_temp_f,
+            input_data.avg_dew_point_f,
+            input_data.avg_humidity_pct,
+            input_data.avg_wind_speed_mph,
+            input_data.avg_pressure_in,
+            input_data.hour,
+            input_data.day_of_week,
+            input_data.month,
+            input_data.day_of_year
+        ]).reshape(1, -1)
     
-    # If still no features, use default 12-feature list
-    if not features_loaded:
-        feature_names = [
-            'total_building_load_rt',
-            'avg_chilled_water_rate_lps',
-            'avg_cooling_water_temp_c',
-            'avg_outside_temp_f',
-            'avg_dew_point_f',
-            'avg_humidity_pct',
-            'avg_wind_speed_mph',
-            'avg_pressure_in',
-            'hour',
-            'day_of_week',
-            'month',
-            'day_of_year'
-        ]
-        print(f"✅ Using default feature names")
+    # Apply scaler if available
+    if scaler is not None:
+        try:
+            features = scaler.transform(features)
+        except:
+            pass  # Use unscaled if transform fails
     
-    return model_loaded
+    return features
 
 # Load model on startup
-load_success = load_model()
-
-# Print debug info about loaded files
-print("\n📁 Files in directory:")
-for file in os.listdir('.'):
-    if file.endswith('.pkl') or file.endswith('.joblib'):
-        size = os.path.getsize(file) / 1024  # KB
-        print(f"   - {file} ({size:.1f} KB)")
+load_success = load_model_with_auto_detection()
 
-print(f"\n📊 Model Load Status: {'SUCCESS' if model else 'FAILED'}")
-print(f"📊 Scaler Load Status: {'SUCCESS' if scaler else 'FAILED'}")
-print(f"📊 Features Load Status: {'SUCCESS' if feature_names else 'FAILED'}")
+print(f"\n📊 Model Status:")
+print(f"   Model loaded: {model is not None}")
+print(f"   Model type: {'Demo (8 features)' if is_demo_model else 'Full (12 features)' if model else 'None'}")
+print(f"   Scaler loaded: {scaler is not None}")
 
 # ============================================
-# REQUEST/RESPONSE MODELS
+# REQUEST MODELS
 # ============================================
 
 class ChillerInput(BaseModel):
-    """Input features matching the Random Forest model - 12 operational parameters"""
-    
-    # Building load (RT - Refrigeration Tons)
-    total_building_load_rt: float = Field(
-        ..., 
-        description="Total building cooling load (200-2500 RT)", 
-        ge=200, 
-        le=2500
-    )
+    """12 operational parameters - automatically mapped to model requirements"""
     
-    # Flow rates (L/sec)
-    avg_chilled_water_rate_lps: float = Field(
-        ..., 
-        description="Average chilled water flow rate (50-500 L/sec)", 
-        ge=50, 
-        le=500
-    )
+    total_building_load_rt: float = Field(1200, ge=200, le=2500)
+    avg_chilled_water_rate_lps: float = Field(250, ge=50, le=500)
+    avg_cooling_water_temp_c: float = Field(25, ge=15, le=35)
+    avg_outside_temp_f: float = Field(85, ge=32, le=120)
+    avg_dew_point_f: float = Field(65, ge=20, le=80)
+    avg_humidity_pct: float = Field(60, ge=20, le=100)
+    avg_wind_speed_mph: float = Field(10, ge=0, le=30)
+    avg_pressure_in: float = Field(29.92, ge=28, le=31)
+    hour: int = Field(14, ge=0, le=23)
+    day_of_week: int = Field(2, ge=0, le=6)
+    month: int = Field(7, ge=1, le=12)
+    day_of_year: int = Field(185, ge=1, le=365)
     
-    # Temperatures
-    avg_cooling_water_temp_c: float = Field(
-        ..., 
-        description="Average cooling water temperature (15-35°C)", 
-        ge=15, 
-        le=35
-    )
-    avg_outside_temp_f: float = Field(
-        ..., 
-        description="Average outside temperature (32-120°F)", 
-        ge=32, 
-        le=120
-    )
-    avg_dew_point_f: float = Field(
-        ..., 
-        description="Average dew point (20-80°F)", 
-        ge=20, 
-        le=80
-    )
-    
-    # Environmental conditions
-    avg_humidity_pct: float = Field(
-        ..., 
-        description="Average relative humidity (20-100%)", 
-        ge=20, 
-        le=100
-    )
-    avg_wind_speed_mph: float = Field(
-        ..., 
-        description="Average wind speed (0-30 mph)", 
-        ge=0, 
-        le=30
-    )
-    avg_pressure_in: float = Field(
-        ..., 
-        description="Average atmospheric pressure (28-31 inches Hg)", 
-        ge=28, 
-        le=31
-    )
-    
-    # Time features
-    hour: int = Field(..., description="Hour of day (0-23)", ge=0, le=23)
-    day_of_week: int = Field(..., description="Day of week (0=Monday, 6=Sunday)", ge=0, le=6)
-    month: int = Field(..., description="Month (1-12)", ge=1, le=12)
-    day_of_year: int = Field(..., description="Day of year (1-365)", ge=1, le=365)
-    
-    # Optional: Current CHW setpoint for recommendations
-    current_chw_setpoint_c: Optional[float] = Field(8.0, description="Current CHW setpoint (5-10°C)", ge=5, le=10)
-    current_limit_pct: Optional[float] = Field(100, description="Current limit percentage (50-100)", ge=50, le=100)
-
-class MCPModelCard(BaseModel):
-    """Model Card information"""
-    model_name: str
-    model_type: str
-    version: str
-    description: str
-    architecture: Dict[str, Any]
-    training_data: Dict[str, Any]
-    intended_use: List[str]
-    limitations: List[str]
-
-class MCPPerformance(BaseModel):
-    """Performance metrics"""
-    metrics: Dict[str, float]
-    feature_importance: Dict[str, float]
-    validation_method: str
-    test_size: float
-    training_date: str
-
-class MCPCapabilities(BaseModel):
-    """Model capabilities"""
-    input_features: List[Dict[str, Any]]
-    output_target: Dict[str, Any]
-    prediction_range: Dict[str, float]
-    interpretability: Dict[str, Any]
-    optimization_modes: List[str]
-
-class MCPResponse(BaseModel):
-    """Complete MCP (Model Card + Performance + Capabilities) output"""
-    model_card: MCPModelCard
-    performance: MCPPerformance
-    capabilities: MCPCapabilities
-    timestamp: str
+    # Optional optimization parameters
+    current_chw_setpoint_c: Optional[float] = Field(8.0, ge=5, le=10)
+    current_limit_pct: Optional[float] = Field(100, ge=50, le=100)
 
 class PredictionResponse(BaseModel):
-    """Prediction response"""
     status: str
     kw_per_tr: float
-    input_features: Dict
-    confidence_interval: Optional[Dict[str, float]]
+    model_type: str
+    features_used: int
+    input_mapped: Dict
     timestamp: str
 
 class OptimizationRecommendation(BaseModel):
@@ -248,7 +187,6 @@ class OptimizationRecommendation(BaseModel):
     operator_action: str
 
 class OptimizeResponse(BaseModel):
-    """Complete optimization response"""
     timestamp: str
     current_kw_per_tr: float
     optimal_kw_per_tr: float
@@ -257,246 +195,19 @@ class OptimizeResponse(BaseModel):
     summary: Dict[str, str]
 
 # ============================================
-# MCP DATA - Model Card + Performance + Capabilities
+# PREDICTION FUNCTION
 # ============================================
 
-def get_mcp_data() -> MCPResponse:
-    """Generate MCP (Model Card + Performance + Capabilities) JSON output"""
-    
-    # Try to extract actual feature importance from model if available
-    feature_importance_dict = {}
-    if model and hasattr(model, 'feature_importances_') and feature_names:
-        importances = model.feature_importances_
-        for name, imp in zip(feature_names, importances):
-            feature_importance_dict[name] = float(imp)
-    else:
-        # Default importance values
-        feature_importance_dict = {
-            "total_building_load_rt": 0.324,
-            "avg_outside_temp_f": 0.156,
-            "avg_cooling_water_temp_c": 0.112,
-            "avg_humidity_pct": 0.089,
-            "hour": 0.078,
-            "avg_chilled_water_rate_lps": 0.067,
-            "month": 0.054,
-            "avg_dew_point_f": 0.043,
-            "day_of_year": 0.032,
-            "avg_wind_speed_mph": 0.021,
-            "avg_pressure_in": 0.015,
-            "day_of_week": 0.009
-        }
-    
-    # Input features description
-    input_features = [
-        {
-            "name": "total_building_load_rt",
-            "type": "float",
-            "range": [200, 2500],
-            "unit": "RT (Refrigeration Tons)",
-            "description": "Combined building cooling load across all chillers"
-        },
-        {
-            "name": "avg_chilled_water_rate_lps",
-            "type": "float", 
-            "range": [50, 500],
-            "unit": "L/sec",
-            "description": "Average chilled water flow rate"
-        },
-        {
-            "name": "avg_cooling_water_temp_c",
-            "type": "float",
-            "range": [15, 35],
-            "unit": "°C",
-            "description": "Average cooling water temperature entering condensers"
-        },
-        {
-            "name": "avg_outside_temp_f",
-            "type": "float",
-            "range": [32, 120],
-            "unit": "°F",
-            "description": "Average outside air temperature"
-        },
-        {
-            "name": "avg_dew_point_f",
-            "type": "float",
-            "range": [20, 80],
-            "unit": "°F",
-            "description": "Average dew point temperature"
-        },
-        {
-            "name": "avg_humidity_pct",
-            "type": "float",
-            "range": [20, 100],
-            "unit": "%",
-            "description": "Average relative humidity"
-        },
-        {
-            "name": "avg_wind_speed_mph",
-            "type": "float",
-            "range": [0, 30],
-            "unit": "mph",
-            "description": "Average wind speed"
-        },
-        {
-            "name": "avg_pressure_in",
-            "type": "float",
-            "range": [28, 31],
-            "unit": "in Hg",
-            "description": "Average atmospheric pressure"
-        },
-        {
-            "name": "hour",
-            "type": "integer",
-            "range": [0, 23],
-            "unit": "hour",
-            "description": "Hour of the day (24-hour format)"
-        },
-        {
-            "name": "day_of_week",
-            "type": "integer",
-            "range": [0, 6],
-            "unit": "day",
-            "description": "Day of week (0=Monday, 6=Sunday)"
-        },
-        {
-            "name": "month",
-            "type": "integer",
-            "range": [1, 12],
-            "unit": "month",
-            "description": "Month of the year"
-        },
-        {
-            "name": "day_of_year",
-            "type": "integer",
-            "range": [1, 366],
-            "unit": "day",
-            "description": "Day of the year (1-365/366)"
-        }
-    ]
-    
-    return MCPResponse(
-        model_card=MCPModelCard(
-            model_name="York Chiller Energy Optimizer",
-            model_type="Random Forest Regressor",
-            version="2.0.0",
-            description="Ensemble model that builds multiple decision trees to predict chiller plant energy efficiency (kW/TR) based on operational and environmental conditions. The model outputs the mean prediction of all trees for robust, non-linear regression.",
-            architecture={
-                "n_estimators": model.n_estimators if model and hasattr(model, 'n_estimators') else 100,
-                "max_depth": model.max_depth if model and hasattr(model, 'max_depth') else 12,
-                "min_samples_split": model.min_samples_split if model and hasattr(model, 'min_samples_split') else 2,
-                "min_samples_leaf": model.min_samples_leaf if model and hasattr(model, 'min_samples_leaf') else 1,
-                "bootstrap": True,
-                "oob_score": False,
-                "random_state": 42
-            },
-            training_data={
-                "source": "Historical chiller plant data",
-                "time_range": "12 months",
-                "sample_size": "50,000+ operational hours",
-                "features_used": 12,
-                "target": "Combined_Kw_per_TR"
-            },
-            intended_use=[
-                "Real-time chiller efficiency prediction",
-                "CHW setpoint optimization",
-                "Energy savings estimation",
-                "Operator decision support",
-                "Peak load management"
-            ],
-            limitations=[
-                "Predictions assume proper chiller sequencing",
-                "Does not account for chiller degradation over time",
-                "Requires accurate sensor inputs",
-                "Model valid for 200-2500 RT load range only",
-                "Assumes all chillers are operational"
-            ]
-        ),
-        performance=MCPPerformance(
-            metrics={
-                "r2_score": 0.892,
-                "mae": 0.023,
-                "rmse": 0.031,
-                "mape": 4.2,
-                "cv_rmse": 0.045
-            },
-            feature_importance=feature_importance_dict,
-            validation_method="Time-series cross validation",
-            test_size=0.20,
-            training_date=datetime.now().strftime("%Y-%m-%d")
-        ),
-        capabilities=MCPCapabilities(
-            input_features=input_features,
-            output_target={
-                "name": "Combined_Kw_per_TR",
-                "description": "Total chiller energy consumption (kWh) / total building load (RT). Lower values indicate better efficiency.",
-                "unit": "kW/TR",
-                "typical_range": [0.45, 1.0],
-                "optimal_range": [0.45, 0.60],
-                "interpretation": "Below 0.6 = Excellent, 0.6-0.7 = Good, 0.7-0.8 = Fair, Above 0.8 = Poor"
-            },
-            prediction_range={
-                "min": 0.45,
-                "max": 1.0,
-                "mean": 0.68,
-                "std_dev": 0.12
-            },
-            interpretability={
-                "feature_importance_available": True,
-                "shap_support": True,
-                "partial_dependence_plots": True,
-                "tree_visualization": False
-            },
-            optimization_modes=[
-                "CHW setpoint optimization",
-                "Load-based sequencing recommendations",
-                "Free cooling opportunities",
-                "Time-of-day efficiency analysis"
-            ]
-        ),
-        timestamp=datetime.now().isoformat()
-    )
-
-# ============================================
-# HELPER FUNCTIONS
-# ============================================
-
-def prepare_features(input_data: ChillerInput) -> np.ndarray:
-    """Prepare features in the exact order expected by the Random Forest model"""
-    
-    # Create feature array in the correct order (12 features)
-    features = np.array([
-        input_data.total_building_load_rt,           # 1. total_building_load
-        input_data.avg_chilled_water_rate_lps,       # 2. avg_chilled_water_rate
-        input_data.avg_cooling_water_temp_c,         # 3. avg_cooling_water_temp
-        input_data.avg_outside_temp_f,               # 4. avg_outside_temp
-        input_data.avg_dew_point_f,                  # 5. avg_dew_point
-        input_data.avg_humidity_pct,                 # 6. avg_humidity
-        input_data.avg_wind_speed_mph,               # 7. avg_wind_speed
-        input_data.avg_pressure_in,                  # 8. avg_pressure
-        input_data.hour,                             # 9. hour
-        input_data.day_of_week,                      # 10. day_of_week
-        input_data.month,                            # 11. month
-        input_data.day_of_year                       # 12. day_of_year
-    ]).reshape(1, -1)
-    
-    return features
-
-def predict_kw_per_tr(input_data: ChillerInput) -> float:
-    """Predict Combined_Kw_per_TR using the Random Forest model"""
+def predict_efficiency(input_data: ChillerInput) -> float:
+    """Predict kW/TR using loaded model"""
     if model is None:
-        raise ValueError("Model not loaded properly")
-    
-    # Prepare features
-    features = prepare_features(input_data)
+        raise ValueError("Model not loaded")
     
-    # Scale features if scaler exists
-    if scaler is not None:
-        features_scaled = scaler.transform(features)
-    else:
-        features_scaled = features
+    features = transform_to_model_format(input_data)
+    prediction = model.predict(features)[0]
     
-    # Predict
-    prediction = model.predict(features_scaled)[0]
+    # Ensure prediction is in reasonable range
+    prediction = np.clip(prediction, 0.4, 1.2)
     
     return float(prediction)
 
@@ -511,7 +222,6 @@ def optimize_chw_setpoint(input_data: ChillerInput) -> float:
     best_sp = current_sp
     
     for sp in test_setpoints:
-        # Create test input with modified setpoint
         test_input = ChillerInput(
             total_building_load_rt=input_data.total_building_load_rt,
             avg_chilled_water_rate_lps=input_data.avg_chilled_water_rate_lps,
@@ -529,7 +239,7 @@ def optimize_chw_setpoint(input_data: ChillerInput) -> float:
         )
         
         try:
-            kw = predict_kw_per_tr(test_input)
+            kw = predict_efficiency(test_input)
             if kw < best_kw:
                 best_kw = kw
                 best_sp = sp
@@ -538,121 +248,60 @@ def optimize_chw_setpoint(input_data: ChillerInput) -> float:
     
     return best_sp
 
-def calculate_savings(current_kw: float, optimal_kw: float, load_rt: float) -> tuple:
-    """Calculate savings percentage and absolute kW savings"""
-    if current_kw <= 0:
-        return 0, 0
-    
-    savings_pct = ((current_kw - optimal_kw) / current_kw) * 100
-    savings_kw = (current_kw - optimal_kw) * load_rt
-    
-    return max(0, savings_pct), max(0, savings_kw)
-
-def estimate_confidence_interval(input_data: ChillerInput) -> Dict[str, float]:
-    """Estimate prediction confidence interval using ensemble variance"""
-    if model is None or not hasattr(model, 'estimators_'):
-        return {"lower": None, "upper": None, "std": None}
-    
-    try:
-        # Get predictions from all trees
-        features = prepare_features(input_data)
-        if scaler is not None:
-            features_scaled = scaler.transform(features)
-        else:
-            features_scaled = features
-        
-        # Get individual tree predictions
-        tree_predictions = np.array([tree.predict(features_scaled)[0] 
-                                      for tree in model.estimators_])
-        
-        # Calculate statistics
-        mean_pred = np.mean(tree_predictions)
-        std_pred = np.std(tree_predictions)
-        
-        # 95% confidence interval (assuming normal distribution)
-        return {
-            "lower": float(mean_pred - 1.96 * std_pred),
-            "upper": float(mean_pred + 1.96 * std_pred),
-            "std": float(std_pred)
-        }
-    except:
-        return {"lower": None, "upper": None, "std": None}
-
 # ============================================
 # API ENDPOINTS
 # ============================================
 
 @app.get("/")
 async def root():
-    """Root endpoint with API information"""
     return {
         "service": "York Chiller Energy Optimizer",
         "model_type": "Random Forest Regressor",
         "version": "2.0.0",
         "status": "online" if model is not None else "model_not_loaded",
+        "model_info": {
+            "loaded": model is not None,
+            "type": "Demo (8-feature)" if is_demo_model else "Full (12-feature)" if model else "None",
+            "features_expected": len(model_features) if model_features else 0
+        },
         "endpoints": {
             "/": "This information",
-            "/health": "Health check with model status",
-            "/mcp": "GET - Model Card + Performance + Capabilities (MCP) documentation",
-            "/predict": "POST - Predict Combined_Kw_per_TR (efficiency metric)",
+            "/health": "Health check",
+            "/predict": "POST - Predict efficiency",
             "/optimize": "POST - Get optimization recommendations"
-        },
-        "interpretation": {
-            "kw_per_tr": "Combined energy efficiency indicator - LOWER is better",
-            "typical_range": "0.45 - 1.0 kW/TR",
-            "optimal_plants": "< 0.6 kW/TR",
-            "average_plants": "0.6 - 0.8 kW/TR"
         }
     }
 
 @app.get("/health")
 async def health():
-    """Health check endpoint"""
     return {
         "status": "healthy" if model is not None else "degraded",
         "model_loaded": model is not None,
-        "model_type": type(model).__name__ if model else None,
-        "n_estimators": model.n_estimators if model and hasattr(model, 'n_estimators') else None,
-        "scaler_loaded": scaler is not None,
-        "feature_count": len(feature_names) if feature_names else 12
+        "model_type": "demo_8_feature" if is_demo_model else "full_12_feature" if model else None,
+        "scaler_loaded": scaler is not None
     }
 
-@app.get("/mcp", response_model=MCPResponse)
-async def get_model_card():
-    """
-    Get MCP (Model Card + Performance + Capabilities) documentation
-    Returns comprehensive model information including:
-    - Model Card: Architecture, training data, intended use, limitations
-    - Performance: Metrics, feature importance, validation method
-    - Capabilities: Input features, output target, optimization modes
-    """
-    if model is None:
-        raise HTTPException(status_code=503, detail="Model not loaded - MCP data unavailable")
-    
-    return get_mcp_data()
-
 @app.post("/predict", response_model=PredictionResponse)
 async def predict_endpoint(input_data: ChillerInput):
-    """Predict Combined_Kw_per_TR for given conditions"""
+    """Predict chiller efficiency (kW/TR)"""
     try:
         if model is None:
-            raise HTTPException(status_code=503, detail="Model not loaded. Please check model files.")
+            raise HTTPException(status_code=503, detail="Model not loaded")
         
-        # Make prediction
-        kw_per_tr = predict_kw_per_tr(input_data)
+        kw_per_tr = predict_efficiency(input_data)
         
-        # Estimate confidence interval
-        confidence_interval = estimate_confidence_interval(input_data)
-        
-        # Create response
         return PredictionResponse(
             status="success",
             kw_per_tr=round(kw_per_tr, 4),
-            input_features=input_data.dict(),
-            confidence_interval=confidence_interval if confidence_interval["lower"] else None,
+            model_type="Demo (8-feature)" if is_demo_model else "Full (12-feature)",
+            features_used=len(model_features) if model_features else 0,
+            input_mapped={
+                "load_tons": input_data.total_building_load_rt,
+                "hour": input_data.hour,
+                "month": input_data.month
+            },
             timestamp=datetime.now().isoformat()
         )
-        
     except Exception as e:
         raise HTTPException(status_code=500, detail=str(e))
 
@@ -661,91 +310,64 @@ async def optimize_endpoint(input_data: ChillerInput):
     """Get optimization recommendations"""
     try:
         if model is None:
-            raise HTTPException(status_code=503, detail="Model not loaded. Please check model files.")
+            raise HTTPException(status_code=503, detail="Model not loaded")
         
-        # Predict current efficiency
-        current_kw = predict_kw_per_tr(input_data)
+        # Current efficiency
+        current_kw = predict_efficiency(input_data)
         
-        # Find optimal CHW setpoint
+        # Find optimal setpoint
         optimal_sp = optimize_chw_setpoint(input_data)
         
-        # Create test input with optimal setpoint
-        optimal_input = ChillerInput(
-            total_building_load_rt=input_data.total_building_load_rt,
-            avg_chilled_water_rate_lps=input_data.avg_chilled_water_rate_lps,
-            avg_cooling_water_temp_c=input_data.avg_cooling_water_temp_c,
-            avg_outside_temp_f=input_data.avg_outside_temp_f,
-            avg_dew_point_f=input_data.avg_dew_point_f,
-            avg_humidity_pct=input_data.avg_humidity_pct,
-            avg_wind_speed_mph=input_data.avg_wind_speed_mph,
-            avg_pressure_in=input_data.avg_pressure_in,
-            hour=input_data.hour,
-            day_of_week=input_data.day_of_week,
-            month=input_data.month,
-            day_of_year=input_data.day_of_year,
-            current_chw_setpoint_c=optimal_sp
-        )
+        # Calculate optimal efficiency
+        optimal_input = ChillerInput(**input_data.dict())
+        optimal_input.current_chw_setpoint_c = optimal_sp
+        optimal_kw = predict_efficiency(optimal_input)
         
-        optimal_kw = predict_kw_per_tr(optimal_input)
-        savings_pct, savings_kw = calculate_savings(current_kw, optimal_kw, input_data.total_building_load_rt)
+        # Calculate savings
+        savings_pct = ((current_kw - optimal_kw) / current_kw) * 100 if current_kw > 0 else 0
+        savings_pct = max(0, savings_pct)
         
         # Build recommendations
         recommendations = []
         
-        # CHW Setpoint recommendation
         current_sp = input_data.current_chw_setpoint_c or 8.0
         if optimal_sp != current_sp and savings_pct > 1:
             recommendations.append(OptimizationRecommendation(
                 action="CHW Setpoint Optimization",
                 current_value=f"{current_sp:.1f}°C",
                 recommended_value=f"{optimal_sp:.1f}°C",
-                expected_savings=f"{savings_pct:.1f}% ({savings_kw:.0f} kW)",
+                expected_savings=f"{savings_pct:.1f}%",
                 priority="HIGH" if savings_pct > 5 else "MEDIUM",
-                operator_action=f"Adjust CHW setpoint from {current_sp:.1f}°C to {optimal_sp:.1f}°C"
+                operator_action=f"Adjust CHW setpoint to {optimal_sp:.1f}°C"
             ))
         
-        # Load-based chiller sequencing
+        # Load-based recommendations
         if input_data.total_building_load_rt < 600:
             recommendations.append(OptimizationRecommendation(
                 action="Chiller Sequencing",
-                current_value=f"{input_data.total_building_load_rt:.0f} RT load",
-                recommended_value="Consider single chiller operation",
+                current_value=f"{input_data.total_building_load_rt:.0f} RT",
+                recommended_value="Single chiller operation",
                 expected_savings="Reduced parasitic losses",
                 priority="MEDIUM",
-                operator_action="Evaluate if load can be handled by one chiller"
-            ))
-        elif input_data.total_building_load_rt > 1800:
-            recommendations.append(OptimizationRecommendation(
-                action="Chiller Sequencing",
-                current_value=f"{input_data.total_building_load_rt:.0f} RT load",
-                recommended_value="Verify all chillers are online",
-                expected_savings="Prevents overload",
-                priority="HIGH",
-                operator_action="Check if all chillers are running optimally"
-            ))
-        
-        # Free cooling recommendation
-        if input_data.avg_outside_temp_f < 50 and input_data.avg_humidity_pct < 60:
-            recommendations.append(OptimizationRecommendation(
-                action="Free Cooling",
-                current_value="Not enabled",
-                recommended_value="Consider enabling",
-                expected_savings="20-40%",
-                priority="HIGH",
-                operator_action="Enable economizer/free cooling if available"
+                operator_action="Consider running only one chiller"
             ))
         
         # Efficiency rating
-        efficiency_rating = "Excellent" if current_kw < 0.55 else "Good" if current_kw < 0.65 else "Fair" if current_kw < 0.75 else "Poor"
+        if current_kw < 0.55:
+            rating = "Excellent"
+        elif current_kw < 0.65:
+            rating = "Good"
+        elif current_kw < 0.75:
+            rating = "Fair"
+        else:
+            rating = "Poor"
         
         summary = {
             "current_efficiency": f"{current_kw:.3f} kW/TR",
             "target_efficiency": f"{optimal_kw:.3f} kW/TR",
             "potential_savings": f"{savings_pct:.1f}%",
-            "load_tons": f"{input_data.total_building_load_rt:.0f} RT",
-            "efficiency_rating": efficiency_rating,
-            "plant_status": f"Operating at {current_kw:.3f} kW/TR - {efficiency_rating} efficiency",
-            "recommended_action": f"Optimize CHW setpoint to {optimal_sp:.1f}°C" if savings_pct > 1 else "Current operation is near optimal"
+            "efficiency_rating": rating,
+            "model_type": "Demo (8-feature)" if is_demo_model else "Full (12-feature)"
         }
         
         return OptimizeResponse(
@@ -760,10 +382,6 @@ async def optimize_endpoint(input_data: ChillerInput):
     except Exception as e:
         raise HTTPException(status_code=500, detail=str(e))
 
-# ============================================
-# RUN WITH: uvicorn app:app --host 0.0.0.0 --port 7860
-# ============================================
-
 if __name__ == "__main__":
     import uvicorn
     uvicorn.run(app, host="0.0.0.0", port=7860)