Update app.py

app.py

@@ -1,23 +1,17 @@
-from flask import Flask, request, jsonify, send_file
+from flask import Flask, request, jsonify
 from flask_cors import CORS
-from transformers import AutoModelForCausalLM, AutoTokenizer, TextStreamer
-from knowledgebase import KiswahiliKnowledgeBase, enhance_with_kiswahili
-import torch
+import os
 import time
-import re
 import logging
-from threading import Thread
-import queue
 import io
 import base64
 import requests
-from PIL import Image, ImageDraw, ImageFont
-import os
+from PIL import Image, ImageDraw
 import random
 import tempfile
 import cv2
 import numpy as np
-from typing import Optional, Dict, Any, List
+from typing import Optional
 
 # Configure logging
 logging.basicConfig(level=logging.INFO)
@@ -26,29 +20,20 @@ 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_API_URLS = {
-    "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",
-    "video": "https://api-inference.huggingface.co/models/cerspense/zeroscope_v2_576w",
-    "image_to_video": "https://api-inference.huggingface.co/models/stabilityai/stable-video-diffusion-img2vid-xt"
+    "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"
 }
 
 # Performance optimizations
 response_cache = {}
 CACHE_SIZE = 100
-request_timeout = 45
+request_timeout = 30
 
-# Advanced System Prompt (Enhanced for Video Generation)
+# Advanced System Prompt
 STANLEY_AI_SYSTEM = """You are STANLEY AI - an advanced AI assistant created by Stanley Samwel Owino, a Machine Learning Engineer from Kenya.
 
 CORE IDENTITY:
@@ -68,8 +53,7 @@ KEY CAPABILITIES:
 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 images
-- I can make slideshows from multiple images
+- I can create animations from text
 - All video generation is FREE using Hugging Face
 
 KISWAHILI INTEGRATION:
@@ -94,66 +78,8 @@ RESPONSE STYLE:
 
 Remember: You represent the intersection of cutting-edge AI technology and rich African cultural heritage."""
 
-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 = "microsoft/DialoGPT-small"  # More reliable and smaller
-        
-        tokenizer = AutoTokenizer.from_pretrained(
-            model_name,
-            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 if torch.cuda.is_available() else torch.float32,
-            device_map="auto" if torch.cuda.is_available() else None,
-            cache_dir="./model_cache",
-            low_cpu_mem_usage=True
-        )
-        
-        # Optimize for inference
-        model.eval()
-        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")
-
-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
-
 # ============================================================================
-# ENHANCED DETECTION FUNCTIONS WITH VIDEO SUPPORT
+# HELPER FUNCTIONS
 # ============================================================================
 
 def detect_kiswahili_context(text):
@@ -172,8 +98,7 @@ def detect_image_request(text):
     image_triggers = [
         'generate image', 'create image', 'make a picture', 'draw',
         'show me an image', 'visualize', 'picture of', 'image of',
-        'generate a picture', 'create a picture', 'make art of',
-        'paint a picture of', 'illustrate', 'draw me'
+        'generate a picture', 'create a picture'
     ]
     text_lower = text.lower()
     return any(trigger in text_lower for trigger in image_triggers)
@@ -183,10 +108,7 @@ def detect_video_request(text):
     video_triggers = [
         'generate video', 'create video', 'make a video', 'video of',
         'animate', 'animation', 'moving picture', 'motion picture',
-        'video generation', 'create animation', 'make animation',
-        'video clip', 'short video', 'motion graphics', 'cinematic',
-        'film', 'movie', 'moving image', 'dynamic image', 'animated video',
-        'make a film', 'create movie', 'produce video', 'animate this'
+        'video generation', 'create animation', 'make animation'
     ]
     text_lower = text.lower()
     return any(trigger in text_lower for trigger in video_triggers)
@@ -199,42 +121,21 @@ def extract_prompt(text, 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', 'make art of',
-            'paint a picture of', 'illustrate', 'draw me', 'show 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',
-            'make a film about', 'create a film about', 'produce video of'
+            'generate animation of', 'video of', 'animation of'
         ]
     
     prompt = text_lower
     for phrase in remove_phrases:
         prompt = prompt.replace(phrase, '')
     
