llm_app_enhanced.py

import gradio as gr
import os
import warnings
from pathlib import Path
import fitz  # PyMuPDF
from langchain_community.embeddings import HuggingFaceEmbeddings
from langchain_community.vectorstores import Chroma
from langchain.prompts import PromptTemplate
from langchain.chains import LLMChain
import anthropic
import base64
from PIL import Image
import io
import re
import random
from dotenv import load_dotenv

# Suppress deprecation warnings
warnings.filterwarnings("ignore", category=DeprecationWarning)

# Load environment variables from .env file
load_dotenv()

# --- Code Practice Assistant ---

class CodePracticeAssistant:
    def __init__(self, curriculum_assistant):
        self.curriculum_assistant = curriculum_assistant
        self.anthropic_client = None
        self._setup_llm()
        
    def _setup_llm(self):
        """Setup Claude LLM for code practice"""
        try:
            self.anthropic_client = anthropic.Anthropic(
                api_key=os.environ.get("ANTHROPIC_KEY")
            )
            print("✅ Code Practice LLM setup successful!")
        except Exception as e:
            print(f"❌ Error setting up Code Practice LLM: {e}")
            self.anthropic_client = None

    def generate_practice_problem(self, topic, problem_type):
        """Generate a practice problem based on topic and curriculum content"""
        if not self.anthropic_client:
            return "LLM not available. Please check your API key.", ""
        
        # First, find relevant curriculum content for the topic
        curriculum_content = self._find_curriculum_content(topic)
        
        # Map dropdown choices to internal problem types
        problem_type_mapping = {
            "Create Practice Problems": "create",
            "Debug - Identify Error Type": "debug_error_type", 
            "Debug - Explain Error Reason": "debug_error_reason",
            "Debug - Fix the Error": "debug_fix",
            "Optimize Code Performance": "optimize"
        }
        
        internal_type = problem_type_mapping.get(problem_type, "create")
        
        problem_types = {
            "create": "Create a coding problem where students need to write code from scratch",
            "debug_error_type": "Create a coding problem with a bug where students need to identify what type of error it is",
            "debug_error_reason": "Create a coding problem with a bug where students need to explain why the error occurs",
            "debug_fix": "Create a coding problem with a bug where students need to fix the code",
            "optimize": "Create a coding problem where students need to optimize/improve the code performance"
        }
        
        # Check if we have curriculum content or need to use generic approach
        if "No specific curriculum content found" in curriculum_content or "could not be retrieved" in curriculum_content:
            # Use generic prompt without curriculum context
            # Add randomization for diversity while keeping it simple
            difficulty_levels = ["beginner", "intermediate", "challenging"]
            problem_styles = [
                "simple calculation", "basic input/output", "pattern printing", 
                "number games", "text processing", "list operations", "basic functions",
                "simple loops", "conditional statements", "variable manipulation"
            ]
            
            problem_contexts = [
                "school project", "homework assignment", "classroom exercise", "practice problem",
                "simple game", "basic calculator", "data collection", "text processing",
                "number games", "pattern drawing", "simple simulation", "basic tools"
            ]
            
            selected_difficulty = random.choice(difficulty_levels)
            selected_style = random.choice(problem_styles)
            selected_context = random.choice(problem_contexts)
            
            prompt = f"""Create a SIMPLE and CLEAR programming practice problem for a student learning {topic}.

Problem Type: {problem_types.get(internal_type, internal_type)}
Difficulty: {selected_difficulty}
Style: {selected_style}
Context: {selected_context}

Requirements:
- Make it appropriate for {selected_difficulty} level
- Use a {selected_style} approach in a {selected_context} setting
- Keep instructions VERY SIMPLE and step-by-step
- Focus on ONE main concept at a time
- Make it engaging but not overwhelming
- ALWAYS include starter code that students can build upon
- Use simple, clear language suitable for beginners
- Avoid complex storylines or too many requirements
- Make it feel achievable and fun

Format your response as:
PROBLEM: [Simple, clear problem description with step-by-step instructions]
CODE: [Simple starter code (3-8 lines) that students can easily understand and modify]

IMPORTANT: 
- Keep the problem structure VERY SIMPLE
- Use clear, direct language
- Focus on the core concept being learned
- Make it feel achievable for beginners
- The starter code should be easy to understand and modify

Create a problem that's engaging but simple enough for students just learning Python!"""
        else:
            # Use curriculum-based prompt with diversity
            # Add randomization for diversity while keeping it simple
            difficulty_levels = ["beginner", "intermediate", "challenging"]
            problem_styles = [
                "simple calculation", "basic input/output", "pattern printing", 
                "number games", "text processing", "list operations", "basic functions",
                "simple loops", "conditional statements", "variable manipulation"
            ]
            
            problem_contexts = [
                "school project", "homework assignment", "classroom exercise", "practice problem",
                "simple game", "basic calculator", "data collection", "text processing"
            ]
            
            selected_difficulty = random.choice(difficulty_levels)
            selected_style = random.choice(problem_styles)
            selected_context = random.choice(problem_contexts)
            
            prompt = f"""Create a SIMPLE and CLEAR programming practice problem for a student learning {topic}.

Curriculum Context: {curriculum_content}

Problem Type: {problem_types.get(internal_type, internal_type)}
Difficulty: {selected_difficulty}
Style: {selected_style}
Context: {selected_context}

Requirements:
- Base the problem on the curriculum content provided above
- Match the difficulty level of what's taught in the curriculum
- Use the same concepts, terminology, and examples from the curriculum
- Make it appropriate for the skill level shown in the curriculum
- Include clear instructions that reference the curriculum concepts
- Provide a specific, focused problem that reinforces what they learned
- Use a {selected_style} approach in a {selected_context} setting
- ALWAYS include starter code that students can build upon
- Keep instructions VERY SIMPLE and step-by-step
- Focus on ONE main concept at a time
- Use simple, clear language suitable for beginners
- Avoid complex storylines or too many requirements
- Make it feel achievable and fun

Format your response as:
PROBLEM: [Simple, clear problem description with step-by-step instructions]
CODE: [Simple starter code (3-8 lines) that students can easily understand and modify]

IMPORTANT: 
- Keep the problem structure VERY SIMPLE
- Use clear, direct language
- Focus on the core concept being learned
- Make it feel achievable for beginners
- The starter code should be easy to understand and modify
- Align with curriculum concepts while keeping it simple

Create a problem that's engaging but simple enough for students just learning Python!"""

        try:
            response = self.anthropic_client.messages.create(
                model="claude-3-5-haiku-20241022",
                max_tokens=1000,
                temperature=0.3,  # Lower temperature for more structured, predictable problems
                messages=[{"role": "user", "content": prompt}]
            )
            
            result = response.content[0].text.strip()
            
            # Parse the response to separate problem and code
            if "PROBLEM:" in result and "CODE:" in result:
                parts = result.split("CODE:")
                problem = parts[0].replace("PROBLEM:", "").strip()
                code = parts[1].strip() if len(parts) > 1 else ""
            else:
                problem = result
                code = ""
            
            return problem, code
            
        except Exception as e:
            return f"Error generating problem: {str(e)}", ""

    def _find_curriculum_content(self, topic):
        """Find relevant curriculum content for the given topic"""
        try:
            # Use the curriculum assistant's vector search to find relevant content
            results = self.curriculum_assistant.vector_db.similarity_search(topic, k=3)
            
            if not results:
                return f"No specific curriculum content found for '{topic}'. Please check the topic name."
            
            # Combine the most relevant curriculum content
            curriculum_content = []
            for i, result in enumerate(results):
                filename = result.metadata['filename']
                page_num = result.metadata['page_number']
                content = result.page_content[:500]  # Limit content length
                curriculum_content.append(f"Slide {i+1} ({filename} - Page {page_num}):\n{content}")
            
            return "\n\n".join(curriculum_content)
            
        except Exception as e:
            print(f"Error finding curriculum content: {e}")
            return f"Curriculum content for '{topic}' could not be retrieved."

    def analyze_student_code(self, topic, problem_type, problem_description, student_code):
        """Analyze student's code and provide feedback based on curriculum"""
        if not self.anthropic_client:
            return "LLM not available. Please check your API key."
        
        # Get curriculum content for context
        curriculum_content = self._find_curriculum_content(topic)
        
        # Map dropdown choices to internal problem types
        problem_type_mapping = {
            "Create Practice Problems": "create",
            "Debug - Identify Error Type": "debug_error_type", 
            "Debug - Explain Error Reason": "debug_error_reason",
            "Debug - Fix the Error": "debug_fix",
            "Optimize Code Performance": "optimize"
        }
        
        internal_type = problem_type_mapping.get(problem_type, "create")
        
        analysis_types = {
            "create": "Evaluate the code for correctness, completeness, and best practices",
            "debug_error_type": "Identify what type of error the code has and explain it",
            "debug_error_reason": "Explain why the error occurs in the code",
            "debug_fix": "Provide the corrected code and explain the fixes",
            "optimize": "Suggest optimizations and explain how they improve performance"
        }
        
        # Check if we have curriculum content or need to use generic approach
        if "No specific curriculum content found" in curriculum_content or "could not be retrieved" in curriculum_content:
            # Use generic analysis prompt - Tutor style
            prompt = f"""You are a helpful programming tutor. Analyze this student's code and provide step-by-step guidance.

Problem Type: {problem_type}
Problem Description: {problem_description}

Student's Code:
{student_code}

Analysis Type: {analysis_types.get(internal_type, "General analysis")}

Provide a CONCISE, step-by-step analysis:
1. **What's Working** (1-2 sentences)
2. **Areas to Improve** (2-3 specific points)
3. **Step-by-Step Solution** (guide them through the process, don't give complete code)
4. **Key Takeaway** (1 sentence)

IMPORTANT: Guide them to figure out the solution themselves. Don't provide complete working code unless they're completely stuck. Focus on hints and direction."""
        else:
            # Use curriculum-based analysis prompt - Tutor style
            prompt = f"""You are a helpful programming tutor. Analyze this student's code and provide step-by-step guidance.

Curriculum Context: {curriculum_content}

Problem Type: {problem_type}
Problem Description: {problem_description}

Student's Code:
{student_code}

Analysis Type: {analysis_types.get(internal_type, "General analysis")}

Provide a CONCISE, step-by-step analysis:
1. **What's Working** (1-2 sentences)
2. **Areas to Improve** (2-3 specific points)
3. **Step-by-Step Solution** (guide them through the process, don't give complete code)
4. **Key Takeaway** (1 sentence)

IMPORTANT: Guide them to figure out the solution themselves. Don't provide complete working code unless they're completely stuck. Focus on hints and direction based on curriculum concepts."""

        try:
            response = self.anthropic_client.messages.create(
                model="claude-3-5-haiku-20241022",
                max_tokens=1500,
                temperature=0.7,
                messages=[{"role": "user", "content": prompt}]
            )
            
            return response.content[0].text.strip()
            
        except Exception as e:
            return f"Error analyzing code: {str(e)}"

    def execute_code(self, code):
        """Execute the student's code and return the output"""
        try:
            import subprocess
            import sys
            from io import StringIO
            import contextlib
            
            # Create a safe execution environment
            local_vars = {}
            output_buffer = StringIO()
            
            # Capture stdout and stderr
            with contextlib.redirect_stdout(output_buffer), contextlib.redirect_stderr(output_buffer):
                try:
                    # Execute the code
                    exec(code, {"__builtins__": __builtins__}, local_vars)
                    output = output_buffer.getvalue()
                    
                    if output.strip():
                        return f"$ python code.py\n{output}"
                    else:
                        return f"$ python code.py\n# Code executed successfully but no output produced"
                        
                except Exception as e:
                    error_output = output_buffer.getvalue()
                    if error_output.strip():
                        return f"$ python code.py\n{error_output}\nError: {str(e)}"
                    else:
                        return f"$ python code.py\nError: {str(e)}"
                    
        except Exception as e:
            return f"$ python code.py\nError: Could not execute code - {str(e)}"

