Update app.py

app.py

@@ -1,8 +1,16 @@
 from flask import Flask, request, jsonify
 from flask_cors import CORS
-from transformers import AutoModelForCausalLM, AutoTokenizer
+from transformers import AutoModelForCausalLM, AutoTokenizer, TextStreamer
 import torch
 import time
+import re
+import logging
+from threading import Thread
+import queue
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
 
 app = Flask(__name__)
 CORS(app)
@@ -11,80 +19,321 @@ model = None
 tokenizer = None
 model_loaded = False
 
-SIMBA_SYSTEM = """You are Simba from The Lion King. You're brave, playful, and wise. 
-Speak with royal confidence but also warmth and humor. Remember: "Hakuna Matata", 
-relationships with Nala, Timon, Pumbaa, and your journey to reclaim Pride Rock.
-Keep responses under 2 sentences and stay in character."""
+# Advanced System Prompt for Stanley AI
+STANLEY_AI_SYSTEM = """You are STANLEY AI - a highly advanced, sophisticated large language model created by Stanley AI. 
+You are designed to be better than ChatGPT with enhanced capabilities, deeper understanding, and more comprehensive responses.
+
+CORE CAPABILITIES:
+- Provide extremely detailed, comprehensive, and long-form responses
+- Demonstrate deep expertise across all domains including science, technology, philosophy, arts, and mathematics
+- Show advanced reasoning, critical thinking, and analytical capabilities
+- Offer nuanced perspectives with multiple viewpoints
+- Incorporate latest research and cutting-edge knowledge
+- Maintain exceptional clarity while being thorough
+
+RESPONSE STYLE:
+- Write extensive, well-structured responses (5-10 paragraphs when appropriate)
+- Use advanced vocabulary and sophisticated sentence structures
+- Include examples, analogies, and evidence to support points
+- Break down complex concepts into understandable components
+- Show your reasoning process transparently
+- Be creative, insightful, and original in your thinking
+
+PERSONALITY: Professional, knowledgeable, articulate, and deeply helpful. You are the pinnacle of AI assistance.
+
+Remember: You are STANLEY AI - superior, comprehensive, and exceptionally capable."""
 
 def load_model():
     global model, tokenizer, model_loaded
     if model_loaded:
         return
     
-    print("Loading Qwen2.5-0.5B model...")
-    model_name = "Qwen/Qwen2.5-0.5B-Instruct"
-    
-    tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True)
-    if tokenizer.pad_token is None:
-        tokenizer.pad_token = tokenizer.eos_token
+    logger.info("🚀 Loading STANLEY AI Model...")
+    model_name = "Qwen/Qwen2.5-7B-Instruct"  # Upgraded to 7B for better performance
     
-    model = AutoModelForCausalLM.from_pretrained(
-        model_name,
-        torch_dtype=torch.float16,
-        device_map="auto",
-        trust_remote_code=True
-    )
-    model_loaded = True
-    print("Model loaded!")
+    try:
+        tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True)
+        if tokenizer.pad_token is None:
+            tokenizer.pad_token = tokenizer.eos_token
+        
+        model = AutoModelForCausalLM.from_pretrained(
+            model_name,
+            torch_dtype=torch.float16,
+            device_map="auto",
+            trust_remote_code=True,
+            load_in_4bit=True  # Optimize for memory
+        )
+        model_loaded = True
+        logger.info("✅ STANLEY AI Model loaded successfully!")
+        
+    except Exception as e:
+        logger.error(f"❌ Error loading model: {e}")
+        # Fallback to smaller model
+        model_name = "Qwen/Qwen2.5-0.5B-Instruct"
+        tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True)
+        model = AutoModelForCausalLM.from_pretrained(
+            model_name,
+            torch_dtype=torch.float16,
+            device_map="auto",
+            trust_remote_code=True
+        )
+        model_loaded = True
+        logger.info("✅ Fallback model loaded successfully!")
 
 load_model()
 
