Update app.py

app.py

@@ -1,10 +1,6 @@
-def load_core_datasets():
-            try:
-                if not DATASETS_AVAILABLE:
-                    self.loading_status = "⚠️"""
-BILLION DOLLAR EDUCATION AI - GLOBAL SCALE
-The ChatGPT for Education - Optimized for Speed, Quality & Scalability
-Serving millions of students, teachers, and lifelong learners worldwide
+"""
+BILLION DOLLAR EDUCATION AI - CLEAN VERSION
+The ChatGPT for Education - Premium Dataset Integration
 """
 
 import gradio as gr
@@ -13,340 +9,211 @@ import json
 import random
 import threading
 import time
-import hashlib
-from typing import Dict, List, Optional
-import asyncio
-from concurrent.futures import ThreadPoolExecutor
+from typing import Dict, List
 
-# Import datasets library (ensure no circular import)
+# Safe dataset import
 try:
     from datasets import load_dataset
     DATASETS_AVAILABLE = True
-except ImportError as e:
-    print(f"Datasets library not available: {e}")
+except ImportError:
     DATASETS_AVAILABLE = False
     def load_dataset(*args, **kwargs):
         return []
 
-class GlobalEducationAI:
+class EducationAI:
     def __init__(self):
-        # Production API configuration
+        # Your API key
         self.groq_api_key = "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"
         self.groq_url = "https://api.groq.com/openai/v1/chat/completions"
         
-        # Scalable dataset architecture
+        # Dataset storage
         self.datasets = {}
-        self.example_cache = {}  # Speed optimization
-        self.loading_status = "🚀 Initializing Global Education AI..."
-        self.total_examples_loaded = 0
+        self.examples = {}
+        self.loading_status = "🚀 Starting Premium Education AI..."
+        self.total_examples = 0
         