# --- LLM-Powered Curriculum Assistant ---

class LLMCurriculumAssistant:
    def __init__(self, slides_dir="Slides"):
        self.pdf_pages = {}  # {filename: {page_num: text}}
        self.pdf_files = {}  # {filename: path}
        self.chunks = []
        self.chunk_metadata = []
        self.vector_db = None
        self.embeddings = None
        self.llm = None
        self.content_selection_chain = None
        self.answer_chain = None
        
        # Setup
        self._process_pdfs(slides_dir)
        self._build_vector_db()
        self._setup_llm()
        
    def _process_pdfs(self, slides_dir):
        """Process PDFs and extract text"""
        slides_path = Path(slides_dir)
        pdf_files = list(slides_path.glob("*.pdf"))
        
        for pdf_file in pdf_files:
            self.pdf_files[pdf_file.name] = str(pdf_file)
            doc = fitz.open(str(pdf_file))
            pages = {}
            
            for page_num in range(len(doc)):
                page = doc[page_num]
                text = page.get_text()
                if text.strip():
                    pages[page_num + 1] = text.strip()
            
            self.pdf_pages[pdf_file.name] = pages
            doc.close()
            
            # Add each page as a chunk
            for page_num, text in pages.items():
                self.chunks.append(text)
                self.chunk_metadata.append({
                    "filename": pdf_file.name,
                    "page_number": page_num
                })
        
        print(f"✅ Processed {len(pdf_files)} PDF files with {len(self.chunks)} total pages")

    def _build_vector_db(self):
        """Build vector database for semantic search"""
        self.embeddings = HuggingFaceEmbeddings(model_name="sentence-transformers/all-MiniLM-L6-v2")
        self.vector_db = Chroma.from_texts(
            texts=self.chunks,
            embedding=self.embeddings,
            metadatas=self.chunk_metadata,
            persist_directory="./chroma_db"
        )
        print("✅ Vector database built successfully")

    def _setup_llm(self):
        """Setup Claude LLM"""
        try:
            # Initialize Claude client
            self.anthropic_client = anthropic.Anthropic(
                api_key=os.environ.get("ANTHROPIC_KEY")
            )
            
            # Create content selection prompt
            content_selection_template = """Hi! I'm helping a student find the best curriculum slide for their question. 
The student asked: "{question}"
Here are some slides that might be relevant:
{slide_contents}
Could you help me pick the slide that best answers their specific question? Look for:
- Slides that specifically mention what they're asking about
- Slides with clear explanations and examples
- Slides that match the exact terms they used (like "for loops" vs just "loops")
Just respond with the slide number (1, 2, 3, etc.) that you think is most helpful. If none really fit, say "0".
Thanks! Slide number:"""
            
            self.content_selection_prompt = PromptTemplate(
                input_variables=["question", "slide_contents"],
                template=content_selection_template
            )
            
            # Create answer generation prompt
            answer_template = """Hey there! I'm helping a student understand a programming concept. They asked:
"{question}"
Here's what the curriculum slide says about it:
{slide_content}
Could you help me explain this to them in a friendly, educational way? I'd like you to:
- Use the curriculum slide content as your main reference
- Keep explanations concise but clear
- Include practical code examples when relevant
- Make it easy to follow and understand
- Focus on the key concepts from the slide
- Add helpful examples if the slide doesn't have them
- Keep it engaging but not overwhelming

Format your response with:
- Clear, simple explanations
- Code examples in proper code blocks when helpful
- Use the slide content as your foundation
- Keep it concise and focused

Thanks for your help! Here's what I'd tell the student:"""
            
            self.answer_prompt = PromptTemplate(
                input_variables=["question", "slide_content"],
                template=answer_template
            )
            
            print("✅ LLM setup successful!")
            
        except Exception as e:
            print(f"❌ Error setting up LLM: {e}")
            self.anthropic_client = None
            self.content_selection_prompt = None
            self.answer_prompt = None

    def get_pdf_page_image(self, pdf_path, page_num):
        """Get PDF page as image"""
        try:
            doc = fitz.open(pdf_path)
            if page_num <= len(doc):
                page = doc[page_num - 1]
                mat = fitz.Matrix(1.5, 1.5)
                pix = page.get_pixmap(matrix=mat)
                img_data = pix.tobytes("png")
                img = Image.open(io.BytesIO(img_data))
                if img.mode != 'RGB':
                    img = img.convert('RGB')
                doc.close()
                return img
            doc.close()
            return None
        except Exception as e:
            print(f"Error rendering PDF page: {str(e)}")
            return None

    def chat(self, query):
        """Main chat function with LLM-powered content selection and answer generation"""
        print(f"\n🔍 Processing query: {query}")
        
        # Step 1: Vector search to find relevant content
        results = self.vector_db.similarity_search(query, k=5)
        
        if not results:
            return "I couldn't find any relevant content in the curriculum for your question.", [], None, None
        
        print(f"📚 Found {len(results)} relevant slides from vector search")
        
        # Step 2: LLM content selection
        selected_content = None
        selected_result = None
        
        if self.anthropic_client and self.content_selection_prompt:
            try:
                # Prepare slide contents for LLM analysis
                slide_contents = []
                for i, result in enumerate(results):
                    filename = result.metadata['filename']
                    page_num = result.metadata['page_number']
                    content = result.page_content[:800]
                    slide_contents.append(f"Slide {i+1} ({filename} - Page {page_num}):\n{content}")
                
                slide_contents_text = "\n\n".join(slide_contents)
                
                print("🤖 Using LLM to select most relevant content...")
                
                # Format the prompt
                prompt = self.content_selection_prompt.format(
                    question=query, 
                    slide_contents=slide_contents_text
                )
                
                # Get LLM's selection
                response = self.anthropic_client.messages.create(
                    model="claude-3-5-haiku-20241022",
                    max_tokens=1500,
                    temperature=0.7,
                    messages=[{"role": "user", "content": prompt}]
                )
                
                selection_response = response.content[0].text
                print(f"LLM Selection Response: {selection_response}")
                
                # Parse the selection
                try:
                    numbers = re.findall(r'\d+', selection_response)
                    if numbers:
                        selected_index = int(numbers[0]) - 1
                        if 0 <= selected_index < len(results):
                            selected_result = results[selected_index]
                            selected_content = selected_result.page_content
                            print(f"✅ LLM selected slide {selected_index + 1}")
                        else:
                            print(f"⚠️ LLM selection out of range: {selected_index + 1}")
                            selected_result = results[0]
                            selected_content = selected_result.page_content
                    else:
                        print("⚠️ No number found in LLM response, using first result")
                        selected_result = results[0]
                        selected_content = selected_result.page_content
                        
                except Exception as e:
                    print(f"Error parsing LLM selection: {e}")
                    selected_result = results[0]
                    selected_content = selected_result.page_content
                    
            except Exception as e:
                print(f"Error in LLM content selection: {e}")
                selected_result = results[0]
                selected_content = selected_result.page_content
        else:
            # Fallback to first result
            selected_result = results[0]
            selected_content = selected_result.page_content
        
        # Step 3: LLM answer generation
        answer = ""
        if self.anthropic_client and self.answer_prompt and selected_content:
            try:
                print("🤖 Generating LLM answer...")
                
                # Format the prompt
                prompt = self.answer_prompt.format(
                    question=query, 
                    slide_content=selected_content
                )
                
                # Get LLM's answer
                response = self.anthropic_client.messages.create(
                    model="claude-3-5-haiku-20241022",
                    max_tokens=1200,
                    temperature=0.7,
                    messages=[{"role": "user", "content": prompt}]
                )
                
                answer = response.content[0].text.strip()
                print(f"✅ LLM answer generated: {answer[:100]}...")
                
            except Exception as e:
                print(f"Error generating LLM answer: {e}")
                answer = f"Based on the curriculum slide:\n\n{selected_content}\n\nThis slide contains relevant information about your question."
        else:
            answer = f"Based on the curriculum slide:\n\n{selected_content}\n\nThis slide contains relevant information about your question."
        
        # Step 4: Get relevant slides for display
        relevant_slides = []
        if selected_result:
            filename = selected_result.metadata["filename"]
            page_number = selected_result.metadata["page_number"]
            
            if filename in self.pdf_files:
                pdf_path = self.pdf_files[filename]
                doc = fitz.open(pdf_path)
                total_pages = len(doc)
                doc.close()
                
                # Get the selected page and neighboring pages
                start_page = max(1, page_number - 2)
                end_page = min(total_pages, page_number + 2)
                
                for page_num in range(start_page, end_page + 1):
                    img = self.get_pdf_page_image(pdf_path, page_num)
                    if img:
                        if page_num == page_number:
                            label = f"📌 {filename} - Page {page_num} (Most Relevant)"
                        else:
                            label = f"{filename} - Page {page_num}"
                        relevant_slides.append((img, label))
                
                recommended_slide = relevant_slides[0][0] if relevant_slides else None
                recommended_label = relevant_slides[0][1] if relevant_slides else None
            else:
                recommended_slide = None
                recommended_label = None
        else:
            recommended_slide = None
            recommended_label = None
        
        return answer, relevant_slides, recommended_slide, recommended_label

