Update app.py

app.py

@@ -8,6 +8,8 @@ import datetime
 from typing import List, Dict, Any
 import hashlib
 import asyncio
+from enum import Enum
+from dataclasses import dataclass
 
 # Import our modules
 from models import ReliabilityEvent, EventSeverity, AnomalyResult, HealingAction
@@ -56,6 +58,257 @@ def save_index():
         with open(TEXTS_FILE, "w") as f:
             json.dump(incident_texts, f)
 
+# === Predictive Models ===
+@dataclass
+class ForecastResult:
+    metric: str
+    predicted_value: float
+    confidence: float
+    trend: str  # "increasing", "decreasing", "stable"
+    time_to_threshold: Any = None
+    risk_level: str = "low"  # low, medium, high, critical
+
+class SimplePredictiveEngine:
+    """Lightweight forecasting engine optimized for Hugging Face Spaces"""
+    
+    def __init__(self, history_window: int = 50):
+        self.history_window = history_window
+        self.service_history: Dict[str, List] = {}
+        self.prediction_cache: Dict[str, ForecastResult] = {}
+        
+    def add_telemetry(self, service: str, event_data: Dict):
+        """Add telemetry data to service history"""
+        if service not in self.service_history:
+            self.service_history[service] = []
+        
+        telemetry_point = {
+            'timestamp': datetime.datetime.now(),
+            'latency': event_data.get('latency_p99', 0),
+            'error_rate': event_data.get('error_rate', 0),
+            'throughput': event_data.get('throughput', 0),
+            'cpu_util': event_data.get('cpu_util'),
+            'memory_util': event_data.get('memory_util')
+        }
+        
+        self.service_history[service].append(telemetry_point)
+        
+        # Keep only recent history
+        if len(self.service_history[service]) > self.history_window:
+            self.service_history[service].pop(0)
+    
+    def forecast_service_health(self, service: str, lookahead_minutes: int = 15) -> List[ForecastResult]:
+        """Forecast service health metrics"""
+        if service not in self.service_history or len(self.service_history[service]) < 10:
+            return []
+        
+        history = self.service_history[service]
+        forecasts = []
+        
+        # Forecast latency
+        latency_forecast = self._forecast_latency(history, lookahead_minutes)
+        if latency_forecast:
+            forecasts.append(latency_forecast)
+        
+        # Forecast error rate
+        error_forecast = self._forecast_error_rate(history, lookahead_minutes)
+        if error_forecast:
+            forecasts.append(error_forecast)
+        
+        # Forecast resource utilization
+        resource_forecasts = self._forecast_resources(history, lookahead_minutes)
+        forecasts.extend(resource_forecasts)
+        
+        # Cache results
+        for forecast in forecasts:
+            cache_key = f"{service}_{forecast.metric}"
+            self.prediction_cache[cache_key] = forecast
+        
+        return forecasts
+    
+    def _forecast_latency(self, history: List, lookahead_minutes: int) -> Any:
+        """Forecast latency using linear regression and trend analysis"""
+        try:
+            latencies = [point['latency'] for point in history[-20:]]
+            
+            if len(latencies) < 5:
+                return None
+            
+            # Simple linear trend
+            x = np.arange(len(latencies))
+            slope, intercept = np.polyfit(x, latencies, 1)
+            
+            # Predict next value
+            next_x = len(latencies)
+            predicted_latency = slope * next_x + intercept
+            
+            # Calculate confidence based on data quality
+            residuals = latencies - (slope * x + intercept)
+            confidence = max(0, 1 - (np.std(residuals) / max(1, np.mean(latencies))))
+            
+            # Determine trend
+            if slope > 5:
+                trend = "increasing"
+                risk = "high" if predicted_latency > 300 else "medium"
+            elif slope < -2:
+                trend = "decreasing" 
+                risk = "low"
+            else:
+                trend = "stable"
+                risk = "low"
+            
+            # Calculate time to reach critical threshold (500ms)
+            time_to_critical = None
+            if slope > 0 and predicted_latency < 500:
+                time_to_critical = datetime.timedelta(
+                    minutes=lookahead_minutes * (500 - predicted_latency) / max(0.1, (predicted_latency - latencies[-1]))
+                )
+            
+            return ForecastResult(
+                metric="latency",
+                predicted_value=predicted_latency,
+                confidence=confidence,
+                trend=trend,
+                time_to_threshold=time_to_critical,
+                risk_level=risk
+            )
+            
+        except Exception as e:
+            print(f"Latency forecast error: {e}")
+            return None
+    
+    def _forecast_error_rate(self, history: List, lookahead_minutes: int) -> Any:
+        """Forecast error rate using exponential smoothing"""
+        try:
+            error_rates = [point['error_rate'] for point in history[-15:]]
+            
+            if len(error_rates) < 5:
+                return None
+            
+            # Exponential smoothing
+            alpha = 0.3
+            forecast = error_rates[0]
+            for rate in error_rates[1:]:
+                forecast = alpha * rate + (1 - alpha) * forecast
+            
+            predicted_rate = forecast
+            
+            # Trend analysis
+            recent_trend = np.mean(error_rates[-3:]) - np.mean(error_rates[-6:-3])
+            
+            if recent_trend > 0.02:
+                trend = "increasing"
+                risk = "high" if predicted_rate > 0.1 else "medium"
+            elif recent_trend < -0.01:
+                trend = "decreasing"
+                risk = "low"
+            else:
+                trend = "stable"
+                risk = "low"
+            
+            # Confidence based on volatility
+            confidence = max(0, 1 - (np.std(error_rates) / max(0.01, np.mean(error_rates))))
+            
+            return ForecastResult(
+                metric="error_rate",
+                predicted_value=predicted_rate,
+                confidence=confidence,
+                trend=trend,
+                risk_level=risk
+            )
+            
+        except Exception as e:
+            print(f"Error rate forecast error: {e}")
+            return None
+    
+    def _forecast_resources(self, history: List, lookahead_minutes: int) -> List[ForecastResult]:
+        """Forecast CPU and memory utilization"""
+        forecasts = []
+        
+        # CPU forecast
+        cpu_values = [point['cpu_util'] for point in history if point.get('cpu_util') is not None]
+        if len(cpu_values) >= 5:
+            try:
+                predicted_cpu = np.mean(cpu_values[-5:])
+                trend = "increasing" if cpu_values[-1] > np.mean(cpu_values[-10:-5]) else "stable"
+                
+                risk = "low"
+                if predicted_cpu > 0.8:
+                    risk = "critical" if predicted_cpu > 0.9 else "high"
+                elif predicted_cpu > 0.7:
+                    risk = "medium"
+                
+                forecasts.append(ForecastResult(
+                    metric="cpu_util",
+                    predicted_value=predicted_cpu,
+                    confidence=0.7,
+                    trend=trend,
+                    risk_level=risk
+                ))
+            except Exception as e:
+                print(f"CPU forecast error: {e}")
+        
+        # Memory forecast
+        memory_values = [point['memory_util'] for point in history if point.get('memory_util') is not None]
+        if len(memory_values) >= 5:
+            try:
+                predicted_memory = np.mean(memory_values[-5:])
+                trend = "increasing" if memory_values[-1] > np.mean(memory_values[-10:-5]) else "stable"
+                
+                risk = "low"
+                if predicted_memory > 0.8:
+                    risk = "critical" if predicted_memory > 0.9 else "high"
+                elif predicted_memory > 0.7:
+                    risk = "medium"
+                
+                forecasts.append(ForecastResult(
+                    metric="memory_util",
+                    predicted_value=predicted_memory,
+                    confidence=0.7,
+                    trend=trend,
+                    risk_level=risk
+                ))
+            except Exception as e:
+                print(f"Memory forecast error: {e}")
+        
+        return forecasts
+    
+    def get_predictive_insights(self, service: str) -> Dict[str, Any]:
+        """Generate actionable insights from forecasts"""
+        forecasts = self.forecast_service_health(service)
+        
+        critical_risks = [f for f in forecasts if f.risk_level in ["high", "critical"]]
+        warnings = []
+        recommendations = []
+        
+        for forecast in critical_risks:
+            if forecast.metric == "latency" and forecast.risk_level in ["high", "critical"]:
+                warnings.append(f"📈 Latency expected to reach {forecast.predicted_value:.0f}ms")
+                if forecast.time_to_threshold:
+                    minutes = int(forecast.time_to_threshold.total_seconds() / 60)
+                    recommendations.append(f"⏰ Critical latency (~500ms) in ~{minutes} minutes")
+                recommendations.append("🔧 Consider scaling or optimizing dependencies")
+            
+            elif forecast.metric == "error_rate" and forecast.risk_level in ["high", "critical"]:
+                warnings.append(f"🚨 Errors expected to reach {forecast.predicted_value*100:.1f}%")
+                recommendations.append("🐛 Investigate recent deployments or dependency issues")
+            
+            elif forecast.metric == "cpu_util" and forecast.risk_level in ["high", "critical"]:
+                warnings.append(f"🔥 CPU expected at {forecast.predicted_value*100:.1f}%")
+                recommendations.append("⚡ Consider scaling compute resources")
+            
+            elif forecast.metric == "memory_util" and forecast.risk_level in ["high", "critical"]:
+                warnings.append(f"💾 Memory expected at {forecast.predicted_value*100:.1f}%")
+                recommendations.append("🧹 Check for memory leaks or optimize usage")
+        
+        return {
+            'service': service,
+            'forecasts': [f.__dict__ for f in forecasts],
+            'warnings': warnings[:3],
+            'recommendations': list(dict.fromkeys(recommendations))[:3],
+            'critical_risk_count': len(critical_risks),
+            'forecast_timestamp': datetime.datetime.now().isoformat()
+        }
+
 # === Core Engine Components ===
 policy_engine = PolicyEngine()
 events_history: List[ReliabilityEvent] = []