-        # Multi-language support for global reach
-        self.supported_languages = ["English", "Spanish", "French", "German", "Chinese", "Japanese"]
-        
-        # User analytics for billion-dollar insights
-        self.usage_stats = {
+        # Usage tracking
+        self.stats = {
             "total_queries": 0,
-            "subject_distribution": {},
-            "difficulty_preferences": {},
+            "subjects": {},
             "response_times": []
         }
         
-        # Start optimized dataset loading
-        self.initialize_datasets()
+        # Load datasets in background
+        self.load_datasets()
     
-    def initialize_datasets(self):
-        """Optimized parallel dataset loading for global scale"""
-        def load_core_datasets():
+    def load_datasets(self):
+        """Load premium datasets in background"""
+        def load_thread():
             try:
-                self.loading_status = "🔥 Loading Core Math Datasets (Competition + Problem Solving)..."
+                if not DATASETS_AVAILABLE:
+                    self.loading_status = "✅ Premium AI Ready (Dataset library unavailable)"
+                    self.create_fallback_examples()
+                    return
+                
+                self.loading_status = "📚 Loading GSM8K Math Dataset..."
                 
-                # TIER 1: GSM8K (Reliable and high-quality)
+                # Load GSM8K (reliable dataset)
                 try:
-                    gsm8k = load_dataset("gsm8k", "main", split="train[:3000]", trust_remote_code=True)
-                    self.datasets['gsm8k'] = self.optimize_dataset(gsm8k, 'math_practical')
+                    gsm8k = load_dataset("gsm8k", "main", split="train[:1000]")
+                    self.datasets['gsm8k'] = gsm8k
+                    self.examples['math'] = self.extract_math_examples(gsm8k)
                     print("✅ GSM8K loaded successfully")
                 except Exception as e:
                     print(f"GSM8K error: {e}")
                 
-                # TIER 2: Try MATH dataset (alternative to competition_math)
-                try:
-                    math_dataset = load_dataset("lighteval/MATH", split="train[:1000]", trust_remote_code=True)
-                    self.datasets['math_competition'] = self.optimize_dataset(math_dataset, 'math_competition')
-                    print("✅ MATH dataset loaded successfully")
-                except Exception as e:
-                    print(f"MATH dataset error: {e}")
-                
-                self.loading_status = "🧪 Loading Science & Reasoning Datasets..."
+                self.loading_status = "🧪 Loading Science Dataset..."
                 
-                # TIER 3: Science QA (Try alternative datasets)
+                # Load SciQ (science questions)
                 try:
-                    science_qa = load_dataset("sciq", split="train[:1000]", trust_remote_code=True)
-                    self.datasets['science_qa'] = self.optimize_dataset(science_qa, 'science')
+                    sciq = load_dataset("sciq", split="train[:500]")
+                    self.datasets['sciq'] = sciq
+                    self.examples['science'] = self.extract_science_examples(sciq)
                     print("✅ SciQ loaded successfully")
                 except Exception as e:
                     print(f"SciQ error: {e}")
                 
-                # TIER 4: Try Arc dataset
-                try:
-                    arc_dataset = load_dataset("allenai/ai2_arc", "ARC-Easy", split="train[:500]", trust_remote_code=True)
-                    self.datasets['arc'] = self.optimize_dataset(arc_dataset, 'science')
-                    print("✅ ARC dataset loaded successfully")
-                except Exception as e:
-                    print(f"ARC error: {e}")
-                
-                # Create optimized example cache
-                self.create_example_cache()
-                self.total_examples_loaded = sum(len(cache) for cache in self.example_cache.values())
+                # Calculate totals
+                self.total_examples = sum(len(examples) for examples in self.examples.values())
                 
-                if self.datasets:
-                    self.loading_status = f"✅ GLOBAL EDUCATION AI READY - {len(self.datasets)} datasets, {self.total_examples_loaded:,} examples"
-                    print(f"🌍 Global Education AI initialized with {self.total_examples_loaded:,} premium examples")
+                if self.total_examples > 0:
+                    self.loading_status = f"✅ PREMIUM AI READY - {len(self.datasets)} datasets, {self.total_examples} examples"
                 else:
-                    # Fallback mode with high-quality prompts
-                    self.loading_status = "✅ AI READY - Premium prompts active (datasets unavailable)"
+                    self.loading_status = "✅ Premium AI Ready (Using high-quality prompts)"
                     self.create_fallback_examples()
-                    print("🌍 Running in premium prompt mode")
+                
+                print(f"🎓 Education AI ready with {self.total_examples} examples")
                 
             except Exception as e:
-                self.loading_status = f"✅ AI READY - Premium mode active"
+                self.loading_status = "✅ Premium AI Ready (Core functionality active)"
                 self.create_fallback_examples()
-                print(f"Dataset loading info: {e}")
+                print(f"Loading info: {e}")
         
-        # Load datasets in background for instant user experience
-        thread = threading.Thread(target=load_core_datasets)
+        # Start background loading
+        thread = threading.Thread(target=load_thread)
         thread.daemon = True
         thread.start()
     
+    def extract_math_examples(self, dataset):
+        """Extract math examples from GSM8K"""
+        examples = []
+        for item in dataset:
+            if item.get('question') and item.get('answer'):
+                examples.append({
+                    'question': item['question'],
+                    'solution': item['answer'],
+                    'type': 'math_word_problem'
+                })
+        return examples[:50]  # Keep top 50
+    
+    def extract_science_examples(self, dataset):
+        """Extract science examples from SciQ"""
+        examples = []
+        for item in dataset:
+            if item.get('question') and item.get('correct_answer'):
+                examples.append({
+                    'question': item['question'],
+                    'solution': item['correct_answer'],
+                    'type': 'science_qa'
+                })
+        return examples[:30]  # Keep top 30
+    
     def create_fallback_examples(self):
-        """Create high-quality fallback examples when datasets unavailable"""
-        self.example_cache = {
-            'mathematics': [
+        """Create high-quality examples when datasets unavailable"""
+        self.examples = {
+            'math': [
                 {
-                    'question': 'Solve the quadratic equation x² + 5x + 6 = 0',
+                    'question': 'Solve x² + 5x + 6 = 0',
                     'solution': 'Factor: (x + 2)(x + 3) = 0, so x = -2 or x = -3',
-                    'type': 'algebra',
-                    'difficulty': 'intermediate',
-                    'category': 'mathematics',
-                    'quality_score': 9
+                    'type': 'algebra'
+                },
+                {
+                    'question': 'Find the derivative of f(x) = x³ + 2x',
+                    'solution': "f'(x) = 3x² + 2",
+                    'type': 'calculus'
                 }
             ],
             'science': [
                 {
                     'question': 'Why do ice cubes float in water?',
                     'solution': 'Ice is less dense than liquid water due to its crystalline structure',
-                    'type': 'physics',
-                    'difficulty': 'beginner',
-                    'category': 'science',
-                    'quality_score': 8
+                    'type': 'physics'
+                },
+                {
+                    'question': 'What is photosynthesis?',
+                    'solution': 'The process by which plants convert sunlight into chemical energy',
+                    'type': 'biology'
                 }
-            ],
-            'general': []
-        }
-        self.total_examples_loaded = 10  # Fallback count
-        
-        # Load datasets in background for instant user experience
-        thread = threading.Thread(target=load_core_datasets)
-        thread.daemon = True
-        thread.start()
-    
-    def optimize_dataset(self, dataset, category: str) -> List[Dict]:
-        """Optimize dataset for speed and quality"""
-        optimized = []
-        
-        for item in dataset:
-            try:
-                if category == 'math_competition':
-                    if item.get('problem') and item.get('solution') and len(item['problem']) > 20:
-                        optimized.append({
-                            'question': item['problem'],
-                            'solution': item['solution'],
-                            'type': item.get('type', 'competition_math'),
-                            'difficulty': 'competition',
-                            'category': 'mathematics',
-                            'quality_score': 10
-                        })
-                
-                elif category == 'math_practical':
-                    if item.get('question') and item.get('answer'):
-                        optimized.append({
-                            'question': item['question'],
-                            'solution': item['answer'],
-                            'type': 'word_problem',
-                            'difficulty': 'intermediate',
-                            'category': 'mathematics',
-                            'quality_score': 9
-                        })
-                
-                elif category == 'science':
-                    if item.get('question') and item.get('correct_answer'):
-                        # Handle SciQ format
-                        optimized.append({
-                            'question': item['question'],
-                            'solution': item['correct_answer'],
-                            'type': 'science_qa',
-                            'difficulty': 'intermediate',
-                            'category': 'science',
-                            'quality_score': 8
-                        })
-                    elif item.get('question_stem') and item.get('choices'):
-                        # Handle ARC format
-                        choices_text = "\n".join([f"{choice['label']}) {choice['text']}" for choice in item['choices']['text']])
-                        optimized.append({
-                            'question': f"{item['question_stem']}\n\n{choices_text}",
-                            'solution': f"Answer: {item['answerKey']}",
-                            'type': 'science_reasoning',
-                            'difficulty': 'intermediate',
-                            'category': 'science',
-                            'quality_score': 8
-                        })
-                
-                elif category in ['math_advanced', 'academic']:
-                    if item.get('question') and item.get('answer'):
-                        optimized.append({
-                            'question': str(item['question'])[:500],  # Truncate for speed
-                            'solution': str(item['answer'])[:500],
-                            'type': category,
-                            'difficulty': 'advanced',
-                            'category': 'general',
-                            'quality_score': 8
-                        })
-                        
-            except Exception:
-                continue  # Skip malformed entries
-        
-        return optimized[:500]  # Limit for speed while maintaining quality
-    
-    def create_example_cache(self):
-        """Create subject-specific example cache for instant retrieval"""
-        self.example_cache = {
-            'mathematics': [],
-            'science': [],
-            'physics': [],
-            'chemistry': [],
-            'biology': [],
-            'general': [],
-            'competition': []
+            ]
         }
-        
-        for dataset_name, examples in self.datasets.items():
-            for example in examples:
-                category = example.get('category', 'general')
-                if category in self.example_cache:
-                    self.example_cache[category].append(example)
-                
-                # Add high-quality examples to general cache
-                if example.get('quality_score', 0) >= 9:
-                    self.example_cache['general'].append(example)
-                
-                # Add competition problems to competition cache
-                if example.get('difficulty') == 'competition':
-                    self.example_cache['competition'].append(example)
+        self.total_examples = 4
     
-    def get_optimal_examples(self, question: str, subject: str, difficulty: str, num_examples: int = 2) -> List[Dict]:
-        """Lightning-fast example retrieval optimized for quality and relevance"""
-        # Map user inputs to cache categories
-        subject_mapping = {
-            'mathematics': 'mathematics',
-            'math': 'mathematics',
+    def get_examples(self, subject):
+        """Get relevant examples for subject"""
+        subject_map = {
+            'mathematics': 'math',
+            'math': 'math',
             'science': 'science',
             'physics': 'science',
             'chemistry': 'science',
-            'biology': 'science',
-            'general': 'general'
+            'biology': 'science'
         }
         
-        target_subject = subject_mapping.get(subject.lower(), 'general')
-        
-        # Get examples from cache (instant retrieval)
-        available_examples = self.example_cache.get(target_subject, [])
-        
-        # If requesting competition difficulty, prioritize competition examples
-        if difficulty == 'competition' and self.example_cache.get('competition'):
-            available_examples = self.example_cache['competition'][:50]
-        
-        # Filter by difficulty if possible
-        if difficulty in ['advanced', 'competition']:
-            filtered = [ex for ex in available_examples if ex.get('difficulty') in ['advanced', 'competition']]
-            if filtered:
-                available_examples = filtered
+        target = subject_map.get(subject.lower(), 'math')
+        examples = self.examples.get(target, [])
         
-        # Return best examples (random selection for variety)
-        if available_examples:
-            return random.sample(available_examples, min(num_examples, len(available_examples)))
-        
-        # Fallback to general examples
-        return random.sample(self.example_cache.get('general', []), min(num_examples, len(self.example_cache.get('general', []))))
+        # Return 2 random examples
+        if examples:
+            return random.sample(examples, min(2, len(examples)))
+        return []
     
-    def create_premium_prompt(self, question: str, subject: str, difficulty: str) -> str:
-        """Create optimized prompt with premium dataset examples"""
-        examples = self.get_optimal_examples(question, subject, difficulty)
-        
-        if not examples:
-            return f"You are an expert {subject} tutor. Provide detailed, step-by-step solutions."
-        
-        # Build efficient few-shot prompt
-        prompt = f"""You are a world-class {subject} educator with access to premium educational datasets. 
-
-TEACHING METHODOLOGY: Use these high-quality examples from educational datasets as your guide:
-
-"""
+    def create_prompt(self, question, subject, difficulty):
+        """Create enhanced prompt with examples"""
+        examples = self.get_examples(subject)
         
-        for i, example in enumerate(examples, 1):
-            prompt += f"EXAMPLE {i} ({example.get('type', 'academic')}):\n"
-            prompt += f"Q: {example['question'][:250]}{'...' if len(example['question']) > 250 else ''}\n"
-            prompt += f"A: {example['solution'][:250]}{'...' if len(example['solution']) > 250 else ''}\n\n"
+        prompt = f"You are an expert {subject} tutor. Provide detailed, step-by-step solutions."
         
-        prompt += f"""INSTRUCTION: Use the same rigorous, step-by-step approach shown above.
-- Subject Focus: {subject}
-- Difficulty Level: {difficulty}
-- Always show your work and explain reasoning
-- Make complex concepts accessible
-- Provide practical applications when relevant
-
-Now solve the student's question:"""
+        if examples:
+            prompt += "\n\nHere are examples of high-quality educational responses:\n\n"
+            for i, ex in enumerate(examples, 1):
+                prompt += f"EXAMPLE {i}:\n"
+                prompt += f"Q: {ex['question'][:200]}...\n"
+                prompt += f"A: {ex['solution'][:200]}...\n\n"
         
+        prompt += f"Use the same detailed approach. Subject: {subject}, Difficulty: {difficulty}"
         return prompt
     
-    def educate(self, question: str, subject: str = "general", difficulty: str = "intermediate", language: str = "English") -> str:
-        """Main education function optimized for global scale and speed"""
-        
-        # Analytics tracking for billion-dollar insights
-        self.usage_stats["total_queries"] += 1
-        self.usage_stats["subject_distribution"][subject] = self.usage_stats["subject_distribution"].get(subject, 0) + 1
-        self.usage_stats["difficulty_preferences"][difficulty] = self.usage_stats["difficulty_preferences"].get(difficulty, 0) + 1
+    def educate(self, question, subject="general", difficulty="intermediate", language="English"):
+        """Main education function"""
         
+        # Track usage
+        self.stats["total_queries"] += 1
+        self.stats["subjects"][subject] = self.stats["subjects"].get(subject, 0) + 1
         start_time = time.time()
         
         if not question.strip():
-            return "🎓 Hello! I'm your AI education assistant. Ask me any academic question and I'll provide detailed, step-by-step explanations using premium educational datasets!"
-        
-        # Check system status
-        if "Initializing" in self.loading_status or "Loading" in self.loading_status:
-            return f"🔄 {self.loading_status}\n\nI'm still loading educational datasets. You can ask questions now, but responses will get even better in a moment!"
+            return "🎓 Hi! I'm your AI education assistant. Ask me any academic question!"
         
-        # Create optimized prompt with dataset examples
-        system_prompt = self.create_premium_prompt(question, subject, difficulty)
+        # Create enhanced prompt
+        system_prompt = self.create_prompt(question, subject, difficulty)
         
-        # Add language instruction for global users
         if language != "English":
-            system_prompt += f"\n\nIMPORTANT: Respond in {language}."
+            system_prompt += f"\n\nRespond in {language}."
         
-        # Optimized API request for speed
+        # API request
         headers = {
             "Authorization": f"Bearer {self.groq_api_key}",
             "Content-Type": "application/json"
         }
         
         payload = {
-            "model": "llama3-70b-8192",  # Fastest model for real-time responses
+            "model": "llama3-70b-8192",
             "messages": [
                 {"role": "system", "content": system_prompt},
                 {"role": "user", "content": question}
             ],
-            "temperature": 0.2,  # Lower for consistency in education
-            "max_tokens": 1500,   # Optimized length
-            "top_p": 0.9,
-            "stream": False       # Disable streaming for faster processing
+            "temperature": 0.3,
+            "max_tokens": 1500
         }
         
         try:
@@ -354,255 +221,172 @@ Now solve the student's question:"""
                 self.groq_url,
                 headers=headers,
                 json=payload,
-                timeout=15  # Aggressive timeout for speed
+                timeout=20
             )
             
             response_time = time.time() - start_time
-            self.usage_stats["response_times"].append(response_time)
+            self.stats["response_times"].append(response_time)
             
             if response.status_code == 200:
                 result = response.json()
                 answer = result["choices"][0]["message"]["content"]
                 
-                # Add premium branding with real stats
-                dataset_count = len(self.datasets)
-                example_count = self.total_examples_loaded
-                
-                footer = f"\n\n---\n*🌍 **Global Education AI** powered by {dataset_count} premium datasets ({example_count:,} examples) | Response time: {response_time:.2f}s | Query #{self.usage_stats['total_queries']:,}*"
-                
+                # Add footer
+                footer = f"\n\n---\n*🎓 Powered by {len(self.datasets)} premium datasets ({self.total_examples} examples) | {response_time:.2f}s | Query #{self.stats['total_queries']}*"
                 return answer + footer
             else:
-                return f"⚠️ Service temporarily unavailable. Please try again in a moment. (Error: {response.status_code})"
+                return f"⚠️ Service temporarily unavailable (Error {response.status_code})"
                 
-        except requests.exceptions.Timeout:
-            return "⚡ Response took too long. Please try a more specific question or try again."
         except Exception as e:
-            return f"🔧 Technical issue occurred. Our team has been notified. Please try again shortly."
+            return "🔧 Technical issue. Please try again in a moment."
     
-    def get_global_analytics(self) -> str:
-        """Get analytics for billion-dollar insights"""
-        total_queries = self.usage_stats["total_queries"]
-        avg_response_time = sum(self.usage_stats["response_times"][-100:]) / len(self.usage_stats["response_times"][-100:]) if self.usage_stats["response_times"] else 0
+    def get_stats(self):
+        """Get usage statistics"""
+        total = self.stats["total_queries"]
+        avg_time = sum(self.stats["response_times"][-50:]) / len(self.stats["response_times"][-50:]) if self.stats["response_times"] else 0
         
-        top_subjects = sorted(self.usage_stats["subject_distribution"].items(), key=lambda x: x[1], reverse=True)[:3]
-        top_difficulties = sorted(self.usage_stats["difficulty_preferences"].items(), key=lambda x: x[1], reverse=True)[:3]
+        top_subjects = sorted(self.stats["subjects"].items(), key=lambda x: x[1], reverse=True)[:3]
         
-        analytics = f"""📊 **GLOBAL EDUCATION AI ANALYTICS**
+        stats = f"""📊 **EDUCATION AI ANALYTICS**
 
-🌍 **Scale Metrics:**
-• Total Queries Served: {total_queries:,}
-• Average Response Time: {avg_response_time:.2f}s
+🚀 **Performance:**
+• Total Queries: {total:,}
+• Average Response Time: {avg_time:.2f}s
 • Datasets Loaded: {len(self.datasets)}
-• Examples Available: {self.total_examples_loaded:,}
+• Examples Available: {self.total_examples}
 
 📚 **Popular Subjects:**"""
         
         for subject, count in top_subjects:
-            analytics += f"\n• {subject.title()}: {count:,} queries"
-        
-        analytics += f"\n\n⚡ **Difficulty Distribution:**"
-        for difficulty, count in top_difficulties:
-            analytics += f"\n• {difficulty.title()}: {count:,} requests"
+            stats += f"\n• {subject.title()}: {count} queries"
         
-        analytics += f"\n\n🚀 **Status**: {self.loading_status}"
-        
-        return analytics
+        stats += f"\n\n🌟 **Status:** {self.loading_status}"
+        return stats
 
-# Initialize Global Education AI
-global_ai = GlobalEducationAI()
+# Initialize AI
+ai = EducationAI()
 
-def create_global_interface():
-    """Create world-class education interface for global scale"""
+def create_interface():
+    """Create the education interface"""
     
     with gr.Blocks(
-        theme=gr.themes.Origin(),  # Professional theme
-        title="🌍 Global Education AI - The ChatGPT for Education",
+        theme=gr.themes.Soft(),
+        title="🎓 Billion Dollar Education AI",
         css="""
-        .gradio-container { max-width: 1400px !important; }
         .header {
             text-align: center;
-            background: linear-gradient(135deg, #667eea 0%, #764ba2 50%, #f093fb 100%);
-            padding: 3rem; border-radius: 20px; margin-bottom: 2rem;
-            box-shadow: 0 10px 30px rgba(0,0,0,0.1);
-        }
-        .stats-panel { 
-            background: linear-gradient(135deg, #f5f7fa 0%, #c3cfe2 100%);
-            border-radius: 15px; padding: 1.5rem; margin: 1rem 0;
-            border: 1px solid #e1e8ed;
-        }
-        .feature-box {
-            background: white; border-radius: 10px; padding: 1rem;
-            margin: 0.5rem 0; border-left: 4px solid #667eea;
+            background: linear-gradient(90deg, #667eea 0%, #764ba2 100%);
+            padding: 2rem;
+            border-radius: 15px;
+            margin-bottom: 2rem;
         }
         """
-    ) as interface:
+    ) as demo:
         
-        # Global Header
-        with gr.Row():
-            gr.HTML("""
-            <div class="header">
-                <h1 style="color: white; margin: 0; font-size: 3em; font-weight: 700;">🌍 Global Education AI</h1>
-                <p style="color: #f0f0f0; margin: 1rem 0 0 0; font-size: 1.3em; font-weight: 300;">
-                    The ChatGPT for Education • Powered by Premium Datasets • Serving Millions Worldwide
-                </p>
-                <div style="margin-top: 1rem;">
-                    <span style="background: rgba(255,255,255,0.2); padding: 0.5rem 1rem; border-radius: 20px; margin: 0.25rem; display: inline-block; color: white;">Competition Math</span>
-                    <span style="background: rgba(255,255,255,0.2); padding: 0.5rem 1rem; border-radius: 20px; margin: 0.25rem; display: inline-block; color: white;">Advanced Science</span>
-                    <span style="background: rgba(255,255,255,0.2); padding: 0.5rem 1rem; border-radius: 20px; margin: 0.25rem; display: inline-block; color: white;">Microsoft Orca</span>
-                    <span style="background: rgba(255,255,255,0.2); padding: 0.5rem 1rem; border-radius: 20px; margin: 0.25rem; display: inline-block; color: white;">Multi-Language</span>
-                </div>
-            </div>
-            """)
+        # Header
+        gr.HTML("""
+        <div class="header">
+            <h1 style="color: white; margin: 0; font-size: 2.5em;">🎓 Premium Education AI</h1>
+            <p style="color: #e8e8e8; margin: 0.5rem 0 0 0; font-size: 1.2em;">
+                The ChatGPT for Education • Real Dataset Integration • Global Scale
+            </p>
+        </div>
+        """)
         
-        # Main Interface
+        # Main interface
         with gr.Row():
-            with gr.Column(scale=3):
-                with gr.Group():
-                    question_input = gr.Textbox(
-                        label="🎓 Ask Your Educational Question",
-                        placeholder="Enter any question: math problems, science concepts, homework help, test prep, or academic topics...",
-                        lines=4,
-                        max_lines=10
+            with gr.Column(scale=2):
+                question = gr.Textbox(
+                    label="📝 Your Question",
+                    placeholder="Ask any educational question: math, science, homework help...",
+                    lines=4
+                )
+                
+                with gr.Row():
+                    subject = gr.Dropdown(
+                        choices=["general", "mathematics", "science", "physics", "chemistry", "biology", "english"],
+                        label="📚 Subject",
+                        value="general"
                     )
                     
-                    with gr.Row():
-                        subject_dropdown = gr.Dropdown(
-                            choices=["general", "mathematics", "science", "physics", "chemistry", "biology", "english", "history", "computer_science"],
-                            label="📚 Subject",
-                            value="general",
-                            interactive=True
-                        )
-                        
-                        difficulty_dropdown = gr.Dropdown(
-                            choices=["beginner", "intermediate", "advanced", "competition", "graduate"],
-                            label="⚡ Difficulty",
-                            value="intermediate",
-                            interactive=True
-                        )
-                        
-                        language_dropdown = gr.Dropdown(
-                            choices=["English", "Spanish", "French", "German", "Chinese", "Japanese"],
-                            label="🌐 Language",
-                            value="English",
-                            interactive=True
-                        )
+                    difficulty = gr.Dropdown(
+                        choices=["beginner", "intermediate", "advanced", "competition"],
+                        label="⚡ Difficulty",
+                        value="intermediate"
+                    )
                     
-                    submit_btn = gr.Button(
-                        "🚀 Get Expert Answer", 
-                        variant="primary", 
-                        size="lg",
-                        elem_classes="submit-button"
+                    language = gr.Dropdown(
+                        choices=["English", "Spanish", "French", "German"],
+                        label="🌐 Language",
+                        value="English"
                     )
+                
+                submit = gr.Button("🚀 Get Expert Answer", variant="primary", size="lg")
             
             with gr.Column(scale=1):
-                with gr.Group():
-                    gr.HTML('<div class="feature-box"><h3>🏆 Premium Features</h3></div>')
-                    
-                    analytics_display = gr.Textbox(
-                        label="📊 Live Analytics",
-                        value=global_ai.get_global_analytics(),
-                        lines=12,
-                        interactive=False
-                    )
-                    
-                    refresh_analytics = gr.Button("🔄 Refresh Analytics", size="sm")
-        
-        # Response Area
-        answer_output = gr.Textbox(
-            label="📖 Expert Educational Response",
-            lines=18,
-            max_lines=25,
-            interactive=False,
-            placeholder="Your detailed, step-by-step educational response will appear here..."
+                stats = gr.Textbox(
+                    label="📊 Live Stats",
+                    value=ai.get_stats(),
+                    lines=12,
+                    interactive=False
+                )
+                refresh = gr.Button("🔄 Refresh", size="sm")
+        
+        # Output
+        answer = gr.Textbox(
+            label="📖 Expert Response",
+            lines=15,
+            interactive=False
         )
         
-        # Example Queries for Global Users
-        with gr.Group():
-            gr.HTML('<h3 style="text-align: center; margin: 1rem 0;">💡 Example Questions from Around the World</h3>')
-            
-            gr.Examples(
-                examples=[
-                    # Math Examples
-                    ["Solve the quadratic equation: x² + 5x + 6 = 0", "mathematics", "intermediate", "English"],
-                    ["Find the derivative of f(x) = ln(x² + 1)", "mathematics", "advanced", "English"],
-                    ["Prove that the square root of 2 is irrational", "mathematics", "competition", "English"],
-                    
-                    # Science Examples  
-                    ["Explain photosynthesis in detail with chemical equations", "biology", "intermediate", "English"],
-                    ["Why do ice cubes float on water? Explain the molecular basis", "chemistry", "beginner", "English"],
-                    ["Derive Newton's second law from first principles", "physics", "advanced", "English"],
-                    
-                    # Multi-language Examples
-                    ["¿Cómo funciona la fotosíntesis?", "science", "intermediate", "Spanish"],
-                    ["Comment résoudre une équation du second degré?", "mathematics", "intermediate", "French"],
-                    
-                    # Advanced Examples
-                    ["Explain quantum entanglement for a graduate student", "physics", "graduate", "English"],
-                    ["How do I prepare for the International Mathematical Olympiad?", "mathematics", "competition", "English"]
-                ],
-                inputs=[question_input, subject_dropdown, difficulty_dropdown, language_dropdown],
-                outputs=answer_output,
-                fn=global_ai.educate,
-                cache_examples=False
-            )
-        
-        # Event Handlers
-        submit_btn.click(
-            fn=global_ai.educate,
-            inputs=[question_input, subject_dropdown, difficulty_dropdown, language_dropdown],
-            outputs=answer_output,
-            api_name="predict"  # Global API endpoint
+        # Examples
+        gr.Examples(
+            examples=[
+                ["Solve x² + 5x + 6 = 0", "mathematics", "intermediate", "English"],
+                ["Explain photosynthesis step by step", "biology", "intermediate", "English"],
+                ["What is Newton's second law?", "physics", "beginner", "English"],
+                ["Find the derivative of ln(x)", "mathematics", "advanced", "English"],
+                ["¿Qué es la fotosíntesis?", "science", "intermediate", "Spanish"]
+            ],
+            inputs=[question, subject, difficulty, language],
+            outputs=answer,
+            fn=ai.educate
         )
         
-        question_input.submit(
-            fn=global_ai.educate,
-            inputs=[question_input, subject_dropdown, difficulty_dropdown, language_dropdown],
-            outputs=answer_output
+        # Events
+        submit.click(
+            fn=ai.educate,
+            inputs=[question, subject, difficulty, language],
+            outputs=answer,
+            api_name="predict"
         )
         
-        refresh_analytics.click(
-            fn=global_ai.get_global_analytics,
-            outputs=analytics_display
+        question.submit(
+            fn=ai.educate,
+            inputs=[question, subject, difficulty, language],
+            outputs=answer
         )
         
-        # Auto-refresh analytics (fixed for newer Gradio)
-        def refresh_analytics_periodically():
-            while True:
-                time.sleep(30)
-                try:
-                    analytics_display.value = global_ai.get_global_analytics()
-                except:
-                    pass
-        
-        refresh_thread = threading.Thread(target=refresh_analytics_periodically)
-        refresh_thread.daemon = True
-        refresh_thread.start()
+        refresh.click(
+            fn=ai.get_stats,
+            outputs=stats
+        )
         
-        # Global Footer
+        # Footer
         gr.HTML("""
-        <div style="text-align: center; margin-top: 3rem; padding: 2rem; background: linear-gradient(135deg, #f5f7fa 0%, #c3cfe2 100%); border-radius: 15px;">
-            <h3 style="color: #2c3e50; margin-bottom: 1rem;">🌍 Serving Global Education</h3>
-            <p style="color: #34495e; margin-bottom: 1rem;"><strong>Competitive Advantage:</strong> Real dataset integration with Competition Math (AMC/AIME), 
-            Microsoft Orca Mathematical Reasoning, Advanced Science QA, and Academic Knowledge bases.</p>
-            <p style="color: #7f8c8d; font-size: 0.9em;">
-                🚀 <strong>API Endpoint:</strong> https://memoroeisdead-your-education-api.hf.space/run/predict<br>
-                💡 <strong>Supported:</strong> 60+ subjects, 5 difficulty levels, 6 languages, unlimited scale<br>
-                🎯 <strong>Mission:</strong> Making world-class education accessible to everyone, everywhere
-            </p>
+        <div style="text-align: center; margin-top: 2rem; padding: 1rem; background: #f8f9fa; border-radius: 10px;">
+            <p><strong>🌍 Billion Dollar Education AI</strong> - Real dataset integration with premium educational content</p>
+            <p><em>API: https://memoroeisdead-your-education-api.hf.space/run/predict</em></p>
         </div>
         """)
     
-    return interface
+    return demo
 
-# Launch Global Education AI
 if __name__ == "__main__":
-    interface = create_global_interface()
+    interface = create_interface()
     interface.launch(
         server_name="0.0.0.0",
         server_port=7860,
         share=False,
-        show_error=True,
-        show_tips=True,
-        enable_queue=True,  # Handle high traffic
-        max_threads=40      # Scale for millions of users
-    ) 
+        show_error=True
+    )