🔧 Fix model loading using proven app_gunicorn.py approach - no pipeline, direct generation

app.py

@@ -1,8 +1,7 @@
 #!/usr/bin/env python3
 """
 Enhanced Flask App with LangGraph + AEGIS Economics AI
-Tech Scores → LangGraph Processing → Qwen2 Model → Economic Predictions
-CPU-optimized version for Modal deployment
+CPU-optimized version with memory/timeout fixes
 """
 
 from flask import Flask, request, jsonify, render_template_string
@@ -14,43 +13,21 @@ import json
 from datetime import datetime
 from typing import Dict, List, Any, Optional
 from dataclasses import dataclass
-import asyncio
-from concurrent.futures import ThreadPoolExecutor
-
-# LangGraph imports
-try:
-    from langgraph.graph import StateGraph, END
-    from langchain_core.messages import BaseMessage, HumanMessage, AIMessage, SystemMessage
-    from langchain_core.prompts import ChatPromptTemplate
-    LANGGRAPH_AVAILABLE = True
-    print("✅ LangGraph successfully imported")
-except ImportError as e:
-    LANGGRAPH_AVAILABLE = False
-    print(f"⚠️ LangGraph import failed: {e}")
-    print("Using simplified processing mode")
+import time
+import gc
 
 # Configure logging
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
+# Disable parallelism to reduce memory usage
+os.environ["TOKENIZERS_PARALLELISM"] = "false"
+
 app = Flask(__name__)
 
 # Global variables
 model = None
 tokenizer = None
-executor = ThreadPoolExecutor(max_workers=2)
-
-def cleanup_memory():
-    """Clean up GPU/CPU memory"""
-    try:
-        if torch.cuda.is_available():
-            torch.cuda.empty_cache()
-            torch.cuda.synchronize()
-        # Force garbage collection
-        import gc
-        gc.collect()
-    except Exception as e:
-        logger.warning(f"Memory cleanup warning: {e}")
 
 @dataclass
 class TechScores:
@@ -86,341 +63,21 @@ class TechScores:
                 threats.append(threat)
         return threats
 
-@dataclass
-class LangGraphState:
-    """State for LangGraph processing"""
-    tech_scores: TechScores
-    processed_analysis: Optional[str] = None
-    economic_context: Optional[str] = None
-    risk_assessment: Optional[str] = None
-    policy_recommendations: Optional[str] = None
-    final_prompt: Optional[str] = None
-    processing_steps: List[str] = None
-    
-    def __post_init__(self):
-        if self.processing_steps is None:
-            self.processing_steps = []
+def cleanup_memory():
+    """Clean up memory aggressively"""
+    try:
+        gc.collect()
+        if torch.cuda.is_available():
+            torch.cuda.empty_cache()
+            torch.cuda.synchronize()
+    except Exception as e:
+        logger.warning(f"Memory cleanup warning: {e}")
 
 class LangGraphProcessor:
-    """LangGraph-based tech score processor"""
+    """Simplified LangGraph-based tech score processor"""
     
     def __init__(self):
         self.graph = None