-    # Remove question words
-    question_words = ['how to', 'what is', 'can you', 'could you', 'would you', 'please']
-    for word in question_words:
-        if prompt.startswith(word):
-            prompt = prompt[len(word):].strip()
-    
     return prompt.strip().capitalize()
 
-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"""
     cache_key = user_message.lower().strip()[:100]
@@ -247,21 +148,43 @@ 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(messages):
-    """Use Hugging Face Inference API for faster responses"""
+def generate_with_huggingface_api(prompt):
+    """Use Hugging Face Inference API for text generation"""
     try:
         headers = {
             "Authorization": f"Bearer {HF_TOKEN}",
             "Content-Type": "application/json"
         }
         
-        # Use GPT-2 as fallback (more reliable)
         payload = {
-            "inputs": messages[-1]["content"],  # Last user message
+            "inputs": prompt,
             "parameters": {
                 "max_new_tokens": 300,
                 "temperature": 0.7,
@@ -272,7 +195,7 @@ def generate_with_huggingface_api(messages):
         }
         
         response = requests.post(
-            "https://api-inference.huggingface.co/models/gpt2",
+            HF_API_URLS["text"],
             headers=headers,
             json=payload,
             timeout=request_timeout
@@ -290,80 +213,68 @@ def generate_with_huggingface_api(messages):
         logger.error(f"HF API error: {e}")
         return None
 
-def generate_comprehensive_response(user_message, stream=False):
-    """Generate responses with fallback to Hugging Face API"""
+def generate_comprehensive_response(user_message):
+    """Generate responses with intelligence"""
     
     # Check cache first
     cached_response = get_cached_response(user_message)
     if cached_response:
         return cached_response
     
-    # Check for common questions first
+    # 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.',
-        'video generation': 'I can create FREE videos! Try saying "generate video of African sunset" or use the video generation endpoint.',
-        'make a video': 'Sure! Describe what you want: "create video of wildlife" or use the video generation feature.'
+        '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
     
-    # 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."
-            
-            # Format messages for DialoGPT
-            chat_history_ids = None
-            new_user_input_ids = tokenizer.encode(user_message + tokenizer.eos_token, return_tensors='pt')
-            
-            # Generate response
-            with torch.no_grad():
-                chat_history_ids = model.generate(
-                    new_user_input_ids,
-                    max_length=1000,
-                    pad_token_id=tokenizer.eos_token_id,
-                    temperature=0.7,
-                    do_sample=True,
-                    top_p=0.9
-                )
-            
-            response = tokenizer.decode(chat_history_ids[:, new_user_input_ids.shape[-1]:][0], 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}")
+    # 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
     
-    # 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}"}
-    ])
+    # 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)
     
     if api_response:
-        enhanced_response = enhance_with_cultural_context(api_response.strip(), user_message)
+        # Enhance with cultural context
+        enhanced_response = enhance_with_kiswahili(api_response.strip(), user_message)
         set_cached_response(user_message, enhanced_response)
         return enhanced_response
     
-    # Final fallback
+    # 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."
     ]
-    return random.choice(fallback_responses)
+    
+    response = random.choice(fallback_responses)
+    set_cached_response(user_message, response)
+    return response
 
 # ============================================================================
 # IMAGE GENERATION FUNCTIONS
@@ -371,14 +282,14 @@ def generate_comprehensive_response(user_message, stream=False):
 
 def generate_image_huggingface(prompt, retry_count=2):
     """Generate images using Hugging Face Inference API"""
-    headers = {"Authorization": f"Bearer {HF_TOKEN}"}
+    headers = {"Authorization": f"Bearer {HF_TOKEN}"} if HF_TOKEN else {}
     
     for attempt in range(retry_count):
         try:
-            logger.info(f"🎨 Generating image (attempt {attempt + 1}): {prompt[:50]}...")
+            logger.info(f"🎨 Generating image: {prompt[:50]}...")
             
             response = requests.post(
-                HF_API_URLS["fast_image"],
+                HF_API_URLS["image"],
                 headers=headers,
                 json={"inputs": prompt},
                 timeout=60
@@ -394,7 +305,6 @@ def generate_image_huggingface(prompt, retry_count=2):
                 return f"data:image/png;base64,{img_str}"
                 
             elif response.status_code == 503:
-                # Model is loading, wait and retry
                 wait_time = (attempt + 1) * 5
                 logger.info(f"⏳ Model loading, waiting {wait_time}s...")
                 time.sleep(wait_time)
@@ -404,9 +314,6 @@ 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
@@ -414,7 +321,7 @@ def generate_image_huggingface(prompt, retry_count=2):
     return None
 
 def generate_image_fallback(prompt):
-    """Create simple placeholder images with text"""
+    """Create simple placeholder images"""
     try:
         width, height = 512, 512
         img = Image.new('RGB', (width, height), color=(
@@ -425,25 +332,13 @@ def generate_image_fallback(prompt):
         
         draw = ImageDraw.Draw(img)
         
-        # Add some simple shapes
+        # Add 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)
             color = (random.randint(0, 255), random.randint(0, 255), random.randint(0, 255))
             draw.rectangle([x1, y1, x2, y2], outline=color, width=3)
         
-        # Add text
-        try:
-            font = ImageFont.truetype("arial.ttf", 20)
-        except:
-            font = ImageFont.load_default()
-        
-        # Truncate long prompts
-        display_text = prompt[:50] + "..." if len(prompt) > 50 else prompt
-        text_color = (255, 255, 255) if sum(img.getpixel((width//2, height//2))) < 384 else (0, 0, 0)
-        
-        draw.text((width//2, height//2), display_text, fill=text_color, font=font, anchor="mm")
-        
         # Convert to base64
         buffered = io.BytesIO()
         img.save(buffered, format="PNG")
@@ -455,18 +350,17 @@ def generate_image_fallback(prompt):
         return None
 
 def enhance_prompt_with_kiswahili(prompt):
-    """Add cultural context to image prompts"""
-    if detect_kiswahili_context(prompt):
+    """Add cultural context to prompts"""
+    if any(word in prompt.lower() for word in ['africa', 'kenya', 'tanzania', 'safari', 'wildlife']):
         enhancements = [
             "East African style", "vibrant African colors", "African landscape",
-            "cultural elements", "traditional patterns", "warm sunset colors",
-            "savanna background", "rich cultural symbolism"
+            "cultural elements", "traditional patterns", "warm sunset colors"
         ]
         return f"{prompt}, {random.choice(enhancements)}"
     return prompt
 
 # ============================================================================
-# FREE VIDEO GENERATION FUNCTIONS
+# VIDEO GENERATION FUNCTIONS
 # ============================================================================
 
 class FreeVideoGenerator:
@@ -478,7 +372,7 @@ class FreeVideoGenerator:
         self.max_retries = 2
         
     def generate_text_to_video(self, prompt: str) -> Optional[str]:
-        """Generate video from text prompt using FREE Hugging Face API"""
+        """Generate video from text prompt"""
         headers = {"Authorization": f"Bearer {self.hf_token}"} if self.hf_token else {}
         
         # Enhance prompt for better video results
@@ -531,14 +425,14 @@ class FreeVideoGenerator:
     
     def enhance_video_prompt(self, prompt: str) -> str:
         """Enhance video prompts with cinematic context"""
-        cinematic_enhancements = [
-            "cinematic, 8k, ultra detailed, high quality, masterpiece",
-            "epic, dramatic lighting, film grain, cinematic shot, professional",
-            "beautiful, stunning, visually striking, vivid colors, trending"
+        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_enhancements)}"
+        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']):
@@ -549,14 +443,13 @@ class FreeVideoGenerator:
         return enhanced
     
     def create_cultural_video(self, theme: str, style: str = "animated") -> Optional[str]:
-        """Create videos with Kiswahili cultural themes"""
+        """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",
-            "village": "Traditional African village life, community activities, sunset"
+            "wildlife": "African wildlife documentary style, lions hunting on savanna"
         }
         
         base_prompt = cultural_themes.get(theme, f"African {theme}, cultural, vibrant")
