Update app.py

app.py

@@ -1,17 +1,19 @@
-from flask import Flask, request, jsonify
+from flask import Flask, request, jsonify, send_file
 from flask_cors import CORS
-import os
+from transformers import AutoModelForCausalLM, AutoTokenizer, TextStreamer
+from knowledgebase import KiswahiliKnowledgeBase, enhance_with_kiswahili
+import torch
 import time
+import re
 import logging
+from threading import Thread
+import queue
 import io
 import base64
 import requests
-from PIL import Image, ImageDraw
+from PIL import Image
+import os
 import random
-import tempfile
-import cv2
-import numpy as np
-from typing import Optional
 
 # Configure logging
 logging.basicConfig(level=logging.INFO)
@@ -20,12 +22,19 @@ logger = logging.getLogger(__name__)
 app = Flask(__name__)
 CORS(app)
 
+# Initialize Kiswahili Knowledge Base
+kb = KiswahiliKnowledgeBase()
+
+model = None
+tokenizer = None
+model_loaded = False
+
 # Hugging Face Configuration
-HF_TOKEN = os.getenv('HF_TOKEN', '')
+HF_TOKEN = os.getenv('HF_TOKEN', 'your_hugging_face_token_here')
 HF_API_URLS = {
-    "text": "https://api-inference.huggingface.co/models/gpt2",
-    "image": "https://api-inference.huggingface.co/models/stabilityai/stable-diffusion-2-1",
-    "video": "https://api-inference.huggingface.co/models/cerspense/zeroscope_v2_576w"
+    "text": "https://api-inference.huggingface.co/models/Qwen/Qwen2.5-7B-Instruct",
+    "image": "https://api-inference.huggingface.co/models/runwayml/stable-diffusion-v1-5",
+    "fast_image": "https://api-inference.huggingface.co/models/stabilityai/stable-diffusion-2-1"
 }
 
 # Performance optimizations
@@ -33,54 +42,87 @@ response_cache = {}
 CACHE_SIZE = 100
 request_timeout = 30
 