-        if LANGGRAPH_AVAILABLE:
-            self._build_graph()
-    
-    def _build_graph(self):
-        """Build the LangGraph processing pipeline"""
-        try:
-            # Create state graph
-            from langgraph.graph import StateGraph, END
-            
-            workflow = StateGraph(dict)  # Use dict instead of LangGraphState for compatibility
-            
-            # Add nodes
-            workflow.add_node("analyze_tech_scores", self._analyze_tech_scores_simple)
-            workflow.add_node("assess_economic_context", self._assess_economic_context_simple)
-            workflow.add_node("evaluate_risks", self._evaluate_risks_simple)
-            workflow.add_node("generate_policy_recs", self._generate_policy_recommendations_simple)
-            workflow.add_node("create_final_prompt", self._create_final_prompt_simple)
-            
-            # Define edges
-            workflow.set_entry_point("analyze_tech_scores")
-            workflow.add_edge("analyze_tech_scores", "assess_economic_context")
-            workflow.add_edge("assess_economic_context", "evaluate_risks")
-            workflow.add_edge("evaluate_risks", "generate_policy_recs")
-            workflow.add_edge("generate_policy_recs", "create_final_prompt")
-            workflow.add_edge("create_final_prompt", END)
-            
-            # Compile graph
-            self.graph = workflow.compile()
-            logger.info("✅ LangGraph pipeline built successfully")
-            
-        except Exception as e:
-            logger.error(f"Failed to build LangGraph: {e}")
-            self.graph = None
-    
-    def _analyze_tech_scores_simple(self, state: dict) -> dict:
-        """Simplified tech scores analysis for LangGraph compatibility"""
-        tech_scores = state.get('tech_scores')
-        if not tech_scores:
-            return state
-            
-        total_threat = tech_scores.get_total_threat_level()
-        dominant_threats = tech_scores.get_dominant_threats()
-        
-        analysis = f"""TECHNOLOGY THREAT ANALYSIS (Year {tech_scores.year}):
-        
-Overall Threat Level: {total_threat:.3f} ({self._threat_level_description(total_threat)})
-Dominant Threats: {', '.join(dominant_threats) if dominant_threats else 'None above threshold'}
-
-Detailed Analysis:
-- AI: {tech_scores.ai:.3f} - {self._ai_threat_analysis(tech_scores.ai)}
-- Cyber: {tech_scores.cyber:.3f} - {self._cyber_threat_analysis(tech_scores.cyber)}
-- Bio: {tech_scores.bio:.3f} - {self._bio_threat_analysis(tech_scores.bio)}
-- Nuclear: {tech_scores.nuclear:.3f} - {self._nuclear_threat_analysis(tech_scores.nuclear)}
-- Climate: {tech_scores.climate:.3f} - {self._climate_threat_analysis(tech_scores.climate)}
-- Space: {tech_scores.space:.3f} - {self._space_threat_analysis(tech_scores.space)}"""
-        
-        state['processed_analysis'] = analysis
-        state['processing_steps'] = state.get('processing_steps', []) + ["Technology threat analysis completed"]
-        return state
-    
-    def _assess_economic_context_simple(self, state: dict) -> dict:
-        """Simplified economic context assessment"""
-        tech_scores = state.get('tech_scores')
-        if not tech_scores:
-            return state
-            
-        total_threat = tech_scores.get_total_threat_level()
-        market_volatility = min(total_threat * 1.2, 1.0)
-        gdp_impact = self._calculate_gdp_impact(tech_scores)
-        
-        economic_context = f"""ECONOMIC CONTEXT ASSESSMENT:
-
-Market Volatility Index: {market_volatility:.3f}
-Projected GDP Impact: {gdp_impact:.1f}%
-Economic Stability Risk: {self._stability_risk_level(total_threat)}
-
-Regional Vulnerabilities:
-{self._assess_regional_vulnerabilities(tech_scores)}"""
-        
-        state['economic_context'] = economic_context
-        state['processing_steps'] = state.get('processing_steps', []) + ["Economic context assessment completed"]
-        return state
-    
-    def _evaluate_risks_simple(self, state: dict) -> dict:
-        """Simplified risk evaluation"""
-        tech_scores = state.get('tech_scores')
-        if not tech_scores:
-            return state
-            
-        cascade_probability = self._calculate_cascade_probability(tech_scores)
-        systemic_risk = self._assess_systemic_risk(tech_scores)
-        
-        risk_assessment = f"""COMPREHENSIVE RISK EVALUATION:
-
-Cascade Failure Probability: {cascade_probability:.3f}
-Systemic Risk Level: {systemic_risk}
-
-Critical Risk Scenarios:
-{self._generate_risk_scenarios(tech_scores)}"""
-        
-        state['risk_assessment'] = risk_assessment
-        state['processing_steps'] = state.get('processing_steps', []) + ["Risk evaluation completed"]
-        return state
-    
-    def _generate_policy_recommendations_simple(self, state: dict) -> dict:
-        """Simplified policy recommendations"""
-        tech_scores = state.get('tech_scores')
-        if not tech_scores:
-            return state
-            
-        immediate_actions = self._immediate_policy_actions(tech_scores)
-        
-        policy_recs = f"""POLICY RECOMMENDATIONS FRAMEWORK:
-
-IMMEDIATE ACTIONS (0-6 months):
-{immediate_actions}
-
-Resource Allocation Priorities:
-{self._resource_allocation_priorities(tech_scores)}"""
-        
-        state['policy_recommendations'] = policy_recs
-        state['processing_steps'] = state.get('processing_steps', []) + ["Policy recommendations generated"]
-        return state
-    
-    def _create_final_prompt_simple(self, state: dict) -> dict:
-        """Simplified final prompt creation"""
-        
-        final_prompt = f"""You are AEGIS Economics AI, analyzing technology threats for economic policy planning.
-
-PROCESSED INTELLIGENCE BRIEFING:
-
-{state.get('processed_analysis', '')}
-
-{state.get('economic_context', '')}
-
-{state.get('risk_assessment', '')}
-
-{state.get('policy_recommendations', '')}
-
-ANALYSIS REQUEST:
-Based on this comprehensive intelligence briefing, provide your final economic analysis with specific numerical estimates and actionable recommendations for economic policy makers."""
-        
-        state['final_prompt'] = final_prompt
-        state['processing_steps'] = state.get('processing_steps', []) + ["Final prompt optimization completed"]
-        return state
-        """Step 1: Analyze technology threat scores"""
-        scores = state.tech_scores
-        total_threat = scores.get_total_threat_level()
-        dominant_threats = scores.get_dominant_threats()
-        
-        analysis = f"""TECHNOLOGY THREAT ANALYSIS (Year {scores.year}):
-        
-Overall Threat Level: {total_threat:.3f} ({self._threat_level_description(total_threat)})
-Dominant Threats: {', '.join(dominant_threats) if dominant_threats else 'None above threshold'}
-
-Detailed Breakdown:
-- AI Threat Level: {scores.ai:.3f} - {self._ai_threat_analysis(scores.ai)}
-- Cyber Threat Level: {scores.cyber:.3f} - {self._cyber_threat_analysis(scores.cyber)}
-- Bio Threat Level: {scores.bio:.3f} - {self._bio_threat_analysis(scores.bio)}
-- Nuclear Threat Level: {scores.nuclear:.3f} - {self._nuclear_threat_analysis(scores.nuclear)}
-- Climate Threat Level: {scores.climate:.3f} - {self._climate_threat_analysis(scores.climate)}
-- Space Threat Level: {scores.space:.3f} - {self._space_threat_analysis(scores.space)}
-
-Cross-Domain Interactions:
-{self._analyze_cross_domain_effects(scores)}"""
-        
-        state.processed_analysis = analysis
-        state.processing_steps.append("Technology threat analysis completed")
-        return state
-    
-    def _assess_economic_context(self, state: LangGraphState) -> LangGraphState:
-        """Step 2: Assess economic context and implications"""
-        scores = state.tech_scores
-        total_threat = scores.get_total_threat_level()
-        
-        # Economic impact assessment based on threat levels
-        market_volatility = min(total_threat * 1.2, 1.0)
-        gdp_impact = self._calculate_gdp_impact(scores)
-        sector_impacts = self._analyze_sector_impacts(scores)
-        
-        economic_context = f"""ECONOMIC CONTEXT ASSESSMENT:
-
-Market Volatility Index: {market_volatility:.3f}
-Projected GDP Impact: {gdp_impact:.1f}%
-Economic Stability Risk: {self._stability_risk_level(total_threat)}
-
-Sector Impact Analysis:
-{sector_impacts}
-
-Regional Economic Vulnerabilities:
-{self._assess_regional_vulnerabilities(scores)}
-
-Supply Chain Disruption Risk: {self._supply_chain_risk(scores):.3f}
-Financial System Stress: {self._financial_stress_assessment(scores)}"""
-        
-        state.economic_context = economic_context
-        state.processing_steps.append("Economic context assessment completed")
-        return state
-    
-    def _evaluate_risks(self, state: LangGraphState) -> LangGraphState:
-        """Step 3: Evaluate comprehensive risk scenarios"""
-        scores = state.tech_scores
-        
-        # Risk scenario modeling
-        cascade_probability = self._calculate_cascade_probability(scores)
-        systemic_risk = self._assess_systemic_risk(scores)
-        timeline_analysis = self._analyze_risk_timeline(scores)
-        
-        risk_assessment = f"""COMPREHENSIVE RISK EVALUATION:
-
-Cascade Failure Probability: {cascade_probability:.3f}
-Systemic Risk Level: {systemic_risk}
-Risk Materialization Timeline: {timeline_analysis}
-
-Critical Risk Scenarios:
-{self._generate_risk_scenarios(scores)}
-
-Mitigation Priorities:
-{self._prioritize_mitigations(scores)}
-
-Early Warning Indicators:
-{self._identify_warning_indicators(scores)}"""
-        
-        state.risk_assessment = risk_assessment
-        state.processing_steps.append("Risk evaluation completed")
-        return state
-    
-    def _generate_policy_recommendations(self, state: LangGraphState) -> LangGraphState:
-        """Step 4: Generate policy recommendations"""
-        scores = state.tech_scores
-        
-        immediate_actions = self._immediate_policy_actions(scores)
-        medium_term_strategies = self._medium_term_strategies(scores)
-        long_term_planning = self._long_term_planning(scores)
-        
-        policy_recs = f"""POLICY RECOMMENDATIONS FRAMEWORK:
-
-IMMEDIATE ACTIONS (0-6 months):
-{immediate_actions}
-
-MEDIUM-TERM STRATEGIES (6 months - 2 years):
-{medium_term_strategies}
-
-LONG-TERM PLANNING (2+ years):
-{long_term_planning}
-
-International Cooperation Requirements:
-{self._international_cooperation_needs(scores)}
-
-Resource Allocation Priorities:
-{self._resource_allocation_priorities(scores)}"""
-        
-        state.policy_recommendations = policy_recs
-        state.processing_steps.append("Policy recommendations generated")
-        return state
-    
-    def _create_final_prompt(self, state: LangGraphState) -> LangGraphState:
-        """Step 5: Create optimized prompt for AEGIS Economics AI"""
-        
-        final_prompt = f"""You are AEGIS Economics AI, analyzing technology threats for economic policy planning.
-
-PROCESSED INTELLIGENCE BRIEFING:
-
-{state.processed_analysis}
-
-{state.economic_context}
-
-{state.risk_assessment}
-
-{state.policy_recommendations}
-
-ANALYSIS REQUEST:
-Based on this comprehensive intelligence briefing, provide your final economic analysis with:
-
-1. MARKET SHOCK INDEX (0.0-1.0): Your calculated overall economic disruption risk
-2. IMPACT CLASSIFICATION: Local/Regional/Global/Catastrophic
-3. QUANTIFIED PREDICTIONS:
-   - GDP impact percentage over 1, 3, and 5 years
-   - Market volatility projections
-   - Sector-specific impact percentages
-   - Regional vulnerability rankings
-
-4. ACTIONABLE INTELLIGENCE:
-   - Top 3 immediate policy priorities
-   - Critical economic indicators to monitor
-   - Investment strategy recommendations
-   - Risk mitigation timeline
-
-5. CONFIDENCE ASSESSMENT:
-   - Prediction confidence levels
-   - Key uncertainty factors
-   - Alternative scenario probabilities
-
-Provide specific numerical estimates and actionable recommendations for economic policy makers."""
-        
-        state.final_prompt = final_prompt
-        state.processing_steps.append("Final prompt optimization completed")
-        return state
-    
-    # Helper methods for analysis
-    def _threat_level_description(self, total_threat: float) -> str:
-        """Get threat level description from total threat score"""
-        if total_threat >= 0.8: return "CRITICAL"
-        elif total_threat >= 0.6: return "HIGH"
-        elif total_threat >= 0.4: return "MODERATE"
-        elif total_threat >= 0.2: return "LOW"
-        else: return "MINIMAL"
-    
-    def _stability_risk_level(self, total_threat: float) -> str:
-        """Calculate stability risk level from total threat"""
-        if total_threat >= 0.8: return "CRITICAL"
-        elif total_threat >= 0.6: return "HIGH"
-        elif total_threat >= 0.4: return "MODERATE"
-        elif total_threat >= 0.2: return "LOW"
-        else: return "MINIMAL"
     
     def _ai_threat_analysis(self, score: float) -> str:
         if score >= 0.8: return "AGI/Singularity risk, massive economic disruption"
