Update app.py

app.py

@@ -1,5 +1,4 @@
-# app.py - AI Study Tutor for SEA Exam Preparation
-# Enhanced with PDF upload and RAG capabilities
+# app.py - AI SEA Exam Tutor with UI API Key Entry
 
 import os
 import json
@@ -10,27 +9,22 @@ from pathlib import Path
 
 import gradio as gr
 from groq import Groq
-import PyPDF2  # For PDF text extraction
+import PyPDF2
 
 # -----------------------------
 # Configuration
 # -----------------------------
-GROQ_API_KEY = os.environ.get("GROQ_API_KEY", "").strip()
-client = Groq(api_key=GROQ_API_KEY)
+# API key is now handled via UI input
+api_key_state = {"value": ""}
 
 # SEA-specific configurations
-SEA_SUBJECTS = [
-    "Mathematics",
-    "English Language Arts"
-]
+SEA_SUBJECTS = ["Mathematics", "English Language Arts"]
 
 SEA_MATH_TOPICS = [
     "Number Theory (Fractions, Decimals, Percentages)",
     "Measurement (Perimeter, Area, Volume)",
-    "Geometry",
-    "Algebra Basics",
-    "Word Problems",
-    "Data Interpretation"
+    "Geometry", "Algebra Basics",
+    "Word Problems", "Data Interpretation"
 ]
 
 SEA_ENGLISH_TOPICS = [
@@ -42,99 +36,91 @@ SEA_ENGLISH_TOPICS = [
     "Listening Comprehension (simulated)"
 ]
 
-LANG_OPTIONS = ["English"]  # Primary language for SEA exam
+LANG_OPTIONS = ["English"]
 LEVEL_OPTIONS = ["Beginner", "Intermediate", "Advanced"]
-
-# Storage for uploaded documents
 UPLOADED_DOCS_FILE = "sea_exam_documents.json"
 
+# -----------------------------
+# API Key Management
+# -----------------------------
+def update_api_key(api_key):
+    """Store API key in session state"""
+    api_key_state["value"] = api_key.strip()
+    if api_key_state["value"]:
+        return "✅ API key saved (not visible for security)"
+    else:
+        return "⚠️ API key cleared"
+
+def get_groq_client():
+    """Get Groq client using UI-provided API key"""
+    api_key = api_key_state["value"]
+    if not api_key:
+        return None, "❌ No API key provided"
+    try:
+        client = Groq(api_key=api_key)
+        return client, ""
+    except Exception as e:
+        return None, f"❌ Invalid API key: {str(e)}"
+
+def generate_with_groq(prompt: str) -> str:
+    """Call Groq API using UI-provided API key"""
+    client, error_msg = get_groq_client()
+    if error_msg:
+        return error_msg
+    
+    try:
+        response = client.chat.completions.create(
+            model="llama-3.1-8b-instant",
+            messages=[{"role": "user", "content": prompt}],
+            temperature=0.7,
+            max_tokens=800,
+        )
+        return response.choices[0].message.content
+    except Exception as e:
+        return f"❌ API error: {e}"
+
 # -----------------------------
 # Document Processing Functions
 # -----------------------------
 def extract_text_from_pdf(file_bytes: bytes, filename: str) -> str:
-    """Extract text from uploaded PDF files with SEA-specific formatting."""
+    """Extract text from uploaded PDF files"""
     try:
-        # Create temporary file
         with tempfile.NamedTemporaryFile(suffix=".pdf", delete=False) as tmp_file:
             tmp_file.write(file_bytes)
             tmp_file_path = tmp_file.name
         
-        # Extract text using PyPDF2
         full_text = ""
         with open(tmp_file_path, 'rb') as pdf_file:
             pdf_reader = PyPDF2.PdfReader(pdf_file)
-            
             for page_num in range(len(pdf_reader.pages)):
                 page = pdf_reader.pages[page_num]
                 page_text = page.extract_text()
-                
-                # Add page marker for reference
-                full_text += f"\n--- SEA Paper Page {page_num+1} ---\n"
-                full_text += page_text + "\n"
+                full_text += f"\n--- Page {page_num+1} ---\n{page_text}\n"
         
-        # Clean up temp file
         os.unlink(tmp_file_path)
-        
-        # Post-process: Detect question patterns
-        processed_text = enhance_sea_text_extraction(full_text, filename)
-        
-        return processed_text
+        return full_text
         
     except Exception as e:
         return f"ERROR processing {filename}: {str(e)}"
 
-def enhance_sea_text_extraction(text: str, filename: str) -> str:
-    """Enhance extracted text with SEA-specific pattern recognition."""
-    enhancements = []
-    
-    # Detect common SEA question patterns
-    question_patterns = [
-        r"Question\s+\d+[:\.]\s*(.*?)(?=\nQuestion\s+\d+|$)",
-        r"\d+\.\s+(.*?)(?=\n\d+\.|\Z)",
-        r"Section\s+[A-Z][:\.]\s*(.*?)(?=\nSection\s+[A-Z]|\Z)"
-    ]
-    
-    for pattern in question_patterns:
-        matches = re.findall(pattern, text, re.DOTALL | re.IGNORECASE)
-        if matches:
-            enhancements.append(f"Detected {len(matches)} SEA-style questions")
-            break
-    
-    # Add metadata based on filename
-    year_match = re.search(r'(20\d{2}|19\d{2})', filename)
-    subject_match = re.search(r'(math|english|mathematics|language)', filename, re.IGNORECASE)
-    
-    metadata = f"\n[FILE METADATA]\nFilename: {filename}\n"
-    if year_match:
-        metadata += f"Year: {year_match.group(1)}\n"
-    if subject_match:
-        metadata += f"Subject: {subject_match.group(1).title()}\n"
-    
-    return metadata + "\n" + text + "\n" + "\n".join(enhancements)
-
 def process_uploaded_documents(files) -> str:
-    """Process all uploaded SEA exam documents and build searchable index."""
+    """Process uploaded SEA exam documents"""
     if not files:
-        return "⚠️ No files uploaded. Please upload SEA exam PDFs or text files."
+        return "⚠️ No files uploaded"
     
     all_documents = []
-    processing_summary = []
     
     for file_info in files:
-        # Gradio provides (temp_path, original_filename) for each file
         if isinstance(file_info, tuple) and len(file_info) >= 2:
             file_path, filename = file_info[0], file_info[1]
         else:
-            # Fallback for different Gradio versions
             file_path = file_info
             filename = os.path.basename(str(file_info))
         
         try:
-            # Read file content
             with open(file_path, 'rb') as f:
                 file_bytes = f.read()
             
-            # Extract text based on file type
             if filename.lower().endswith('.pdf'):
                 text_content = extract_text_from_pdf(file_bytes, filename)
                 file_type = "PDF"
@@ -142,86 +128,29 @@ def process_uploaded_documents(files) -> str:
                 text_content = file_bytes.decode('utf-8', errors='replace')
                 file_type = "Text"
             else:
-                text_content = f"Unsupported file type: {filename}"
-                file_type = "Unknown"
+                continue
             
-            # Create structured document entry
             doc_entry = {
                 "filename": filename,
-                "content": text_content[:10000] if len(text_content) > 10000 else text_content,  # Limit size
+                "content": text_content[:10000] if len(text_content) > 10000 else text_content,
                 "type": file_type,
-                "subject": detect_subject_from_content(text_content),
-                "size_chars": len(text_content),
                 "upload_time": gr.utils.datetime.datetime.now().isoformat()
             }
-            
             all_documents.append(doc_entry)
-            processing_summary.append(f"✅ {filename} ({file_type}, {len(text_content)} chars)")
             
         except Exception as e:
-            error_msg = f"❌ Failed to process {filename}: {str(e)}"
-            processing_summary.append(error_msg)
-            print(error_msg)
+            print(f"Failed to process {filename}: {str(e)}")
     
-    # Save documents to JSON file for persistence
     try:
         with open(UPLOADED_DOCS_FILE, 'w', encoding='utf-8') as f:
             json.dump(all_documents, f, ensure_ascii=False, indent=2)
         
-        # Create a quick-search index
-        create_search_index(all_documents)
-        
-        summary = f"📚 **Processing Complete**\n\n"
-        summary += f"**Processed {len(all_documents)} files:**\n"
-        summary += "\n".join(processing_summary)
-        summary += f"\n\n📁 Documents saved to: `{UPLOADED_DOCS_FILE}`"
-        summary += f"\n🔍 Index created for RAG queries."
-        
-        return summary
-        
+        return f"✅ Processed {len(all_documents)} files. Ready for RAG queries."
     except Exception as e:
         return f"❌ Error saving documents: {str(e)}"
 
-def detect_subject_from_content(text: str) -> str:
-    """Auto-detect subject from document content."""
-    text_lower = text.lower()
-    
-    math_keywords = ['fraction', 'decimal', 'percentage', 'geometry', 'algebra', 'equation', 'calculate', 'sum']
-    english_keywords = ['comprehension', 'grammar', 'vocabulary', 'essay', 'reading', 'writing', 'passage']
-    
-    math_count = sum(1 for keyword in math_keywords if keyword in text_lower)
-    english_count = sum(1 for keyword in english_keywords if keyword in text_lower)
-    
-    if math_count > english_count:
-        return "Mathematics"
-    elif english_count > math_count:
-        return "English Language Arts"
-    else:
-        return "General SEA"
-
-def create_search_index(documents: List[Dict]):
-    """Create a simplified search index for quick lookups."""
-    index_entries = []
-    
-    for doc in documents:
-        # Extract first few lines as preview
-        preview_lines = doc['content'].split('\n')[:10]
-        preview = ' '.join([line.strip() for line in preview_lines if line.strip()])
-        
-        index_entry = {
-            "filename": doc['filename'],
-            "subject": doc['subject'],
-            "preview": preview[:200] + "..." if len(preview) > 200 else preview,
-            "size": doc['size_chars']
-        }
-        index_entries.append(index_entry)
-    
-    # Save index
-    with open("sea_document_index.json", 'w', encoding='utf-8') as f:
-        json.dump(index_entries, f, ensure_ascii=False, indent=2)
-
 def get_relevant_context(subject: str, topic: str, max_context: int = 1500) -> str:
-    """Retrieve relevant context from uploaded SEA papers."""
+    """Retrieve relevant context from uploaded papers"""
     try:
         if not os.path.exists(UPLOADED_DOCS_FILE):
             return ""
@@ -230,220 +159,106 @@ def get_relevant_context(subject: str, topic: str, max_context: int = 1500) -> s
             documents = json.load(f)
         
         relevant_parts = []
-        topic_lower = topic.lower()
-        subject_lower = subject.lower()
-        
         for doc in documents:
-            doc_content = doc.get('content', '').lower()
-            doc_subject = doc.get('subject', '').lower()
-            
-            # Check relevance
-            relevance_score = 0
-            if topic_lower in doc_content:
-                relevance_score += 3
-            if subject_lower in doc_subject or subject_lower in doc_content:
-                relevance_score += 2
-            
-            if relevance_score > 0:
-                # Extract most relevant snippet
-                content = doc['content']
-                
-                # Try to find topic mention
-                if topic_lower in content.lower():
-                    idx = content.lower().find(topic_lower)
-                    start = max(0, idx - 200)
-                    end = min(len(content), idx + 500)
-                    snippet = content[start:end]
-                else:
-                    # Take beginning of document
-                    snippet = content[:500] + "..."
-                
-                relevant_parts.append(f"\n--- From: {doc['filename']} (Subject: {doc['subject']}) ---\n{snippet}\n")
+            content = doc.get('content', '').lower()
+            if topic.lower() in content or subject.lower() in content:
+                relevant_parts.append(f"\n--- From: {doc['filename']} ---\n{doc['content'][:500]}...\n")
         
-        # Combine and limit total size
         combined = "\n".join(relevant_parts)
         if len(combined) > max_context:
-            combined = combined[:max_context] + "\n...[context truncated]..."
+            combined = combined[:max_context] + "\n...[truncated]..."
         
         return combined if combined else ""
-        
-    except Exception as e:
-        print(f"Context retrieval error: {e}")
+    except:
         return ""
 
 # -----------------------------
 # Enhanced Generation with RAG
 # -----------------------------
 def generate_with_context(prompt: str, subject: str, topic: str, language: str, level: str) -> str:
-    """Enhanced generator using uploaded SEA papers as context."""
-    # Retrieve relevant context from uploaded documents
+    """Enhanced generator using uploaded papers as context"""
     context = get_relevant_context(subject, topic)
     
-    context_header = ""
     if context:
-        context_header = f"""
-IMPORTANT CONTEXT FROM UPLOADED SEA EXAM PAPERS:
+        enhanced_prompt = f"""
+SEA EXAM CONTEXT FROM UPLOADED PAPERS:
 {context}
 
-BASED ON THE ABOVE SEA EXAM CONTEXT, please respond to the following request:
+REQUEST:
+Subject: {subject}
+Topic: {topic}
+Level: {level}
+
+TASK: {prompt}
+
+Create content aligned with Trinidad & Tobago SEA exam standards.
 """
     else:
-        context_header = """
-NOTE: No SEA exam papers uploaded yet. For more accurate SEA-aligned content, upload past papers using the document upload section.
-"""
-    
-    # Build enhanced prompt
-    enhanced_prompt = f"""
-SEA EXAM TUTOR MODE
-{context_header}
----
-REQUEST DETAILS:
+        enhanced_prompt = f"""
 Subject: {subject}
 Topic: {topic}
-Language: {language}
-Student Level: {level}
+Level: {level}
 
 TASK: {prompt}
 
-SPECIFIC SEA REQUIREMENTS:
-1. Align with Trinidad & Tobago SEA exam standards
-2. Use appropriate difficulty for {level} level
-3. Format similar to actual SEA past papers
-4. Include clear, step-by-step explanations where applicable
-5. Focus on conceptual understanding rather than rote memorization
+Create SEA-aligned content. (No papers uploaded yet)
 """
     
     return generate_with_groq(enhanced_prompt)
 
 # -----------------------------
-# Original Helper Functions (Updated to use RAG)
+# Helper Functions
 # -----------------------------
-def generate_with_groq(prompt: str) -> str:
-    """Call Groq API with error handling."""
-    if not GROQ_API_KEY:
-        return "❌ Missing GROQ_API_KEY. Please set it as a secret/environment variable."
-    
-    try:
-        response = client.chat.completions.create(
-            model="llama-3.1-8b-instant",
-            messages=[{"role": "user", "content": prompt}],
-            temperature=0.7,
-            max_tokens=800,
-        )
-        return response.choices[0].message.content
-    except Exception as e:
-        return f"❌ API error: {e}"
-
 def build_system_context(subject: str, topic: str, language: str, level: str) -> str:
-    return (
-        f"Subject: {subject}\n"
-        f"Topic: {topic}\n"
-        f"Language: {language}\n"
-        f"Student Level: {level}\n"
-        f"Exam: Trinidad & Tobago Secondary Entrance Assessment (SEA)\n"
-    )
+    return f"SEA Exam - {subject}: {topic} ({level})"
 
 def prompt_explanation(subject: str, topic: str, language: str, level: str) -> str:
     ctx = build_system_context(subject, topic, language, level)
-    return (
-        f"{ctx}\n"
-        "Task: Write a clear, friendly, step-by-step explanation of the topic suitable for SEA exam preparation. "
-        "Use examples similar to those found in SEA past papers. "
-        "Include common mistakes students make and how to avoid them. "
-        "Reply in English only."
-    )
-
-def prompt_resources(subject: str, topic: str, language: str, level: str) -> str:
-    ctx = build_system_context(subject, topic, language, level)
-    return (
-        f"{ctx}\n"
-        "Task: Recommend SEA-specific learning resources. "
-        "Include official resources, practice papers, and study strategies. "
-        "Return as a markdown list with resource type, description, and why it's useful for SEA. "
-        "Reply in English only."
-    )
-
-def prompt_roadmap(subject: str, topic: str, language: str, level: str) -> str:
-    ctx = build_system_context(subject, topic, language, level)
-    return (
-        f"{ctx}\n"
-        "Task: Create a 4-week study roadmap for this SEA topic. "
-        "Include weekly goals, practice activities, and checkpoints. "
-        "Add test-taking strategies specific to SEA exam format. "
-        "Reply in English only."
-    )
+    return f"{ctx}\nWrite a step-by-step SEA exam explanation with examples."
 
 def prompt_quiz(subject: str, topic: str, language: str, level: str) -> str:
-    ctx = build_system_context(subject, topic, language, level)
-    return (
-        f"{ctx}\n"
-        "Task: Create SEA-style multiple choice questions with 4 options each. "
-        "Return STRICT JSON only with this schema:\n"
-        "{\n"
-        '  "questions": [\n'
-        '    {\n'
-        '      "question": "string",\n'
-        '      "options": ["A", "B", "C", "D"],\n'
-        '      "answer_index": 0,\n'
-        '      "explanation": "string"\n'
-        "    }\n"
-        "  ]\n"
-        "}\n"
-        "Requirements:\n"
-        "- Exactly 3-5 questions\n"
-        "- Options A-D only\n"
-        "- answer_index is 0-3\n"
-        "- Include explanation for answer\n"
-        "- Questions must be SEA exam appropriate\n"
-    )
-
-def prompt_past_paper_question(subject: str, topic: str) -> str:
-    """Generate a new question in SEA exam format."""
-    return (
-        f"Subject: {subject}\n"
-        f"Topic: {topic}\n"
-        "Task: Create a NEW practice question in the exact format of Trinidad & Tobago SEA exam. "
-        "Include:\n"
-        "1. The question text\n"
-        "2. Multiple choice options (A-D) or structured answer format\n"
-        "3. Correct answer\n"
-        "4. Step-by-step solution\n"
-        "5. Marks allocation\n"
-        "6. Common errors to avoid\n"
-        "Make it original but consistent with SEA standards."
-    )
+    return f"""
+Subject: {subject}, Topic: {topic}, Level: {level}
+Create 3-5 SEA-style multiple choice questions. Return JSON:
+{{
+  "questions": [
+    {{
+      "question": "string",
+      "options": ["A", "B", "C", "D"],
+      "answer_index": 0
+    }}
+  ]
+}}
+"""
 
 # -----------------------------
-# Gradio Callbacks (Updated)
+# Gradio Callbacks
 # -----------------------------
 def on_generate_explanation(subject, topic, language, level):
-    base_prompt = prompt_explanation(subject, topic, language, level)
-    return generate_with_context(base_prompt, subject, topic, language, level)
-
-def on_generate_resources(subject, topic, language, level):
-    base_prompt = prompt_resources(subject, topic, language, level)
-    return generate_with_context(base_prompt, subject, topic, language, level)
-
-def on_generate_roadmap(subject, topic, language, level):
-    base_prompt = prompt_roadmap(subject, topic, language, level)
-    return generate_with_context(base_prompt, subject, topic, language, level)
+    prompt = prompt_explanation(subject, topic, language, level)
+    return generate_with_context(prompt, subject, topic, language, level)
 
 def on_generate_quiz(subject, topic, language, level):
-    base_prompt = prompt_quiz(subject, topic, language, level)
-    raw_json = generate_with_context(base_prompt, subject, topic, language, level)
+    prompt = prompt_quiz(subject, topic, language, level)
+    raw = generate_with_context(prompt, subject, topic, language, level)
     
-    # Parse and normalize quiz
-    quiz = normalize_quiz(parse_quiz_json(raw_json))
+    # Parse JSON
+    quiz = []
+    try:
+        match = re.search(r'\{.*\}', raw, re.DOTALL)
+        if match:
+            parsed = json.loads(match.group())
+            quiz = parsed.get("questions", [])
+    except:
+        pass
     
-    # Update UI components
+    # Update UI
     vis = [False] * 5
-    labels = [("Question", ["Option 1", "Option 2", "Option 3", "Option 4"])] * 5
+    labels = [("Q", ["A", "B", "C", "D"])] * 5
     
-    for i, q in enumerate(quiz[:5]):  # Max 5 questions
+    for i, q in enumerate(quiz[:5]):
         vis[i] = True
-        labels[i] = (f"Q{i+1}. {q['question']}", q["options"])
-    
-    status = f"✅ Generated {len(quiz)} SEA-style questions." if quiz else "⚠️ No valid questions generated."
+        labels[i] = (f"Q{i+1}. {q.get('question', '')}", q.get('options', []))
     
     return (
         quiz,
@@ -452,420 +267,77 @@ def on_generate_quiz(subject, topic, language, level):
         gr.update(visible=vis[2], label=labels[2][0], choices=labels[2][1], value=None),
         gr.update(visible=vis[3], label=labels[3][0], choices=labels[3][1], value=None),
         gr.update(visible=vis[4], label=labels[4][0], choices=labels[4][1], value=None),
-        status
+        f"Generated {len(quiz)} questions" if quiz else "No questions generated"
     )
 
-def on_generate_past_paper_question(subject, topic):
-    prompt = prompt_past_paper_question(subject, topic)
-    return generate_with_context(prompt, subject, topic, "English", "Intermediate")
-
-# -----------------------------
-# Original Quiz Functions (Keep as is)
-# -----------------------------
-def parse_quiz_json(text: str) -> Dict[str, Any]:
-    """Extract and parse JSON quiz from model output."""
-    try:
-        parsed = json.loads(text)
-        if "questions" in parsed:
-            return parsed
-    except Exception:
-        pass
-    
-    match = re.search(r"\{(?:[^{}]|(?R))*\}", text, re.DOTALL)
-    if match:
-        try:
-            parsed = json.loads(match.group(0))
-            if "questions" in parsed:
-                return parsed
-        except Exception:
-            pass
-    
-    return {"questions": []}
-
-def normalize_quiz(quiz: Dict[str, Any]) -> List[Dict[str, Any]]:
-    """Ensure each question has required fields."""
-    cleaned = []
-    for q in quiz.get("questions", []):
-        question = q.get("question")
-        options = q.get("options", [])
-        answer_index = q.get("answer_index")
-        
-        if (
-            isinstance(question, str)
-            and isinstance(options, list)
-            and 2 <= len(options) <= 5
-            and isinstance(answer_index, int)
-            and 0 <= answer_index < len(options)
-        ):
-            cleaned.append({
-                "question": question.strip(),
-                "options": [str(o).strip() for o in options],
-                "answer_index": answer_index,
-                "explanation": q.get("explanation", "No explanation provided.")
-            })
-    
-    return cleaned[:5]
-
-def evaluate_answers(
-    user_choices: List[int], quiz_data: List[Dict[str, Any]]
-) -> Tuple[str, str]:
-    """Compute score and feedback."""
-    if not quiz_data:
-        return "No quiz available.", "Generate a quiz first."
-    
-    correct = 0
-    details = []
-    
-    for i, q in enumerate(quiz_data):
-        user_idx = user_choices[i] if i < len(user_choices) else None
-        ans_idx = q["answer_index"]
-        is_correct = (user_idx == ans_idx)
-        
-        if is_correct:
-            correct += 1
-        
-        chosen = (
-            f"{q['options'][user_idx]}"
-            if isinstance(user_idx, int) and 0 <= user_idx < len(q["options"])
-            else "No answer"
-        )
-        
-        details.append(
-            f"**Q{i+1}:** {'✅ Correct' if is_correct else '❌ Incorrect'}\n"
-            f"Your answer: {chosen}\n"
-            f"Correct answer: {q['options'][ans_idx]}\n"
-            f"Explanation: {q.get('explanation', 'No explanation')}\n"
-        )
-    
-    total = len(quiz_data)
-    score_text = f"## 📊 Score: {correct} / {total}"
-    
-    if correct == total:
-        feedback = "**Excellent!** You've mastered these SEA-style questions."
-    elif correct >= total * 0.7:
-        feedback = "**Good work!** Review the explanations for any mistakes."
-    else:
-        feedback = "**Keep practicing!** Review the topic and try again."
-    
-    feedback += "\n\n### Question Details:\n" + "\n".join(details)
-    return score_text, feedback
-
-def on_display_results(quiz_state, a1, a2, a3, a4, a5):
-    quiz = quiz_state or []
-    
-    # Map selected options to indices
-    selections = []
-    chosen_texts = [a1, a2, a3, a4, a5]
-    
-    for i, q in enumerate(quiz):
-        chosen = chosen_texts[i] if i < len(chosen_texts) else None
-        if chosen is None:
-            selections.append(None)
-            continue
-        
-        try:
-            idx = q["options"].index(chosen)
-            selections.append(idx)
-        except ValueError:
-            selections.append(None)
-    
-    return evaluate_answers(selections, quiz)
-
 # -----------------------------
-# Enhanced Gradio UI
+# Gradio UI
 # -----------------------------
 CSS = """
-:root {
-  --sea-blue: #1a5f7a;
-  --sea-light-blue: #57cc99;
-  --card-bg: #f8f9fa;
-  --border: #dee2e6;
-}
-.gradio-container {max-width: 1200px !important; font-family: 'Segoe UI', sans-serif;}
-#title h1 {color: var(--sea-blue); margin-bottom: 6px; border-bottom: 3px solid var(--sea-light-blue); padding-bottom: 10px;}
-#subtitle {color: #495057; margin-top: 0; font-style: italic;}
-.card {
-  background: var(--card-bg);
-  border: 1px solid var(--border);
-  border-radius: 12px;
-  padding: 18px;
-  box-shadow: 0 4px 12px rgba(26, 95, 122, 0.08);
-  margin-bottom: 20px;
-}
-.btn-primary button {
-  background: linear-gradient(135deg, var(--sea-blue), #2a9d8f) !important;
-  border: none !important;
-  color: white !important;
-  font-weight: 600 !important;
-  border-radius: 8px !important;
-  padding: 10px 24px !important;
-}
-.btn-primary button:hover {
-  background: linear-gradient(135deg, #2a9d8f, var(--sea-blue)) !important;
-  transform: translateY(-2px);
-  transition: all 0.3s ease;
-}
-.section-title {
-  font-weight: 700;
-  color: var(--sea-blue);
-  margin-bottom: 12px;
-  font-size: 18px;
-  display: flex;
-  align-items: center;
-  gap: 8px;
-}
-.section-title::before {
-  content: "📘";
-}
-.upload-section {
-  border: 2px dashed var(--sea-light-blue) !important;
-  background: rgba(87, 204, 153, 0.05) !important;
-}
-.sea-badge {
-  background: var(--sea-light-blue);
-  color: white;
-  padding: 2px 8px;
-  border-radius: 12px;
-  font-size: 12px;
-  font-weight: 600;
-  margin-left: 8px;
-}
+.card {background: #f8f9fa; border-radius: 10px; padding: 15px; margin-bottom: 15px;}
+.btn-primary button {background: #2563eb; color: white; border: none; border-radius: 6px;}
 """
 
-with gr.Blocks(css=CSS, theme=gr.themes.Soft(primary_hue="blue")) as demo:
-    gr.Markdown(
-        """
-        <div id='title'>
-            <h1>🇹🇹 AI SEA Exam Tutor - Trinidad & Tobago</h1>
-            <p id='subtitle'>Secondary Entrance Assessment Preparation Assistant</p>
-        </div>
-        """
-    )
-    
+with gr.Blocks(css=CSS, theme=gr.themes.Soft()) as demo:
+    gr.Markdown("# 🇹🇹 AI SEA Exam Tutor")
+    
+    # API Key Section
+    with gr.Group(elem_classes="card"):
+        gr.Markdown("### 🔑 API Key Configuration")
+        with gr.Row():
+            api_key_input = gr.Textbox(
+                label="Groq API Key",
+                type="password",
+                placeholder="gsk_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
+                lines=1,
+                scale=3
+            )
+            api_key_btn = gr.Button("Save Key", variant="primary", scale=1)
+        api_key_status = gr.Markdown("Enter API key and click Save")
+        api_key_btn.click(update_api_key, [api_key_input], [api_key_status])
+    
+    # Main Inputs
     with gr.Row():
         with gr.Column(scale=1):
             with gr.Group(elem_classes="card"):
-                gr.Markdown("### 📝 SEA Study Parameters")
-                
-                subject = gr.Dropdown(
-                    choices=SEA_SUBJECTS,
-                    value="Mathematics",
-                    label="SEA Subject",
-                    info="Select subject area"
-                )
-                
-                # Dynamic topic based on subject
-                def update_topics(subject):
-                    if subject == "Mathematics":
-                        return gr.Dropdown(choices=SEA_MATH_TOPICS, value=SEA_MATH_TOPICS[0])
-                    else:
-                        return gr.Dropdown(choices=SEA_ENGLISH_TOPICS, value=SEA_ENGLISH_TOPICS[0])
-                
-                topic = gr.Dropdown(
-                    choices=SEA_MATH_TOPICS,
-                    value=SEA_MATH_TOPICS[0],
-                    label="Topic Area"
-                )
-                
-                subject.change(update_topics, inputs=[subject], outputs=[topic])
-                
-                language = gr.Dropdown(
-                    choices=LANG_OPTIONS,
-                    value="English",
-                    label="Language",
-                    interactive=False  # SEA is primarily English
-                )
-                
-                level = gr.Radio(
-                    choices=LEVEL_OPTIONS,
-                    value="Intermediate",
-                    label="Student Level"
-                )
+                gr.Markdown("### Study Parameters")
+                subject = gr.Dropdown(SEA_SUBJECTS, value="Mathematics", label="Subject")
+                topic = gr.Dropdown(SEA_MATH_TOPICS, value=SEA_MATH_TOPICS[0], label="Topic")
+                level = gr.Radio(LEVEL_OPTIONS, value="Intermediate", label="Level")
         
         with gr.Column(scale=2):
-            # Document Upload Section
-            with gr.Group(elem_classes="card upload-section"):
-                gr.Markdown("### 📤 Upload SEA Exam Papers")
-                gr.Markdown("Upload past papers, answer sheets, or study materials. The AI will use these to generate accurate SEA-style content.")
-                
+            with gr.Group(elem_classes="card"):
+                gr.Markdown("### 📤 Upload SEA Papers")
                 uploaded_files = gr.Files(
-                    label="Upload Files (PDF, TXT)",
+                    label="Upload PDF/TXT files",
                     file_types=[".pdf", ".txt"],
-                    file_count="multiple",
-                    interactive=True
-                )
-                
-                with gr.Row():
-                    process_btn = gr.Button(
-                        "Process Uploaded Documents",
-                        variant="primary",
-                        scale=2
-                    )
-                    clear_btn = gr.Button("Clear Files", variant="secondary", scale=1)
-                
-                upload_status = gr.Markdown(
-                    "**Status:** No documents uploaded yet. Upload SEA papers for enhanced accuracy.",
-                    elem_classes="status-text"
-                )
-                
-                # Processing events
-                process_btn.click(
-                    fn=process_uploaded_documents,
-                    inputs=[uploaded_files],
-                    outputs=[upload_status]
-                )
-                
-                clear_btn.click(
-                    fn=lambda: (None, "✅ Files cleared. Upload new documents."),
-                    inputs=[],
-                    outputs=[uploaded_files, upload_status]
+                    file_count="multiple"
                 )
+                process_btn = gr.Button("Process Documents", variant="primary")
+                upload_status = gr.Markdown("Upload files then click Process")
+                process_btn.click(process_uploaded_documents, [uploaded_files], [upload_status])
     
-    # Main Features in Tabs
-    with gr.Tabs():
-        with gr.TabItem("📚 Explanation & Resources"):
-            with gr.Column():
-                with gr.Group(elem_classes="card"):
-                    gr.Markdown("<div class='section-title'>Generate SEA-Aligned Explanation</div>")
-                    btn_explain = gr.Button("Generate Explanation", variant="primary")
-                    explanation = gr.Markdown(
-                        label="SEA-Focused Explanation",
-                        value="Click 'Generate Explanation' for a topic-specific guide.",
-                        elem_classes="output-area"
-                    )
-                
-                with gr.Group(elem_classes="card"):
-                    gr.Markdown("<div class='section-title'>Generate Study Resources</div>")
-                    btn_resources = gr.Button("Generate Resources", variant="primary")
-                    resources = gr.Markdown(
-                        label="Recommended Resources",
-                        value="Resources will appear here.",
-                        elem_classes="output-area"
-                    )
-        
-        with gr.TabItem("🗺️ Study Roadmap"):
-            with gr.Column():
-                with gr.Group(elem_classes="card"):
-                    gr.Markdown("<div class='section-title'>Generate 4-Week Study Roadmap</div>")
-                    btn_roadmap = gr.Button("Generate Roadmap", variant="primary")
-                    roadmap = gr.Markdown(
-                        label="Study Roadmap",
-                        value="Your personalized roadmap will appear here.",
-                        elem_classes="output-area"
-                    )
-        
-        with gr.TabItem("📝 Quiz & Assessment"):
-            with gr.Column():
-                with gr.Group(elem_classes="card"):
-                    gr.Markdown("<div class='section-title'>Generate SEA-Style Quiz</div>")
-                    
-                    with gr.Row():
-                        btn_quiz = gr.Button("Generate New Quiz", variant="primary", scale=2)
-                        btn_past_paper = gr.Button("Generate Past Paper Question", variant="secondary", scale=1)
-                    
-                    quiz_info = gr.Markdown("Click 'Generate New Quiz' to create SEA-style questions.")
-                    
-                    # Past paper question output
-                    past_paper_output = gr.Markdown(visible=False)
-                    
-                    # Quiz state and questions
-                    quiz_state = gr.State([])
-                    
-                    # Question containers (up to 5)
-                    with gr.Column(visible=False) as quiz_container:
-                        q1 = gr.Radio(label="Question 1", choices=[], visible=False, interactive=True)
-                        q2 = gr.Radio(label="Question 2", choices=[], visible=False, interactive=True)
-                        q3 = gr.Radio(label="Question 3", choices=[], visible=False, interactive=True)
-                        q4 = gr.Radio(label="Question 4", choices=[], visible=False, interactive=True)
-                        q5 = gr.Radio(label="Question 5", choices=[], visible=False, interactive=True)
-                
-                with gr.Group(elem_classes="card"):
-                    gr.Markdown("<div class='section-title'>Evaluate Your Answers</div>")
-                    btn_results = gr.Button("Check Answers", variant="primary")
-                    
-                    with gr.Row():
-                        with gr.Column(scale=1):
-                            score = gr.Markdown("**Score:** Not assessed yet.")
-                        with gr.Column(scale=3):
-                            feedback = gr.Markdown("**Feedback:** Submit quiz answers for evaluation.")
-        
-        with gr.TabItem("ℹ️ System Info"):
+    # Features
+    with gr.Row():
+        with gr.Column():
             with gr.Group(elem_classes="card"):
-                gr.Markdown("### System Information")
-                gr.Markdown(f"""
-                **Current Configuration:**
-                - Model: Llama 3.1 8B Instant (via Groq)
-                - RAG Enabled: {'Yes' if os.path.exists(UPLOADED_DOCS_FILE) else 'No'}
-                - Documents Loaded: {len(json.load(open(UPLOADED_DOCS_FILE))) if os.path.exists(UPLOADED_DOCS_FILE) else 0}
-                - Subjects Configured: {len(SEA_SUBJECTS)}
-                
-                **How to use:**
-                1. Upload SEA past papers (PDF format)
-                2. Select subject and topic
-                3. Generate explanations, resources, or quizzes
-                4. The AI will reference uploaded papers for accuracy
-                
-                **Note:** All content is generated based on SEA exam standards and any uploaded materials.
-                """)
-    
-    # Event Handlers
-    btn_explain.click(
-        fn=on_generate_explanation,
-        inputs=[subject, topic, language, level],
-        outputs=[explanation]
-    )
+                gr.Markdown("### Explanation")
+                btn_explain = gr.Button("Generate Explanation", variant="primary")
+                explanation = gr.Markdown("Explanation will appear here")
+                btn_explain.click(on_generate_explanation, [subject, topic, "English", level], [explanation])
     
-    btn_resources.click(
-        fn=on_generate_resources,
-        inputs=[subject, topic, language, level],
-        outputs=[resources]
-    )
-    
-    btn_roadmap.click(
-        fn=on_generate_roadmap,
-        inputs=[subject, topic, language, level],
-        outputs=[roadmap]
-    )
-    
-    btn_quiz.click(
-        fn=on_generate_quiz,
-        inputs=[subject, topic, language, level],
-        outputs=[quiz_state, q1, q2, q3, q4, q5, quiz_info]
-    ).then(
-        fn=lambda: gr.update(visible=True),
-        inputs=[],
-        outputs=[quiz_container]
-    )
-    
-    btn_past_paper.click(
-        fn=on_generate_past_paper_question,
-        inputs=[subject, topic],
-        outputs=[past_paper_output]
-    ).then(
-        fn=lambda: gr.update(visible=True),
-        inputs=[],
-        outputs=[past_paper_output]
-    )
-    
-    btn_results.click(
-        fn=on_display_results,
-        inputs=[quiz_state, q1, q2, q3, q4, q5],
-        outputs=[score, feedback]
-    )
+    with gr.Row():
+        with gr.Column():
+            with gr.Group(elem_classes="card"):
+                gr.Markdown("### Quiz")
+                btn_quiz = gr.Button("Generate Quiz", variant="primary")
+                quiz_info = gr.Markdown("Click to generate quiz")
+                quiz_state = gr.State([])
+                q1 = gr.Radio([], visible=False, label="Q1")
+                q2 = gr.Radio([], visible=False, label="Q2")
+                q3 = gr.Radio([], visible=False, label="Q3")
+                btn_quiz.click(on_generate_quiz, [subject, topic, "English", level], 
+                             [quiz_state, q1, q2, q3, quiz_info, quiz_info, quiz_info])
 
-# -----------------------------
-# Launch Application
-# -----------------------------
 if __name__ == "__main__":
-    # Create necessary directories
-    os.makedirs("uploads", exist_ok=True)
-    os.makedirs("data", exist_ok=True)
-    
-    # Launch with file upload support
-    demo.launch(
-        server_name="0.0.0.0",
-        server_port=7860,
-        share=False,
-        max_file_size="20mb",  # Limit file size for safety
-        show_error=True
-    )
+    demo.launch(server_name="0.0.0.0", server_port=7860)