Upload app.py

app.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python3
 """
-Enhanced Flask App with LangGraph + AEGIS Economics AI
-CPU-optimized version with memory/timeout fixes
+Flask App with Gunicorn for Deep Modal Files
+Economics Chat Application using Qwen2 model
 """
 
 from flask import Flask, request, jsonify, render_template_string
@@ -9,300 +9,18 @@ import torch
 from transformers import AutoTokenizer, AutoModelForCausalLM
 import os
 import logging
-import json
-from datetime import datetime
-from typing import Dict, List, Any, Optional
-from dataclasses import dataclass
-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
+# Global variables for model and tokenizer
 model = None
 tokenizer = None
 
-@dataclass
-class TechScores:
-    """Technology threat scores structure"""
-    ai: float = 0.0
-    cyber: float = 0.0
-    bio: float = 0.0
-    nuclear: float = 0.0
-    climate: float = 0.0
-    space: float = 0.0
-    year: int = 2024
-    
-    def to_dict(self) -> Dict[str, float]:
-        return {
-            'AI': self.ai,
-            'Cyber': self.cyber,
-            'Bio': self.bio,
-            'Nuclear': self.nuclear,
-            'Climate': self.climate,
-            'Space': self.space
-        }
-    
-    def get_total_threat_level(self) -> float:
-        """Calculate overall threat level"""
-        return (self.ai + self.cyber + self.bio + self.nuclear + self.climate + self.space) / 6
-    
-    def get_dominant_threats(self, threshold: float = 0.6) -> List[str]:
-        """Get threats above threshold"""
-        threats = []
-        scores = self.to_dict()
-        for threat, score in scores.items():
-            if score >= threshold:
-                threats.append(threat)
-        return threats
-
-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:
-    """Simplified LangGraph-based tech score processor"""
-    
-    def __init__(self):
-        self.graph = None
-    
-    def _ai_threat_analysis(self, score: float) -> str:
-        if score >= 0.8: return "AGI/Singularity risk, massive economic disruption"
-        elif score >= 0.6: return "Advanced AI deployment, significant job displacement"
-        elif score >= 0.4: return "AI automation acceleration, sector-specific impacts"
-        else: return "Gradual AI integration, manageable transitions"
-    
-    def _cyber_threat_analysis(self, score: float) -> str:
-        if score >= 0.8: return "Critical infrastructure at risk, potential economic paralysis"
-        elif score >= 0.6: return "Major cybersecurity incidents, financial system vulnerabilities"
-        elif score >= 0.4: return "Increased cyber attacks, business continuity risks"
-        else: return "Standard cyber threats, manageable with current defenses"
-    
-    def _bio_threat_analysis(self, score: float) -> str:
-        if score >= 0.8: return "Pandemic-level biological threats, global economic shutdown risk"
-        elif score >= 0.6: return "Significant biological incidents, healthcare system strain"
-        elif score >= 0.4: return "Regional biological threats, supply chain disruptions"
-        else: return "Contained biological risks, minimal economic impact"
-    
-    def _nuclear_threat_analysis(self, score: float) -> str:
-        if score >= 0.8: return "Nuclear conflict risk, catastrophic economic collapse"
-        elif score >= 0.6: return "Nuclear incidents, regional economic devastation"
-        elif score >= 0.4: return "Nuclear security concerns, defense spending increases"
-        else: return "Stable nuclear environment, minimal economic impact"
-    
-    def _climate_threat_analysis(self, score: float) -> str:
-        if score >= 0.8: return "Climate catastrophe, fundamental economic restructuring needed"
-        elif score >= 0.6: return "Severe climate impacts, major adaptation costs"
-        elif score >= 0.4: return "Accelerating climate change, increasing economic pressures"
-        else: return "Manageable climate impacts, gradual adaptation"
-    
-    def _space_threat_analysis(self, score: float) -> str:
-        if score >= 0.8: return "Space warfare/debris cascade, satellite infrastructure collapse"
-        elif score >= 0.6: return "Major space incidents, communication/GPS disruptions"
-        elif score >= 0.4: return "Space security concerns, increased space militarization"
-        else: return "Stable space environment, continued commercial growth"
-    
-    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 with simplified analysis"""
-        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)}"""
-        
-        simplified_prompt = f"""{analysis}
-
-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
-
-Keep the analysis concise and actionable."""
-        
-        return {
-            'success': True,
-            'final_prompt': simplified_prompt,
-            'processing_steps': ['Simplified analysis completed'],
-            'metadata': {
-                'total_threat_level': total_threat,
-                'dominant_threats': dominant_threats,
-                'processing_timestamp': datetime.now().isoformat(),
-                'processing_mode': 'simplified'
-            }
-        }
-
-# Initialize processor
-processor = LangGraphProcessor()
-
-def load_model():
-    """Load the model with aggressive memory optimizations"""
-    global model, tokenizer
-    
-    try:
-        logger.info("🔄 Loading model from Gaston895/Aegisecon1...")
-        
-        # Use a smaller model variant for testing if the main one is too large
-        model_repo = "Gaston895/Aegisecon1"
-        
-        # First try loading with aggressive optimizations
-        tokenizer = AutoTokenizer.from_pretrained(
-            model_repo,
-            trust_remote_code=True,
-            use_auth_token=False
-        )
-        
-        # Fix pad token
-        if tokenizer.pad_token is None:
-            tokenizer.pad_token = tokenizer.eos_token
-        
-        # Load model with maximum CPU optimizations
-        model = AutoModelForCausalLM.from_pretrained(
-            model_repo,
-            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,
-            offload_folder="./offload",  # Offload to disk if needed
-            offload_state_dict=True
-        )
-        
-        # Set to eval mode
-        model.eval()
-        
-        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"❌ Model loading failed: {e}")
-        
-        # Try loading a much smaller model as fallback
-        try:
-            logger.info("🔄 Trying fallback model (Qwen2-1.5B)...")
-            tokenizer = AutoTokenizer.from_pretrained(
-                "Qwen/Qwen2-1.5B",
-                trust_remote_code=True
-            )
-            if tokenizer.pad_token is None:
-                tokenizer.pad_token = tokenizer.eos_token
-            
-            model = AutoModelForCausalLM.from_pretrained(
-                "Qwen/Qwen2-1.5B",
-                torch_dtype=torch.float32,
-                device_map="cpu",
-                trust_remote_code=True,
-                low_cpu_mem_usage=True
-            )
-            model.eval()
-            
-            logger.info("✅ Fallback model loaded successfully!")
-            return True
-            
-        except Exception as e2:
-            logger.error(f"❌ Fallback also failed: {e2}")
-            return False
-
-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 not available. Please try the /health endpoint to check status."
-        
-        # Check timeout
-        if time.time() - start_time > max_time:
-            return "Response generation timed out. Please try with a shorter query."
-        
-        # 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 with very conservative limits
-        inputs = tokenizer(
-            full_prompt, 
-            return_tensors="pt", 
-            truncation=True, 
-            max_length=512,  # Reduced from 1024
-            padding=True
-        )
-        
-        # Generate with conservative settings for CPU
-        with torch.no_grad():
-            outputs = model.generate(
-                inputs.input_ids,
-                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.05,  # Reduced penalty
-                no_repeat_ngram_size=2,
-                num_beams=1,  # Single beam for speed
-                early_stopping=True
-            )
-        
-        # Decode response
-        response = tokenizer.decode(outputs[0], skip_special_tokens=True)
-        
-        # 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"Generation error: {e}")
-        return "Sorry, I encountered an error. Please try again."
-
-# Load model immediately
-model_loaded = load_model()
-
+# HTML template
 HTML_TEMPLATE = """
 <!DOCTYPE html>
 <html>
@@ -312,74 +30,84 @@ HTML_TEMPLATE = """
     <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: 20px; }