@@ -576,7 +469,7 @@ class FreeVideoGenerator:
             with tempfile.TemporaryDirectory() as tmpdir:
                 # Create frames with text
                 fps = 10
-                duration = 3  # seconds
+                duration = 3
                 total_frames = fps * duration
                 height, width = 320, 576
                 
@@ -584,20 +477,18 @@ class FreeVideoGenerator:
                 fourcc = cv2.VideoWriter_fourcc(*'mp4v')
                 out = cv2.VideoWriter(output_path, fourcc, fps, (width, height))
                 
-                # Create gradient background colors
+                # Colors for gradient
                 colors = [
                     (41, 128, 185),   # Blue
                     (39, 174, 96),    # Green
                     (142, 68, 173),   # Purple
-                    (230, 126, 34),   # Orange
-                    (231, 76, 60)     # Red
                 ]
                 
                 for frame_num in range(total_frames):
                     # Create gradient background
                     frame = np.zeros((height, width, 3), dtype=np.uint8)
                     
-                    # Select color based on frame
+                    # Select color
                     color_idx = (frame_num // (total_frames // len(colors))) % len(colors)
                     bg_color = colors[color_idx]
                     
@@ -612,10 +503,10 @@ class FreeVideoGenerator:
                         frame[i, :, 1] = g
                         frame[i, :, 2] = r
                     
-                    # Add text with animation
+                    # Add text
                     font = cv2.FONT_HERSHEY_SIMPLEX
                     
-                    # Calculate text size and position
+                    # 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
@@ -664,26 +555,20 @@ def home():
         "role": "Machine Learning Engineer",
         "location": "Kenya, East Africa",
         "features": [
-            "Hugging Face Optimized",
-            "Fast Text Generation", 
-            "FREE Image Generation",
-            "FREE Video Generation",  # NEW
-            "Kiswahili Integration",
-            "Cultural Knowledge",
-            "Response Caching",
-            "API Fallbacks"
-        ],
-        "video_capabilities": [  # NEW
-            "Text-to-Video (FREE)",
-            "Cultural Theme Videos",
-            "Text Animations",
-            "576x320 Resolution",
-            "4-second videos"
+            "Text Generation (GPT-2 via API)",
+            "Image Generation (Stable Diffusion)",
+            "Video Generation (FREE Zeroscope v2)",
+            "Kiswahili Cultural Integration",
+            "Response Caching"
         ],
         "status": "active",
-        "model": "DialoGPT + HF Inference",
-        "image_generation": "Hugging Face API",
-        "video_generation": "Hugging Face FREE API"  # NEW
+        "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"
+        ]
     })
 
 @app.route('/api/chat', methods=['POST'])
