Refactor app.py into modular architecture

- Created config.py for configuration and constants
- Created database.py for database operations
- Created email_service.py for email functionality
- Created ai_services.py for AI/ML related functions
- Created content_generators.py for lesson plan and quiz generation
- Created ui_components.py for Gradio interface components
- Created utils.py for utility functions
- Created app_modular.py as new main entry point
- Updated generate_image_with_huggingface with improved error handling and multiple model fallbacks
- Improved code organization and maintainability

ai_services.py

@@ -0,0 +1,280 @@
+"""
+AI services module for BrightMind AI
+Handles all AI/ML related functionality including Hugging Face API calls and image generation
+"""
+
+import requests
+import base64
+from config import HF_TOKEN, HUGGINGFACE_HEADERS
+
+
+def call_hugging_face_api(prompt):
+    """Call Hugging Face API for Albert chatbot"""
+    if not HF_TOKEN:
+        return None
+    
+    headers = {
+        "Authorization": f"Bearer {HF_TOKEN}",
+        "Content-Type": "application/json"
+    }
+    
+    data = {
+        "model": "deepseek-ai/DeepSeek-V3-0324",
+        "messages": [
+            {
+                "role": "user",
+                "content": prompt
+            }
+        ],
+        "max_tokens": 200,
+        "temperature": 0.7
+    }
+    
+    try:
+        response = requests.post(
+            "https://router.huggingface.co/v1/chat/completions",
+            headers=headers,
+            json=data,
+            timeout=30
+        )
+        
+        if response.status_code == 200:
+            result = response.json()
+            return result['choices'][0]['message']['content']
+        else:
+            print(f"❌ Albert API error: {response.status_code}")
+            return None
+    except Exception as e:
+        print(f"❌ Albert API error: {str(e)}")
+        return None
+
+
+def call_hugging_face_api_content(prompt):
+    """Call Hugging Face API for content generation with more tokens"""
+    if not HF_TOKEN:
+        return None
+    
+    headers = {
+        "Authorization": f"Bearer {HF_TOKEN}",
+        "Content-Type": "application/json"
+    }
+    
+    data = {
+        "model": "deepseek-ai/DeepSeek-V3-0324",
+        "messages": [
+            {
+                "role": "user",
+                "content": prompt
+            }
+        ],
+        "max_tokens": 1000,  # More tokens for content generation
+        "temperature": 0.7
+    }
+    
+    try:
+        print(f"🌐 Making API call for content generation...")
+        print(f"🔗 Endpoint: https://router.huggingface.co/v1/chat/completions")
+        print(f"🔑 Token available: {HF_TOKEN is not None}")
+        print(f"📝 Prompt length: {len(prompt)} characters")
+        
+        response = requests.post(
+            "https://router.huggingface.co/v1/chat/completions",
+            headers=headers,
+            json=data,
+            timeout=60  # Longer timeout for content generation
+        )
+        
+        print(f"📊 Response status: {response.status_code}")
+        
+        if response.status_code == 200:
+            result = response.json()
+            content = result['choices'][0]['message']['content']
+            print(f"✅ Content generation successful! Length: {len(content)} characters")
+            return content
+        else:
+            print(f"❌ Content API error: {response.status_code}")
+            print(f"❌ Response: {response.text}")
+            return None
+    except Exception as e:
+        print(f"❌ Content API error: {str(e)}")
+        return None
+
+
+def generate_image_with_huggingface(prompt, topic, content_type):
+    """Generate image using only Hugging Face Inference API models"""
+    try:
+        if not HF_TOKEN:
+            print("No HF_TOKEN available for image generation")
+            return None
+            
+        headers = {
+            "Authorization": f"Bearer {HF_TOKEN}",
+            "Content-Type": "application/json"
+        }
+        
+        # Models available on Hugging Face Inference API
+        models = [
+            "runwayml/stable-diffusion-v1-5",
+            "CompVis/stable-diffusion-v1-4", 
+            "stabilityai/stable-diffusion-2-1",
+            "prompthero/openjourney",
+            "dreamlike-art/dreamlike-diffusion-1.0"
+        ]
+        
+        # Simple prompt optimized for educational content
+        clean_prompt = f"educational diagram of {topic}, simple illustration, clean design, white background"
+        
+        print(f"Generating image for: {topic}")
+        print(f"Using prompt: {clean_prompt}")
+        
+        for model_name in models:
+            try:
+                print(f"Trying model: {model_name}")
+                
+                # Use the correct API format for HF Inference API
+                payload = {"inputs": clean_prompt}
+                
+                response = requests.post(
+                    f"https://api-inference.huggingface.co/models/{model_name}",
+                    headers=headers,
+                    json=payload,
+                    timeout=60
+                )
+                
+                print(f"Response status: {response.status_code}")
+                
+                if response.status_code == 200:
+                    content_length = len(response.content)
+                    print(f"Content length: {content_length} bytes")
+                    
+                    # Check if we got actual image data (not error JSON)
+                    if content_length > 5000:
+                        try:
+                            # Try to decode as JSON first to check for errors
+                            json_response = response.json()
+                            if "error" in json_response:
+                                print(f"API error: {json_response['error']}")
+                                continue
+                        except:
+                            # If it's not JSON, it should be binary image data
+                            import base64
+                            image_base64 = base64.b64encode(response.content).decode('utf-8')
+                            print(f"Successfully generated image with {model_name}")
+                            return f"data:image/png;base64,{image_base64}"
+                    else:
+                        print("Response too small, likely an error")
+                        
+                elif response.status_code == 503:
+                    # Model is loading - this is common on first request
+                    try:
+                        error_info = response.json()
+                        if "estimated_time" in error_info:
+                            print(f"Model loading, estimated time: {error_info['estimated_time']} seconds")
+                        else:
+                            print("Model is currently loading")
+                    except:
+                        print("Model unavailable (503)")
+                    continue
+                    
+                elif response.status_code == 401:
+                    print("Authentication failed - invalid HF_TOKEN")
+                    break
+                    
+                else:
+                    print(f"HTTP {response.status_code}: {response.text[:200]}")
+                    
+            except requests.exceptions.Timeout:
+                print(f"Timeout with model {model_name}")
+                continue
+            except Exception as model_error:
+                print(f"Error with model {model_name}: {str(model_error)}")
+                continue
+        
+        print("All models failed or unavailable")
+        return None
+        
+    except Exception as e:
+        print(f"Critical error in image generation: {str(e)}")
+        return None
+
+
+def get_educational_image_url(topic, description, content_type):
+    """Get educational image URL using Hugging Face generation first, then fallbacks"""
+    try:
+        # Create a detailed prompt for image generation
+        image_prompt = f"Educational illustration of {topic}, {description}, {content_type}, clean diagram, colorful, professional, suitable for middle school students"
+        
+        print(f"🎨 Generating image with prompt: {image_prompt}")
+        
+        # Try to generate image with Hugging Face first
+        generated_image = generate_image_with_huggingface(image_prompt, topic, content_type)
+        
+        if generated_image:
+            print(f"✅ Generated image successfully")
+            return generated_image
+        
+        # Fallback to reliable sources if generation fails
+        print("🔄 Image generation failed, using fallback sources")
+        
+        educational_sources = [
+            # 1. Lorem Picsum (reliable placeholder)
+            f"https://picsum.photos/800/600?random={hash(topic) % 1000}",
+            
+            # 2. Placeholder with educational styling
+            f"https://via.placeholder.com/800x600/667eea/ffffff?text={topic.replace(' ', '+')}+Educational+Content",
+            
+            # 3. Educational diagram generator
+            f"https://via.placeholder.com/800x600/4f46e5/ffffff?text={content_type.replace(' ', '+')}+{topic.replace(' ', '+')}",
+        ]
+        
+        # Try each fallback source
+        for i, url in enumerate(educational_sources):
+            try:
+                print(f"🔍 Trying fallback source {i+1}: {url}")
+                response = requests.head(url, timeout=5)
+                if response.status_code == 200:
+                    print(f"✅ Found working fallback image: {url}")
+                    return url
+            except:
+                continue
+        
+        # Final fallback
+        return f"https://via.placeholder.com/800x600/667eea/ffffff?text={topic.replace(' ', '+')}+{content_type.replace(' ', '+')}"
+    
+    except Exception as e:
+        print(f"❌ Image URL generation error: {str(e)}")
+        return f"https://via.placeholder.com/800x600/667eea/ffffff?text={topic.replace(' ', '+')}+{content_type.replace(' ', '+')}"
+
+
+def generate_real_image(description, topic, content_type):
+    """Generate actual image for educational content"""
+    try:
+        # Try to generate image with Hugging Face
+        image_data = generate_image_with_huggingface(description, topic, content_type)
+        
+        if image_data:
+            return f'\n<img src="{image_data}" alt="{description}" style="max-width: 100%; height: auto; border-radius: 8px; margin: 20px 0;">\n'
+        else:
+            # Fallback to text placeholder
+            return f"\n**[📸 Image: {description}]**\n*Visual content would appear here*\n"
+    
+    except Exception as e:
+        return f"\n**[📸 Image: {description}]**\n*Visual content would appear here*\n"
+
+
+def generate_image_placeholder(description, topic, content_type):
+    """Generate image placeholder with description for educational content (fallback)"""
+    # Create a structured image placeholder that can be replaced with real images
+    image_placeholder = f"""
+<div style="border: 2px dashed #667eea; padding: 20px; margin: 20px 0; text-align: center; background: linear-gradient(135deg, #f8f9fa 0%, #e9ecef 100%); border-radius: 12px;">
+    <div style="font-size: 48px; margin-bottom: 10px;">🖼️</div>
+    <h3 style="color: #667eea; margin: 10px 0;">📸 Image Placeholder</h3>
+    <p style="color: #4a5568; margin: 10px 0;"><strong>Description:</strong> {description}</p>
+    <p style="color: #718096; font-size: 14px; margin: 5px 0;"><strong>Topic:</strong> {topic}</p>
+    <p style="color: #718096; font-size: 14px; margin: 5px 0;"><strong>Content Type:</strong> {content_type}</p>
+    <div style="background: #667eea; color: white; padding: 8px 16px; border-radius: 6px; display: inline-block; margin-top: 10px; font-size: 12px;">
+        💡 This image would enhance the learning experience
+    </div>
+</div>
+"""
+    return image_placeholder