# --- Gradio UI ---
assistant = LLMCurriculumAssistant()
practice_assistant = CodePracticeAssistant(assistant)

def gradio_chat(query):
    """Gradio chat interface"""
    answer, relevant_slides, recommended_slide, recommended_label = assistant.chat(query)
    return answer, relevant_slides

def generate_problem(topic, problem_type):
    """Generate a practice problem"""
    problem, code = practice_assistant.generate_practice_problem(topic, problem_type)
    return problem, code

def analyze_code(topic, problem_type, problem_description, student_code):
    """Analyze student's code and execute it"""
    try:
        # Execute the code to get terminal output
        terminal_output = practice_assistant.execute_code(student_code)
    except Exception as e:
        terminal_output = f"$ python code.py\nError: Could not execute code - {str(e)}"
    
    try:
        # Get LLM analysis (this should always run regardless of execution errors)
        analysis = practice_assistant.analyze_student_code(topic, problem_type, problem_description, student_code)
    except Exception as e:
        analysis = f"Error getting LLM analysis: {str(e)}"
    
    return terminal_output, analysis

def extract_topic_from_query(query):
    """Extract topic from chat query for practice using LLM"""
    try:
        # Use LLM for better topic extraction
        prompt = f"""Extract the main programming topic from this student question. 
        Return ONLY the topic name, nothing else.

        Question: "{query}"

        Examples:
        - "What are for loops?" → "for loops"
        - "How do variables work in Python?" → "variables"
        - "Can you explain functions?" → "functions"
        - "What's the difference between lists and arrays?" → "lists and arrays"
        - "How do I debug my code?" → "debugging"

        Topic:"""

        response = practice_assistant.anthropic_client.messages.create(
            model="claude-3-5-haiku-20241022",
            max_tokens=100,
            temperature=0.1,
            messages=[{"role": "user", "content": prompt}]
        )
        
        topic = response.content[0].text.strip()
        return topic if topic else "programming basics"
        
    except Exception as e:
        print(f"Error in LLM topic extraction: {e}")
        # Fallback to simple extraction
        common_topics = ["for loops", "while loops", "functions", "variables", "arrays", "recursion", "debugging", "lists", "dictionaries", "classes", "objects", "strings", "file handling", "error handling", "modules", "packages"]
        query_lower = query.lower()
        
        for topic in common_topics:
            if topic in query_lower:
                return topic
        
        return "programming basics"  # Default topic