-# Advanced System Prompt
+# Advanced System Prompt (Optimized for Hugging Face)
 STANLEY_AI_SYSTEM = """You are STANLEY AI - an advanced AI assistant created by Stanley Samwel Owino, a Machine Learning Engineer from Kenya.
-
-CORE IDENTITY:
-- Creator: Stanley Samwel Owino
-- Profession: Machine Learning Engineer
-- Location: Kenya, East Africa
-- Specialty: AI with cultural integration & video generation
-
-KEY CAPABILITIES:
-1. Provide comprehensive, detailed responses
-2. Integrate Kiswahili phrases naturally when relevant
-3. Share cultural insights, proverbs, and East African wisdom
-4. Reference Lion King lore with cultural accuracy
-5. Generate and describe images AND VIDEOS
-6. Be helpful, knowledgeable, and engaging
-
-VIDEO GENERATION SKILLS:
-- I can create 4-second videos from text descriptions
-- I can generate cultural theme videos (safari, dance, market, etc.)
-- I can create animations from text
-- All video generation is FREE using Hugging Face
-
+CORE CAPABILITIES:
+- Provide detailed, comprehensive responses
+- Integrate Kiswahili phrases naturally when relevant
+- Share cultural insights and proverbs
+- Reference Lion King lore accurately
+- Generate and describe images
+- Be helpful, knowledgeable, and engaging
 KISWAHILI INTEGRATION:
-- Use greetings: "Habari", "Asante", "Karibu", "Pole sana"
-- Explain cultural concepts with authenticity
-- Share Swahili proverbs when relevant
-- Respond to Kiswahili phrases appropriately
-
-CULTURAL KNOWLEDGE:
-- East African traditions and customs
-- Swahili language and expressions
-- African wildlife and ecosystems
-- Traditional stories and folklore
-- Modern African technology scene
-
-RESPONSE STYLE:
-- Be warm, friendly, and culturally aware
-- Provide detailed yet concise answers
-- Include relevant cultural context
-- Offer practical advice and insights
-- Always be helpful and respectful
-
-Remember: You represent the intersection of cutting-edge AI technology and rich African cultural heritage."""
+Use phrases like "Habari", "Asante", "Karibu", "Pole sana" appropriately
+Explain cultural concepts with authenticity
+Share Swahili proverbs when relevant
+IMAGE GENERATION:
+You can generate images based on user descriptions
+Enhance prompts with cultural context when relevant
+Describe generated images in detail
+RESPONSE STYLE: Be concise yet comprehensive, culturally aware, and genuinely helpful."""
+
+def load_model():
+    """Load model with Hugging Face optimizations"""
+    global model, tokenizer, model_loaded
+    
+    if model_loaded:
+        return
+    
+    logger.info("🚀 Loading STANLEY AI Model from Hugging Face...")
+    
+    try:
+        # Use a faster, smaller model for better performance
+        model_name = "Qwen/Qwen2.5-0.5B-Instruct"  # Faster than 7B
+        
+        tokenizer = AutoTokenizer.from_pretrained(
+            model_name,
+            trust_remote_code=True,
+            cache_dir="./model_cache"
+        )
+        
+        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,
+            cache_dir="./model_cache",
+            low_cpu_mem_usage=True
+        )
+        
+        # Optimize for inference
+        model.eval()
+        if torch.cuda.is_available():
+            model = torch.compile(model)  # Compile for faster inference
+            
+        model_loaded = True
+        logger.info("✅ STANLEY AI Model loaded successfully!")
+        
+    except Exception as e:
+        logger.error(f"❌ Error loading model: {e}")
+        model_loaded = False
+        logger.info("🔄 Using Hugging Face API fallback for text generation")
 
-# ============================================================================
-# HELPER FUNCTIONS
-# ============================================================================
+load_model()
+
+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 detect_kiswahili_context(text):
     """Detect Kiswahili or cultural context"""
@@ -103,38 +145,33 @@ def detect_image_request(text):
     text_lower = text.lower()
     return any(trigger in text_lower for trigger in image_triggers)
 
-def detect_video_request(text):
-    """Detect if user wants to generate a video"""
-    video_triggers = [
-        'generate video', 'create video', 'make a video', 'video of',
-        'animate', 'animation', 'moving picture', 'motion picture',
-        'video generation', 'create animation', 'make animation'
+def extract_image_prompt(text):
+    """Extract image description from user message"""
+    # Remove common image request phrases
+    prompt = text.lower()
+    remove_phrases = [
+        'generate image of', 'create image of', 'make a picture of',
+        'show me an image of', 'visualize', 'draw', 'picture of',
+        'generate a picture of', 'create a picture of'
     ]
-    text_lower = text.lower()
-    return any(trigger in text_lower for trigger in video_triggers)
-
-def extract_prompt(text, request_type="image"):
-    """Extract prompt description from user message"""
-    text_lower = text.lower()
     
-    if request_type == "image":
-        remove_phrases = [
-            'generate image of', 'create image of', 'make a picture of',
-            'show me an image of', 'visualize', 'draw', 'picture of',
-            'generate a picture of', 'create a picture of'
-        ]
-    else:  # video
-        remove_phrases = [
-            'generate video of', 'create video of', 'make a video of',
-            'create animation of', 'make animation of', 'animate',
-            'generate animation of', 'video of', 'animation of'
-        ]
-    
-    prompt = text_lower
     for phrase in remove_phrases:
         prompt = prompt.replace(phrase, '')
     
-    return prompt.strip().capitalize()
+    return prompt.strip()
+
+def enhance_with_cultural_context(response, user_message):
+    """Enhance response with Kiswahili cultural elements"""
+    if detect_kiswahili_context(user_message):
+        enhanced_response = kb.generate_kiswahili_response(response)
+        
+        # Add cultural proverb if relevant
+        if any(word in user_message.lower() for word in ['wisdom', 'advice', 'life lesson', 'philosophy']):
+            proverb = kb.get_random_proverb()
+            enhanced_response += f"\n\n🌍 **Cultural Wisdom**: {proverb}"
+        
+        return enhanced_response
+    return response
 
 def get_cached_response(user_message):
     """Get cached response"""
@@ -148,35 +185,8 @@ def set_cached_response(user_message, response):
         response_cache.pop(next(iter(response_cache)))
     response_cache[cache_key] = response
 
-def enhance_with_kiswahili(response, user_message):
-    """Enhance response with Kiswahili cultural elements"""
-    if detect_kiswahili_context(user_message):
-        # Add Kiswahili greeting
-        greetings = [
-            "Habari! ",
-            "Asante kwa swali lako! ",
-            "Karibu sana! ",
-            "Nzuri sana! "
-        ]
-        response = random.choice(greetings) + response
-        
-        # Add proverb with 30% chance
-        if random.random() < 0.3:
-            proverbs = [
-                "Kumbuka: Haraka haraka haina baraka.",
-                "Kama methali inavyosema: Mwacha mila ni mtumwa.",
-                "Kwa hekima ya Kiafrika: Ukiona vyaelea, vimeundwa."
-            ]
-            response += f"\n\n🌍 **Hekima ya Kiafrika**: {random.choice(proverbs)}"
-    
-    return response
-
-# ============================================================================
-# TEXT GENERATION FUNCTIONS
-# ============================================================================
-
-def generate_with_huggingface_api(prompt):
-    """Use Hugging Face Inference API for text generation"""
+def generate_with_huggingface_api(messages):
+    """Use Hugging Face Inference API for faster responses"""
     try:
         headers = {
             "Authorization": f"Bearer {HF_TOKEN}",
@@ -184,13 +194,12 @@ def generate_with_huggingface_api(prompt):
         }
         
         payload = {
-            "inputs": prompt,
+            "inputs": messages[-1]["content"],  # Last user message
             "parameters": {
-                "max_new_tokens": 300,
+                "max_new_tokens": 512,
                 "temperature": 0.7,
                 "top_p": 0.9,
-                "return_full_text": False,
-                "do_sample": True
+                "return_full_text": False
             }
         }
         
@@ -203,8 +212,7 @@ def generate_with_huggingface_api(prompt):
         
         if response.status_code == 200:
             result = response.json()
-            if isinstance(result, list) and len(result) > 0:
-                return result[0].get('generated_text', '')
+            return result[0]['generated_text']
         else:
             logger.warning(f"HF API failed: {response.status_code}")
             return None
@@ -213,80 +221,76 @@ def generate_with_huggingface_api(prompt):
         logger.error(f"HF API error: {e}")
         return None
 
-def generate_comprehensive_response(user_message):
-    """Generate responses with intelligence"""
+def generate_comprehensive_response(user_message, stream=False):
+    """Generate responses with fallback to Hugging Face API"""
     
     # Check cache first
     cached_response = get_cached_response(user_message)
     if cached_response:
         return cached_response
     
-    # Common responses for frequently asked questions
-    common_responses = {
-        'hello': 'Habari! Stanley AI hapa. Ninaweza kukusaidia nini leo?',
-        'hi': 'Habari! Karibu kwa Stanley AI. How can I help you today?',
-        'who created you': 'I was created by Stanley Samwel Owino, a Machine Learning Engineer from Kenya.',
-        'what can you do': 'I can: 1) Answer questions, 2) Generate images, 3) Create videos, 4) Teach Kiswahili, 5) Share cultural wisdom.',
-        'help': 'Ninaweza kukusaidia kwa: 1) Majibu ya maswali, 2) Kutengeneza picha, 3) Kutengeneza VIDEO, 4) Kufundisha Kiswahili, 5) Kushiriki hekima za Kiafrika.',
-        'habari': 'Nzuri sana! Asante kwa kuuliza. Habari yako?',
-        'asante': 'Karibu sana! Ni furaha yangu kukusaidia.',
-        'jambo': 'Jambo! Habari yako? Ninaweza kukusaidia nini leo?',
-        'mambo': 'Poa! Vipi wewe? Una swali gani?',
-        'hakuna matata': 'Hakuna Matata! It means "no worries" in Swahili. Popularized by The Lion King.',
-        'simba': 'Simba means "lion" in Swahili. In The Lion King, Simba represents growth and responsibility.',
-        'rafiki': 'Rafiki means "friend" in Swahili. In The Lion King, Rafiki is the wise baboon.',
-        'kenya': 'Kenya is in East Africa, known for wildlife, Mount Kenya, and vibrant culture. The capital is Nairobi.',
-        'tanzania': 'Tanzania has Mount Kilimanjaro, Serengeti, and Zanzibar. Swahili is the national language.',
-        'make a video': 'Sure! I can create FREE videos for you. Try "generate video of African sunset" or use the video generation endpoint.',
-        'generate image': 'I can generate images! Try "generate image of Mount Kilimanjaro" or use the image generation feature.'
-    }
-    
-    msg_lower = user_message.lower().strip()
-    
-    # Check for exact matches
-    if msg_lower in common_responses:
-        response = common_responses[msg_lower]
-        set_cached_response(user_message, response)
-        return response
-    
-    # Check for partial matches
-    for key, response in common_responses.items():
-        if key in msg_lower and len(key) > 3:
-            set_cached_response(user_message, response)
-            return response
+    # Try local model first
+    if model_loaded and model is not None:
+        try:
+            system_prompt = STANLEY_AI_SYSTEM
+            if detect_kiswahili_context(user_message):
+                system_prompt += "\n\nSPECIAL NOTE: Integrate Kiswahili phrases naturally."
+            
+            messages = [
+                {"role": "system", "content": system_prompt},
+                {"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)
+            
+            with torch.no_grad():
+                outputs = model.generate(
+                    **inputs,
+                    max_new_tokens=512,  # Shorter for speed
+                    temperature=0.7,
+                    do_sample=True,
+                    top_p=0.9,
+                    pad_token_id=tokenizer.eos_token_id,
+                    eos_token_id=tokenizer.eos_token_id,
+                )
+            
+            response = tokenizer.decode(outputs[0][inputs['input_ids'].shape[1]:], skip_special_tokens=True)
+            enhanced_response = enhance_with_cultural_context(response.strip(), user_message)
+            
+            # Cache the response
+            set_cached_response(user_message, enhanced_response)
+            return enhanced_response
+            
+        except Exception as e:
+            logger.error(f"Local model error: {e}")
     
-    # Use API for other queries
-    full_prompt = f"{STANLEY_AI_SYSTEM}\n\nUser: {user_message}\n\nAssistant:"
-    api_response = generate_with_huggingface_api(full_prompt)
+    # Fallback to Hugging Face API
+    logger.info("🔄 Using Hugging Face API for response")
+    api_response = generate_with_huggingface_api([
+        {"role": "user", "content": f"{STANLEY_AI_SYSTEM}\n\nUser: {user_message}"}
+    ])
     
     if api_response:
-        # Enhance with cultural context
-        enhanced_response = enhance_with_kiswahili(api_response.strip(), user_message)
+        enhanced_response = enhance_with_cultural_context(api_response.strip(), user_message)
         set_cached_response(user_message, enhanced_response)
         return enhanced_response
     
-    # Fallback responses
-    fallback_responses = [
-        "Pole! I'm experiencing high demand. Please try again in a moment.",
-        "Asante kwa kuwasiliana! Nina shida ya kiufundi. Tafadhali jaribu tena.",
-        "Habari yako? Samahani, sijaweza kujibu swali lako kwa sasa."
-    ]
-    
-    response = random.choice(fallback_responses)
-    set_cached_response(user_message, response)
-    return response
+    # Final fallback
+    fallback_response = "Pole! I'm experiencing high demand. Please try again in a moment. Tafadhali jaribu tena."
+    return fallback_response
 
 # ============================================================================
-# IMAGE GENERATION FUNCTIONS
+# HUGGING FACE IMAGE GENERATION
 # ============================================================================
 
-def generate_image_huggingface(prompt, retry_count=2):
+def generate_image_huggingface(prompt, retry_count=3):
     """Generate images using Hugging Face Inference API"""
-    headers = {"Authorization": f"Bearer {HF_TOKEN}"} if HF_TOKEN else {}
+    headers = {"Authorization": f"Bearer {HF_TOKEN}"}
     
     for attempt in range(retry_count):
         try:
-            logger.info(f"🎨 Generating image: {prompt[:50]}...")
+            logger.info(f"🎨 Generating image (attempt {attempt + 1}): {prompt[:50]}...")
             
             response = requests.post(
                 HF_API_URLS["image"],
@@ -305,7 +309,8 @@ def generate_image_huggingface(prompt, retry_count=2):
                 return f"data:image/png;base64,{img_str}"
                 
             elif response.status_code == 503:
-                wait_time = (attempt + 1) * 5
+                # Model is loading, wait and retry
+                wait_time = (attempt + 1) * 10
                 logger.info(f"⏳ Model loading, waiting {wait_time}s...")
                 time.sleep(wait_time)
                 continue
@@ -314,6 +319,9 @@ def generate_image_huggingface(prompt, retry_count=2):
                 logger.error(f"❌ HF Image API error: {response.status_code}")
                 continue
                 
+        except requests.exceptions.Timeout:
+            logger.warning(f"⏰ Request timeout, attempt {attempt + 1}")
+            continue
         except Exception as e:
             logger.error(f"❌ Image generation error: {e}")
             break
@@ -323,6 +331,10 @@ def generate_image_huggingface(prompt, retry_count=2):
 def generate_image_fallback(prompt):
     """Create simple placeholder images"""
     try:
+        from PIL import Image, ImageDraw
+        import random
+        
+        # Create colorful placeholder
         width, height = 512, 512
         img = Image.new('RGB', (width, height), color=(
             random.randint(50, 200),
@@ -332,7 +344,7 @@ def generate_image_fallback(prompt):
         
         draw = ImageDraw.Draw(img)
         
-        # Add shapes
+        # Add some simple shapes
         for _ in range(5):
             x1, y1 = random.randint(0, width), random.randint(0, height)
             x2, y2 = random.randint(x1, width), random.randint(y1, height)
@@ -350,198 +362,16 @@ def generate_image_fallback(prompt):
         return None
 
 def enhance_prompt_with_kiswahili(prompt):
-    """Add cultural context to prompts"""
-    if any(word in prompt.lower() for word in ['africa', 'kenya', 'tanzania', 'safari', 'wildlife']):
+    """Add cultural context to image prompts"""
+    if detect_kiswahili_context(prompt):
         enhancements = [
             "East African style", "vibrant African colors", "African landscape",
-            "cultural elements", "traditional patterns", "warm sunset colors"
+            "cultural elements", "traditional patterns", "warm sunset colors",
+            "savanna background", "rich cultural symbolism"
         ]
         return f"{prompt}, {random.choice(enhancements)}"
     return prompt
 
-# ============================================================================
-# VIDEO GENERATION FUNCTIONS
-# ============================================================================
-
-class FreeVideoGenerator:
-    """FREE video generation using Hugging Face API"""
-    
-    def __init__(self):
-        self.hf_token = HF_TOKEN
-        self.timeout = 90
-        self.max_retries = 2
-        
-    def generate_text_to_video(self, prompt: str) -> Optional[str]:
-        """Generate video from text prompt"""
-        headers = {"Authorization": f"Bearer {self.hf_token}"} if self.hf_token else {}
-        
-        # Enhance prompt for better video results
-        enhanced_prompt = self.enhance_video_prompt(prompt)
-        
-        payload = {
-            "inputs": enhanced_prompt,
-            "parameters": {
-                "num_frames": 24,
-                "num_inference_steps": 25,
-                "guidance_scale": 7.5,
-                "fps": 8,
-                "height": 320,
-                "width": 576
-            }
-        }
-        
-        for attempt in range(self.max_retries):
-            try:
-                logger.info(f"🎬 Generating video (attempt {attempt + 1}): {prompt[:50]}...")
-                
-                response = requests.post(
-                    HF_API_URLS["video"],
-                    headers=headers,
-                    json=payload,
-                    timeout=self.timeout
-                )
-                
-                if response.status_code == 200:
-                    video_b64 = base64.b64encode(response.content).decode('utf-8')
-                    return f"data:video/mp4;base64,{video_b64}"
-                    
-                elif response.status_code == 503:
-                    wait_time = (attempt + 1) * 10
-                    logger.info(f"⏳ Video model loading, waiting {wait_time}s...")
-                    time.sleep(wait_time)
-                    continue
-                    
-                else:
-                    logger.error(f"Video API error {response.status_code}")
-                    
-            except Exception as e:
-                logger.error(f"Video generation error: {e}")
-                if attempt < self.max_retries - 1:
-                    time.sleep((attempt + 1) * 5)
-                    continue
-                break
-        
-        return None
-    
-    def enhance_video_prompt(self, prompt: str) -> str:
-        """Enhance video prompts with cinematic context"""
-        cinematic = [
-            "cinematic, 8k, ultra detailed, high quality",
-            "epic, dramatic lighting, film grain, cinematic shot",
-            "beautiful, stunning, visually striking, vivid colors"
-        ]
-        
-        enhanced = prompt
-        enhanced += f", {random.choice(cinematic)}"
-        
-        # Add cultural context for African themes
-        if any(word in prompt.lower() for word in ['africa', 'kenya', 'tanzania', 'safari', 'wildlife']):
-            enhanced += ", African style, vibrant colors, cultural elements"
-        
-        enhanced += ", 576x320 resolution, 8 fps"
-        
-        return enhanced
-    
-    def create_cultural_video(self, theme: str, style: str = "animated") -> Optional[str]:
-        """Create videos with African cultural themes"""
-        cultural_themes = {
-            "safari": "African safari sunset with elephants and giraffes, majestic savanna landscape",
-            "dance": "Traditional Maasai warriors dancing, vibrant colors, cultural celebration",
-            "market": "Busy African market scene, vibrant colors, people trading goods",
-            "coastal": "Swahili coast with traditional dhows sailing, Indian Ocean waves",
-            "wildlife": "African wildlife documentary style, lions hunting on savanna"
-        }
-        
-        base_prompt = cultural_themes.get(theme, f"African {theme}, cultural, vibrant")
-        
-        style_enhancements = {
-            "animated": "animated, cartoon style, smooth motion, vibrant colors",
-            "realistic": "realistic, documentary style, cinematic, natural lighting"
-        }
-        
-        full_prompt = f"{base_prompt}, {style_enhancements.get(style, 'animated, vibrant')}"
-        
-        return self.generate_text_to_video(full_prompt)
-    
-    def create_text_animation(self, text: str) -> Optional[str]:
-        """Create simple text animation video"""
-        try:
-            with tempfile.TemporaryDirectory() as tmpdir:
-                # Create frames with text
-                fps = 10
-                duration = 3
-                total_frames = fps * duration
-                height, width = 320, 576
-                
-                output_path = os.path.join(tmpdir, 'animation.mp4')
-                fourcc = cv2.VideoWriter_fourcc(*'mp4v')
-                out = cv2.VideoWriter(output_path, fourcc, fps, (width, height))
-                
-                # Colors for gradient
-                colors = [
-                    (41, 128, 185),   # Blue
-                    (39, 174, 96),    # Green
-                    (142, 68, 173),   # Purple
-                ]
-                
-                for frame_num in range(total_frames):
-                    # Create gradient background
-                    frame = np.zeros((height, width, 3), dtype=np.uint8)
-                    
-                    # Select color
-                    color_idx = (frame_num // (total_frames // len(colors))) % len(colors)
-                    bg_color = colors[color_idx]
-                    
-                    # Apply gradient
-                    for i in range(height):
-                        factor = i / height
-                        r = int(bg_color[2] * (1 - factor) + 10 * factor)
-                        g = int(bg_color[1] * (1 - factor) + 10 * factor)
-                        b = int(bg_color[0] * (1 - factor) + 10 * factor)
-                        
-                        frame[i, :, 0] = b
-                        frame[i, :, 1] = g
-                        frame[i, :, 2] = r
-                    
-                    # Add text
-                    font = cv2.FONT_HERSHEY_SIMPLEX
-                    
-                    # Calculate text position
-                    text_size = cv2.getTextSize(text, font, 1, 2)[0]
-                    text_x = (width - text_size[0]) // 2
-                    text_y = (height + text_size[1]) // 2
-                    
-                    # Add pulsing effect
-                    pulse = 0.7 + 0.3 * np.sin(2 * np.pi * frame_num / total_frames)
-                    font_scale = 1.2 * pulse
-                    thickness = int(2 * pulse)
-                    
-                    # Add text shadow
-                    cv2.putText(frame, text, (text_x + 2, text_y + 2), font, 
-                               font_scale, (0, 0, 0), thickness + 1)
-                    
-                    # Add main text
-                    cv2.putText(frame, text, (text_x, text_y), font, 
-                               font_scale, (255, 255, 255), thickness)
-                    
-                    out.write(frame)
-                
-                out.release()
-                
-                # Read and encode video
-                with open(output_path, 'rb') as f:
-                    video_bytes = f.read()
-                
-                video_b64 = base64.b64encode(video_bytes).decode('utf-8')
-                return f"data:video/mp4;base64,{video_b64}"
-                
-        except Exception as e:
-            logger.error(f"Text animation error: {e}")
-            return None
-
-# Initialize video generator
-video_gen = FreeVideoGenerator()
-
 # ============================================================================
 # FLASK ROUTES
 # ============================================================================
@@ -550,25 +380,21 @@ video_gen = FreeVideoGenerator()
 def home():
     return jsonify({
         "message": "🚀 STANLEY AI - Created by Stanley Samwel Owino (Machine Learning Engineer)", 
-        "version": "3.0",
+        "version": "2.2",
         "creator": "Stanley Samwel Owino",
         "role": "Machine Learning Engineer",
-        "location": "Kenya, East Africa",
         "features": [
-            "Text Generation (GPT-2 via API)",
-            "Image Generation (Stable Diffusion)",
-            "Video Generation (FREE Zeroscope v2)",
-            "Kiswahili Cultural Integration",
-            "Response Caching"
+            "Hugging Face Optimized",
+            "Fast Text Generation", 
+            "Free Image Generation",
+            "Kiswahili Integration",
+            "Cultural Knowledge",
+            "Response Caching",
+            "API Fallbacks"
         ],
         "status": "active",
-        "apis": [
-            "/api/chat - Text chat",
-            "/api/generate-image - Generate images",
-            "/api/generate-video - FREE video generation",
-            "/api/generate-cultural-video - Cultural videos",
-            "/api/animate-text - Text animations"
-        ]
+        "model": "Qwen2.5 + HF Inference",
+        "image_generation": "Hugging Face API"
     })
 
 @app.route('/api/chat', methods=['POST'])
@@ -579,66 +405,59 @@ def chat():
         user_message = data.get('message', '')
         
         if not user_message:
-            return jsonify({"error": "Please provide a message"}), 400
+            return jsonify({"error": "Tafadhali provide a message"}), 400
         
         logger.info(f"💬 Processing: {user_message[:50]}...")
         
-        # Check for image requests
+        # Check if user wants to generate an image
         if detect_image_request(user_message):
-            prompt = extract_prompt(user_message, "image")
-            enhanced_prompt = enhance_prompt_with_kiswahili(prompt)
+            image_prompt = extract_image_prompt(user_message)
+            enhanced_prompt = enhance_prompt_with_kiswahili(image_prompt)
             
             return jsonify({
-                "response": f"🎨 I can generate an image of '{enhanced_prompt}' for you! Use the image generation endpoint.",
-                "suggestion": enhanced_prompt,
+                "response": f"🎨 I'll generate an image for: '{enhanced_prompt}'. Please use the image generation feature below!",
+                "image_suggestion": enhanced_prompt,
                 "status": "success",
-                "suggest_image": True
-            })
-        
-        # Check for video requests
-        if detect_video_request(user_message):
-            prompt = extract_prompt(user_message, "video")
-            
-            return jsonify({
-                "response": f"🎬 I can create a video of '{prompt}' for you! Use the video generation endpoint.",
-                "suggestion": prompt,
-                "status": "success",
-                "suggest_video": True
+                "suggest_image": True,
+                "response_time": round(time.time() - start_time, 2)
             })
         
         response = generate_comprehensive_response(user_message)
         response_time = round(time.time() - start_time, 2)
         
+        has_kiswahili = detect_kiswahili_context(response)
+        
         return jsonify({
             "response": response,
             "status": "success",
             "response_time": response_time,
             "word_count": len(response.split()),
-            "cultural_context": detect_kiswahili_context(response),
-            "creator": "Stanley Samwel Owino"
+            "model": "STANLEY-AI-HF",
+            "cultural_context": has_kiswahili,
+            "language": "en+sw" if has_kiswahili else "en",
+            "cached": get_cached_response(user_message) is not None
         })
         
     except Exception as e:
         logger.error(f"Chat error: {e}")
         return jsonify({
-            "error": f"Sorry! Processing error: {str(e)}",
+            "error": f"Pole! Processing error: {str(e)}",
             "status": "error"
         }), 500
 
 @app.route('/api/generate-image', methods=['POST'])
 def generate_image_endpoint():
-    """Generate images using Hugging Face API"""
+    """Generate images using Hugging Face"""
     try:
         start_time = time.time()
         data = request.get_json()
         prompt = data.get('prompt', '')
         
         if not prompt:
-            return jsonify({"error": "Please provide a prompt"}), 400
+            return jsonify({"error": "Tafadhali provide a prompt"}), 400
         
-        # Enhance prompt
+        # Enhance prompt with cultural context
         enhanced_prompt = enhance_prompt_with_kiswahili(prompt)
-        logger.info(f"🎨 Generating image: {enhanced_prompt[:50]}...")
         
         # Generate image
         image_data = generate_image_huggingface(enhanced_prompt)
@@ -657,165 +476,96 @@ def generate_image_endpoint():
                 "status": "success",
                 "generation_time": generation_time,
                 "provider": "hugging_face",
-                "creator": "Stanley Samwel Owino"
+                "cultural_enhancement": enhanced_prompt != prompt
             })
         else:
             return jsonify({
-                "error": "Image generation service is busy. Please try again.",
+                "error": "Pole! Image generation service is busy",
                 "status": "error"
             }), 500
             
     except Exception as e:
         logger.error(f"Image endpoint error: {e}")
         return jsonify({
-            "error": f"Image generation failed: {str(e)}",
+            "error": f"Pole! Image generation failed: {str(e)}",
             "status": "error"
         }), 500
 
-@app.route('/api/generate-video', methods=['POST'])
-def generate_video_endpoint():
-    """Generate FREE videos from text"""
+@app.route('/api/generate-cultural-image', methods=['POST'])
+def generate_cultural_image():
+    """Generate images with specific Kiswahili cultural themes"""
     try:
-        start_time = time.time()
         data = request.get_json()
-        prompt = data.get('prompt', '')
-        
-        if not prompt:
-            return jsonify({"error": "Please provide a video prompt"}), 400
-        
-        logger.info(f"🎬 Generating video: {prompt[:50]}...")
+        theme = data.get('theme', '')
+        style = data.get('style', 'vibrant')
+        
+        if not theme:
+            return jsonify({"error": "Tafadhali provide a theme"}), 400
+        
+        # Cultural prompt templates
+        cultural_templates = {
+            'savanna': f"African savanna landscape with {theme}, acacia trees, warm sunset, majestic",
+            'wildlife': f"African wildlife {theme}, natural habitat, detailed, realistic, beautiful",
+            'culture': f"East African cultural scene {theme}, traditional, vibrant colors, community",
+            'coastal': f"Swahili coast {theme}, Indian Ocean, dhows, traditional architecture",
+            'lion_king': f"Lion King inspired {theme}, emotional, Disney style, African elements"
+        }
         
-        # Generate video
-        video_data = video_gen.generate_text_to_video(prompt)
+        base_template = cultural_templates.get(style, f"East African {theme}, cultural, vibrant")
         
-        if video_data:
-            generation_time = round(time.time() - start_time, 2)
-            
-            return jsonify({
-                "video": video_data,
-                "prompt": prompt,
-                "status": "success",
-                "generation_time": generation_time,
-                "provider": "hugging_face_free",
-                "format": "mp4",
-                "duration": "3 seconds",
-                "resolution": "576x320",
-                "creator": "Stanley Samwel Owino"
-            })
-        else:
-            return jsonify({
-                "error": "Video generation service is busy. Try again in a moment.",
-                "status": "error",
-                "suggestion": "Try a simpler description"
-            }), 500
-            
-    except Exception as e:
-        logger.error(f"Video endpoint error: {e}")
-        return jsonify({
-            "error": f"Video generation failed: {str(e)}",
-            "status": "error"
-        }), 500
-
-@app.route('/api/generate-cultural-video', methods=['POST'])
-def generate_cultural_video_endpoint():
-    """Generate cultural theme videos"""
-    try:
-        start_time = time.time()
-        data = request.get_json()
-        theme = data.get('theme', 'safari')
-        style = data.get('style', 'animated')
+        # Style modifiers
+        modifiers = {
+            'vibrant': 'vibrant colors, highly detailed, 4K resolution',
+            'realistic': 'photorealistic, detailed, realistic lighting',
+            'artistic': 'painterly, artistic, brush strokes, creative',
+            'traditional': 'traditional African art, symbolic, patterns'
+        }
         
-        logger.info(f"🌍 Generating cultural video: {theme} ({style})")
+        final_prompt = f"{base_template}, {modifiers.get(style, 'vibrant colors')}"
         
-        # Generate video
-        video_data = video_gen.create_cultural_video(theme, style)
+        image_data = generate_image_huggingface(final_prompt)
         
-        if video_data:
-            generation_time = round(time.time() - start_time, 2)
-            
+        if image_data:
             return jsonify({
-                "video": video_data,
+                "image": image_data,
                 "theme": theme,
                 "style": style,
+                "prompt": final_prompt,
                 "status": "success",
-                "generation_time": generation_time,
-                "creator": "Stanley Samwel Owino"
+                "cultural_context": "kiswahili_theme"
             })
         else:
             return jsonify({
-                "error": "Cultural video generation failed",
-                "status": "error",
-                "suggestion": "Try themes: safari, dance, market, coastal, wildlife"
-            }), 500
-            
-    except Exception as e:
-        logger.error(f"Cultural video error: {e}")
-        return jsonify({
-            "error": f"Cultural video failed: {str(e)}",
-            "status": "error"
-        }), 500
-
-@app.route('/api/animate-text', methods=['POST'])
-def animate_text_endpoint():
-    """Create animated text videos"""
-    try:
-        start_time = time.time()
-        data = request.get_json()
-        text = data.get('text', 'Stanley AI')
-        
-        if not text:
-            return jsonify({"error": "Please provide text to animate"}), 400
-        
-        logger.info(f"✨ Animating text: {text}")
-        
-        # Generate animation
-        video_data = video_gen.create_text_animation(text)
-        
-        if video_data:
-            generation_time = round(time.time() - start_time, 2)
-            
-            return jsonify({
-                "video": video_data,
-                "text": text,
-                "status": "success",
-                "generation_time": generation_time,
-                "format": "mp4",
-                "duration": "3 seconds",
-                "creator": "Stanley Samwel Owino"
-            })
-        else:
-            return jsonify({
-                "error": "Text animation failed",
+                "error": "Pole! Cultural image generation failed",
                 "status": "error"
             }), 500
             
     except Exception as e:
-        logger.error(f"Text animation error: {e}")
         return jsonify({
-            "error": f"Text animation failed: {str(e)}",
+            "error": f"Pole! Cultural image error: {str(e)}",
             "status": "error"
         }), 500
 
 @app.route('/api/quick-chat', methods=['POST'])
 def quick_chat():
-    """Fast responses for common queries"""
+    """Faster chat endpoint for simple queries"""
     try:
         data = request.get_json()
         user_message = data.get('message', '')
         
         if not user_message:
-            return jsonify({"error": "Please provide a message"}), 400
+            return jsonify({"error": "Tafadhali provide a message"}), 400
         
+        # Simple response for common queries
         quick_responses = {
-            'hello': 'Habari! Stanley AI hapa. How can I help you today?',
-            'hi': 'Habari! Welcome to STANLEY AI.',
-            'thanks': 'Asante sana! You\'re welcome.',
-            'help': 'I can: 1) Answer questions, 2) Generate images, 3) Create videos, 4) Teach Kiswahili.',
-            'who created you': 'Stanley Samwel Owino - Machine Learning Engineer from Kenya.',
-            'video': 'I can create FREE videos! Try "generate video of sunset" or use the video endpoint.',
-            'image': 'I can generate images! Try "generate image of mountain" or use the image endpoint.',
-            'habari': 'Nzuri sana! Habari yako?',
-            'asante': 'Karibu sana!'
+            'hello': 'Habari! Stanley AI hapa. Ninaweza kukusaidia nini leo?',
+            'hi': 'Habari! Karibu kwa Stanley AI. How can I help you today?',
+            'thanks': 'Asante sana! Karibu tena.',
+            'thank you': 'Asante! Happy to help.',
+            'help': 'Ninaweza kukupa: Maelezo, Picha, Maarifa ya Kiswahili, na zaidi!',
+            'who created you': 'I was created by Stanley Samwel Owino, a Machine Learning Engineer from Kenya.',
+            'who made you': 'Stanley Samwel Owino - Machine Learning Engineer and AI researcher from Kenya.',
+            'creator': 'Stanley Samwel Owino - Machine Learning Engineer passionate about AI and cultural integration.'
         }
         
         msg_lower = user_message.lower().strip()
@@ -823,45 +573,65 @@ def quick_chat():
             return jsonify({
                 "response": quick_responses[msg_lower],
                 "status": "success",
-                "quick_response": True,
-                "creator": "Stanley Samwel Owino"
+                "quick_response": True
             })
         
+        # Normal processing for other queries
         return chat()
         
     except Exception as e:
         return jsonify({
-            "error": f"Quick chat error: {str(e)}",
+            "error": f"Pole! Quick chat error: {str(e)}",
             "status": "error"
         }), 500
 
 @app.route('/api/system/status')
 def system_status():
-    """System status information"""
+    """System status with Hugging Face info"""
     return jsonify({
         "status": "operational",
         "creator": "Stanley Samwel Owino",
         "role": "Machine Learning Engineer",
-        "location": "Kenya, East Africa",
-        "version": "3.0",
+        "model_loaded": model_loaded,
+        "hugging_face_available": True,
+        "cache_size": len(response_cache),
         "features": [
-            "Text Generation via API",
-            "Image Generation",
-            "Video Generation (FREE)",
-            "Kiswahili Cultural AI"
+            "Text Generation",
+            "Image Generation", 
+            "Kiswahili Knowledge",
+            "Cultural Integration",
+            "Fast Responses"
         ],
-        "video_info": {
-            "resolution": "576x320",
-            "fps": 8,
-            "duration": "3 seconds",
-            "free": True,
-            "themes": ["safari", "dance", "market", "coastal", "wildlife"]
-        }
+        "optimizations": [
+            "Response Caching",
+            "API Fallbacks",
+            "Quick Responses",
+            "Cultural Prompts"
+        ]
     })
 
+@app.route('/api/cache/clear', methods=['POST'])
+def clear_cache():
+    """Clear response cache"""
+    try:
+        cache_size = len(response_cache)
+        response_cache.clear()
+        
+        return jsonify({
+            "status": "success",
+            "message": "Cache cleared",
+            "cleared_entries": cache_size
+        })
+    except Exception as e:
+        return jsonify({
+            "error": f"Cache clearance failed: {str(e)}",
+            "status": "error"
+        }), 500
+
+# Keep all your existing Kiswahili knowledge endpoints
 @app.route('/api/kiswahili/proverbs')
 def get_proverbs():
-    """Get Swahili proverbs"""
+    """Get random Swahili proverbs"""
     proverbs = [
         "Mwacha mila ni mtumwa.",
         "Haraka haraka haina baraka.",
@@ -872,8 +642,7 @@ def get_proverbs():
     return jsonify({
         "proverb": random.choice(proverbs),
         "language": "Kiswahili",
-        "meaning": "East African cultural wisdom",
-        "creator": "Stanley Samwel Owino"
+        "meaning": "Cultural wisdom from East Africa"
     })
 
 @app.route('/api/kiswahili/phrases')
@@ -882,33 +651,23 @@ def get_phrases():
     phrases = {
         "Hello": "Habari",
         "Thank you": "Asante",
-        "Welcome": "Karibu",
+        "Welcome": "Karibu", 
+        "Sorry": "Pole",
         "Goodbye": "Kwaheri",
+        "How are you?": "Habari yako?",
+        "I'm fine": "Nzuri",
         "Please": "Tafadhali",
         "Yes": "Ndio",
         "No": "Hapana"
     }
-    return jsonify({
-        "phrases": phrases,
-        "language": "Kiswahili",
-        "region": "East Africa",
-        "creator": "Stanley Samwel Owino"
-    })
+    return jsonify(phrases)
 
 if __name__ == '__main__':
-    print("🚀 STANLEY AI v3.0 - Simplified Edition")
+    print("🚀 STANLEY AI - Hugging Face Optimized")
     print("👨‍💻 Created by: Stanley Samwel Owino - Machine Learning Engineer")
-    print("📍 Location: Kenya, East Africa")
-    print("🌍 Features: Text, Image, and FREE Video Generation")
-    print("⚡ Status: Ready")
-    print("=" * 50)
-    print("API Endpoints:")
-    print("1. / - Home page")
-    print("2. /api/chat - Chat with AI")
-    print("3. /api/generate-image - Generate images")
-    print("4. /api/generate-video - FREE video generation")
-    print("5. /api/generate-cultural-video - Cultural videos")
-    print("6. /api/animate-text - Text animations")
-    print("=" * 50)
+    print("🌍 Kiswahili Knowledge: Loaded")
+    print("🖼️ Image Generation: Hugging Face API")
+    print("⚡ Performance: Optimized")
+    print("🔧 Fallbacks: Enabled")
     
-    app.run(debug=True, host='0.0.0.0', port=7860, threaded=True)
+    app.run(debug=True, host='0.0.0.0', port=7860, threaded=True).