@@ -67,29 +320,23 @@ class BusinessImpactCalculator:
         self.revenue_per_request = revenue_per_request
     
     def calculate_impact(self, event: ReliabilityEvent, duration_minutes: int = 5) -> Dict[str, Any]:
-        """Enhanced business impact calculation"""
+        base_revenue_per_minute = 100
         
-        # More realistic impact calculation
-        base_revenue_per_minute = 100  # Base revenue per minute for the service
-        
-        # Calculate impact based on severity of anomalies
         impact_multiplier = 1.0
         
         if event.latency_p99 > 300:
-            impact_multiplier += 0.5  # High latency impact
+            impact_multiplier += 0.5
         if event.error_rate > 0.1:
-            impact_multiplier += 0.8  # High error rate impact
+            impact_multiplier += 0.8
         if event.cpu_util and event.cpu_util > 0.9:
-            impact_multiplier += 0.3  # Resource exhaustion impact
+            impact_multiplier += 0.3
         
         revenue_loss = base_revenue_per_minute * impact_multiplier * (duration_minutes / 60)
         
-        # More realistic user impact
-        base_users_affected = 1000  # Base user count
+        base_users_affected = 1000
         user_impact_multiplier = (event.error_rate * 10) + (max(0, event.latency_p99 - 100) / 500)
         affected_users = int(base_users_affected * user_impact_multiplier)
         