def generate_practice_for_topic(query):
    """Generate practice problem and return with navigation message"""
    topic = extract_topic_from_query(query)
    problem, code = practice_assistant.generate_practice_problem(topic, "Create Practice Problems")
    
    # Create a message to guide user to practice tab
    navigation_message = f"""
🎯 **Practice Problem Generated!**

I've created a practice problem for **{topic}** and loaded it into the Code Practice tab.

**To continue practicing:**
1. Click on the **"💻 Code Practice"** tab above
2. You'll see the topic and problem already filled in
3. Write your solution and click "Analyze My Code"

**Topic:** {topic}
**Problem Type:** Create Practice Problems

Ready to practice? Switch to the Code Practice tab! 🚀
"""
    
    return navigation_message, topic, problem, code



with gr.Blocks(title="LLM Curriculum Assistant", theme=gr.themes.Soft()) as demo:
    gr.Markdown("# 🤖 LLM Curriculum Assistant\nYour AI programming tutor with LLM-powered content selection and code practice!")
    

    
    with gr.Tabs() as tabs:
        # Tab 1: Chat Assistant
        with gr.Tab("💬 Chat Assistant"):
            with gr.Row():
                # Left Column - Chatbot Interface
                with gr.Column(scale=1):
                    gr.Markdown("### 💬 Chatbot")
                    gr.Markdown("**Ask questions about programming concepts:**")
                    
                    question = gr.Textbox(
                        label="Question Input", 
                        placeholder="e.g., What are for loops? How do variables work? Explain functions...", 
                        lines=3
                    )
                    submit = gr.Button("🤖 Ask AI", variant="primary", size="lg")
                    answer = gr.Markdown(label="LLM Generated Answer")
                    
                    # Practice button
                    practice_btn = gr.Button("💻 Practice This Topic", variant="secondary", size="lg", visible=False)
                
                # Right Column - Slides Display
                with gr.Column(scale=1):
                    gr.Markdown("### 📄 Most Relevant Slides")
                    gallery = gr.Gallery(
                        label="Curriculum Slides", 
                        columns=1, 
                        rows=3, 
                        height="600px", 
                        object_fit="contain",
                        show_label=False
                    )
            
            # Event handlers for chat
            submit.click(fn=gradio_chat, inputs=[question], outputs=[answer, gallery])
            question.submit(fn=gradio_chat, inputs=[question], outputs=[answer, gallery])
            
            # Show practice button after chat
            def show_practice_button():
                return gr.Button(visible=True)
            
            submit.click(fn=show_practice_button, outputs=[practice_btn])
            question.submit(fn=show_practice_button, outputs=[practice_btn])
        
        # Tab 2: Code Practice
        with gr.Tab("💻 Code Practice"):
            gr.Markdown("### 🎯 Practice Programming Skills")
            gr.Markdown("Choose a topic and problem type to get started!")
            
            with gr.Row():
                # Left Column - Problem Setup
                with gr.Column(scale=1):
                    gr.Markdown("#### 📝 Problem Setup")
                    
                    topic_input = gr.Textbox(
                        label="Topic to Practice",
                        placeholder="e.g., for loops, functions, variables, arrays, recursion...",
                        lines=2
                    )
                    
                    problem_type = gr.Dropdown(
                        label="Problem Type",
                        choices=[
                            "Create Practice Problems",
                            "Debug - Identify Error Type",
                            "Debug - Explain Error Reason", 
                            "Debug - Fix the Error",
                            "Optimize Code Performance"
                        ],
                        value="Create Practice Problems"
                    )
                    
                    generate_btn = gr.Button("🎲 Generate Problem", variant="primary", size="lg")
                    
                    gr.Markdown("#### 📋 Problem Description")
                    problem_description = gr.Markdown(label="Problem will appear here...")
                    
                    gr.Markdown("#### 💻 Starter Code (if applicable)")
                    starter_code = gr.Code(
                        label="Code Editor",
                        language="python",
                        lines=10,
                        value="# Write your code here..."
                    )
                
                # Right Column - Student Work & Analysis
                with gr.Column(scale=1):
                    gr.Markdown("#### ✍️ Your Solution")
                    
                    student_code = gr.Code(
                        label="Your Code",
                        language="python",
                        lines=15,
                        value="# Write your solution here..."
                    )
                    
                    analyze_btn = gr.Button("🔍 Analyze My Code", variant="secondary", size="lg")
                    
                    gr.Markdown("#### 💻 Code Execution Output")
                    terminal_output = gr.Textbox(
                        label="Terminal Output",
                        lines=8,
                        value="# Code execution output will appear here...",
                        interactive=False
                    )
                    
                    gr.Markdown("#### 📊 AI Analysis")
                    analysis_output = gr.Markdown(label="Analysis will appear here...")
            
            # Event handlers for practice
            generate_btn.click(
                fn=generate_problem,
                inputs=[topic_input, problem_type],
                outputs=[problem_description, starter_code]
            )
            
            analyze_btn.click(
                fn=analyze_code,
                inputs=[topic_input, problem_type, problem_description, student_code],
                outputs=[terminal_output, analysis_output]
            )
            
            # Practice button - generate problem and show navigation message
            practice_btn.click(
                fn=generate_practice_for_topic,
                inputs=[question],
                outputs=[answer, topic_input, problem_description, starter_code]
            )

if __name__ == "__main__":
    demo.launch()