+        .container { max-width: 800px; 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; }
         .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; max-width: 80%; }
-        .user-message { background: #007bff; color: white; margin-left: auto; }
-        .ai-message { background: #e9ecef; color: #333; margin-right: auto; }
+        .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%; }
         .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:disabled { background: #ccc; cursor: not-allowed; }
+        .send-btn:hover { background: #0056b3; }
         .loading { text-align: center; color: #666; font-style: italic; }
-        .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</h1>
-            <p>Economic Analysis with Technology Threat Assessment</p>
-            <div id="status" class="status status-warning">Checking status...</div>
+            <p>Advanced Economic Analysis & Policy Insights</p>
         </div>
         
         <div id="chat-container" class="chat-container">
             <div class="message ai-message">
-                Welcome! I'm AEGIS Economics AI. I can help analyze technology threats and their economic impacts.
-                <br><br>
-                <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>
+                Hello! I'm AEGIS Economics AI. Ask me about economic policies, market analysis, or financial strategies.
+                <div id="model-status" style="font-size: 0.8em; color: #666; margin-top: 5px;">
+                    Checking model status...
+                </div>
             </div>
         </div>
         
         <div class="input-group">
-            <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>
+            <input type="text" id="user-input" class="input-field" placeholder="Ask about economics, policy, markets..." onkeypress="handleKeyPress(event)">
+            <button onclick="sendMessage()" class="send-btn">Send</button>
         </div>
     </div>
 
     <script>
-        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;
+        // Check model status on page load
+        async function checkModelStatus() {
+            try {
+                const response = await fetch('/health');
+                const data = await response.json();
+                const statusDiv = document.getElementById('model-status');
+                
+                if (data.model_loaded) {
+                    statusDiv.textContent = '✅ Model loaded and ready!';
+                    statusDiv.style.color = '#28a745';
+                } else {
+                    statusDiv.textContent = '⏳ Model loading... Please wait.';
+                    statusDiv.style.color = '#ffc107';
+                    // Try to load model
+                    setTimeout(tryLoadModel, 2000);
+                }
+            } catch (error) {
+                const statusDiv = document.getElementById('model-status');
+                statusDiv.textContent = '❌ Connection error';
+                statusDiv.style.color = '#dc3545';
             }
         }
 
-        async function checkStatus() {
+        async function tryLoadModel() {
             try {
-                const response = await fetch('/health');
+                const response = await fetch('/load_model', { method: 'POST' });
                 const data = await response.json();
-                updateStatus(data);
+                
+                if (data.success) {
+                    const statusDiv = document.getElementById('model-status');
+                    statusDiv.textContent = '✅ Model loaded successfully!';
+                    statusDiv.style.color = '#28a745';
+                } else {
+                    setTimeout(checkModelStatus, 5000); // Check again in 5 seconds
+                }
             } catch (error) {
-                document.getElementById('status').className = 'status status-error';
-                document.getElementById('status').textContent = '❌ Connection error';
+                setTimeout(checkModelStatus, 5000);
             }
         }
 
-        window.onload = checkStatus;
+        // Call on page load
+        window.onload = checkModelStatus;
 
         function handleKeyPress(event) {
             if (event.key === 'Enter') {
@@ -387,15 +115,11 @@ HTML_TEMPLATE = """
             }
         }
 
-        function addMessage(content, type = 'ai') {
+        function addMessage(content, isUser) {
             const chatContainer = document.getElementById('chat-container');
             const messageDiv = document.createElement('div');
-            messageDiv.className = `message ${type}-message`;
-            
-            // Safely handle newlines without regex
-            const lines = content.split('\\n');
-            messageDiv.innerHTML = lines.join('<br>');
-            
+            messageDiv.className = `message ${isUser ? 'user-message' : 'ai-message'}`;
+            messageDiv.textContent = content;
             chatContainer.appendChild(messageDiv);
             chatContainer.scrollTop = chatContainer.scrollHeight;
         }
@@ -405,29 +129,34 @@ HTML_TEMPLATE = """
             const loadingDiv = document.createElement('div');
             loadingDiv.className = 'loading';
             loadingDiv.id = 'loading';
-            loadingDiv.textContent = 'Thinking...';
+            loadingDiv.textContent = 'AI is thinking...';
             chatContainer.appendChild(loadingDiv);
             chatContainer.scrollTop = chatContainer.scrollHeight;
         }
 
         function hideLoading() {
             const loading = document.getElementById('loading');
-            if (loading) loading.remove();
+            if (loading) {
+                loading.remove();
+            }
         }
 
         async function sendMessage() {
             const input = document.getElementById('user-input');
             const message = input.value.trim();
+            
             if (!message) return;
             
-            addMessage(message, 'user');
+            addMessage(message, true);
             input.value = '';
             showLoading();
             
             try {
                 const response = await fetch('/chat', {
                     method: 'POST',
-                    headers: { 'Content-Type': 'application/json' },
+                    headers: {
+                        'Content-Type': 'application/json',
+                    },
                     body: JSON.stringify({ message: message })
                 });
                 
@@ -435,13 +164,13 @@ HTML_TEMPLATE = """
                 hideLoading();
                 
                 if (data.response) {
-                    addMessage(data.response, 'ai');
+                    addMessage(data.response, false);
                 } else {
-                    addMessage('Sorry, I encountered an error.', 'ai');
+                    addMessage('Sorry, I encountered an error. Please try again.', false);
                 }
             } catch (error) {
                 hideLoading();
-                addMessage('Connection error. Please try again.', 'ai');
+                addMessage('Connection error. Please try again.', false);
             }
         }
     </script>
@@ -449,47 +178,103 @@ HTML_TEMPLATE = """
 </html>
 """
 
-@app.route('/')
-def home():
-    """Serve the main chat interface"""
-    return render_template_string(HTML_TEMPLATE)
-
-@app.route('/process_tech_scores', methods=['POST'])
-def process_tech_scores():
-    """Process technology scores"""
+def load_model():
+    """Load the Qwen2 model and tokenizer from HF repository"""
+    global model, tokenizer
+    
     try:
-        data = request.get_json()
+        logger.info("Loading model and tokenizer from Hugging Face...")
         
-        tech_scores = TechScores(
-            ai=data.get('ai', 0.0),
-            cyber=data.get('cyber', 0.0),
-            bio=data.get('bio', 0.0),
-            nuclear=data.get('nuclear', 0.0),
-            climate=data.get('climate', 0.0),
-            space=data.get('space', 0.0),
-            year=data.get('year', 2024)
+        # Load from the deployed model repository
+        model_repo = "Gaston895/Aegisecon1"
+        
+        logger.info(f"Loading tokenizer from {model_repo}...")
+        tokenizer = AutoTokenizer.from_pretrained(
+            model_repo,
+            trust_remote_code=True,
+            use_auth_token=False
+        )
+        
+        logger.info(f"Loading model from {model_repo}...")
+        model = AutoModelForCausalLM.from_pretrained(
+            model_repo,
+            torch_dtype=torch.float16,  # Changed from bfloat16 for better compatibility
+            device_map="cpu",           # Force CPU for HF Spaces compatibility
+            trust_remote_code=True,
+            use_auth_token=False,
+            low_cpu_mem_usage=True
         )
         
-        logger.info(f"Processing tech scores...")
+        logger.info("Model loaded successfully from HF repository!")
+        return True
         
-        # Process with simplified analysis
-        result = processor.process_tech_scores(tech_scores)
+    except Exception as e:
+        logger.error(f"Error loading model from HF: {str(e)}")
+        # Try alternative loading method
+        try:
+            logger.info("Trying alternative loading method...")
+            tokenizer = AutoTokenizer.from_pretrained(
+                "Qwen/Qwen2-1.5B",  # Fallback to base model
+                trust_remote_code=True
+            )
+            model = AutoModelForCausalLM.from_pretrained(
+                "Qwen/Qwen2-1.5B",
+                torch_dtype=torch.float16,
+                device_map="cpu",
+                trust_remote_code=True,
+                low_cpu_mem_usage=True
+            )
+            logger.info("Fallback model loaded successfully!")
+            return True
+        except Exception as e2:
+            logger.error(f"Fallback loading also failed: {str(e2)}")
+            return False
+
+def generate_response(prompt):
+    """Generate response using the loaded model"""
+    try:
+        if model is None or tokenizer is None:
+            return "Model is still loading, please wait a moment and try again..."
         
-        if not result['success']:
-            return jsonify({'success': False, 'error': 'Processing failed'})
+        # Economics-focused system prompt
+        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."""
         
-        # Generate analysis
-        final_analysis = generate_response(result['final_prompt'], max_time=15)
+        full_prompt = f"{system_prompt}\n\nUser: {prompt}\nAssistant:"
         
-        return jsonify({
-            'success': True,
-            'processing_steps': result['processing_steps'],
-            'final_analysis': final_analysis
-        })
+        # Tokenize input
+        inputs = tokenizer(full_prompt, return_tensors="pt", truncation=True, max_length=1024)
+        
+        # Generate response
+        with torch.no_grad():
+            outputs = model.generate(
+                inputs.input_ids,
+                max_new_tokens=256,  # Reduced for faster generation
+                temperature=0.7,
+                do_sample=True,
+                pad_token_id=tokenizer.eos_token_id,
+                repetition_penalty=1.1,
+                no_repeat_ngram_size=3
+            )
+        
+        # Decode response
+        response = tokenizer.decode(outputs[0], skip_special_tokens=True)
+        
+        # Extract only the assistant's response
+        if "Assistant:" in response:
+            response = response.split("Assistant:")[-1].strip()
+        
+        return response
         
     except Exception as e:
-        logger.error(f"Error: {e}")
-        return jsonify({'success': False, 'error': str(e)}), 500
+        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."
+
+@app.route('/')
+def home():
+    """Serve the main chat interface"""
+    return render_template_string(HTML_TEMPLATE)
 
 @app.route('/chat', methods=['POST'])
 def chat():
@@ -499,45 +284,51 @@ def chat():
         user_message = data.get('message', '')
         
         if not user_message:
-            return jsonify({'error': 'No message'}), 400
+            return jsonify({'error': 'No message provided'}), 400
         
-        # Generate response with timeout
-        response = generate_response(user_message, max_time=15)
+        # Generate AI response
+        ai_response = generate_response(user_message)
         
-        return jsonify({'response': response})
+        return jsonify({'response': ai_response})
         
     except Exception as e:
-        logger.error(f"Chat error: {e}")
-        return jsonify({'error': 'Server error'}), 500
+        logger.error(f"Error in chat endpoint: {str(e)}")
+        return jsonify({'error': 'Internal server error'}), 500
 
 @app.route('/health')
 def health():
-    """Health check"""
+    """Health check endpoint"""
     return jsonify({
-        'status': 'ok',
+        'status': 'healthy',
         'model_loaded': model is not None,
-        'timestamp': datetime.now().isoformat()
+        'tokenizer_loaded': tokenizer is not None,
+        'model_info': 'Gaston895/Aegisecon1' if model is not None else 'Not loaded'
     })
 
-@app.route('/reload_model')
-def reload_model():
-    """Reload model endpoint"""
-    global model, tokenizer
+@app.route('/load_model', methods=['POST'])
+def load_model_endpoint():
+    """Endpoint to trigger model loading"""
     try:
-        # Clear existing model
-        del model
-        del tokenizer
-        cleanup_memory()
-        
-        # Reload
         success = load_model()
         return jsonify({
             'success': success,
-            'message': 'Model reloaded' if success else 'Reload failed'
+            'model_loaded': model is not None,
+            'tokenizer_loaded': tokenizer is not None
         })
     except Exception as e:
-        return jsonify({'success': False, 'error': str(e)}), 500
+        return jsonify({'error': str(e)}), 500
 
 if __name__ == '__main__':
-    logger.info("🚀 Starting AEGIS Economics AI...")
-    app.run(host='0.0.0.0', port=7860, debug=False, threaded=True)
+    # Load model on startup
+    logger.info("Starting AEGIS Economics AI...")
+    
+    # Try to load model, but don't fail if it doesn't work
+    logger.info("Attempting to load model...")
+    model_loaded = load_model()
+    
+    if model_loaded:
+        logger.info("Model loaded successfully, starting server...")
+    else:
+        logger.warning("Model failed to load, starting server anyway. Model can be loaded via /load_model endpoint.")
+    
+    app.run(host='0.0.0.0', port=7860, debug=False)