@@ -458,631 +115,271 @@ Provide specific numerical estimates and actionable recommendations for economic
         elif score >= 0.4: return "Space security concerns, increased space militarization"
         else: return "Stable space environment, continued commercial growth"
     
-    def _calculate_gdp_impact(self, scores: TechScores) -> float:
-        """Calculate projected GDP impact"""
-        base_impact = scores.get_total_threat_level() * -15  # Base negative impact
-        
-        # Amplification factors
-        if scores.ai >= 0.8: base_impact *= 1.5  # AI singularity amplification
-        if scores.climate >= 0.8: base_impact *= 1.3  # Climate catastrophe
-        if scores.nuclear >= 0.6: base_impact *= 2.0  # Nuclear conflict
-        
-        return max(base_impact, -50)  # Cap at -50% GDP impact
-    
-    def _assess_regional_vulnerabilities(self, scores: TechScores) -> str:
-        """Assess regional vulnerabilities"""
-        regions = {
-            'North America': (scores.ai * 0.8 + scores.cyber * 0.9 + scores.climate * 0.6) / 3,
-            'Europe': (scores.cyber * 0.7 + scores.climate * 0.8 + scores.nuclear * 0.6) / 3,
-            'Asia Pacific': (scores.ai * 0.9 + scores.cyber * 0.8 + scores.climate * 0.7) / 3,
-            'China': (scores.ai * 0.9 + scores.cyber * 0.8 + scores.space * 0.7) / 3,
-            'Russia': (scores.nuclear * 0.9 + scores.cyber * 0.7 + scores.space * 0.6) / 3,
-            'Middle East': (scores.nuclear * 0.8 + scores.climate * 0.9 + scores.cyber * 0.5) / 3,
-            'Africa': (scores.climate * 0.9 + scores.bio * 0.7 + scores.cyber * 0.4) / 3,
-            'South America': (scores.climate * 0.8 + scores.bio * 0.6 + scores.cyber * 0.4) / 3
-        }
-        
-        return "\n".join([f"- {region}: {vuln:.3f} vulnerability index" for region, vuln in regions.items()])
-    
-    def _calculate_cascade_probability(self, scores: TechScores) -> float:
-        """Calculate cascade failure probability"""
-        base_prob = scores.get_total_threat_level() * 0.8
-        
-        # Cross-domain amplification
-        if scores.ai >= 0.7 and scores.cyber >= 0.7: base_prob += 0.2
-        if scores.climate >= 0.8: base_prob += 0.15
-        if scores.nuclear >= 0.5: base_prob += 0.25
-        
-        return min(base_prob, 1.0)
-    
-    def _assess_systemic_risk(self, scores: TechScores) -> str:
-        """Assess systemic risk level"""
-        risk_score = (scores.ai * 0.25 + scores.cyber * 0.25 + scores.nuclear * 0.2 + 
-                     scores.climate * 0.15 + scores.bio * 0.1 + scores.space * 0.05)
-        
-        if risk_score >= 0.8: return "EXISTENTIAL - Civilization-level threats"
-        elif risk_score >= 0.6: return "CRITICAL - System-wide failure risk"
-        elif risk_score >= 0.4: return "HIGH - Major disruption likely"
-        elif risk_score >= 0.2: return "MODERATE - Manageable with preparation"
-        else: return "LOW - Standard risk management sufficient"
-    
-    def _generate_risk_scenarios(self, scores: TechScores) -> str:
-        """Generate risk scenarios"""
-        scenarios = []
-        
-        if scores.ai >= 0.8:
-            scenarios.append("AI Singularity Scenario: Rapid economic obsolescence, mass unemployment")
-        if scores.cyber >= 0.7 and scores.ai >= 0.5:
-            scenarios.append("Cyber-AI Warfare: Autonomous attacks on critical infrastructure")
-        if scores.climate >= 0.8:
-            scenarios.append("Climate Collapse: Supply chain breakdown, mass migration")
-        if scores.nuclear >= 0.6:
-            scenarios.append("Nuclear Exchange: Regional economic devastation, global recession")
-        if scores.bio >= 0.7:
-            scenarios.append("Pandemic Scenario: Healthcare collapse, economic shutdown")
-        
-        return "\n".join([f"- {scenario}" for scenario in scenarios]) if scenarios else "- No critical scenarios identified"
-    
-    def _immediate_policy_actions(self, scores: TechScores) -> str:
-        """Generate immediate policy actions"""
-        actions = []
-        
-        if scores.ai >= 0.7:
-            actions.append("Emergency AI safety protocols, regulatory frameworks")
-        if scores.cyber >= 0.6:
-            actions.append("Critical infrastructure protection, cyber emergency response")
-        if scores.nuclear >= 0.5:
-            actions.append("Nuclear security enhancement, crisis communication protocols")
-        if scores.climate >= 0.7:
-            actions.append("Climate emergency declarations, adaptation funding")
-        if scores.bio >= 0.6:
-            actions.append("Public health emergency preparedness, medical stockpiling")
-        
-        return "\n".join([f"- {action}" for action in actions]) if actions else "- Continue standard monitoring and preparedness"
-    
-    def _resource_allocation_priorities(self, scores: TechScores) -> str:
-        """Calculate resource allocation priorities"""
-        priorities = []
-        threat_scores = scores.to_dict()
-        
-        # Calculate resource allocation based on threat levels
-        total_threat = sum(threat_scores.values())
-        if total_threat > 0:
-            for threat, score in threat_scores.items():
-                percentage = (score / total_threat) * 100
-                if percentage >= 15:  # Significant allocation threshold
-                    priorities.append(f"{threat} defense/mitigation: {percentage:.1f}% of emergency resources")
-        
-        return "\n".join([f"- {priority}" for priority in priorities]) if priorities else "- Balanced resource allocation across all domains"
-    
-    def _calculate_gdp_impact(self, scores: TechScores) -> float:
-        """Calculate projected GDP impact"""
-        base_impact = scores.get_total_threat_level() * -15  # Base negative impact
-        
-        # Amplification factors
-        if scores.ai >= 0.8: base_impact *= 1.5  # AI singularity amplification
-        if scores.climate >= 0.8: base_impact *= 1.3  # Climate catastrophe
-        if scores.nuclear >= 0.6: base_impact *= 2.0  # Nuclear conflict
-        
-        return max(base_impact, -50)  # Cap at -50% GDP impact
-    
-    def _analyze_sector_impacts(self, scores: TechScores) -> str:
-        sectors = {
-            'Technology': max(scores.ai, scores.cyber) * 100,
-            'Finance': (scores.cyber * 0.8 + scores.ai * 0.6) * 100,
-            'Energy': (scores.climate * 0.9 + scores.cyber * 0.5) * 100,
-            'Healthcare': (scores.bio * 0.9 + scores.ai * 0.4) * 100,
-            'Defense': (scores.nuclear * 0.8 + scores.space * 0.7 + scores.cyber * 0.6) * 100,
-            'Agriculture': (scores.climate * 0.8 + scores.bio * 0.5) * 100,
-            'Transportation': (scores.cyber * 0.6 + scores.climate * 0.5 + scores.ai * 0.4) * 100,
-            'Manufacturing': (scores.ai * 0.7 + scores.cyber * 0.5 + scores.climate * 0.4) * 100
-        }
-        
-        return "\n".join([f"- {sector}: {impact:.1f}% disruption risk" for sector, impact in sectors.items()])
-    
-    def _assess_regional_vulnerabilities(self, scores: TechScores) -> str:
-        regions = {
-            'North America': (scores.ai * 0.8 + scores.cyber * 0.9 + scores.climate * 0.6) / 3,
-            'Europe': (scores.cyber * 0.7 + scores.climate * 0.8 + scores.nuclear * 0.6) / 3,
-            'Asia Pacific': (scores.ai * 0.9 + scores.cyber * 0.8 + scores.climate * 0.7) / 3,
-            'China': (scores.ai * 0.9 + scores.cyber * 0.8 + scores.space * 0.7) / 3,
-            'Russia': (scores.nuclear * 0.9 + scores.cyber * 0.7 + scores.space * 0.6) / 3,
-            'Middle East': (scores.nuclear * 0.8 + scores.climate * 0.9 + scores.cyber * 0.5) / 3,
-            'Africa': (scores.climate * 0.9 + scores.bio * 0.7 + scores.cyber * 0.4) / 3,
-            'South America': (scores.climate * 0.8 + scores.bio * 0.6 + scores.cyber * 0.4) / 3
-        }
-        
-        return "\n".join([f"- {region}: {vuln:.3f} vulnerability index" for region, vuln in regions.items()])
-    
-    def _supply_chain_risk(self, scores: TechScores) -> float:
-        return min((scores.cyber * 0.4 + scores.climate * 0.3 + scores.ai * 0.2 + scores.bio * 0.1), 1.0)
-    
-    def _financial_stress_assessment(self, scores: TechScores) -> str:
-        stress_level = scores.cyber * 0.4 + scores.ai * 0.3 + scores.nuclear * 0.3
-        if stress_level >= 0.8: return "CRITICAL - System failure risk"
-        elif stress_level >= 0.6: return "HIGH - Major instability expected"
-        elif stress_level >= 0.4: return "MODERATE - Increased volatility"
-        else: return "LOW - Manageable stress levels"
-    
-    def _calculate_cascade_probability(self, scores: TechScores) -> float:
-        # Complex cascade probability calculation
-        base_prob = scores.get_total_threat_level() * 0.8
-        
-        # Cross-domain amplification
-        if scores.ai >= 0.7 and scores.cyber >= 0.7: base_prob += 0.2
-        if scores.climate >= 0.8: base_prob += 0.15
-        if scores.nuclear >= 0.5: base_prob += 0.25
-        
-        return min(base_prob, 1.0)
-    
-    def _assess_systemic_risk(self, scores: TechScores) -> str:
-        risk_score = (scores.ai * 0.25 + scores.cyber * 0.25 + scores.nuclear * 0.2 + 
-                     scores.climate * 0.15 + scores.bio * 0.1 + scores.space * 0.05)
-        
-        if risk_score >= 0.8: return "EXISTENTIAL - Civilization-level threats"
-        elif risk_score >= 0.6: return "CRITICAL - System-wide failure risk"
-        elif risk_score >= 0.4: return "HIGH - Major disruption likely"
-        elif risk_score >= 0.2: return "MODERATE - Manageable with preparation"
-        else: return "LOW - Standard risk management sufficient"
-    
-    def _analyze_risk_timeline(self, scores: TechScores) -> str:
-        timelines = []
-        if scores.cyber >= 0.6: timelines.append("Cyber threats: Immediate (0-6 months)")
-        if scores.ai >= 0.7: timelines.append("AI disruption: Near-term (1-3 years)")
-        if scores.climate >= 0.6: timelines.append("Climate impacts: Medium-term (2-5 years)")
-        if scores.nuclear >= 0.5: timelines.append("Nuclear risks: Variable (immediate to long-term)")
-        if scores.bio >= 0.5: timelines.append("Biological threats: Short to medium-term (6 months - 2 years)")
-        if scores.space >= 0.6: timelines.append("Space threats: Medium-term (1-5 years)")
-        
-        return "\n".join([f"- {timeline}" for timeline in timelines]) if timelines else "- No immediate timeline concerns"
-    
-    def _generate_risk_scenarios(self, scores: TechScores) -> str:
-        scenarios = []
-        
-        if scores.ai >= 0.8:
-            scenarios.append("AI Singularity Scenario: Rapid economic obsolescence, mass unemployment")
-        if scores.cyber >= 0.7 and scores.ai >= 0.5:
-            scenarios.append("Cyber-AI Warfare: Autonomous attacks on critical infrastructure")
-        if scores.climate >= 0.8:
-            scenarios.append("Climate Collapse: Supply chain breakdown, mass migration")
-        if scores.nuclear >= 0.6:
-            scenarios.append("Nuclear Exchange: Regional economic devastation, global recession")
-        if scores.bio >= 0.7:
-            scenarios.append("Pandemic Scenario: Healthcare collapse, economic shutdown")
-        
-        return "\n".join([f"- {scenario}" for scenario in scenarios]) if scenarios else "- No critical scenarios identified"
-    
-    def _prioritize_mitigations(self, scores: TechScores) -> str:
-        mitigations = []
-        threat_scores = scores.to_dict()
-        
-        # Sort by threat level
-        sorted_threats = sorted(threat_scores.items(), key=lambda x: x[1], reverse=True)
-        
-        for threat, score in sorted_threats[:3]:  # Top 3 threats
-            if score >= 0.5:
-                if threat == 'AI':
-                    mitigations.append("AI governance frameworks, safety research funding")
-                elif threat == 'Cyber':
-                    mitigations.append("Critical infrastructure hardening, cyber defense capabilities")
-                elif threat == 'Bio':
-                    mitigations.append("Pandemic preparedness, biosecurity measures")
-                elif threat == 'Nuclear':
-                    mitigations.append("Nuclear security, arms control agreements")
-                elif threat == 'Climate':
-                    mitigations.append("Climate adaptation, green transition acceleration")
-                elif threat == 'Space':
-                    mitigations.append("Space debris mitigation, satellite protection")
-        
-        return "\n".join([f"- {mit}" for mit in mitigations]) if mitigations else "- Standard risk management protocols sufficient"
-    
-    def _identify_warning_indicators(self, scores: TechScores) -> str:
-        indicators = []
-        
-        if scores.ai >= 0.6:
-            indicators.append("AI capability benchmarks, automation deployment rates")
-        if scores.cyber >= 0.5:
-            indicators.append("Cyber incident frequency, critical system vulnerabilities")
-        if scores.climate >= 0.6:
-            indicators.append("Climate tipping point indicators, extreme weather frequency")
-        if scores.nuclear >= 0.4:
-            indicators.append("Nuclear material security, geopolitical tensions")
-        if scores.bio >= 0.5:
-            indicators.append("Disease surveillance systems, biosafety incidents")
-        if scores.space >= 0.5:
-            indicators.append("Space debris levels, satellite collision risks")
-        
-        return "\n".join([f"- {indicator}" for indicator in indicators]) if indicators else "- Standard monitoring protocols"
-    
-    def _immediate_policy_actions(self, scores: TechScores) -> str:
-        actions = []
-        
-        if scores.ai >= 0.7:
-            actions.append("Emergency AI safety protocols, regulatory frameworks")
-        if scores.cyber >= 0.6:
-            actions.append("Critical infrastructure protection, cyber emergency response")
-        if scores.nuclear >= 0.5:
-            actions.append("Nuclear security enhancement, crisis communication protocols")
-        if scores.climate >= 0.7:
-            actions.append("Climate emergency declarations, adaptation funding")
-        if scores.bio >= 0.6:
-            actions.append("Public health emergency preparedness, medical stockpiling")
-        
-        return "\n".join([f"- {action}" for action in actions]) if actions else "- Continue standard monitoring and preparedness"
-    
-    def _medium_term_strategies(self, scores: TechScores) -> str:
-        strategies = []
-        
-        if scores.ai >= 0.5:
-            strategies.append("AI workforce transition programs, safety research investment")
-        if scores.cyber >= 0.4:
-            strategies.append("Cybersecurity infrastructure modernization, international cooperation")
-        if scores.climate >= 0.5:
-            strategies.append("Green infrastructure investment, carbon pricing mechanisms")
-        if scores.nuclear >= 0.3:
-            strategies.append("Nuclear security upgrades, non-proliferation efforts")
-        if scores.bio >= 0.4:
-            strategies.append("Healthcare system resilience, biosecurity capabilities")
-        
-        return "\n".join([f"- {strategy}" for strategy in strategies]) if strategies else "- Standard policy development"
-    
-    def _long_term_planning(self, scores: TechScores) -> str:
-        plans = []
-        
-        if scores.ai >= 0.4:
-            plans.append("Post-AI economic models, universal basic income consideration")
-        if scores.climate >= 0.4:
-            plans.append("Climate-resilient infrastructure, economic transformation")
-        if scores.cyber >= 0.3:
-            plans.append("Quantum-safe cryptography, next-gen security architectures")
-        if scores.nuclear >= 0.2:
-            plans.append("Nuclear disarmament pathways, alternative security frameworks")
-        
-        return "\n".join([f"- {plan}" for plan in plans]) if plans else "- Continue adaptive planning processes"
-    
-    def _international_cooperation_needs(self, scores: TechScores) -> str:
-        needs = []
-        
-        if scores.ai >= 0.6:
-            needs.append("Global AI governance, safety standards coordination")
-        if scores.cyber >= 0.5:
-            needs.append("Cyber norms, attribution mechanisms, response coordination")
-        if scores.climate >= 0.6:
-            needs.append("Enhanced climate cooperation, technology transfer")
-        if scores.nuclear >= 0.4:
-            needs.append("Arms control renewal, nuclear security cooperation")
-        if scores.bio >= 0.5:
-            needs.append("Global health security, pandemic preparedness")
-        
-        return "\n".join([f"- {need}" for need in needs]) if needs else "- Standard international engagement"
-    
-    def _resource_allocation_priorities(self, scores: TechScores) -> str:
-        priorities = []
-        threat_scores = scores.to_dict()
-        
-        # Calculate resource allocation based on threat levels
-        total_threat = sum(threat_scores.values())
-        if total_threat > 0:
-            for threat, score in threat_scores.items():
-                percentage = (score / total_threat) * 100
-                if percentage >= 15:  # Significant allocation threshold
-                    priorities.append(f"{threat} defense/mitigation: {percentage:.1f}% of emergency resources")
-        
-        return "\n".join([f"- {priority}" for priority in priorities]) if priorities else "- Balanced resource allocation across all domains"
+    def _threat_level_description(self, total_threat: float) -> str:
+        if total_threat >= 0.8: return "CRITICAL"
+        elif total_threat >= 0.6: return "HIGH"
+        elif total_threat >= 0.4: return "MODERATE"
+        elif total_threat >= 0.2: return "LOW"
+        else: return "MINIMAL"
     
     def process_tech_scores(self, tech_scores: TechScores) -> Dict[str, Any]:
-        """Process tech scores through LangGraph pipeline"""
-        if not self.graph:
-            logger.warning("LangGraph not available, using simplified processing")
-            return self._simplified_processing(tech_scores)
-        
-        try:
-            # Initialize state as dict for compatibility
-            initial_state = {
-                'tech_scores': tech_scores,
-                'processing_steps': []
-            }
-            
-            # Run through LangGraph pipeline
-            result = self.graph.invoke(initial_state)
-            
-            return {
-                'success': True,
-                'processed_analysis': result.get('processed_analysis'),
-                'economic_context': result.get('economic_context'),
-                'risk_assessment': result.get('risk_assessment'),
-                'policy_recommendations': result.get('policy_recommendations'),
-                'final_prompt': result.get('final_prompt'),
-                'processing_steps': result.get('processing_steps', []),
-                'metadata': {
-                    'total_threat_level': tech_scores.get_total_threat_level(),
-                    'dominant_threats': tech_scores.get_dominant_threats(),
-                    'processing_timestamp': datetime.now().isoformat()
-                }
-            }
-            
-        except Exception as e:
-            logger.error(f"LangGraph processing failed: {e}")
-            return self._simplified_processing(tech_scores)
-    
-    def _simplified_processing(self, tech_scores: TechScores) -> Dict[str, Any]:
-        """Fallback processing without LangGraph"""
+        """Process tech scores with simplified analysis"""
         total_threat = tech_scores.get_total_threat_level()
         dominant_threats = tech_scores.get_dominant_threats()
         