@@ -694,73 +579,65 @@ def chat():
         user_message = data.get('message', '')
         
         if not user_message:
-            return jsonify({"error": "Tafadhali provide a message"}), 400
+            return jsonify({"error": "Please provide a message"}), 400
         
         logger.info(f"💬 Processing: {user_message[:50]}...")
         
-        # Check if user wants to generate an image
+        # Check for image requests
         if detect_image_request(user_message):
-            image_prompt = extract_prompt(user_message, "image")
-            enhanced_prompt = enhance_prompt_with_kiswahili(image_prompt)
+            prompt = extract_prompt(user_message, "image")
+            enhanced_prompt = enhance_prompt_with_kiswahili(prompt)
             
             return jsonify({
-                "response": f"🎨 I'll generate an image for: '{enhanced_prompt}'. Use the image generation feature!",
-                "image_suggestion": enhanced_prompt,
+                "response": f"🎨 I can generate an image of '{enhanced_prompt}' for you! Use the image generation endpoint.",
+                "suggestion": enhanced_prompt,
                 "status": "success",
-                "suggest_image": True,
-                "response_time": round(time.time() - start_time, 2)
+                "suggest_image": True
             })
         
-        # Check if user wants to generate a video
+        # Check for video requests
         if detect_video_request(user_message):
-            video_prompt = extract_prompt(user_message, "video")
+            prompt = extract_prompt(user_message, "video")
             
             return jsonify({
-                "response": f"🎬 I can create a video for: '{video_prompt}'. Use the video generation feature!",
-                "video_suggestion": video_prompt,
+                "response": f"🎬 I can create a video of '{prompt}' for you! Use the video generation endpoint.",
+                "suggestion": prompt,
                 "status": "success",
-                "suggest_video": True,
-                "response_time": round(time.time() - start_time, 2)
+                "suggest_video": True
             })
         
         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()),
-            "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,
+            "cultural_context": detect_kiswahili_context(response),
             "creator": "Stanley Samwel Owino"
         })
         
     except Exception as e:
         logger.error(f"Chat error: {e}")
         return jsonify({
-            "error": f"Pole! Processing error: {str(e)}",
+            "error": f"Sorry! Processing error: {str(e)}",
             "status": "error"
         }), 500
 
 @app.route('/api/generate-image', methods=['POST'])
 def generate_image_endpoint():