-        # Severity classification
         if revenue_loss > 500 or affected_users > 5000:
             severity = "CRITICAL"
         elif revenue_loss > 100 or affected_users > 1000:
@@ -114,38 +361,30 @@ class AdvancedAnomalyDetector:
     def __init__(self):
         self.historical_data = []
         self.adaptive_thresholds = {
-            'latency_p99': 150,  # Will adapt based on history
+            'latency_p99': 150,
             'error_rate': 0.05
         }
     
     def detect_anomaly(self, event: ReliabilityEvent) -> bool:
-        """Enhanced anomaly detection with adaptive thresholds"""
-        
-        # Basic threshold checks
         latency_anomaly = event.latency_p99 > self.adaptive_thresholds['latency_p99']
         error_anomaly = event.error_rate > self.adaptive_thresholds['error_rate']
         
-        # Resource-based anomalies
         resource_anomaly = False
         if event.cpu_util and event.cpu_util > 0.9:
             resource_anomaly = True
         if event.memory_util and event.memory_util > 0.9:
             resource_anomaly = True
         
-        # Update adaptive thresholds (simplified)
         self._update_thresholds(event)
         
         return latency_anomaly or error_anomaly or resource_anomaly
     
     def _update_thresholds(self, event: ReliabilityEvent):
-        """Update adaptive thresholds based on historical data"""
         self.historical_data.append(event)
         