-        simplified_prompt = f"""Analyze these technology threat scores for year {tech_scores.year}:
+        analysis = f"""TECHNOLOGY THREAT ANALYSIS (Year {tech_scores.year}):
 
-AI Score: {tech_scores.ai:.3f}
-Cyber Score: {tech_scores.cyber:.3f}
-Bio Score: {tech_scores.bio:.3f}
-Nuclear Score: {tech_scores.nuclear:.3f}
-Climate Score: {tech_scores.climate:.3f}
-Space Score: {tech_scores.space:.3f}
+Overall Threat Level: {total_threat:.3f} ({self._threat_level_description(total_threat)})
+Dominant Threats: {', '.join(dominant_threats) if dominant_threats else 'None above threshold'}
 
-Overall Threat Level: {total_threat:.3f}
-Dominant Threats: {', '.join(dominant_threats) if dominant_threats else 'None'}
+Detailed Analysis:
+- AI: {tech_scores.ai:.3f} - {self._ai_threat_analysis(tech_scores.ai)}
+- Cyber: {tech_scores.cyber:.3f} - {self._cyber_threat_analysis(tech_scores.cyber)}
+- Bio: {tech_scores.bio:.3f} - {self._bio_threat_analysis(tech_scores.bio)}
+- Nuclear: {tech_scores.nuclear:.3f} - {self._nuclear_threat_analysis(tech_scores.nuclear)}
+- Climate: {tech_scores.climate:.3f} - {self._climate_threat_analysis(tech_scores.climate)}
+- Space: {tech_scores.space:.3f} - {self._space_threat_analysis(tech_scores.space)}"""
+        
+        simplified_prompt = f"""{analysis}
 
-Provide comprehensive economic analysis including:
-1. Market shock index (0-1 scale)
-2. Impact classification (Local/Regional/Global/Catastrophic)
-3. GDP impact projections
-4. Regional vulnerability assessment
-5. Policy recommendations
-6. Investment strategies
+Based on these technology threat scores, provide an economic analysis with:
+1. Market shock index (0-1)
+2. GDP impact projections
+3. Key policy recommendations
+4. Investment implications
 
-Focus on quantitative metrics and actionable insights."""
+Keep the analysis concise and actionable."""
         
         return {
             'success': True,
             'final_prompt': simplified_prompt,
-            'processing_steps': ['Simplified processing completed'],
+            'processing_steps': ['Simplified analysis completed'],
             'metadata': {
                 'total_threat_level': total_threat,
                 'dominant_threats': dominant_threats,
+                'processing_timestamp': datetime.now().isoformat(),
                 'processing_mode': 'simplified'
             }
         }
 
-# Initialize LangGraph processor
-langgraph_processor = LangGraphProcessor()
+# Initialize processor
+processor = LangGraphProcessor()
 
 def load_model():
-    """Load the model and tokenizer from Gaston895/Aegisecon1 repository using the working approach"""
-    global model, tokenizer, chat_pipeline
+    """Load the model with aggressive memory optimizations"""
+    global model, tokenizer
     
     try:
-        logger.info("Loading model and tokenizer from Hugging Face...")
+        logger.info("🔄 Loading model from Gaston895/Aegisecon1...")
         
-        # Load from the deployed model repository
+        # Use a smaller model variant for testing if the main one is too large
         model_repo = "Gaston895/Aegisecon1"
         
-        logger.info(f"Loading tokenizer from {model_repo}...")
+        # First try loading with aggressive optimizations
         tokenizer = AutoTokenizer.from_pretrained(
             model_repo,
             trust_remote_code=True,
             use_auth_token=False
         )
         
-        # Fix pad token issue to resolve attention mask warning
+        # Fix pad token
         if tokenizer.pad_token is None:
             tokenizer.pad_token = tokenizer.eos_token
-            tokenizer.pad_token_id = tokenizer.eos_token_id
         
-        logger.info(f"Loading model from {model_repo}...")
+        # Load model with maximum CPU optimizations
         model = AutoModelForCausalLM.from_pretrained(
             model_repo,
-            torch_dtype=torch.float16,  # Use float16 for better compatibility
-            device_map="cpu",           # Force CPU for HF Spaces compatibility
+            torch_dtype=torch.float32,  # Use float32 for CPU stability
+            device_map="cpu",
             trust_remote_code=True,
             use_auth_token=False,
-            low_cpu_mem_usage=True
+            low_cpu_mem_usage=True,
+            offload_folder="./offload",  # Offload to disk if needed
+            offload_state_dict=True
         )
         
-        # Don't create pipeline - use direct model generation like the working version
-        chat_pipeline = None  # Set to None to indicate we're using direct generation
+        # Set to eval mode
+        model.eval()
         