-    """Generate images using Hugging Face"""
+    """Generate images using Hugging Face API"""
     try:
         start_time = time.time()
         data = request.get_json()
         prompt = data.get('prompt', '')
         
         if not prompt:
-            return jsonify({"error": "Tafadhali provide a prompt"}), 400
+            return jsonify({"error": "Please provide a prompt"}), 400
         
-        # Enhance prompt with cultural context
+        # Enhance prompt
         enhanced_prompt = enhance_prompt_with_kiswahili(prompt)
-        
         logger.info(f"🎨 Generating image: {enhanced_prompt[:50]}...")
         
         # Generate image
@@ -780,93 +657,31 @@ def generate_image_endpoint():
                 "status": "success",
                 "generation_time": generation_time,
                 "provider": "hugging_face",
-                "cultural_enhancement": enhanced_prompt != prompt,
-                "creator": "Stanley Samwel Owino"
-            })
-        else:
-            return jsonify({
-                "error": "Pole! Image generation service is busy",
-                "status": "error",
-                "suggestion": "Try again in a moment or use a simpler description"
-            }), 500
-            
-    except Exception as e:
-        logger.error(f"Image endpoint error: {e}")
-        return jsonify({
-            "error": f"Pole! Image generation failed: {str(e)}",
-            "status": "error"
-        }), 500
-
-@app.route('/api/generate-cultural-image', methods=['POST'])
-def generate_cultural_image():
-    """Generate images with specific Kiswahili cultural themes"""
-    try:
-        data = request.get_json()
-        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 = {
-            'safari': 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"
-        }
-        
-        base_template = cultural_templates.get(style, f"East African {theme}, cultural, vibrant")
-        
-        # 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'
-        }
-        
-        final_prompt = f"{base_template}, {modifiers.get(style, 'vibrant colors')}"
-        
-        image_data = generate_image_huggingface(final_prompt)
-        
-        if image_data:
-            return jsonify({
-                "image": image_data,
-                "theme": theme,
-                "style": style,
-                "prompt": final_prompt,
-                "status": "success",
-                "cultural_context": "kiswahili_theme",
                 "creator": "Stanley Samwel Owino"
             })
         else:
             return jsonify({
-                "error": "Pole! Cultural image generation failed",
+                "error": "Image generation service is busy. Please try again.",
                 "status": "error"
             }), 500
             
     except Exception as e:
+        logger.error(f"Image endpoint error: {e}")
         return jsonify({
-            "error": f"Pole! Cultural image error: {str(e)}",
+            "error": f"Image generation failed: {str(e)}",
             "status": "error"
         }), 500
 
-# ============================================================================
-# VIDEO GENERATION ROUTES (NEW)
-# ============================================================================
-
 @app.route('/api/generate-video', methods=['POST'])
 def generate_video_endpoint():
-    """Generate FREE videos from text prompts"""
+    """Generate FREE videos from text"""
     try:
         start_time = time.time()
         data = request.get_json()
         prompt = data.get('prompt', '')
         
         if not prompt:
-            return jsonify({"error": "Tafadhali provide a video prompt"}), 400
+            return jsonify({"error": "Please provide a video prompt"}), 400
         
         logger.info(f"🎬 Generating video: {prompt[:50]}...")
         
@@ -883,71 +698,60 @@ def generate_video_endpoint():
                 "generation_time": generation_time,
                 "provider": "hugging_face_free",
                 "format": "mp4",
-                "duration": "3-4 seconds",
+                "duration": "3 seconds",
                 "resolution": "576x320",
                 "creator": "Stanley Samwel Owino"
             })
         else:
             return jsonify({
-                "error": "Pole! Video generation service is busy. Try again in a moment.",
+                "error": "Video generation service is busy. Try again in a moment.",
                 "status": "error",
-                "suggestion": "Try a simpler description or use image generation instead"
+                "suggestion": "Try a simpler description"
             }), 500
             
     except Exception as e:
         logger.error(f"Video endpoint error: {e}")
         return jsonify({
-            "error": f"Pole! Video generation failed: {str(e)}",
+            "error": f"Video generation failed: {str(e)}",
             "status": "error"
         }), 500
 
 @app.route('/api/generate-cultural-video', methods=['POST'])
 def generate_cultural_video_endpoint():