-        # Keep only recent history
         if len(self.historical_data) > 100:
             self.historical_data.pop(0)
         
-        # Update latency threshold to 90th percentile of recent data
         if len(self.historical_data) > 10:
             recent_latencies = [e.latency_p99 for e in self.historical_data[-20:]]
             self.adaptive_thresholds['latency_p99'] = np.percentile(recent_latencies, 90)
@@ -153,11 +392,10 @@ class AdvancedAnomalyDetector:
 anomaly_detector = AdvancedAnomalyDetector()
 
 # === Multi-Agent Foundation ===
-from enum import Enum
-
 class AgentSpecialization(Enum):
     DETECTIVE = "anomaly_detection"
     DIAGNOSTICIAN = "root_cause_analysis"
+    PREDICTIVE = "predictive_analytics"
 
 class BaseAgent:
     def __init__(self, specialization: AgentSpecialization):
@@ -171,7 +409,6 @@ class AnomalyDetectionAgent(BaseAgent):
         super().__init__(AgentSpecialization.DETECTIVE)
     
     async def analyze(self, event: ReliabilityEvent) -> Dict[str, Any]:
-        """Enhanced anomaly detection with confidence scoring"""
         anomaly_score = self._calculate_anomaly_score(event)
         
         return {
@@ -186,20 +423,16 @@ class AnomalyDetectionAgent(BaseAgent):
         }
     
     def _calculate_anomaly_score(self, event: ReliabilityEvent) -> float:
-        """Calculate comprehensive anomaly score (0-1)"""
         scores = []
         
-        # Latency anomaly (weighted 40%)
         if event.latency_p99 > 150:
             latency_score = min(1.0, (event.latency_p99 - 150) / 500)
             scores.append(0.4 * latency_score)
         
-        # Error rate anomaly (weighted 30%)
         if event.error_rate > 0.05:
             error_score = min(1.0, event.error_rate / 0.3)
             scores.append(0.3 * error_score)
         
-        # Resource anomaly (weighted 30%)
         resource_score = 0
         if event.cpu_util and event.cpu_util > 0.8:
             resource_score += 0.15 * min(1.0, (event.cpu_util - 0.8) / 0.2)
@@ -210,7 +443,6 @@ class AnomalyDetectionAgent(BaseAgent):
         return min(1.0, sum(scores))
     
     def _classify_severity(self, anomaly_score: float) -> str:
-        """Classify severity based on anomaly score"""
         if anomaly_score > 0.8:
             return "CRITICAL"
         elif anomaly_score > 0.6:
@@ -221,10 +453,8 @@ class AnomalyDetectionAgent(BaseAgent):
             return "LOW"
     
     def _identify_affected_metrics(self, event: ReliabilityEvent) -> List[Dict[str, Any]]:
-        """Enhanced metric analysis with severity levels"""
         affected = []
         
-        # Latency analysis
         if event.latency_p99 > 500:
             affected.append({"metric": "latency", "value": event.latency_p99, "severity": "CRITICAL", "threshold": 150})
         elif event.latency_p99 > 300:
@@ -232,7 +462,6 @@ class AnomalyDetectionAgent(BaseAgent):
         elif event.latency_p99 > 150:
             affected.append({"metric": "latency", "value": event.latency_p99, "severity": "MEDIUM", "threshold": 150})
         
-        # Error rate analysis  
         if event.error_rate > 0.3:
             affected.append({"metric": "error_rate", "value": event.error_rate, "severity": "CRITICAL", "threshold": 0.05})
         elif event.error_rate > 0.15:
@@ -240,7 +469,6 @@ class AnomalyDetectionAgent(BaseAgent):
         elif event.error_rate > 0.05:
             affected.append({"metric": "error_rate", "value": event.error_rate, "severity": "MEDIUM", "threshold": 0.05})
         
-        # Resource analysis
         if event.cpu_util and event.cpu_util > 0.9:
             affected.append({"metric": "cpu", "value": event.cpu_util, "severity": "CRITICAL", "threshold": 0.8})
         elif event.cpu_util and event.cpu_util > 0.8:
@@ -254,7 +482,6 @@ class AnomalyDetectionAgent(BaseAgent):
         return affected
     
     def _generate_detection_recommendations(self, event: ReliabilityEvent, anomaly_score: float) -> List[str]:
-        """Generate specific, actionable recommendations"""
         recommendations = []
         affected_metrics = self._identify_affected_metrics(event)
         
@@ -286,7 +513,6 @@ class AnomalyDetectionAgent(BaseAgent):
             elif metric_name == "memory":
                 recommendations.append(f"💾 Memory {severity}: {value*100:.1f}% utilization - Check for memory leaks")
         
-        # Add overall recommendations based on anomaly score
         if anomaly_score > 0.8:
             recommendations.append("🎯 IMMEDIATE ACTION REQUIRED: Multiple critical metrics affected")
         elif anomaly_score > 0.6:
@@ -294,19 +520,18 @@ class AnomalyDetectionAgent(BaseAgent):
         elif anomaly_score > 0.4:
             recommendations.append("📊 MONITOR: Early warning signs detected")
         
-        return recommendations[:4]  # Return top 4 most important recommendations
+        return recommendations[:4]
 
 class RootCauseAgent(BaseAgent):
     def __init__(self):
         super().__init__(AgentSpecialization.DIAGNOSTICIAN)
     
     async def analyze(self, event: ReliabilityEvent) -> Dict[str, Any]:
-        """Basic root cause analysis"""
         causes = self._analyze_potential_causes(event)
         
         return {
             'specialization': self.specialization.value,
-            'confidence': 0.7,  # Base confidence
+            'confidence': 0.7,
             'findings': {
                 'likely_root_causes': causes,
                 'evidence_patterns': self._identify_evidence(event),
@@ -318,10 +543,8 @@ class RootCauseAgent(BaseAgent):
         }
     
     def _analyze_potential_causes(self, event: ReliabilityEvent) -> List[Dict[str, Any]]:
-        """Enhanced root cause analysis with confidence scoring"""
         causes = []
         
-        # High latency + high errors pattern
         if event.latency_p99 > 500 and event.error_rate > 0.2:
             causes.append({
                 "cause": "Database/External Dependency Failure",
@@ -330,7 +553,6 @@ class RootCauseAgent(BaseAgent):
                 "investigation": "Check database connection pool, external API health"
             })
         
-        # Resource exhaustion pattern
         if event.cpu_util and event.cpu_util > 0.9 and event.memory_util and event.memory_util > 0.9:
             causes.append({
                 "cause": "Resource Exhaustion",
@@ -339,7 +561,6 @@ class RootCauseAgent(BaseAgent):
                 "investigation": "Check for memory leaks, infinite loops, insufficient resources"
             })
         
-        # Error spike pattern
         if event.error_rate > 0.3 and event.latency_p99 < 200:
             causes.append({
                 "cause": "Application Bug / Configuration Issue",
@@ -348,7 +569,6 @@ class RootCauseAgent(BaseAgent):
                 "investigation": "Review recent deployments, configuration changes, application logs"
             })
         
-        # Gradual degradation pattern
         if 200 <= event.latency_p99 <= 400 and 0.05 <= event.error_rate <= 0.15:
             causes.append({
                 "cause": "Gradual Performance Degradation",
@@ -368,7 +588,6 @@ class RootCauseAgent(BaseAgent):
         return causes
     
     def _identify_evidence(self, event: ReliabilityEvent) -> List[str]:
-        """Identify evidence patterns"""
         evidence = []
         if event.latency_p99 > event.error_rate * 1000:
             evidence.append("latency_disproportionate_to_errors")
@@ -377,27 +596,50 @@ class RootCauseAgent(BaseAgent):
         return evidence
     
     def _prioritize_investigation(self, causes: List[Dict[str, Any]]) -> str:
-        """Prioritize investigation based on causes"""
         for cause in causes:
             if "Database" in cause["cause"] or "Resource Exhaustion" in cause["cause"]:
                 return "HIGH"
         return "MEDIUM"
 
+class PredictiveAgent(BaseAgent):
+    def __init__(self):
+        super().__init__(AgentSpecialization.PREDICTIVE)
+        self.engine = SimplePredictiveEngine()
+    
+    async def analyze(self, event: ReliabilityEvent) -> Dict[str, Any]:
+        """Predictive analysis for future risks"""
+        event_data = {
+            'latency_p99': event.latency_p99,
+            'error_rate': event.error_rate,
+            'throughput': event.throughput,
+            'cpu_util': event.cpu_util,
+            'memory_util': event.memory_util
+        }
+        self.engine.add_telemetry(event.component, event_data)
+        
+        insights = self.engine.get_predictive_insights(event.component)
+        
+        return {
+            'specialization': self.specialization.value,
+            'confidence': 0.8 if insights['critical_risk_count'] > 0 else 0.5,
+            'findings': insights,
+            'recommendations': insights['recommendations']
+        }
+
 class OrchestrationManager:
     def __init__(self):
         self.agents = {
             AgentSpecialization.DETECTIVE: AnomalyDetectionAgent(),
             AgentSpecialization.DIAGNOSTICIAN: RootCauseAgent(),
+            AgentSpecialization.PREDICTIVE: PredictiveAgent(),
         }
     
     async def orchestrate_analysis(self, event: ReliabilityEvent) -> Dict[str, Any]:
-        """Coordinate multiple agents for comprehensive analysis"""
         agent_tasks = {
             spec: agent.analyze(event)
             for spec, agent in self.agents.items()
         }
         
-        # Execute agents in parallel
         agent_results = {}
         for specialization, task in agent_tasks.items():
             try:
@@ -409,9 +651,9 @@ class OrchestrationManager:
         return self._synthesize_agent_findings(event, agent_results)
     
     def _synthesize_agent_findings(self, event: ReliabilityEvent, agent_results: Dict) -> Dict[str, Any]:
-        """Combine insights from all specialized agents"""
         detective_result = agent_results.get(AgentSpecialization.DETECTIVE.value)
         diagnostician_result = agent_results.get(AgentSpecialization.DIAGNOSTICIAN.value)
+        predictive_result = agent_results.get(AgentSpecialization.PREDICTIVE.value)
         
         if not detective_result:
             return {'error': 'No agent results available'}
@@ -423,9 +665,11 @@ class OrchestrationManager:
                 'primary_metrics_affected': [metric["metric"] for metric in detective_result['findings'].get('primary_metrics_affected', [])]
             },
             'root_cause_insights': diagnostician_result['findings'] if diagnostician_result else {},
+            'predictive_insights': predictive_result['findings'] if predictive_result else {},
             'recommended_actions': self._prioritize_actions(
                 detective_result.get('recommendations', []),
-                diagnostician_result.get('recommendations', []) if diagnostician_result else []
+                diagnostician_result.get('recommendations', []) if diagnostician_result else [],
+                predictive_result.get('recommendations', []) if predictive_result else []
             ),
             'agent_metadata': {
                 'participating_agents': list(agent_results.keys()),
@@ -435,17 +679,15 @@ class OrchestrationManager:
         
         return synthesis
     
-    def _prioritize_actions(self, detection_actions: List[str], diagnosis_actions: List[str]) -> List[str]:
-        """Combine and prioritize actions from different agents"""
-        all_actions = detection_actions + diagnosis_actions
-        # Remove duplicates while preserving order
+    def _prioritize_actions(self, detection_actions: List[str], diagnosis_actions: List[str], predictive_actions: List[str]) -> List[str]:
+        all_actions = detection_actions + diagnosis_actions + predictive_actions
         seen = set()
         unique_actions = []
         for action in all_actions:
             if action not in seen:
                 seen.add(action)
                 unique_actions.append(action)
-        return unique_actions[:4]  # Return top 4 actions
+        return unique_actions[:5]
 
 # Initialize enhanced components
 orchestration_manager = OrchestrationManager()
@@ -460,9 +702,7 @@ class EnhancedReliabilityEngine:
     async def process_event_enhanced(self, component: str, latency: float, error_rate: float,
                                    throughput: float = 1000, cpu_util: float = None,
                                    memory_util: float = None) -> Dict[str, Any]:
-        """Enhanced event processing with multi-agent orchestration"""
         
-        # Create event
         event = ReliabilityEvent(
             component=component,
             latency_p99=latency,
@@ -473,21 +713,16 @@ class EnhancedReliabilityEngine:
             upstream_deps=["auth-service", "database"] if component == "api-service" else []
         )
         
-        # Multi-agent analysis
         agent_analysis = await orchestration_manager.orchestrate_analysis(event)
         
-        # Traditional detection (for compatibility)
         is_anomaly = anomaly_detector.detect_anomaly(event)
 
-        # Enhanced severity classification using agent confidence
         agent_confidence = 0.0
         if agent_analysis and 'incident_summary' in agent_analysis:
             agent_confidence = agent_analysis.get('incident_summary', {}).get('anomaly_confidence', 0)
         else:
-            # Fallback to basic anomaly detection confidence
             agent_confidence = 0.8 if is_anomaly else 0.1
 
-        # Set severity based on confidence
         if agent_confidence > 0.8:
             event.severity = EventSeverity.CRITICAL
         elif agent_confidence > 0.6:
@@ -497,13 +732,10 @@ class EnhancedReliabilityEngine:
         else:
             event.severity = EventSeverity.LOW
         
-        # Policy evaluation
         healing_actions = policy_engine.evaluate_policies(event)
         
-        # Business impact
         business_impact = business_calculator.calculate_impact(event) if is_anomaly else None
         
-        # Vector memory learning
         if index is not None and is_anomaly:
             analysis_text = agent_analysis.get('recommended_actions', ['No analysis'])[0]
             vector_text = f"{component} {latency} {error_rate} {analysis_text}"
@@ -512,7 +744,6 @@ class EnhancedReliabilityEngine:
             incident_texts.append(vector_text)
             save_index()
         
-        # Prepare comprehensive result
         result = {
             "timestamp": event.timestamp,
             "component": component,
@@ -541,7 +772,6 @@ class EnhancedReliabilityEngine:
 enhanced_engine = EnhancedReliabilityEngine()
 
 def call_huggingface_analysis(prompt: str) -> str:
-    """Use HF Inference API or fallback simulation"""
     if not HF_TOKEN:
         fallback_insights = [
             "High latency detected - possible resource contention or network issues",
@@ -588,13 +818,12 @@ def call_huggingface_analysis(prompt: str) -> str:
 
 # === Enhanced UI with Multi-Agent Insights ===
 def create_enhanced_ui():
-    """Create enhanced UI with multi-agent capabilities"""
     with gr.Blocks(title="🧠 Enterprise Agentic Reliability Framework", theme="soft") as demo:
         gr.Markdown("""
         # 🧠 Enterprise Agentic Reliability Framework
         **Multi-Agent AI System for Production Reliability**
         
-        *Specialized AI agents working together to detect, diagnose, and heal system issues*
+        *Specialized AI agents working together to detect, diagnose, predict, and heal system issues*
         """)
         
         with gr.Row():
@@ -638,15 +867,15 @@ def create_enhanced_ui():
                 output_text = gr.Textbox(
                     label="Agent Synthesis",
                     placeholder="AI agents are analyzing...",
-                    lines=5
+                    lines=6
                 )
                 
-                # New agent insights section
                 with gr.Accordion("🤖 Agent Specialists Analysis", open=False):
                     gr.Markdown("""
                     **Specialized AI Agents:**
                     - 🕵️ **Detective**: Anomaly detection & pattern recognition
-                    - 🔍 **Diagnostician**: Root cause analysis & investigation
+                    - 🔍 **Diagnostician**: Root cause analysis & investigation  
+                    - 🔮 **Predictive**: Future risk forecasting & trend analysis
                     """)
                     
                     agent_insights = gr.JSON(
@@ -654,6 +883,20 @@ def create_enhanced_ui():
                         value={}
                     )
                 
+                with gr.Accordion("🔮 Predictive Analytics & Forecasting", open=False):
+                    gr.Markdown("""
+                    **Future Risk Forecasting:**
+                    - 📈 Latency trends and thresholds
+                    - 🚨 Error rate predictions  
+                    - 🔥 Resource utilization forecasts
+                    - ⏰ Time-to-failure estimates
+                    """)
+                    
+                    predictive_insights = gr.JSON(
+                        label="Predictive Forecasts",
+                        value={}
+                    )
+                
                 gr.Markdown("### 📈 Recent Events (Last 15)")
                 events_table = gr.Dataframe(
                     headers=["Timestamp", "Component", "Latency", "Error Rate", "Throughput", "Severity", "Analysis"],
@@ -661,10 +904,10 @@ def create_enhanced_ui():
                     wrap=True,
                 )
         
-        # Information sections
         with gr.Accordion("ℹ️ Framework Capabilities", open=False):
             gr.Markdown("""
-            - **🤖 Multi-Agent AI**: Specialized agents for detection, diagnosis, and healing
+            - **🤖 Multi-Agent AI**: Specialized agents for detection, diagnosis, prediction, and healing
+            - **🔮 Predictive Analytics**: Forecast future risks and performance degradation
             - **🔧 Policy-Based Healing**: Automated recovery actions based on severity and context
             - **💰 Business Impact**: Revenue and user impact quantification
             - **🎯 Adaptive Detection**: ML-powered thresholds that learn from your environment
@@ -681,23 +924,18 @@ def create_enhanced_ui():
             
             gr.Markdown("\n\n".join(policy_info))
         
-        # Event handling
         async def submit_event_enhanced(component, latency, error_rate, throughput, cpu_util, memory_util):
-            """Enhanced event submission with async processing"""
             try:
-                # Convert inputs
                 latency = float(latency)
                 error_rate = float(error_rate)
                 throughput = float(throughput) if throughput else 1000
                 cpu_util = float(cpu_util) if cpu_util else None
                 memory_util = float(memory_util) if memory_util else None
                 
-                # Process with enhanced engine
                 result = await enhanced_engine.process_event_enhanced(
                     component, latency, error_rate, throughput, cpu_util, memory_util
                 )
                 
-                # Prepare table data
                 table_data = []
                 for event in events_history[-15:]:
                     table_data.append([
@@ -710,35 +948,36 @@ def create_enhanced_ui():
                         "Multi-agent analysis" if 'multi_agent_analysis' in result else 'N/A'
                     ])
                 
-                # Enhanced output formatting
                 status_emoji = "🚨" if result["status"] == "ANOMALY" else "✅"
                 output_msg = f"{status_emoji} {result['status']}"
                 
-                # Add multi-agent insights
                 if "multi_agent_analysis" in result:
                     analysis = result["multi_agent_analysis"]
                     confidence = analysis.get('incident_summary', {}).get('anomaly_confidence', 0)
                     output_msg += f"\n🎯 Confidence: {confidence*100:.1f}%"
                     
+                    predictive_data = analysis.get('predictive_insights', {})
+                    if predictive_data.get('critical_risk_count', 0) > 0:
+                        output_msg += f"\n🔮 PREDICTIVE: {predictive_data['critical_risk_count']} critical risks forecast"
+                    
                     if analysis.get('recommended_actions'):
                         output_msg += f"\n💡 Insights: {', '.join(analysis['recommended_actions'][:2])}"
                 
-                # Add business impact
                 if result["business_impact"]:
                     impact = result["business_impact"]
                     output_msg += f"\n💰 Business Impact: ${impact['revenue_loss_estimate']} | 👥 {impact['affected_users_estimate']} users | 🚨 {impact['severity_level']}"
                 
-                # Add healing actions
                 if result["healing_actions"] and result["healing_actions"] != ["no_action"]:
                     actions = ", ".join(result["healing_actions"])
                     output_msg += f"\n🔧 Auto-Actions: {actions}"
                 
-                # Prepare agent insights for JSON display
                 agent_insights_data = result.get("multi_agent_analysis", {})
+                predictive_insights_data = agent_insights_data.get('predictive_insights', {})
                 
                 return (
                     output_msg,
                     agent_insights_data,
+                    predictive_insights_data,
                     gr.Dataframe(
                         headers=["Timestamp", "Component", "Latency", "Error Rate", "Throughput", "Severity", "Analysis"],
                         value=table_data,
@@ -747,12 +986,12 @@ def create_enhanced_ui():
                 )
                 
             except Exception as e:
-                return f"❌ Error processing event: {str(e)}", {}, gr.Dataframe(value=[])
+                return f"❌ Error processing event: {str(e)}", {}, {}, gr.Dataframe(value=[])
         
         submit_btn.click(
             fn=submit_event_enhanced,
             inputs=[component, latency, error_rate, throughput, cpu_util, memory_util],
-            outputs=[output_text, agent_insights, events_table]
+            outputs=[output_text, agent_insights, predictive_insights, events_table]
         )
     
     return demo