-        logger.info("Model loaded successfully from HF repository!")
-        logger.info(f"Model device: {next(model.parameters()).device}")
-        logger.info(f"Model dtype: {next(model.parameters()).dtype}")
+        logger.info("✅ Model loaded successfully!")
+        logger.info(f"Model size: {sum(p.numel() for p in model.parameters()):,} parameters")
         
         return True
         
     except Exception as e:
-        logger.error(f"Error loading model from HF: {str(e)}")
-        # Try alternative loading method
+        logger.error(f"❌ Model loading failed: {e}")
+        
+        # Try loading a much smaller model as fallback
         try:
-            logger.info("Trying alternative loading method...")
+            logger.info("🔄 Trying fallback model (Qwen2-1.5B)...")
             tokenizer = AutoTokenizer.from_pretrained(
-                "Qwen/Qwen2-1.5B",  # Fallback to base model
+                "Qwen/Qwen2-1.5B",
                 trust_remote_code=True
             )
-            # Fix pad token for fallback too
             if tokenizer.pad_token is None:
                 tokenizer.pad_token = tokenizer.eos_token
-                tokenizer.pad_token_id = tokenizer.eos_token_id
+            
             model = AutoModelForCausalLM.from_pretrained(
                 "Qwen/Qwen2-1.5B",
-                torch_dtype=torch.float16,
+                torch_dtype=torch.float32,
                 device_map="cpu",
                 trust_remote_code=True,
                 low_cpu_mem_usage=True
             )
-            chat_pipeline = None
-            logger.info("Fallback model loaded successfully!")
+            model.eval()
+            
+            logger.info("✅ Fallback model loaded successfully!")
             return True
+            
         except Exception as e2:
-            logger.error(f"Fallback loading also failed: {str(e2)}")
+            logger.error(f"❌ Fallback also failed: {e2}")
             return False
 
-def generate_response(prompt, temperature=0.7):
-    """Generate response using direct model generation (like the working app_gunicorn.py)"""
+def generate_response(prompt, max_time=20):
+    """Generate response with strict timeout and memory limits"""
+    start_time = time.time()
+    
     try:
         if model is None or tokenizer is None:
-            return "Model is still loading, please wait a moment and try again..."
+            return "Model not available. Please try the /health endpoint to check status."
         
-        # Economics-focused system prompt (like the working version)
-        system_prompt = """You are AEGIS Economics AI, an expert economic analyst and policy advisor. 
-        Provide clear, accurate, and insightful responses about economics, finance, markets, and policy.
-        Focus on practical analysis and actionable insights."""
+        # Check timeout
+        if time.time() - start_time > max_time:
+            return "Response generation timed out. Please try with a shorter query."
         
-        full_prompt = f"{system_prompt}\n\nUser: {prompt}\nAssistant:"
+        # Clean memory before generation
+        cleanup_memory()
+        
+        # Prepare prompt
+        system_prompt = "You are AEGIS Economics AI, an expert economic analyst."
+        full_prompt = f"{system_prompt}\n\n{prompt}\n\nAssistant:"
         
-        # Tokenize input with attention mask (fixes the warning)
+        # Tokenize with very conservative limits
         inputs = tokenizer(
             full_prompt, 
             return_tensors="pt", 
             truncation=True, 
-            max_length=1024,
-            padding=True,
-            return_attention_mask=True
+            max_length=512,  # Reduced from 1024
+            padding=True
         )
         
-        # Generate response with attention mask
+        # Generate with conservative settings for CPU
         with torch.no_grad():
             outputs = model.generate(
                 inputs.input_ids,
-                attention_mask=inputs.attention_mask,  # Add attention mask
-                max_new_tokens=256,
-                temperature=temperature,
-                do_sample=True,
-                pad_token_id=tokenizer.pad_token_id,  # Use pad_token_id instead of eos_token_id
+                max_new_tokens=150,  # Reduced from 256
+                temperature=0.7,
+                do_sample=False,  # Greedy decoding for speed
+                pad_token_id=tokenizer.pad_token_id,
                 eos_token_id=tokenizer.eos_token_id,
-                repetition_penalty=1.1,
-                no_repeat_ngram_size=3
+                repetition_penalty=1.05,  # Reduced penalty
+                no_repeat_ngram_size=2,
+                num_beams=1,  # Single beam for speed
+                early_stopping=True
             )
         
-        # Decode response (like the working version)
+        # Decode response
         response = tokenizer.decode(outputs[0], skip_special_tokens=True)
         
-        # Extract only the assistant's response (like the working version)
+        # Extract assistant response
         if "Assistant:" in response:
             response = response.split("Assistant:")[-1].strip()
         
+        # Check total time
+        total_time = time.time() - start_time
+        logger.info(f"Generation completed in {total_time:.1f}s")
+        
+        # Clean memory after generation
+        cleanup_memory()
+        
         return response
         
+    except torch.cuda.OutOfMemoryError:
+        return "Out of memory error. The model is too large for this environment."
     except Exception as e:
-        logger.error(f"Error generating response: {str(e)}")
-        return "I apologize, but I'm having trouble processing your request right now. Please try again in a moment."
+        logger.error(f"Generation error: {e}")
+        return "Sorry, I encountered an error. Please try again."
+
+# Load model immediately
+model_loaded = load_model()
 