-    """Generate videos with specific Kiswahili cultural themes"""
+    """Generate cultural theme videos"""
     try:
         start_time = time.time()
         data = request.get_json()
         theme = data.get('theme', 'safari')
         style = data.get('style', 'animated')
         
-        logger.info(f"🌍 Generating cultural video: {theme} ({style} style)")
+        logger.info(f"🌍 Generating cultural video: {theme} ({style})")
         
-        # Generate cultural video
+        # Generate video
         video_data = video_gen.create_cultural_video(theme, style)
         
         if video_data:
             generation_time = round(time.time() - start_time, 2)
             
-            theme_descriptions = {
-                "safari": "African wildlife and savanna landscape",
-                "dance": "Traditional African dance celebration",
-                "market": "Vibrant African market scene",
-                "coastal": "Swahili coast with ocean views",
-                "wildlife": "African wildlife documentary style",
-                "village": "Traditional village life in Africa"
-            }
-            
             return jsonify({
                 "video": video_data,
                 "theme": theme,
                 "style": style,
-                "description": theme_descriptions.get(theme, "Cultural scene"),
                 "status": "success",
                 "generation_time": generation_time,
-                "cultural_context": True,
                 "creator": "Stanley Samwel Owino"
             })
         else:
             return jsonify({
-                "error": "Pole! Cultural video generation failed",
+                "error": "Cultural video generation failed",
                 "status": "error",
-                "suggestion": "Try a different theme: safari, dance, market, coastal, wildlife, or village"
+                "suggestion": "Try themes: safari, dance, market, coastal, wildlife"
             }), 500
             
     except Exception as e:
         logger.error(f"Cultural video error: {e}")
         return jsonify({
-            "error": f"Pole! Cultural video failed: {str(e)}",
+            "error": f"Cultural video failed: {str(e)}",
             "status": "error"
         }), 500
 
@@ -960,11 +764,11 @@ def animate_text_endpoint():
         text = data.get('text', 'Stanley AI')
         
         if not text:
-            return jsonify({"error": "Tafadhali provide text to animate"}), 400
+            return jsonify({"error": "Please provide text to animate"}), 400
         
         logger.info(f"✨ Animating text: {text}")
         
-        # Generate text animation
+        # Generate animation
         video_data = video_gen.create_text_animation(text)
         
         if video_data:
@@ -981,54 +785,40 @@ def animate_text_endpoint():
             })
         else:
             return jsonify({
-                "error": "Pole! Text animation failed",
+                "error": "Text animation failed",
                 "status": "error"
             }), 500
             
     except Exception as e:
         logger.error(f"Text animation error: {e}")
         return jsonify({
-            "error": f"Pole! Text animation failed: {str(e)}",
+            "error": f"Text animation failed: {str(e)}",
             "status": "error"
         }), 500
 
 @app.route('/api/quick-chat', methods=['POST'])
 def quick_chat():
-    """Faster chat endpoint for simple queries"""
+    """Fast responses for common queries"""
     try:
         data = request.get_json()
         user_message = data.get('message', '')
         
         if not user_message:
-            return jsonify({"error": "Tafadhali provide a message"}), 400
+            return jsonify({"error": "Please provide a message"}), 400
         
-        # Enhanced quick responses with video info
         quick_responses = {
-            '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: 1) Majibu ya maswali, 2) Kutengeneza picha, 3) Kutengeneza VIDEO, 4) Kufundisha Kiswahili, 5) Kushiriki hekima za Kiafrika.',
-            '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.',
-            'can you make videos': 'Ndio! I can create FREE videos from text. Try "generate video of African sunset" or use the video generation endpoint.',
-            'video capabilities': 'I can generate: 1) Text-to-video (FREE), 2) Cultural theme videos, 3) Text animations, 4) 4-second videos at 576x320 resolution.',
-            'make a video': 'Sure! Describe what you want: "create video of wildlife" or use the video generation feature. All videos are FREE!',
-            'habari': 'Nzuri sana! Asante kwa kuuliza. Habari yako?',
-            'asante': 'Karibu sana! Ni furaha yangu kukusaidia.',
-            'jambo': 'Jambo! Habari yako? Una swali gani kwa leo?',
-            'mambo': 'Poa! Vipi wewe? Ninaweza kukusaidia nini?',
-            '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.',
-            'generate': 'I can generate images and videos! Try: "generate image of sunset" or "create video of wildlife".',
-            'create': 'I can create content for you! Try: "create image of mountain" or "make video of city".'
+            '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!'
         }
         
         msg_lower = user_message.lower().strip()