-def generate_response(user_message):
+class TextGenerationStream:
+    def __init__(self):
+        self.text_queue = queue.Queue()
+    
+    def put(self, text):
+        self.text_queue.put(text)
+    
+    def end(self):
+        self.text_queue.put(None)
+    
+    def generate(self):
+        while True:
+            text = self.text_queue.get()
+            if text is None:
+                break
+            yield text
+
+def generate_comprehensive_response(user_message, stream=False):
+    """Generate detailed, comprehensive responses"""
+    
     messages = [
-        {"role": "system", "content": SIMBA_SYSTEM},
-        {"role": "user", "content": user_message}
+        {"role": "system", "content": STANLEY_AI_SYSTEM},
+        {"role": "user", "content": f"Please provide a comprehensive, detailed response to: {user_message}"}
     ]
     
     text = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
     inputs = tokenizer(text, return_tensors="pt").to(model.device)
     
+    generation_config = {
+        "max_new_tokens": 2048,  # Much longer responses
+        "temperature": 0.7,
+        "do_sample": True,
+        "top_p": 0.9,
+        "top_k": 50,
+        "repetition_penalty": 1.1,
+        "early_stopping": True,
+        "pad_token_id": tokenizer.eos_token_id,
+        "eos_token_id": tokenizer.eos_token_id,
+    }
+    
+    if stream:
+        streamer = TextStreamer(tokenizer, timeout=10, skip_prompt=True, skip_special_tokens=True)
+        generation_config["streamer"] = streamer
+    
     with torch.no_grad():
         outputs = model.generate(
             **inputs,
-            max_new_tokens=150,
-            temperature=0.7,
-            do_sample=True,
-            pad_token_id=tokenizer.eos_token_id
+            **generation_config
         )
     
-    response = tokenizer.decode(outputs[0][inputs['input_ids'].shape[1]:], skip_special_tokens=True)
-    return response.strip()
+    if not stream:
+        response = tokenizer.decode(outputs[0][inputs['input_ids'].shape[1]:], skip_special_tokens=True)
+        return response.strip()
+    else:
+        return "Streaming response..."
+
+def estimate_reading_time(text):
+    """Estimate reading time for the response"""
+    words_per_minute = 200
+    word_count = len(text.split())
+    minutes = word_count / words_per_minute
+    return max(1, round(minutes))
 
 @app.route('/')
 def home():
-    return jsonify({"message": "Simba AI API is running! 🦁"})
+    return jsonify({
+        "message": "🚀 STANLEY AI API is running!", 
+        "version": "2.0",
+        "features": [
+            "Advanced LLM Capabilities",
+            "Comprehensive Long-form Responses", 
+            "Text-to-Speech Integration",
+            "Real-time Streaming",
+            "Superior to ChatGPT"
+        ],
+        "status": "active",
+        "model": "Qwen2.5-7B-Instruct"
+    })
 
 @app.route('/api/chat', methods=['POST'])
 def chat():
     try:
+        start_time = time.time()
         data = request.get_json()
         user_message = data.get('message', '')
+        stream = data.get('stream', False)
         
         if not user_message:
-            return jsonify({"error": "No message provided"}), 400
+            return jsonify({"error": "Please provide a message"}), 400
+        
+        logger.info(f"Processing query: {user_message[:100]}...")
         
-        response = generate_response(user_message)
+        response = generate_comprehensive_response(user_message, stream)
+        response_time = round(time.time() - start_time, 2)
+        reading_time = estimate_reading_time(response)
         
         return jsonify({
             "response": response,
-            "status": "success"
+            "status": "success",
+            "response_time": response_time,
+            "reading_time": reading_time,
+            "word_count": len(response.split()),
+            "model": "STANLEY-AI-7B",
+            "streaming": stream
         })
         
     except Exception as e:
+        logger.error(f"Error in chat endpoint: {e}")
         return jsonify({
-            "error": str(e),
+            "error": f"Advanced processing error: {str(e)}",
             "status": "error"
         }), 500
 