-# HTML template (same as before)
 HTML_TEMPLATE = """
 <!DOCTYPE html>
 <html>
 <head>
-    <title>AEGIS Economics AI with LangGraph</title>
+    <title>AEGIS Economics AI</title>
     <meta charset="utf-8">
     <meta name="viewport" content="width=device-width, initial-scale=1">
     <style>
         body { font-family: Arial, sans-serif; margin: 0; padding: 20px; background: #f5f5f5; }
         .container { max-width: 900px; margin: 0 auto; background: white; padding: 20px; border-radius: 10px; box-shadow: 0 2px 10px rgba(0,0,0,0.1); }
-        .header { text-align: center; margin-bottom: 30px; }
-        .pipeline { background: #e3f2fd; padding: 15px; border-radius: 5px; margin-bottom: 20px; }
+        .header { text-align: center; margin-bottom: 20px; }
         .chat-container { border: 1px solid #ddd; border-radius: 5px; height: 400px; overflow-y: auto; padding: 10px; margin-bottom: 20px; background: #fafafa; }
-        .message { margin: 10px 0; padding: 10px; border-radius: 5px; }
-        .user-message { background: #007bff; color: white; margin-left: 20%; }
-        .ai-message { background: #e9ecef; color: #333; margin-right: 20%; }
-        .system-message { background: #fff3cd; color: #856404; border: 1px solid #ffeaa7; }
+        .message { margin: 10px 0; padding: 10px; border-radius: 5px; max-width: 80%; }
+        .user-message { background: #007bff; color: white; margin-left: auto; }
+        .ai-message { background: #e9ecef; color: #333; margin-right: auto; }
         .input-group { display: flex; gap: 10px; }
         .input-field { flex: 1; padding: 10px; border: 1px solid #ddd; border-radius: 5px; }
         .send-btn { padding: 10px 20px; background: #007bff; color: white; border: none; border-radius: 5px; cursor: pointer; }
-        .send-btn:hover { background: #0056b3; }
+        .send-btn:disabled { background: #ccc; cursor: not-allowed; }
         .loading { text-align: center; color: #666; font-style: italic; }
-        .tech-scores { background: #f8f9fa; padding: 15px; border-radius: 5px; margin-bottom: 20px; }
-        .score-input { width: 80px; padding: 5px; margin: 5px; border: 1px solid #ddd; border-radius: 3px; }
-        .process-btn { background: #28a745; margin-left: 10px; }
-        .process-btn:hover { background: #218838; }
+        .status { padding: 10px; border-radius: 5px; margin-bottom: 15px; text-align: center; }
+        .status-good { background: #d4edda; color: #155724; }
+        .status-warning { background: #fff3cd; color: #856404; }
+        .status-error { background: #f8d7da; color: #721c24; }
     </style>
 </head>
 <body>
     <div class="container">
         <div class="header">
-            <h1>🏛️ AEGIS Economics AI with LangGraph</h1>
-            <p>Advanced Economic Analysis with Multi-Stage Processing Pipeline</p>
-        </div>
-        
-        <div class="pipeline">
-            <h3>🔄 Processing Pipeline</h3>
-            <p><strong>Tech Scores → LangGraph Analysis → AEGIS Economics AI → Final Predictions</strong></p>
-            <p>LangGraph processes technology threats through multiple analysis stages before final AI prediction.</p>
-        </div>
-        
-        <div class="tech-scores">
-            <h3>🎯 Technology Threat Scores (0.0 - 1.0)</h3>
-            <div style="display: grid; grid-template-columns: repeat(3, 1fr); gap: 15px;">
-                <div>
-                    <label>AI Score:</label><br>
-                    <input type="number" id="ai-score" class="score-input" min="0" max="1" step="0.1" value="0.5">
-                </div>
-                <div>
-                    <label>Cyber Score:</label><br>
-                    <input type="number" id="cyber-score" class="score-input" min="0" max="1" step="0.1" value="0.4">
-                </div>
-                <div>
-                    <label>Bio Score:</label><br>
-                    <input type="number" id="bio-score" class="score-input" min="0" max="1" step="0.1" value="0.3">
-                </div>
-                <div>
-                    <label>Nuclear Score:</label><br>
-                    <input type="number" id="nuclear-score" class="score-input" min="0" max="1" step="0.1" value="0.2">
-                </div>
-                <div>
-                    <label>Climate Score:</label><br>
-                    <input type="number" id="climate-score" class="score-input" min="0" max="1" step="0.1" value="0.6">
-                </div>
-                <div>
-                    <label>Space Score:</label><br>
-                    <input type="number" id="space-score" class="score-input" min="0" max="1" step="0.1" value="0.3">
-                </div>
-            </div>
-            <div style="margin-top: 15px;">
-                <label>Analysis Year:</label>
-                <input type="number" id="year-input" class="score-input" min="2024" max="2100" value="2030">
-                <button onclick="processTechScores()" class="send-btn process-btn">🚀 Process via LangGraph</button>
-            </div>
+            <h1>🏛️ AEGIS Economics AI</h1>
+            <p>Economic Analysis with Technology Threat Assessment</p>
+            <div id="status" class="status status-warning">Checking status...</div>
         </div>
         
         <div id="chat-container" class="chat-container">
             <div class="message ai-message">
-                Hello! I'm AEGIS Economics AI with LangGraph processing. 
+                Welcome! I'm AEGIS Economics AI. I can help analyze technology threats and their economic impacts.
                 <br><br>
-                <strong>Two ways to interact:</strong><br>
-                1. <strong>Tech Score Analysis:</strong> Set threat scores above and click "Process via LangGraph"<br>
-                2. <strong>Direct Chat:</strong> Ask economic questions below
-                <div id="model-status" style="font-size: 0.8em; color: #666; margin-top: 10px;">
-                    Checking model status...
-                </div>
+                <strong>Try asking:</strong><br>
+                • "Analyze AI threat level 0.7 for economic impact"<br>
+                • "What are the economic risks of cyber threats?"<br>
+                • "How does climate change affect global markets?"<br>
             </div>
         </div>
         
         <div class="input-group">
-            <input type="text" id="user-input" class="input-field" placeholder="Ask about economics, or use tech scores above..." onkeypress="handleKeyPress(event)">
-            <button onclick="sendMessage()" class="send-btn">Send</button>
+            <input type="text" id="user-input" class="input-field" placeholder="Ask about economics or technology threats..." onkeypress="handleKeyPress(event)">
+            <button id="send-btn" onclick="sendMessage()" class="send-btn">Send</button>
         </div>
     </div>
 
     <script>
-        // Check model status on page load
-        async function checkModelStatus() {
+        function updateStatus(data) {
+            const status = document.getElementById('status');
+            if (data.model_loaded) {
+                status.className = 'status status-good';
+                status.innerHTML = '✅ Model loaded and ready!';
+                document.getElementById('send-btn').disabled = false;
+            } else {
+                status.className = 'status status-error';
+                status.innerHTML = '❌ Model not loaded. Please refresh or check logs.';
+                document.getElementById('send-btn').disabled = true;
+            }
+        }
+
+        async function checkStatus() {
             try {
                 const response = await fetch('/health');
                 const data = await response.json();
-                const statusDiv = document.getElementById('model-status');
-                
-                if (data.model_loaded) {
-                    statusDiv.innerHTML = '✅ Model loaded and ready!<br>🔄 LangGraph pipeline: ' + (data.langgraph_available ? 'Available' : 'Simplified mode');
-                    statusDiv.style.color = '#28a745';
-                } else {
-                    statusDiv.textContent = '⏳ Model loading... Please wait.';
-                    statusDiv.style.color = '#ffc107';
-                }
+                updateStatus(data);
             } catch (error) {
-                const statusDiv = document.getElementById('model-status');
-                statusDiv.textContent = '❌ Connection error';
-                statusDiv.style.color = '#dc3545';
+                document.getElementById('status').className = 'status status-error';
+                document.getElementById('status').textContent = '❌ Connection error';
             }
         }
 
-        window.onload = checkModelStatus;
+        window.onload = checkStatus;
 
         function handleKeyPress(event) {
             if (event.key === 'Enter') {
@@ -1094,85 +391,29 @@ HTML_TEMPLATE = """
             const chatContainer = document.getElementById('chat-container');
             const messageDiv = document.createElement('div');
             messageDiv.className = `message ${type}-message`;
-            
-            if (typeof content === 'string') {
-                messageDiv.innerHTML = content.replace(/\\n/g, '<br>');
-            } else {
-                messageDiv.textContent = content;
-            }
-            
+            messageDiv.innerHTML = content.replace(/\n/g, '<br>');
             chatContainer.appendChild(messageDiv);
             chatContainer.scrollTop = chatContainer.scrollHeight;
         }
 