-        
-        # Check for exact matches
         if msg_lower in quick_responses:
             return jsonify({
                 "response": quick_responses[msg_lower],
@@ -1037,101 +827,52 @@ def quick_chat():
                 "creator": "Stanley Samwel Owino"
             })
         
-        # Check for partial matches
-        for key, response in quick_responses.items():
-            if key in msg_lower and len(key) > 3:
-                return jsonify({
-                    "response": response,
-                    "status": "success",
-                    "quick_response": True,
-                    "creator": "Stanley Samwel Owino"
-                })
-        
-        # If no quick response, use normal chat
         return chat()
         
     except Exception as e:
         return jsonify({
-            "error": f"Pole! Quick chat error: {str(e)}",
+            "error": f"Quick chat error: {str(e)}",
             "status": "error"
         }), 500
 
 @app.route('/api/system/status')
 def system_status():
-    """System status with enhanced video info"""
+    """System status information"""
     return jsonify({
         "status": "operational",
         "creator": "Stanley Samwel Owino",
         "role": "Machine Learning Engineer",
         "location": "Kenya, East Africa",
-        "model_loaded": model_loaded,
-        "hugging_face_available": True,
-        "video_generation_available": True,
-        "cache_size": len(response_cache),
+        "version": "3.0",
         "features": [
-            "Text Generation",
-            "Image Generation", 
+            "Text Generation via API",
+            "Image Generation",
             "Video Generation (FREE)",
-            "Kiswahili Knowledge",
-            "Cultural Integration",
-            "Fast Responses"
-        ],
-        "video_capabilities": [
-            "Text-to-Video: 576x320, 8fps, 4s",
-            "Cultural Themes: Safari, Dance, Market, Coastal",
-            "Text Animations",
-            "FREE using Hugging Face API"
-        ],
-        "optimizations": [
-            "Response Caching",
-            "API Fallbacks",
-            "Quick Responses",
-            "Cultural Prompts",
-            "Enhanced Video Prompts"
+            "Kiswahili Cultural AI"
         ],
-        "endpoints": [
-            "/api/chat - Text chat",
-            "/api/generate-image - Image generation",
-            "/api/generate-video - Video generation",
-            "/api/generate-cultural-video - Cultural videos",
-            "/api/animate-text - Text animations"
-        ]
+        "video_info": {
+            "resolution": "576x320",
+            "fps": 8,
+            "duration": "3 seconds",
+            "free": True,
+            "themes": ["safari", "dance", "market", "coastal", "wildlife"]
+        }
     })
 
-@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,
-            "creator": "Stanley Samwel Owino"
-        })
-    except Exception as e:
-        return jsonify({
-            "error": f"Cache clearance failed: {str(e)}",
-            "status": "error"
-        }), 500
-
-# Kiswahili knowledge endpoints
 @app.route('/api/kiswahili/proverbs')
 def get_proverbs():
-    """Get random Swahili proverbs"""
+    """Get Swahili proverbs"""
     proverbs = [
-        {"swahili": "Mwacha mila ni mtumwa.", "english": "He who abandons his culture is a slave.", "meaning": "Cherish your cultural heritage"},
-        {"swahili": "Haraka haraka haina baraka.", "english": "Hurry hurry has no blessing.", "meaning": "Patience yields better results"},
-        {"swahili": "Asiyesikia la mkuu huvunjika guu.", "english": "He who does not listen to elders breaks a leg.", "meaning": "Respect and learn from experience"},
-        {"swahili": "Mwenye pupa hadiriki kula tamu.", "english": "The impatient one misses out on sweetness.", "meaning": "Good things come to those who wait"},
-        {"swahili": "Ukiona vyaelea, vimeundwa.", "english": "If you see things floating, they were made to float.", "meaning": "Everything happens for a reason"}
+        "Mwacha mila ni mtumwa.",
+        "Haraka haraka haina baraka.",
+        "Asiyesikia la mkuu huvunjika guu.",
+        "Mwenye pupa hadiriki kula tamu.",
+        "Ukiona vyaelea, vimeundwa."
     ]
     return jsonify({
         "proverb": random.choice(proverbs),
         "language": "Kiswahili",
-        "origin": "East Africa",
+        "meaning": "East African cultural wisdom",
         "creator": "Stanley Samwel Owino"
     })
 