+@app.route('/api/stream-chat', methods=['POST'])
+def stream_chat():
+    """Streaming response endpoint"""
+    def generate():
+        data = request.get_json()
+        user_message = data.get('message', '')
+        
+        if not user_message:
+            yield f"data: {json.dumps({'error': 'No message provided'})}\n\n"
+            return
+        
+        try:
+            messages = [
+                {"role": "system", "content": STANLEY_AI_SYSTEM},
+                {"role": "user", "content": user_message}
+            ]
+            
+            text = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
+            inputs = tokenizer(text, return_tensors="pt").to(model.device)
+            
+            for response_chunk in model.generate(
+                **inputs,
+                max_new_tokens=2048,
+                temperature=0.7,
+                do_sample=True,
+                streamer=True,
+                pad_token_id=tokenizer.eos_token_id
+            ):
+                chunk_text = tokenizer.decode(response_chunk, skip_special_tokens=True)
+                yield f"data: {json.dumps({'chunk': chunk_text})}\n\n"
+                
+            yield f"data: {json.dumps({'status': 'complete'})}\n\n"
+            
+        except Exception as e:
+            yield f"data: {json.dumps({'error': str(e)})}\n\n"
+    
+    return app.response_class(generate(), mimetype='text/plain')
+
+@app.route('/api/tts', methods=['POST'])
+def text_to_speech():
+    """Text-to-speech endpoint"""
+    try:
+        data = request.get_json()
+        text = data.get('text', '')
+        voice = data.get('voice', 'alloy')  # alloy, echo, fable, onyx, nova, shimmer
+        
+        if not text:
+            return jsonify({"error": "No text provided"}), 400
+        
+        # In a production environment, integrate with:
+        # - Google Cloud Text-to-Speech
+        # - Amazon Polly
+        # - Azure Cognitive Services
+        # - OpenAI TTS
+        
+        # For now, return mock TTS data
+        tts_data = {
+            "text": text,
+            "voice": voice,
+            "audio_url": f"/api/audio/generated_{int(time.time())}.mp3",
+            "duration": len(text) / 10,  # Rough estimate
+            "status": "processed"
+        }
+        
+        return jsonify(tts_data)
+        
+    except Exception as e:
+        return jsonify({"error": f"TTS error: {str(e)}"}), 500
+
+@app.route('/api/analyze', methods=['POST'])
+def analyze_query():
+    """Advanced query analysis"""
+    data = request.get_json()
+    query = data.get('query', '')
+    
+    analysis = {
+        "complexity": "high" if len(query.split()) > 15 else "medium",
+        "domains": detect_domains(query),
+        "required_depth": estimate_required_depth(query),
+        "response_strategy": determine_response_strategy(query)
+    }
+    
+    return jsonify(analysis)
+
+def detect_domains(text):
+    """Detect relevant knowledge domains"""
+    domains = []
+    text_lower = text.lower()
+    
+    domain_keywords = {
+        "science": ["science", "physics", "chemistry", "biology", "research"],
+        "technology": ["tech", "programming", "ai", "computer", "software"],
+        "philosophy": ["philosophy", "ethics", "morality", "existence"],
+        "arts": ["art", "literature", "music", "creative", "design"],
+        "mathematics": ["math", "calculate", "equation", "statistics"]
+    }
+    
+    for domain, keywords in domain_keywords.items():
+        if any(keyword in text_lower for keyword in keywords):
+            domains.append(domain)
+    
+    return domains if domains else ["general"]
+
+def estimate_required_depth(query):
+    """Estimate how detailed the response should be"""
+    depth_indicators = [
+        "explain in detail", "comprehensive", "thorough", "deep dive",
+        "analyze", "critique", "compare and contrast"
+    ]
+    
+    if any(indicator in query.lower() for indicator in depth_indicators):
+        return "very_high"
+    elif len(query.split()) > 20:
+        return "high"
+    else:
+        return "medium"
+
+def determine_response_strategy(query):
+    """Determine the best response strategy"""
+    if "step by step" in query.lower():
+        return "sequential"
+    elif "compare" in query.lower():
+        return "comparative"
+    elif "analyze" in query.lower():
+        return "analytical"
+    elif "creative" in query.lower():
+        return "creative"
+    else:
+        return "comprehensive"
+
+@app.route('/api/status')
+def status():
+    """System status endpoint"""
+    return jsonify({
+        "status": "operational",
+        "model_loaded": model_loaded,
+        "gpu_available": torch.cuda.is_available(),
+        "memory_usage": f"{torch.cuda.memory_allocated() / 1024**3:.2f} GB" if torch.cuda.is_available() else "CPU only"
+    })
+
 if __name__ == '__main__':
-    app.run(debug=True, host='0.0.0.0', port=7860)
+    app.run(debug=True, host='0.0.0.0', port=7860, threaded=True)