app_modular.py

@@ -0,0 +1,37 @@
+"""
+BrightMind AI - Modular Educational Assistant
+Main application file using modular architecture
+"""
+
+import gradio as gr
+from config import debug_token_status
+from database import init_database
+from ui_components import create_main_interface
+
+
+def main():
+    """Main application entry point"""
+    
+    # Debug token status
+    debug_token_status()
+    
+    # Initialize database
+    print("🔧 Initializing database...")
+    init_database()
+    
+    # Create and launch the interface
+    print("🚀 Starting BrightMind AI...")
+    interface = create_main_interface()
+    
+    # Launch the application
+    interface.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=False,
+        debug=True,
+        show_error=True
+    )
+
+
+if __name__ == "__main__":
+    main()

config.py

@@ -0,0 +1,65 @@
+"""
+Configuration module for BrightMind AI
+Contains all configuration constants and environment variables
+"""
+
+import os
+
+# Get Hugging Face token from environment variable
+HF_TOKEN = os.getenv("HUGGINGFACE_TOKEN")
+
+# Database configuration
+DATABASE_FILE = "feedback.db"
+
+# Email configuration (private)
+FEEDBACK_EMAIL = "mahdi@brightmind-ai.com"
+SMTP_SERVER = "smtp.gmail.com"
+SMTP_PORT = 587
+SMTP_USERNAME = os.getenv("SMTP_USERNAME", "")
+SMTP_PASSWORD = os.getenv("SMTP_PASSWORD", "")
+
+# Debug token detection
+def debug_token_status():
+    """Print debug information about token status"""
+    print(f"🔍 Token detection debug:")
+    print(f"   - HF_TOKEN exists: {HF_TOKEN is not None}")
+    print(f"   - HF_TOKEN length: {len(HF_TOKEN) if HF_TOKEN else 0}")
+    print(f"   - HF_TOKEN starts with hf_: {HF_TOKEN.startswith('hf_') if HF_TOKEN else False}")
+    print(f"   - SMTP configured: {SMTP_USERNAME != '' and SMTP_PASSWORD != ''}")
+
+# Hugging Face API configuration
+HUGGINGFACE_API_URL = "https://api-inference.huggingface.co/models/microsoft/DialoGPT-medium"
+HUGGINGFACE_HEADERS = {
+    "Authorization": f"Bearer {HF_TOKEN}" if HF_TOKEN else None
+}
+
+# Content generation settings
+DEFAULT_DIFFICULTY = "intermediate"
+DEFAULT_QUESTION_COUNT = 5
+DEFAULT_DURATION = 60
+
+# UI Configuration
+PROGRESS_HTML = """
+<div class="progress-container">
+    <div class="generation-status">🤖 Generating your lesson plan...</div>
+    <div class="progress-bar">
+        <div class="progress-fill"></div>
+    </div>
+    <div class="generation-status">Analyzing requirements and creating content...</div>
+</div>
+"""
+
+COMPLETION_HTML = """
+<div class="progress-container">
+    <div class="generation-status">✅ Lesson Plan Generated Successfully!</div>
+</div>
+"""
+
+FALLBACK_HTML = """
+<div class="progress-container">
+    <div class="generation-status">🔄 Using educational algorithms...</div>
+    <div class="progress-bar">
+        <div class="progress-fill"></div>
+    </div>
+</div>
+"""

content_generators.py