@@ -1139,81 +880,35 @@ def get_proverbs():
 def get_phrases():
     """Get common Swahili phrases"""
     phrases = {
-        "greetings": {
-            "Habari": "Hello / How are you?",
-            "Nzuri": "Good / Fine",
-            "Asante": "Thank you",
-            "Karibu": "Welcome / You're welcome",
-            "Tafadhali": "Please",
-            "Samahani": "Excuse me / Sorry",
-            "Kwaheri": "Goodbye",
-            "Lala salama": "Sleep well"
-        },
-        "questions": {
-            "Unaitwa nani?": "What is your name?",
-            "Unatoka wapi?": "Where are you from?",
-            "Unaishi wapi?": "Where do you live?",
-            "Unafanya nini?": "What do you do?"
-        },
-        "responses": {
-            "Ninaitwa...": "My name is...",
-            "Ninatoka Kenya": "I am from Kenya",
-            "Naishi Nairobi": "I live in Nairobi",
-            "Mimi ni mwanafunzi": "I am a student"
-        },
-        "lion_king": {
-            "Simba": "Lion",
-            "Rafiki": "Friend",
-            "Pumbaa": "Simpleton / Foolish",
-            "Shenzi": "Uncouth / Barbaric",
-            "Hakuna Matata": "No worries / No problems"
-        }
+        "Hello": "Habari",
+        "Thank you": "Asante",
+        "Welcome": "Karibu",
+        "Goodbye": "Kwaheri",
+        "Please": "Tafadhali",
+        "Yes": "Ndio",
+        "No": "Hapana"
     }
     return jsonify({
         "phrases": phrases,
         "language": "Kiswahili",
         "region": "East Africa",
-        "creator": "Stanley Samwel Owino",
-        "note": "Swahili is spoken by over 200 million people"
-    })
-
-@app.route('/api/video/info')
-def video_info():
-    """Get information about video generation"""
-    return jsonify({
-        "video_generation": "FREE using Hugging Face API",
-        "models": ["cerspense/zeroscope_v2_576w"],
-        "resolution": "576x320 pixels",
-        "frame_rate": "8 fps",
-        "duration": "3-4 seconds",
-        "max_frames": 24,
-        "formats": ["MP4"],
-        "cultural_themes": ["safari", "dance", "market", "coastal", "wildlife", "village"],
-        "creator": "Stanley Samwel Owino",
-        "note": "All video generation is completely FREE. May take 30-60 seconds to generate."
+        "creator": "Stanley Samwel Owino"
     })
 
 if __name__ == '__main__':
-    print("🚀 STANLEY AI v3.0 - Complete Edition")
+    print("🚀 STANLEY AI v3.0 - Simplified Edition")
     print("👨‍💻 Created by: Stanley Samwel Owino - Machine Learning Engineer")
     print("📍 Location: Kenya, East Africa")
-    print("🌍 Kiswahili Knowledge: Active")
-    print("🎬 Video Generation: FREE Hugging Face API")
-    print("🎨 Image Generation: Active")
-    print("⚡ Performance: Optimized with Caching")
-    print("=" * 60)
+    print("🌍 Features: Text, Image, and FREE Video Generation")
+    print("⚡ Status: Ready")
+    print("=" * 50)
     print("API Endpoints:")
-    print("1. /api/chat - Text chat with AI")
-    print("2. /api/generate-image - Generate images from text")
-    print("3. /api/generate-video - FREE video generation")
-    print("4. /api/generate-cultural-video - Cultural theme videos")
-    print("5. /api/animate-text - Animated text videos")
-    print("6. /api/quick-chat - Fast responses")
-    print("7. /api/kiswahili/* - Kiswahili learning")
-    print("8. /api/system/status - System information")
-    print("9. /api/video/info - Video generation details")
-    print("=" * 60)
-    print("🌐 Access your AI at: http://localhost:7860")
-    print("=" * 60)
+    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)
     
     app.run(debug=True, host='0.0.0.0', port=7860, threaded=True)