-        function showLoading(message = 'AI is processing...') {
+        function showLoading() {
             const chatContainer = document.getElementById('chat-container');
             const loadingDiv = document.createElement('div');
             loadingDiv.className = 'loading';
             loadingDiv.id = 'loading';
-            loadingDiv.textContent = message;
+            loadingDiv.textContent = 'Thinking...';
             chatContainer.appendChild(loadingDiv);
             chatContainer.scrollTop = chatContainer.scrollHeight;
         }
 
         function hideLoading() {
             const loading = document.getElementById('loading');
-            if (loading) {
-                loading.remove();
-            }
-        }
-
-        async function processTechScores() {
-            const techScores = {
-                ai: parseFloat(document.getElementById('ai-score').value),
-                cyber: parseFloat(document.getElementById('cyber-score').value),
-                bio: parseFloat(document.getElementById('bio-score').value),
-                nuclear: parseFloat(document.getElementById('nuclear-score').value),
-                climate: parseFloat(document.getElementById('climate-score').value),
-                space: parseFloat(document.getElementById('space-score').value),
-                year: parseInt(document.getElementById('year-input').value)
-            };
-            
-            addMessage(`🎯 Processing Tech Scores via LangGraph Pipeline:<br>
-                AI: ${techScores.ai}, Cyber: ${techScores.cyber}, Bio: ${techScores.bio}<br>
-                Nuclear: ${techScores.nuclear}, Climate: ${techScores.climate}, Space: ${techScores.space}<br>
-                Year: ${techScores.year}`, 'user');
-            
-            showLoading('🔄 LangGraph processing tech scores... This may take several minutes...');
-            
-            try {
-                const response = await fetch('/process_tech_scores', {
-                    method: 'POST',
-                    headers: { 'Content-Type': 'application/json' },
-                    body: JSON.stringify(techScores)
-                });
-                
-                const data = await response.json();
-                hideLoading();
-                
-                if (data.success) {
-                    if (data.processing_steps) {
-                        addMessage(`📋 LangGraph Processing Steps:<br>• ${data.processing_steps.join('<br>• ')}`, 'system');
-                    }
-                    
-                    if (data.final_analysis) {
-                        addMessage(`🏛️ AEGIS Economics AI Final Analysis:<br><br>${data.final_analysis}`, 'ai');
-                    } else {
-                        addMessage('✅ LangGraph processing completed. Check the analysis above.', 'system');
-                    }
-                } else {
-                    addMessage(`❌ Processing failed: ${data.error}`, 'system');
-                }
-            } catch (error) {
-                hideLoading();
-                addMessage('❌ Connection error during tech score processing.', 'system');
-            }
+            if (loading) loading.remove();
         }
 
         async function sendMessage() {
             const input = document.getElementById('user-input');
             const message = input.value.trim();
-            
             if (!message) return;
             
             addMessage(message, 'user');
@@ -1192,7 +433,7 @@ HTML_TEMPLATE = """
                 if (data.response) {
                     addMessage(data.response, 'ai');
                 } else {
-                    addMessage('Sorry, I encountered an error. Please try again.', 'ai');
+                    addMessage('Sorry, I encountered an error.', 'ai');
                 }
             } catch (error) {
                 hideLoading();
@@ -1211,11 +452,10 @@ def home():
 
 @app.route('/process_tech_scores', methods=['POST'])
 def process_tech_scores():
-    """Process technology scores through LangGraph pipeline with memory optimization"""
+    """Process technology scores"""
     try:
         data = request.get_json()
         
-        # Create TechScores object
         tech_scores = TechScores(
             ai=data.get('ai', 0.0),
             cyber=data.get('cyber', 0.0),
@@ -1226,161 +466,74 @@ def process_tech_scores():
             year=data.get('year', 2024)
         )
         
-        logger.info(f"Processing tech scores: {tech_scores.to_dict()}")
-        
-        # Clean memory before processing
-        cleanup_memory()
-        
-        # Process through LangGraph with timeout
-        try:
-            langgraph_result = langgraph_processor.process_tech_scores(tech_scores)
-        except Exception as e:
-            logger.error(f"LangGraph processing failed: {e}")
-            # Fallback to simplified processing
-            langgraph_result = langgraph_processor._simplified_processing(tech_scores)
-        
-        if not langgraph_result['success']:
-            return jsonify({'success': False, 'error': 'LangGraph processing failed'})
-        
-        # Get the optimized prompt from LangGraph
-        final_prompt = langgraph_result['final_prompt']
+        logger.info(f"Processing tech scores...")
         
-        # Truncate prompt if too long to save memory
-        if len(final_prompt) > 1000:
-            final_prompt = final_prompt[:1000] + "... [truncated for efficiency]"
+        # Process with simplified analysis
+        result = processor.process_tech_scores(tech_scores)
         
-        # Generate final analysis using AEGIS Economics AI
-        logger.info("Generating final analysis with AEGIS Economics AI...")
-        final_analysis = generate_response(final_prompt)
+        if not result['success']:
+            return jsonify({'success': False, 'error': 'Processing failed'})
         
-        # Clean memory after processing
-        cleanup_memory()
+        # Generate analysis
+        final_analysis = generate_response(result['final_prompt'], max_time=15)
         
         return jsonify({
             'success': True,
-            'processing_steps': langgraph_result.get('processing_steps', []),
-            'langgraph_metadata': langgraph_result.get('metadata', {}),
-            'final_analysis': final_analysis,
-            'processing_mode': 'langgraph' if LANGGRAPH_AVAILABLE else 'simplified'
+            'processing_steps': result['processing_steps'],
+            'final_analysis': final_analysis
         })
         
     except Exception as e:
-        logger.error(f"Error in tech score processing: {str(e)}")
-        cleanup_memory()  # Clean memory on error
+        logger.error(f"Error: {e}")
         return jsonify({'success': False, 'error': str(e)}), 500
 
 @app.route('/chat', methods=['POST'])
 def chat():
-    """Handle regular chat messages"""
+    """Handle chat messages"""
     try:
         data = request.get_json()
         user_message = data.get('message', '')
         
         if not user_message:
-            return jsonify({'error': 'No message provided'}), 400
-        
-        # Add economics context to regular chat
-        economics_prompt = f"""You are AEGIS Economics AI, an expert economic analyst and policy advisor. 
-        Provide clear, accurate, and insightful responses about economics, finance, markets, and policy.
-        Focus on practical analysis and actionable insights.
-
-        User: {user_message}
-        Assistant:"""
+            return jsonify({'error': 'No message'}), 400
         
-        # Generate AI response
-        ai_response = generate_response(economics_prompt)
+        # Generate response with timeout
+        response = generate_response(user_message, max_time=15)
         
-        return jsonify({'response': ai_response})
+        return jsonify({'response': response})
         
     except Exception as e:
-        logger.error(f"Error in chat endpoint: {str(e)}")
-        return jsonify({'error': 'Internal server error'}), 500
+        logger.error(f"Chat error: {e}")
+        return jsonify({'error': 'Server error'}), 500
 
-@app.route('/load_model_manual', methods=['POST'])
-def load_model_manual():
-    """Manually trigger model loading"""
+@app.route('/health')
+def health():
+    """Health check"""
+    return jsonify({
+        'status': 'ok',
+        'model_loaded': model is not None,
+        'timestamp': datetime.now().isoformat()
+    })
+
+@app.route('/reload_model')
+def reload_model():
+    """Reload model endpoint"""
+    global model, tokenizer
     try:
-        logger.info("🔄 Manual model loading triggered...")
-        success = load_model()
+        # Clear existing model
+        del model
+        del tokenizer
+        cleanup_memory()
         
+        # Reload
+        success = load_model()
         return jsonify({
             'success': success,
-            'model_loaded': model is not None,
-            'tokenizer_loaded': tokenizer is not None,
-            'message': 'Model loaded successfully' if success else 'Model loading failed'
+            'message': 'Model reloaded' if success else 'Reload failed'
         })
     except Exception as e:
-        logger.error(f"Manual model loading error: {str(e)}")
         return jsonify({'success': False, 'error': str(e)}), 500
 
-@app.route('/startup_check')
-def startup_check():
-    """Check startup status and trigger model loading if needed"""
-    try:
-        status = {
-            'model_loaded': chat_pipeline is not None,
-            'tokenizer_loaded': tokenizer is not None,
-            'langgraph_available': LANGGRAPH_AVAILABLE
-        }
-        
-        # If model not loaded, try to load it
-        if not chat_pipeline:
-            logger.info("Model not loaded, attempting to load...")
-            success = load_model()
-            status['model_load_attempted'] = True
-            status['model_load_success'] = success
-            status['model_loaded'] = chat_pipeline is not None
-        
-        return jsonify(status)
-        
-    except Exception as e:
-        logger.error(f"Startup check error: {str(e)}")
-        return jsonify({'error': str(e)}), 500
-@app.route('/health')
-def health():
-    """Health check endpoint"""
-    return jsonify({
-        'status': 'healthy',
-        'model_loaded': model is not None,
-        'tokenizer_loaded': tokenizer is not None,
-        'langgraph_available': LANGGRAPH_AVAILABLE,
-        'processing_mode': 'langgraph' if LANGGRAPH_AVAILABLE else 'simplified'
-    })
-
-@app.errorhandler(Exception)
-def handle_exception(e):
-    """Handle all unhandled exceptions"""
-    logger.error(f"Unhandled exception: {e}", exc_info=True)
-    return jsonify({
-        'error': 'Internal server error',
-        'message': str(e)
-    }), 500
-
 if __name__ == '__main__':
-    # Load model on startup
-    logger.info("Starting AEGIS Economics AI with LangGraph...")
-    logger.info(f"LangGraph available: {LANGGRAPH_AVAILABLE}")
-    
-    # Load model immediately on startup
-    logger.info("Loading model from Gaston895/Aegisecon1...")
-    model_loaded = load_model()
-    
-    if model_loaded:
-        logger.info("✅ Model loaded successfully, starting server...")
-    else:
-        logger.error("❌ Model failed to load. Starting server anyway, but model endpoints will fail.")
-    
-    app.run(host='0.0.0.0', port=7860, debug=False)
-else:
-    # For production deployment (Gunicorn), load model when module is imported
-    logger.info("Production mode: Loading model during module import...")
-    logger.info(f"LangGraph available: {LANGGRAPH_AVAILABLE}")
-    
-    # Try to load model, but don't fail if it doesn't work (like the working version)
-    logger.info("Attempting to load model...")
-    model_loaded = load_model()
-    
-    if model_loaded:
-        logger.info("✅ Model loaded successfully for production!")
-    else:
-        logger.warning("⚠️ Model failed to load, but server will start anyway. Model can be loaded via /load_model_manual endpoint.")
+    logger.info("🚀 Starting AEGIS Economics AI...")
+    app.run(host='0.0.0.0', port=7860, debug=False, threaded=True)