@@ -0,0 +1,643 @@
+"""
+Content generators module for BrightMind AI
+Handles lesson plan and quiz generation functionality
+"""
+
+from config import HF_TOKEN, PROGRESS_HTML, COMPLETION_HTML, FALLBACK_HTML
+from ai_services import call_hugging_face_api_content
+from utils import typewriter_effect, process_content_with_images, apply_content_styling
+
+
+def generate_lesson_plan_with_progress(topic, subject, grade_level, duration, difficulty="intermediate"):
+    """Generate a lesson plan with progress updates"""
+    
+    # Show progress bar
+    yield PROGRESS_HTML, ""
+    
+    print(f"🚀 Starting lesson plan generation for: {topic}")
+    print(f"📚 Subject: {subject}, Grade: {grade_level}, Duration: {duration}min")
+    
+    # Try Hugging Face API first if token is available
+    if HF_TOKEN:
+        print("🤖 Token found! Attempting Hugging Face API call...")
+        try:
+            prompt = f"""Create a comprehensive lesson plan for:
+Topic: {topic}
+Subject: {subject}
+Grade Level: {grade_level}
+Duration: {duration} minutes
+Difficulty: {difficulty}
+
+Include:
+1. Learning objectives
+2. Activities with time allocations
+3. Materials needed
+4. Assessment methods
+5. Differentiation strategies
+6. Educational standards
+7. Real-world connections
+8. Extension activities
+
+Make it practical, engaging, and ready for classroom use."""
+
+            result = call_hugging_face_api_content(prompt)
+            
+            if result:
+                print("✅ Successfully generated with Hugging Face API")
+                
+                # Show completion and return result
+                yield COMPLETION_HTML, result
+            else:
+                print("❌ API call returned no content, falling back to algorithms")
+                raise Exception("No content returned from API")
+            
+        except Exception as e:
+            print(f"❌ Hugging Face API failed: {e}")
+            print("🔄 Falling back to educational algorithms...")
+            
+            # Show fallback progress
+            yield FALLBACK_HTML, ""
+            
+            result = generate_with_algorithms(topic, subject, grade_level, duration, difficulty)
+            print("✅ Generated with educational algorithms")
+            
+            # Show completion
+            yield COMPLETION_HTML, result
+    else:
+        print("⚠️ No Hugging Face token found, using educational algorithms...")
+        
+        # Show progress for algorithms
+        yield FALLBACK_HTML, ""
+        
+        result = generate_with_algorithms(topic, subject, grade_level, duration, difficulty)
+        print("✅ Generated with educational algorithms")
+        
+        # Show completion
+        yield COMPLETION_HTML, result
+
+
+def generate_lesson_plan(topic, subject, grade_level, duration, difficulty="intermediate"):
+    """Generate a lesson plan using Hugging Face API or fallback algorithms"""
+    
+    print(f"🚀 Starting lesson plan generation for: {topic}")
+    print(f"📚 Subject: {subject}, Grade: {grade_level}, Duration: {duration}min")
+    
+    # Try Hugging Face API first if token is available
+    if HF_TOKEN:
+        print("🤖 Token found! Attempting Hugging Face API call...")
+        try:
+            result = generate_with_hugging_face(topic, subject, grade_level, duration, difficulty)
+            print("✅ Successfully generated with Hugging Face API")
+            return result
+        except Exception as e:
+            print(f"❌ Hugging Face API failed: {e}")
+            print("🔄 Falling back to educational algorithms...")
+    else:
+        print("⚠️ No Hugging Face token found, using educational algorithms...")
+    
+    # Fallback to educational algorithms
+    result = generate_with_algorithms(topic, subject, grade_level, duration, difficulty)
+    print("✅ Generated with educational algorithms")
+    return result
+
+
+def generate_with_hugging_face(topic, subject, grade_level, duration, difficulty):
+    """Generate lesson plan using Hugging Face API"""
+    prompt = f"""Create a comprehensive lesson plan for:
+Topic: {topic}
+Subject: {subject}
+Grade Level: {grade_level}
+Duration: {duration} minutes
+Difficulty: {difficulty}
+
+Include:
+1. Learning objectives
+2. Activities with time allocations
+3. Materials needed
+4. Assessment methods
+5. Differentiation strategies
+6. Educational standards
+7. Real-world connections
+8. Extension activities
+
+Make it practical, engaging, and ready for classroom use."""
+
+    result = call_hugging_face_api_content(prompt)
+    
+    if result:
+        return format_lesson_plan(result, topic, subject, grade_level, duration, True)
+    else:
+        raise Exception("No content returned from API")
+
+
+def generate_with_algorithms(topic, subject, grade_level, duration, difficulty):
+    """Generate lesson plan using educational algorithms"""
+    
+    # Generate lesson plan components
+    objectives = generate_objectives(topic, grade_level)
+    activities = generate_activities(topic, duration, grade_level)
+    materials = generate_materials(subject, grade_level)
+    assessment = generate_assessment(grade_level)
+    differentiation = generate_differentiation()
+    
+    # Create structured lesson plan
+    lesson_plan = {
+        "topic": topic,
+        "subject": subject,
+        "grade_level": grade_level,
+        "duration": duration,
+        "difficulty": difficulty,
+        "objectives": objectives,
+        "activities": activities,
+        "materials": materials,
+        "assessment": assessment,
+        "differentiation": differentiation
+    }
+    
+    return format_lesson_plan_from_dict(lesson_plan)
+
+
+def generate_objectives(topic, grade):
+    """Generate learning objectives for a topic and grade level"""
+    objectives = [
+        f"Students will understand the key concepts of {topic}",
+        f"Students will be able to explain {topic} in their own words",
+        f"Students will apply knowledge of {topic} to solve problems"
+    ]
+    
+    if grade in ["6th", "7th", "8th"]:
+        objectives.append(f"Students will analyze the relationship between {topic} and real-world applications")
+    elif grade in ["9th", "10th", "11th", "12th"]:
+        objectives.append(f"Students will evaluate different perspectives on {topic}")
+        objectives.append(f"Students will create original work demonstrating understanding of {topic}")
+    
+    return objectives
+
+
+def generate_activities(topic, duration, grade):
+    """Generate activities for a lesson plan"""
+    activities = []
+    
+    # Opening activity (10% of duration)
+    opening_time = max(5, duration // 10)
+    activities.append({
+        "name": f"Introduction to {topic}",
+        "duration": f"{opening_time} minutes",
+        "description": f"Engage students with a thought-provoking question about {topic}"
+    })
+    
+    # Main activities (70% of duration)
+    main_time = int(duration * 0.7)
+    if main_time > 20:
+        activities.append({
+            "name": f"Explore {topic}",
+            "duration": f"{main_time // 2} minutes",
+            "description": f"Hands-on exploration of {topic} concepts"
+        })
+        activities.append({
+            "name": f"Practice with {topic}",
+            "duration": f"{main_time - main_time // 2} minutes",
+            "description": f"Guided practice and application of {topic}"
+        })
+    else:
+        activities.append({
+            "name": f"Learn about {topic}",
+            "duration": f"{main_time} minutes",
+            "description": f"Interactive learning about {topic}"
+        })
+    
+    # Closing activity (20% of duration)
+    closing_time = max(5, duration - opening_time - main_time)
+    activities.append({
+        "name": f"Reflect on {topic}",
+        "duration": f"{closing_time} minutes",
+        "description": f"Students share what they learned about {topic}"
+    })
+    
+    return activities
+
+
+def generate_materials(subject, grade):
+    """Generate materials list for a lesson"""
+    base_materials = [
+        "Whiteboard and markers",
+        "Student notebooks",
+        "Pencils and erasers"
+    ]
+    
+    if subject.lower() in ["science", "biology", "chemistry", "physics"]:
+        base_materials.extend([
+            "Safety goggles",
+            "Lab materials (as needed)",
+            "Scientific calculator"
+        ])
+    elif subject.lower() in ["math", "mathematics", "algebra", "geometry"]:
+        base_materials.extend([
+            "Graph paper",
+            "Ruler and compass",
+            "Calculator"
+        ])
+    elif subject.lower() in ["english", "language arts", "literature"]:
+        base_materials.extend([
+            "Texts or reading materials",
+            "Dictionary",
+            "Highlighters"
+        ])
+    
+    return base_materials
+
+
+def generate_assessment(grade):
+    """Generate assessment methods for a lesson"""
+    assessments = [
+        "Exit ticket with key questions",
+        "Class participation and discussion",
+        "Quick quiz on main concepts"
+    ]
+    
+    if grade in ["9th", "10th", "11th", "12th"]:
+        assessments.append("Short written reflection")
+        assessments.append("Peer review activity")
+    
+    return assessments
+
+
+def generate_differentiation():
+    """Generate differentiation strategies"""
+    return [
+        "Provide visual aids for visual learners",
+        "Offer hands-on activities for kinesthetic learners",
+        "Use audio explanations for auditory learners",
+        "Provide additional support for struggling students",
+        "Offer extension activities for advanced students"
+    ]
+
+
+def format_lesson_plan(content, topic, subject, grade_level, duration, ai_generated):
+    """Format lesson plan content with proper styling"""
+    
+    # Process content with images and math
+    processed_content = process_content_with_images(content, topic, "lesson plan")
+    
+    # Apply content styling
+    styled_content = apply_content_styling(processed_content, "lesson plan")
+    
+    # Add header information
+    header = f"""# 📚 Lesson Plan: {topic}
+
+**Subject:** {subject}  
+**Grade Level:** {grade_level}  
+**Duration:** {duration} minutes  
+**Generated by:** {'AI Assistant' if ai_generated else 'Educational Algorithms'}
+
+---
+
+"""
+    
+    return header + styled_content
+
+
+def format_lesson_plan_from_dict(lesson_plan):
+    """Format lesson plan from dictionary structure"""
+    
+    content = f"""# 📚 Lesson Plan: {lesson_plan['topic']}
+
+**Subject:** {lesson_plan['subject']}  
+**Grade Level:** {lesson_plan['grade_level']}  
+**Duration:** {lesson_plan['duration']} minutes  
+**Difficulty:** {lesson_plan['difficulty']}  
+**Generated by:** Educational Algorithms
+
+---
+
+## 🎯 Learning Objectives
+
+"""
+    
+    for i, objective in enumerate(lesson_plan['objectives'], 1):
+        content += f"{i}. {objective}\n"
+    
+    content += "\n## 📋 Activities\n\n"
+    
+    for activity in lesson_plan['activities']:
+        content += f"### {activity['name']} ({activity['duration']})\n"
+        content += f"{activity['description']}\n\n"
+    
+    content += "## 📦 Materials Needed\n\n"
+    for material in lesson_plan['materials']:
+        content += f"- {material}\n"
+    
+    content += "\n## 📊 Assessment Methods\n\n"
+    for assessment in lesson_plan['assessment']:
+        content += f"- {assessment}\n"
+    
+    content += "\n## 🎨 Differentiation Strategies\n\n"
+    for strategy in lesson_plan['differentiation']:
+        content += f"- {strategy}\n"
+    
+    return content
+
+
+def generate_quiz_with_progress(topic, subject, grade_level, question_count, question_types):
+    """Generate quiz with progress updates"""
+    
+    # Show progress bar
+    yield PROGRESS_HTML, ""
+    
+    print(f"🚀 Starting quiz generation for: {topic}")
+    print(f"📚 Subject: {subject}, Grade: {grade_level}, Questions: {question_count}")
+    
+    # Try Hugging Face API first if token is available
+    if HF_TOKEN:
+        print("🤖 Token found! Attempting Hugging Face API call...")
+        try:
+            result = generate_quiz_with_hugging_face(topic, subject, grade_level, question_count, question_types)
+            print("✅ Successfully generated with Hugging Face API")
+            
+            # Show completion and return result
+            yield COMPLETION_HTML, result
+        except Exception as e:
+            print(f"❌ Hugging Face API failed: {e}")
+            print("🔄 Falling back to educational algorithms...")
+            
+            # Show fallback progress
+            yield FALLBACK_HTML, ""
+            
+            result = generate_quiz_with_algorithms(topic, subject, grade_level, question_count, question_types)
+            print("✅ Generated with educational algorithms")
+            
+            # Show completion
+            yield COMPLETION_HTML, result
+    else:
+        print("⚠️ No Hugging Face token found, using educational algorithms...")
+        
+        # Show progress for algorithms
+        yield FALLBACK_HTML, ""
+        
+        result = generate_quiz_with_algorithms(topic, subject, grade_level, question_count, question_types)
+        print("✅ Generated with educational algorithms")
+        
+        # Show completion
+        yield COMPLETION_HTML, result
+
+
+def generate_quiz(topic, subject, grade_level, question_count, question_types):
+    """Generate quiz using Hugging Face API or fallback algorithms"""
+    
+    print(f"🚀 Starting quiz generation for: {topic}")
+    print(f"📚 Subject: {subject}, Grade: {grade_level}, Questions: {question_count}")
+    
+    # Try Hugging Face API first if token is available
+    if HF_TOKEN:
+        print("🤖 Token found! Attempting Hugging Face API call...")
+        try:
+            result = generate_quiz_with_hugging_face(topic, subject, grade_level, question_count, question_types)
+            print("✅ Successfully generated with Hugging Face API")
+            return result
+        except Exception as e:
+            print(f"❌ Hugging Face API failed: {e}")
+            print("🔄 Falling back to educational algorithms...")
+    else:
+        print("⚠️ No Hugging Face token found, using educational algorithms...")
+    
+    # Fallback to educational algorithms
+    result = generate_quiz_with_algorithms(topic, subject, grade_level, question_count, question_types)
+    print("✅ Generated with educational algorithms")
+    return result
+
+
+def generate_quiz_with_hugging_face(topic, subject, grade_level, question_count, question_types):
+    """Generate quiz using Hugging Face API"""
+    prompt = f"""Create a {question_count}-question quiz about {topic} for {grade_level} grade {subject} students.
+
+Question types to include: {', '.join(question_types)}
+
+Make the questions:
+- Age-appropriate for {grade_level} grade
+- Clear and unambiguous
+- Cover different aspects of {topic}
+- Include a mix of difficulty levels
+- Provide clear answer choices for multiple choice questions
+
+Format each question with:
+1. Question number
+2. Question text
+3. Answer choices (for multiple choice)
+4. Correct answer
+5. Brief explanation
+
+Topic: {topic}
+Subject: {subject}
+Grade: {grade_level}
+Number of questions: {question_count}"""
+
+    result = call_hugging_face_api_content(prompt)
+    
+    if result:
+        return format_quiz(result, topic, subject, grade_level, question_count, True)
+    else:
+        raise Exception("No content returned from API")
+
+
+def generate_quiz_with_algorithms(topic, subject, grade_level, question_count, question_types):
+    """Generate quiz using educational algorithms"""
+    
+    questions = []
+    
+    for i in range(question_count):
+        # Select question type (cycle through available types)
+        question_type = question_types[i % len(question_types)]
+        
+        question = generate_question_by_type(question_type, topic, subject, grade_level, i + 1)
+        questions.append(question)
+    
+    # Create quiz structure
+    quiz = {
+        "topic": topic,
+        "subject": subject,
+        "grade_level": grade_level,
+        "question_count": question_count,
+        "questions": questions
+    }
+    
+    return format_quiz_from_dict(quiz)
+
+
+def generate_question_by_type(question_type, topic, subject, grade, question_number):
+    """Generate a question of specific type"""
+    
+    if question_type == "Multiple Choice":
+        return generate_multiple_choice_question(topic, subject, grade, question_number)
+    elif question_type == "True/False":
+        return generate_true_false_question(topic, subject, grade, question_number)
+    elif question_type == "Short Answer":
+        return generate_short_answer_question(topic, subject, grade, question_number)
+    elif question_type == "Fill in the Blank":
+        return generate_fill_in_blank_question(topic, subject, grade, question_number)
+    else:
+        return generate_multiple_choice_question(topic, subject, grade, question_number)
+
+
+def generate_multiple_choice_question(topic, subject, grade, question_number):
+    """Generate a multiple choice question"""
+    
+    questions = [
+        {
+            "question": f"What is the main concept of {topic}?",
+            "options": [
+                f"The primary idea behind {topic}",
+                f"A secondary aspect of {topic}",
+                f"An unrelated concept to {topic}",
+                f"A complex theory about {topic}"
+            ],
+            "correct": 0,
+            "explanation": f"The main concept of {topic} is the primary idea that students need to understand."
+        },
+        {
+            "question": f"Which of the following best describes {topic}?",
+            "options": [
+                f"A simple explanation of {topic}",
+                f"A complex theory about {topic}",
+                f"An advanced concept in {topic}",
+                f"A basic principle of {topic}"
+            ],
+            "correct": 3,
+            "explanation": f"{topic} is best described as a basic principle that students should learn."
+        }
+    ]
+    
+    selected = questions[question_number % len(questions)]
+    return {
+        "type": "Multiple Choice",
+        "question": selected["question"],
+        "options": selected["options"],
+        "correct_answer": selected["options"][selected["correct"]],
+        "explanation": selected["explanation"]
+    }
+
+
+def generate_true_false_question(topic, subject, grade, question_number):
+    """Generate a true/false question"""
+    
+    questions = [
+        {
+            "question": f"{topic} is an important concept in {subject}.",
+            "answer": True,
+            "explanation": f"Yes, {topic} is indeed an important concept that students need to understand in {subject}."
+        },
+        {
+            "question": f"Understanding {topic} requires advanced knowledge.",
+            "answer": False,
+            "explanation": f"While {topic} can be complex, it can be understood at the {grade} grade level with proper instruction."
+        }
+    ]
+    
+    selected = questions[question_number % len(questions)]
+    return {
+        "type": "True/False",
+        "question": selected["question"],
+        "correct_answer": "True" if selected["answer"] else "False",
+        "explanation": selected["explanation"]
+    }
+
+
+def generate_short_answer_question(topic, subject, grade, question_number):
+    """Generate a short answer question"""
+    
+    questions = [
+        {
+            "question": f"Explain {topic} in your own words.",
+            "explanation": f"Students should provide a clear explanation of {topic} using their own understanding."
+        },
+        {
+            "question": f"What are the key components of {topic}?",
+            "explanation": f"Students should identify and explain the main parts or elements that make up {topic}."
+        }
+    ]
+    
+    selected = questions[question_number % len(questions)]
+    return {
+        "type": "Short Answer",
+        "question": selected["question"],
+        "correct_answer": "Open-ended response",
+        "explanation": selected["explanation"]
+    }
+
+
+def generate_fill_in_blank_question(topic, subject, grade, question_number):
+    """Generate a fill in the blank question"""
+    
+    questions = [
+        {
+            "question": f"_______ is the main concept we learned about {topic}.",
+            "answer": topic,
+            "explanation": f"The blank should be filled with '{topic}' as it's the main concept being studied."
+        },
+        {
+            "question": f"In {subject}, we study _______ to understand {topic}.",
+            "answer": "concepts",
+            "explanation": f"The blank should be filled with 'concepts' as we study various concepts to understand {topic}."
+        }
+    ]
+    
+    selected = questions[question_number % len(questions)]
+    return {
+        "type": "Fill in the Blank",
+        "question": selected["question"],
+        "correct_answer": selected["answer"],
+        "explanation": selected["explanation"]
+    }
+
+
+def format_quiz(content, topic, subject, grade_level, question_count, ai_generated):
+    """Format quiz content with proper styling"""
+    
+    # Process content with images and math
+    processed_content = process_content_with_images(content, topic, "quiz")
+    
+    # Apply content styling
+    styled_content = apply_content_styling(processed_content, "quiz")
+    
+    # Add header information
+    header = f"""# 📝 Quiz: {topic}
+
+**Subject:** {subject}  
+**Grade Level:** {grade_level}  
+**Number of Questions:** {question_count}  
+**Generated by:** {'AI Assistant' if ai_generated else 'Educational Algorithms'}
+
+---
+
+"""
+    
+    return header + styled_content
+
+
+def format_quiz_from_dict(quiz):
+    """Format quiz from dictionary structure"""
+    
+    content = f"""# 📝 Quiz: {quiz['topic']}
+
+**Subject:** {quiz['subject']}  
+**Grade Level:** {quiz['grade_level']}  
+**Number of Questions:** {quiz['question_count']}  
+**Generated by:** Educational Algorithms
+
+---
+
+"""
+    
+    for i, question in enumerate(quiz['questions'], 1):
+        content += f"## Question {i} ({question['type']})\n\n"
+        content += f"{question['question']}\n\n"
+        
+        if question['type'] == "Multiple Choice":
+            for j, option in enumerate(question['options'], 1):
+                content += f"{j}. {option}\n"
+            content += "\n"
+        
+        content += f"**Answer:** {question['correct_answer']}\n\n"
+        content += f"**Explanation:** {question['explanation']}\n\n"
+        content += "---\n\n"
+    
+    return content

database.py

@@ -0,0 +1,143 @@
+"""
+Database module for BrightMind AI
+Handles all database operations including feedback storage and retrieval
+"""
+
+import sqlite3
+from datetime import datetime
+from config import DATABASE_FILE
+
+
+def init_database():
+    """Initialize the SQLite database"""
+    try:
+        conn = sqlite3.connect(DATABASE_FILE)
+        cursor = conn.cursor()
+        
+        # Create feedback table
+        cursor.execute('''
+            CREATE TABLE IF NOT EXISTS feedback (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                timestamp TEXT NOT NULL,
+                feedback_type TEXT NOT NULL,
+                rating INTEGER NOT NULL,
+                comments TEXT NOT NULL,
+                user_email TEXT,
+                created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+            )
+        ''')
+        
+        conn.commit()
+        conn.close()
+        print("✅ Database initialized successfully")
+        return True
+    except Exception as e:
+        print(f"❌ Database initialization error: {e}")
+        return False
+
+
+def save_feedback_to_db(feedback_type, rating, comments, user_email=""):
+    """Save feedback to SQLite database"""
+    try:
+        conn = sqlite3.connect(DATABASE_FILE)
+        cursor = conn.cursor()
+        
+        # Convert feedback_type list to string
+        feedback_type_str = ', '.join(feedback_type) if isinstance(feedback_type, list) else str(feedback_type)
+        
+        cursor.execute('''
+            INSERT INTO feedback (timestamp, feedback_type, rating, comments, user_email)
+            VALUES (?, ?, ?, ?, ?)
+        ''', (
+            datetime.now().isoformat(),
+            feedback_type_str,
+            rating,
+            comments,
+            user_email
+        ))
+        
+        conn.commit()
+        conn.close()
+        print("✅ Feedback saved to database successfully")
+        return True
+    except Exception as e:
+        print(f"❌ Database save error: {e}")
+        return False
+
+
+def get_feedback_stats():
+    """Get feedback statistics for admin"""
+    try:
+        conn = sqlite3.connect(DATABASE_FILE)
+        cursor = conn.cursor()
+        
+        # Get total feedback count
+        cursor.execute('SELECT COUNT(*) FROM feedback')
+        total_feedback = cursor.fetchone()[0]
+        
+        # Get average rating
+        cursor.execute('SELECT AVG(rating) FROM feedback')
+        avg_rating = cursor.fetchone()[0]
+        avg_rating = round(avg_rating, 2) if avg_rating else 0
+        
+        # Get recent feedback (last 5)
+        cursor.execute('''
+            SELECT timestamp, feedback_type, rating, comments, user_email 
+            FROM feedback 
+            ORDER BY created_at DESC 
+            LIMIT 5
+        ''')
+        recent_feedback = cursor.fetchall()
+        
+        conn.close()
+        
+        return {
+            'total_feedback': total_feedback,
+            'avg_rating': avg_rating,
+            'recent_feedback': recent_feedback
+        }
+    except Exception as e:
+        print(f"❌ Database stats error: {e}")
+        return {
+            'total_feedback': 0,
+            'avg_rating': 0,
+            'recent_feedback': []
+        }
+
+
+def view_feedback_admin():
+    """Admin function to view all feedback"""
+    try:
+        conn = sqlite3.connect(DATABASE_FILE)
+        cursor = conn.cursor()
+        
+        cursor.execute('''
+            SELECT id, timestamp, feedback_type, rating, comments, user_email, created_at
+            FROM feedback 
+            ORDER BY created_at DESC
+        ''')
+        
+        feedback_data = cursor.fetchall()
+        conn.close()
+        
+        if not feedback_data:
+            return "No feedback found in database."
+        
+        # Format feedback data
+        result = "# 📊 Feedback Database\n\n"
+        result += f"**Total Feedback Entries:** {len(feedback_data)}\n\n"
+        
+        for entry in feedback_data:
+            id_val, timestamp, feedback_type, rating, comments, user_email, created_at = entry
+            result += f"## Entry #{id_val}\n"
+            result += f"**Date:** {timestamp}\n"
+            result += f"**Type:** {feedback_type}\n"
+            result += f"**Rating:** {rating}/5 ⭐\n"
+            result += f"**Comments:** {comments}\n"
+            result += f"**Email:** {user_email if user_email else 'Not provided'}\n"
+            result += f"**Created:** {created_at}\n"
+            result += "---\n\n"
+        
+        return result
+    except Exception as e:
+        return f"❌ Error accessing database: {str(e)}"

email_service.py

@@ -0,0 +1,101 @@
+"""
+Email service module for BrightMind AI
+Handles email functionality including feedback notifications
+"""
+
+import json
+import smtplib
+from datetime import datetime
+from email.mime.text import MIMEText
+from email.mime.multipart import MIMEMultipart
+from config import FEEDBACK_EMAIL, SMTP_SERVER, SMTP_PORT, SMTP_USERNAME, SMTP_PASSWORD
+from database import save_feedback_to_db
+
+
+def send_feedback_email(feedback_type, rating, comments, user_email=""):
+    """Send feedback email to admin"""
+    
+    if not SMTP_USERNAME or not SMTP_PASSWORD:
+        print("⚠️ SMTP credentials not configured, storing feedback locally")
+        # Store feedback locally if no email configured
+        feedback_data = {
+            "timestamp": datetime.now().isoformat(),
+            "feedback_type": feedback_type,
+            "rating": rating,
+            "comments": comments,
+            "user_email": user_email
+        }
+        
+        # Save to local file
+        try:
+            with open("feedback_log.json", "a") as f:
+                f.write(json.dumps(feedback_data) + "\n")
+            return "✅ Feedback saved successfully! (Email not configured)"
+        except Exception as e:
+            return f"❌ Error saving feedback: {str(e)}"
+    
+    try:
+        # Create message
+        msg = MIMEMultipart()
+        msg['From'] = SMTP_USERNAME
+        msg['To'] = FEEDBACK_EMAIL
+        msg['Subject'] = f"BrightMind AI Feedback - {feedback_type}"
+        
+        # Create email body
+        body = f"""
+        New Feedback Received from BrightMind AI Platform
+        
+        Feedback Type: {', '.join(feedback_type) if isinstance(feedback_type, list) else feedback_type}
+        Rating: {rating}/5
+        User Email: {user_email if user_email else 'Not provided'}
+        Comments: {comments}
+        
+        Timestamp: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}
+        
+        ---
+        This feedback was automatically sent from the BrightMind AI platform.
+        """
+        
+        msg.attach(MIMEText(body, 'plain'))
+        
+        # Send email
+        server = smtplib.SMTP(SMTP_SERVER, SMTP_PORT)
+        server.starttls()
+        server.login(SMTP_USERNAME, SMTP_PASSWORD)
+        text = msg.as_string()
+        server.sendmail(SMTP_USERNAME, FEEDBACK_EMAIL, text)
+        server.quit()
+        
+        print(f"✅ Feedback email sent successfully to {FEEDBACK_EMAIL}")
+        return "✅ Thank you! Your feedback has been sent successfully."
+        
+    except Exception as e:
+        print(f"❌ Error sending feedback email: {str(e)}")
+        return f"❌ Error sending feedback: {str(e)}"
+
+
+def submit_feedback(feedback_type, rating, comments, user_email):
+    """Handle feedback submission"""
+    
+    if not feedback_type:
+        return "❌ Please select at least one feedback type."
+    
+    if not rating:
+        return "❌ Please provide a rating."
+    
+    if not comments.strip():
+        return "❌ Please provide your comments."
+    
+    # Save to database first
+    db_success = save_feedback_to_db(feedback_type, rating, comments, user_email)
+    
+    if not db_success:
+        return "❌ Error saving feedback to database. Please try again."
+    
+    # Try to send email (optional)
+    email_result = send_feedback_email(feedback_type, rating, comments, user_email)
+    
+    if "✅" in email_result:
+        return "✅ Thank you! Your feedback has been saved and sent successfully."
+    else:
+        return "✅ Thank you! Your feedback has been saved successfully. (Email notification not available)"

ui_components.py

@@ -0,0 +1,577 @@
+"""
+UI components module for BrightMind AI
+Contains Gradio interface components and styling
+"""
+
+import gradio as gr
+from config import debug_token_status
+from content_generators import (
+    generate_lesson_plan_with_progress, 
+    generate_quiz_with_progress,
+    generate_content_with_progress
+)
+from email_service import submit_feedback
+from database import get_feedback_stats, view_feedback_admin
+from ai_services import generate_albert_response
+
+
+def create_main_interface():
+    """Create the main Gradio interface"""
+    
+    # Debug token status
+    debug_token_status()
+    
+    # Custom CSS for modern styling
+    custom_css = """
+    .modern-card {
+        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+        border-radius: 20px;
+        padding: 30px;
+        margin: 20px 0;
+        box-shadow: 0 10px 30px rgba(0,0,0,0.1);
+        color: white;
+        transition: transform 0.3s ease, box-shadow 0.3s ease;
+    }
+    
+    .modern-card:hover {
+        transform: translateY(-5px);
+        box-shadow: 0 15px 40px rgba(0,0,0,0.2);
+    }
+    
+    .slide-in-left {
+        animation: slideInLeft 0.6s ease-out;
+    }
+    
+    .slide-in-right {
+        animation: slideInRight 0.6s ease-out;
+    }
+    
+    @keyframes slideInLeft {
+        from { transform: translateX(-100px); opacity: 0; }
+        to { transform: translateX(0); opacity: 1; }
+    }
+    
+    @keyframes slideInRight {
+        from { transform: translateX(100px); opacity: 0; }
+        to { transform: translateX(0); opacity: 1; }
+    }
+    
+    .progress-container {
+        background: linear-gradient(135deg, #f8f9fa 0%, #e9ecef 100%);
+        border-radius: 15px;
+        padding: 20px;
+        margin: 20px 0;
+        text-align: center;
+        border: 2px solid #667eea;
+    }
+    
+    .progress-bar {
+        width: 100%;
+        height: 8px;
+        background: #e9ecef;
+        border-radius: 4px;
+        overflow: hidden;
+        margin: 15px 0;
+    }
+    
+    .progress-fill {
+        height: 100%;
+        background: linear-gradient(90deg, #667eea, #764ba2);
+        border-radius: 4px;
+        animation: progress 2s ease-in-out infinite;
+    }
+    
+    @keyframes progress {
+        0% { width: 0%; }
+        50% { width: 70%; }
+        100% { width: 100%; }
+    }
+    
+    .generation-status {
+        font-weight: 600;
+        color: #667eea;
+        margin: 10px 0;
+        font-size: 1.1rem;
+    }
+    
+    .typewriter-container {
+        background: linear-gradient(135deg, #f8f9fa 0%, #e9ecef 100%);
+        border-radius: 15px;
+        padding: 20px;
+        margin: 20px 0;
+        border-left: 4px solid #667eea;
+    }
+    
+    .typewriter-header {
+        display: flex;
+        align-items: center;
+        margin-bottom: 15px;
+    }
+    
+    .book-icon {
+        font-size: 24px;
+        margin-right: 10px;
+    }
+    
+    .typing-dots span {
+        animation: typing 1.4s infinite;
+        margin: 0 2px;
+    }
+    
+    .typing-dots span:nth-child(2) { animation-delay: 0.2s; }
+    .typing-dots span:nth-child(3) { animation-delay: 0.4s; }
+    
+    @keyframes typing {
+        0%, 60%, 100% { opacity: 0; }
+        30% { opacity: 1; }
+    }
+    """
+    
+    with gr.Blocks(css=custom_css, title="BrightMind AI - Educational Assistant") as interface:
+        
+        # Header
+        gr.HTML("""
+        <div style="text-align: center; padding: 40px 20px; background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); color: white; border-radius: 20px; margin-bottom: 30px;">
+            <h1 style="font-size: 3rem; margin: 0; text-shadow: 2px 2px 4px rgba(0,0,0,0.3);">🧠 BrightMind AI</h1>
+            <p style="font-size: 1.3rem; margin: 10px 0; opacity: 0.9;">Your Intelligent Educational Assistant</p>
+            <p style="font-size: 1rem; margin: 0; opacity: 0.8;">Generate lesson plans, quizzes, and educational content with AI</p>
+        </div>
+        """)
+        
+        # Main tabs
+        with gr.Tabs():
+            
+            # Albert Chat Tab
+            with gr.TabItem("🤖 Albert Chat"):
+                create_albert_chat_tab()
+            
+            # Lesson Plan Generator Tab
+            with gr.TabItem("📚 Lesson Plan Generator"):
+                create_lesson_plan_tab()
+            
+            # Quiz Generator Tab
+            with gr.TabItem("📝 Quiz Generator"):
+                create_quiz_tab()
+            
+            # Content Generator Tab
+            with gr.TabItem("📄 Content Generator"):
+                create_content_tab()
+            
+            # Feedback Tab
+            with gr.TabItem("💬 Feedback"):
+                create_feedback_tab()
+            
+            # Admin Tab
+            with gr.TabItem("⚙️ Admin"):
+                create_admin_tab()
+    
+    return interface
+
+
+def create_albert_chat_tab():
+    """Create the Albert chat interface"""
+    
+    with gr.Row():
+        with gr.Column(scale=1):
+            gr.HTML("""
+            <div class="modern-card slide-in-left">
+                <h2 style="color: white; margin-bottom: 20px; font-size: 1.8rem;">🤖 Albert Chat</h2>
+                <p style="color: white; font-size: 1.1rem; margin-bottom: 20px;">Chat with Albert, your AI learning buddy!</p>
+            """)
+            
+            user_name = gr.Textbox(
+                label="👤 Your Name", 
+                placeholder="Enter your name to start chatting",
+                value=""
+            )
+            
+            user_age_group = gr.Dropdown(
+                choices=["Elementary (K-5)", "Middle School (6-8)", "High School (9-12)", "College", "Adult"],
+                label="🎓 Age Group",
+                value="Middle School (6-8)",
+                interactive=True
+            )
+            
+            gr.HTML("</div>")
+        
+        with gr.Column(scale=2):
+            gr.HTML("""
+            <div class="modern-card slide-in-right">
+                <h3 style="color: white; margin-bottom: 20px; font-size: 1.4rem;">💬 Chat with Albert</h3>
+            """)
+            
+            chat_display = gr.Chatbot(
+                label="",
+                height=400,
+                show_label=False,
+                container=True,
+                bubble_full_width=False
+            )
+            
+            chat_input = gr.Textbox(
+                label="Type your message here...",
+                placeholder="Ask Albert anything about learning!",
+                lines=2
+            )
+            
+            with gr.Row():
+                send_btn = gr.Button("Send", variant="primary")
+                clear_btn = gr.Button("Clear Chat", variant="secondary")
+            
+            context_display = gr.HTML("", visible=False)
+            typing_indicator = gr.HTML("", visible=False)
+            
+            gr.HTML("</div>")
+    
+    # Event handlers
+    def send_message_with_typing(message, name, age_group, history):
+        """Send message with typing effect"""
+        if not message.strip():
+            return history, "", "", ""
+        
+        if history is None:
+            history = []
+        
+        history.append([f"{name}: {message}", None])
+        
+        # Generate Albert's response
+        albert_response = generate_albert_response(message, name, age_group, history)
+        history[-1][1] = albert_response
+        
+        return history, "", "", ""
+    
+    def clear_chat():
+        return [], "", "", ""
+    
+    def initialize_chat(name, age_group):
+        if not name.strip():
+            return [], "", ""
+        
+        welcome_message = f"Hi {name}! 🧠✨ I'm Albert, your learning buddy! What would you like to know about today? 😊🚀"
+        return [[None, welcome_message]], "", ""
+    
+    # Connect event handlers
+    send_btn.click(
+        fn=send_message_with_typing,
+        inputs=[chat_input, user_name, user_age_group, chat_display],
+        outputs=[chat_display, chat_input, context_display, typing_indicator]
+    )
+    
+    clear_btn.click(
+        fn=clear_chat,
+        outputs=[chat_display, context_display, context_display, typing_indicator]
+    )
+    
+    user_name.change(
+        fn=initialize_chat,
+        inputs=[user_name, user_age_group],
+        outputs=[chat_display, context_display, context_display]
+    )
+
+
+def create_lesson_plan_tab():
+    """Create the lesson plan generator interface"""
+    
+    with gr.Row():
+        with gr.Column():
+            gr.HTML("""
+            <div class="modern-card slide-in-left">
+                <h2 style="color: white; margin-bottom: 20px; font-size: 1.8rem;">📚 Lesson Plan Generator</h2>
+                <p style="color: white; font-size: 1.1rem; margin-bottom: 20px;">Create comprehensive lesson plans with AI assistance</p>
+            """)
+            
+            topic = gr.Textbox(label="📝 Topic", placeholder="e.g., Photosynthesis, World War II, Algebra")
+            subject = gr.Dropdown(
+                choices=["Science", "Mathematics", "History", "English Language Arts", "Geography", "Art"],
+                label="📚 Subject",
+                value="Science",
+                interactive=True
+            )
+            grade_level = gr.Dropdown(
+                choices=["K-2", "3-5", "6-8", "9-12"],
+                label="🎓 Grade Level",
+                value="6-8",
+                interactive=True
+            )
+            duration = gr.Slider(
+                minimum=30,
+                maximum=180,
+                step=15,
+                value=60,
+                label="⏱️ Duration (minutes)"
+            )
+            difficulty = gr.Dropdown(
+                choices=["Beginner", "Intermediate", "Advanced"],
+                label="🎯 Difficulty",
+                value="Intermediate",
+                interactive=True
+            )
+            
+            generate_lesson_btn = gr.Button("🚀 Generate Lesson Plan", variant="primary")
+            
+            gr.HTML("</div>")
+        
+        with gr.Column():
+            gr.HTML("""
+            <div class="modern-card slide-in-right">
+                <h3 style="color: white; margin-bottom: 20px; font-size: 1.4rem;">📋 Generated Lesson Plan</h3>
+            """)
+            
+            progress_display = gr.HTML("", visible=False)
+            lesson_plan_output = gr.Markdown(label="")
+            
+            gr.HTML("</div>")
+    
+    # Event handler
+    generate_lesson_btn.click(
+        fn=generate_lesson_plan_with_progress,
+        inputs=[topic, subject, grade_level, duration, difficulty],
+        outputs=[progress_display, lesson_plan_output]
+    )
+
+
+def create_quiz_tab():
+    """Create the quiz generator interface"""
+    
+    with gr.Row():
+        with gr.Column():
+            gr.HTML("""
+            <div class="modern-card slide-in-left">
+                <h2 style="color: white; margin-bottom: 20px; font-size: 1.8rem;">📝 Quiz Generator</h2>
+                <p style="color: white; font-size: 1.1rem; margin-bottom: 20px;">Create engaging quizzes with AI assistance</p>
+            """)
+            
+            quiz_topic = gr.Textbox(label="📝 Topic", placeholder="e.g., Photosynthesis, World War II, Algebra")
+            quiz_subject = gr.Dropdown(
+                choices=["Science", "Mathematics", "History", "English Language Arts", "Geography", "Art"],
+                label="📚 Subject",
+                value="Science",
+                interactive=True
+            )
+            quiz_grade_level = gr.Dropdown(
+                choices=["K-2", "3-5", "6-8", "9-12"],
+                label="🎓 Grade Level",
+                value="6-8",
+                interactive=True
+            )
+            question_count = gr.Slider(
+                minimum=3,
+                maximum=20,
+                step=1,
+                value=5,
+                label="❓ Number of Questions"
+            )
+            question_types = gr.CheckboxGroup(
+                choices=["Multiple Choice", "True/False", "Short Answer", "Fill in the Blank"],
+                label="📋 Question Types",
+                value=["Multiple Choice", "True/False"]
+            )
+            
+            generate_quiz_btn = gr.Button("🚀 Generate Quiz", variant="primary")
+            
+            gr.HTML("</div>")
+        
+        with gr.Column():
+            gr.HTML("""
+            <div class="modern-card slide-in-right">
+                <h3 style="color: white; margin-bottom: 20px; font-size: 1.4rem;">📝 Generated Quiz</h3>
+            """)
+            
+            quiz_progress_display = gr.HTML("", visible=False)
+            quiz_output = gr.Markdown(label="")
+            
+            gr.HTML("</div>")
+    
+    # Event handler
+    generate_quiz_btn.click(
+        fn=generate_quiz_with_progress,
+        inputs=[quiz_topic, quiz_subject, quiz_grade_level, question_count, question_types],
+        outputs=[quiz_progress_display, quiz_output]
+    )
+
+
+def create_content_tab():
+    """Create the content generator interface"""
+    
+    with gr.Row():
+        with gr.Column():
+            gr.HTML("""
+            <div class="modern-card slide-in-left">
+                <h2 style="color: white; margin-bottom: 20px; font-size: 1.8rem;">📄 Content Generator</h2>
+                <p style="color: white; font-size: 1.1rem; margin-bottom: 20px;">Generate educational content with AI assistance</p>
+            """)
+            
+            content_topic = gr.Textbox(label="📝 Topic", placeholder="e.g., Photosynthesis, World War II, Algebra")
+            content_subject = gr.Dropdown(
+                choices=["Science", "Mathematics", "History", "English Language Arts", "Geography", "Art"],
+                label="📚 Subject",
+                value="Science",
+                interactive=True
+            )
+            content_grade_level = gr.Dropdown(
+                choices=["K-2", "3-5", "6-8", "9-12"],
+                label="🎓 Grade Level",
+                value="6-8",
+                interactive=True
+            )
+            content_type = gr.Dropdown(
+                choices=["Study Guide", "Worksheet", "Reading Material", "Summary", "Notes"],
+                label="📄 Content Type",
+                value="Study Guide",
+                interactive=True
+            )
+            content_length = gr.Dropdown(
+                choices=["Short (1-2 pages)", "Medium (3-5 pages)", "Long (6+ pages)"],
+                label="📏 Length",
+                value="Medium (3-5 pages)",
+                interactive=True
+            )
+            content_difficulty = gr.Dropdown(
+                choices=["Beginner", "Intermediate", "Advanced"],
+                label="🎯 Difficulty",
+                value="Intermediate",
+                interactive=True
+            )
+            
+            generate_content_btn = gr.Button("🚀 Generate Content", variant="primary")
+            
+            gr.HTML("</div>")
+        
+        with gr.Column():
+            gr.HTML("""
+            <div class="modern-card slide-in-right">
+                <h3 style="color: white; margin-bottom: 20px; font-size: 1.4rem;">📄 Generated Content</h3>
+            """)
+            
+            content_progress_display = gr.HTML("", visible=False)
+            content_output = gr.Markdown(label="")
+            
+            gr.HTML("</div>")
+    
+    # Event handler
+    generate_content_btn.click(
+        fn=generate_content_with_progress,
+        inputs=[content_topic, content_subject, content_grade_level, content_difficulty, content_type, content_length],
+        outputs=[content_progress_display, content_output]
+    )
+
+
+def create_feedback_tab():
+    """Create the feedback interface"""
+    
+    with gr.Row():
+        with gr.Column():
+            gr.HTML("""
+            <div class="modern-card slide-in-left">
+                <h2 style="color: white; margin-bottom: 20px; font-size: 1.8rem;">💬 Feedback</h2>
+                <p style="color: white; font-size: 1.1rem; margin-bottom: 20px;">Help us improve BrightMind AI</p>
+            """)
+            
+            feedback_type = gr.CheckboxGroup(
+                choices=["Lesson Plan Generator", "Quiz Generator", "Content Generator", "Albert Chat", "Overall Experience"],
+                label="📋 What would you like to provide feedback on?",
+                value=["Overall Experience"]
+            )
+            
+            rating = gr.Radio(
+                choices=[1, 2, 3, 4, 5],
+                label="⭐ Rating (1-5 stars)",
+                value=5
+            )
+            
+            comments = gr.Textbox(
+                label="💭 Comments",
+                placeholder="Please share your thoughts, suggestions, or any issues you encountered...",
+                lines=4
+            )
+            
+            user_email = gr.Textbox(
+                label="📧 Email (optional)",
+                placeholder="your.email@example.com"
+            )
+            
+            submit_feedback_btn = gr.Button("📤 Submit Feedback", variant="primary")
+            
+            gr.HTML("</div>")
+        
+        with gr.Column():
+            gr.HTML("""
+            <div class="modern-card slide-in-right">
+                <h3 style="color: white; margin-bottom: 20px; font-size: 1.4rem;">📊 Feedback Status</h3>
+            """)
+            
+            feedback_status = gr.Markdown("Your feedback helps us improve! Please fill out the form and click submit.")
+            
+            gr.HTML("</div>")
+    
+    # Event handler
+    submit_feedback_btn.click(
+        fn=submit_feedback,
+        inputs=[feedback_type, rating, comments, user_email],
+        outputs=[feedback_status]
+    )
+
+
+def create_admin_tab():
+    """Create the admin interface"""
+    
+    with gr.Row():
+        with gr.Column():
+            gr.HTML("""
+            <div class="modern-card slide-in-left">
+                <h2 style="color: white; margin-bottom: 20px; font-size: 1.8rem;">⚙️ Admin Panel</h2>
+                <p style="color: white; font-size: 1.1rem; margin-bottom: 20px;">View feedback statistics and system information</p>
+            """)
+            
+            refresh_stats_btn = gr.Button("🔄 Refresh Statistics", variant="primary")
+            view_feedback_btn = gr.Button("📊 View All Feedback", variant="secondary")
+            
+            gr.HTML("</div>")
+        
+        with gr.Column():
+            gr.HTML("""
+            <div class="modern-card slide-in-right">
+                <h3 style="color: white; margin-bottom: 20px; font-size: 1.4rem;">📈 Statistics</h3>
+            """)
+            
+            stats_display = gr.Markdown("Click 'Refresh Statistics' to view feedback data.")
+            feedback_display = gr.Markdown("Click 'View All Feedback' to see detailed feedback entries.")
+            
+            gr.HTML("</div>")
+    
+    # Event handlers
+    def refresh_stats():
+        stats = get_feedback_stats()
+        return f"""
+        ## 📊 Feedback Statistics
+        
+        **Total Feedback Entries:** {stats['total_feedback']}
+        **Average Rating:** {stats['avg_rating']}/5 ⭐
+        
+        **Recent Feedback:**
+        {format_recent_feedback(stats['recent_feedback'])}
+        """
+    
+    def view_all_feedback():
+        return view_feedback_admin()
+    
+    def format_recent_feedback(recent_feedback):
+        if not recent_feedback:
+            return "No recent feedback available."
+        
+        formatted = ""
+        for entry in recent_feedback:
+            timestamp, feedback_type, rating, comments, user_email = entry
+            formatted += f"- **{timestamp}**: {rating}/5 ⭐ - {comments[:100]}{'...' if len(comments) > 100 else ''}\n"
+        
+        return formatted
+    
+    refresh_stats_btn.click(
+        fn=refresh_stats,
+        outputs=[stats_display]
+    )
+    
+    view_feedback_btn.click(
+        fn=view_all_feedback,
+        outputs=[feedback_display]
+    )

utils.py

@@ -0,0 +1,254 @@
+"""
+Utility functions module for BrightMind AI
+Contains helper functions for content processing, math conversion, and styling
+"""
+
+import re
+from algebra_solver import AlgebraSolver
+
+# Initialize algebra solver
+algebra_solver = AlgebraSolver()
+
+
+def convert_math_to_html(text):
+    """Convert LaTeX-style math expressions to HTML"""
+    
+    # Handle LaTeX math delimiters first
+    # Convert \[ ... \] to display math
+    text = re.sub(r'\\\[([^\]]+)\\\]', r'<div style="text-align: center; margin: 10px 0; padding: 10px; background: #f8f9fa; border-radius: 5px; font-family: \'Times New Roman\', serif; font-size: 1.1em;">\1</div>', text)
+    
+    # Convert \( ... \) to inline math
+    text = re.sub(r'\\\(([^)]+)\\\)', r'<span style="font-family: \'Times New Roman\', serif; font-size: 1.05em; background: #f0f0f0; padding: 2px 4px; border-radius: 3px;">\1</span>', text)
+    
+    # Handle fractions: \frac{a}{b}
+    text = re.sub(r'\\frac\{([^}]+)\}\{([^}]+)\}', r'<div style="display: inline-block; text-align: center; vertical-align: middle; margin: 0 5px;"><div style="border-bottom: 1px solid #333; padding-bottom: 2px; font-size: 0.9em;">\1</div><div style="padding-top: 2px; font-size: 0.9em;">\2</div></div>', text)
+    
+    # Handle simple fractions like 120/2
+    text = re.sub(r'(\d+)/(\d+)', r'<div style="display: inline-block; text-align: center; vertical-align: middle; margin: 0 3px;"><div style="border-bottom: 1px solid #333; padding-bottom: 1px; font-size: 0.9em;">\1</div><div style="padding-top: 1px; font-size: 0.9em;">\2</div></div>', text)
+    
+    # Handle superscripts: ^{text}
+    text = re.sub(r'\^\{([^}]+)\}', r'<sup>\1</sup>', text)
+    text = re.sub(r'\^(\w)', r'<sup>\1</sup>', text)
+    
+    # Handle subscripts: _{text}
+    text = re.sub(r'_\{([^}]+)\}', r'<sub>\1</sub>', text)
+    text = re.sub(r'_(\w)', r'<sub>\1</sub>', text)
+    
+    # Handle \text{} commands first (before other processing)
+    text = re.sub(r'\\text\{([^}]+)\}', r'\1', text)
+    
+    # Handle \boxed{} commands
+    text = re.sub(r'\\boxed\{([^}]+)\}', r'<span style="border: 2px solid #333; padding: 2px 4px; background: #f0f0f0; border-radius: 3px;">\1</span>', text)
+    
+    # Handle underscore patterns that are not subscripts (like \_\_\_)
+    text = re.sub(r'\\_+', r'<span style="border-bottom: 2px solid #333; min-width: 20px; display: inline-block;">&nbsp;</span>', text)
+    
+    # Re-process fractions after text commands are handled
+    text = re.sub(r'\\frac\{([^}]+)\}\{([^}]+)\}', r'<div style="display: inline-block; text-align: center; vertical-align: middle; margin: 0 5px;"><div style="border-bottom: 1px solid #333; padding-bottom: 2px; font-size: 0.9em;">\1</div><div style="padding-top: 2px; font-size: 0.9em;">\2</div></div>', text)
+    
+    # Handle common math symbols
+    text = text.replace('\\times', '×')
+    text = text.replace('\\rightarrow', '→')
+    text = text.replace('\\leftarrow', '←')
+    text = text.replace('\\leq', '≤')
+    text = text.replace('\\geq', '≥')
+    text = text.replace('\\neq', '≠')
+    text = text.replace('\\approx', '≈')
+    text = text.replace('\\pm', '±')
+    text = text.replace('\\sqrt', '√')
+    text = text.replace('\\pi', 'π')
+    
+    return text
+
+
+def solve_algebra_problem(problem_type, *args):
+    """Solve algebra problems interactively"""
+    try:
+        if problem_type == "speed":
+            distance, time = args
+            result = algebra_solver.solve_speed_problem(float(distance), float(time))
+        elif problem_type == "volume":
+            mass, density = args
+            result = algebra_solver.solve_volume_problem(float(mass), float(density))
+        elif problem_type == "linear":
+            a, b, c = args
+            result = algebra_solver.solve_linear_equation(float(a), float(b), float(c))
+        elif problem_type == "quadratic":
+            h, coefficient = args
+            result = algebra_solver.solve_quadratic_equation(float(h), float(coefficient))
+        else:
+            return "❌ Unknown problem type"
+        
+        if "error" in result:
+            return f"❌ Error: {result['error']}"
+        
+        # Format the solution nicely
+        solution_text = f"✅ **{result['solution']}**\n\n"
+        if "steps" in result:
+            solution_text += "**Steps:**\n"
+            for i, step in enumerate(result["steps"], 1):
+                solution_text += f"{i}. {step}\n"
+        elif "formula" in result:
+            solution_text += f"**Formula:** {result['formula']}\n"
+            solution_text += f"**Calculation:** {result['calculation']}\n"
+        
+        return solution_text
+        
+    except Exception as e:
+        return f"❌ Error solving problem: {str(e)}"
+
+
+def apply_content_styling(content, content_type):
+    """Apply simple and robust styling to educational content"""
+    
+    # Clean up any malformed HTML first
+    content = re.sub(r'="[^"]*style="[^"]*"[^"]*"', '', content)
+    content = re.sub(r'="[^"]*color: [^"]*"[^"]*"', '', content)
+    content = re.sub(r'="[^"]*background: [^"]*"[^"]*"', '', content)
+    content = re.sub(r'="[^"]*border: [^"]*"[^"]*"', '', content)
+    content = re.sub(r'="[^"]*padding: [^"]*"[^"]*"', '', content)
+    content = re.sub(r'="[^"]*margin: [^"]*"[^"]*"', '', content)
+    
+    # Fix broken image tags and malformed HTML
+    content = re.sub(r'<div style>.*?</div>', '', content)
+    content = re.sub(r'stylelazy">', 'loading="lazy">', content)
+    content = re.sub(r'<img[^>]*style[^>]*>', '', content)
+    
+    # Fix malformed button attributes
+    content = re.sub(r'styleselectRating\(\d+\)"', '', content)
+    content = re.sub(r'styletext"', '', content)
+    content = re.sub(r'style="[^"]*"[^"]*style="[^"]*"', 'style="margin-right: 8px; transform: scale(1.2);"', content)
+    
+    # Fix broken input attributes
+    content = re.sub(r'<input typeready-check"', '<input type="checkbox" id="ready-check"', content)
+    content = re.sub(r'styleSolve"', 'onclick="solveSpeed()"', content)
+    
+    # Clean up any remaining malformed attributes
+    content = re.sub(r'="[^"]*"[^"]*"', '', content)
+    
+    # Return content as-is for Markdown rendering
+    styled_content = content
+    
+    # Apply Markdown-friendly styling
+    styled_content = re.sub(r'\[ANSWER: ([^\]]+)\]', r'**Answer:** \1', styled_content)
+    
+    styled_content = re.sub(r'___+', r'_________________', styled_content)
+    
+    styled_content = re.sub(r'\[ \]', r'☐', styled_content)
+    styled_content = re.sub(r'☑', r'☑', styled_content)
+    
+    styled_content = re.sub(r'\[(\d+)\]', r'**\1**', styled_content)
+    
+    return styled_content
+
+
+def process_content_with_images(content, topic, content_type):
+    """Process generated content to include real images and multimedia elements"""
+    from ai_services import get_educational_image_url, generate_image_placeholder
+    
+    # Replace image placeholders with actual images
+    # Convert LaTeX-style math expressions to HTML first
+    content = convert_math_to_html(content)
+    
+    # Fix LaTeX math rendering by converting to HTML
+    def fix_latex_math(match):
+        latex_formula = match.group(1)
+        
+        # Handle fractions first (most complex) - improved regex
+        def process_fraction(match):
+            numerator = match.group(1)
+            denominator = match.group(2)
+            return f'<div style="display: inline-block; text-align: center; vertical-align: middle; margin: 0 5px;"><div style="border-bottom: 1px solid #333; padding-bottom: 2px; font-size: 0.9em;">{numerator}</div><div style="padding-top: 2px; font-size: 0.9em;">{denominator}</div></div>'
+        
+        # Process fractions: \frac{numerator}{denominator} - more robust regex
+        latex_formula = re.sub(r'\\frac\{([^{}]+)\}\{([^{}]+)\}', process_fraction, latex_formula)
+        
+        # Handle text commands more carefully
+        latex_formula = latex_formula.replace('\\text{', '<span style="font-style: normal;">')
+        
+        # Handle math symbols
+        latex_formula = latex_formula.replace('\\times', '×')
+        latex_formula = latex_formula.replace('\\rightarrow', '→')
+        latex_formula = latex_formula.replace('\\leftarrow', '←')
+        latex_formula = latex_formula.replace('\\leq', '≤')
+        latex_formula = latex_formula.replace('\\geq', '≥')
+        latex_formula = latex_formula.replace('\\neq', '≠')
+        latex_formula = latex_formula.replace('\\approx', '≈')
+        latex_formula = latex_formula.replace('\\pm', '±')
+        latex_formula = latex_formula.replace('\\sqrt{', '√(')
+        latex_formula = latex_formula.replace('\\pi', 'π')
+        latex_formula = latex_formula.replace('\\alpha', 'α')
+        latex_formula = latex_formula.replace('\\beta', 'β')
+        latex_formula = latex_formula.replace('\\gamma', 'γ')
+        latex_formula = latex_formula.replace('\\delta', 'δ')
+        latex_formula = latex_formula.replace('\\theta', 'θ')
+        latex_formula = latex_formula.replace('\\lambda', 'λ')
+        latex_formula = latex_formula.replace('\\mu', 'μ')
+        latex_formula = latex_formula.replace('\\sigma', 'σ')
+        latex_formula = latex_formula.replace('\\tau', 'τ')
+        latex_formula = latex_formula.replace('\\phi', 'φ')
+        latex_formula = latex_formula.replace('\\omega', 'ω')
+        
+        # Handle superscripts and subscripts
+        latex_formula = re.sub(r'\^(\w+)', r'<sup>\1</sup>', latex_formula)
+        latex_formula = re.sub(r'_(\w+)', r'<sub>\1</sub>', latex_formula)
+        
+        # Clean up any remaining unmatched braces
+        latex_formula = latex_formula.replace('{', '').replace('}', '')
+        
+        return f'<div style="text-align: center; margin: 20px 0; padding: 15px; background: #f8f9fa; border-radius: 8px; border-left: 4px solid #667eea; font-family: \'Times New Roman\', serif; font-size: 1.1em;">{latex_formula}</div>'
+    
+    # Find LaTeX math formulas and convert them (both [formula] and (formula) formats)
+    # Updated patterns to be more specific to LaTeX commands
+    latex_patterns = [
+        re.compile(r'\[([^\[\]]*\\[a-zA-Z]+[^\[\]]*)\]', re.MULTILINE),  # [formula with LaTeX commands]
+        re.compile(r'\(([^()]*\\[a-zA-Z]+[^()]*)\)', re.MULTILINE)    # (formula with LaTeX commands)
+    ]
+    
+    for pattern in latex_patterns:
+        content = pattern.sub(fix_latex_math, content)
+    
+    # Find all IMAGE: description patterns (both [IMAGE: description] and IMAGE: description)
+    image_patterns = [
+        re.compile(r'\[IMAGE:\s*([^\]]+)\]', re.IGNORECASE),
+        re.compile(r'IMAGE:\s*([^\n]+)', re.IGNORECASE)
+    ]
+    
+    for pattern in image_patterns:
+        def replace_image(match):
+            description = match.group(1).strip()
+            print(f"🖼️ Processing image: {description}")
+            
+            # Try to get a real image URL
+            image_url = get_educational_image_url(topic, description, content_type)
+            
+            if image_url and not image_url.startswith('https://via.placeholder.com'):
+                # Real image found
+                return f'\n<img src="{image_url}" alt="{description}" style="max-width: 100%; height: auto; border-radius: 8px; margin: 20px 0; box-shadow: 0 4px 6px rgba(0,0,0,0.1);">\n'
+            else:
+                # Use placeholder
+                return generate_image_placeholder(description, topic, content_type)
+        
+        content = pattern.sub(replace_image, content)
+    
+    return content
+
+
+def typewriter_effect(text, status_message):
+    """Create a typewriter effect for text display"""
+    import time
+    
+    if not text:
+        return status_message
+    
+    # Split text into words for smoother effect
+    words = text.split()
+    result = ""
+    
+    for i, word in enumerate(words):
+        result += word + " "
+        if i % 10 == 0:  # Yield every 10 words
+            yield result, status_message
+        time.sleep(0.05)  # Small delay for effect
+    
+    yield result, status_message