llm_app.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
            difficulty_levels = ["beginner", "intermediate", "challenging"]
            problem_styles = [
                "real-world scenario", "mathematical calculation", "data processing", 
                "game logic", "text manipulation", "pattern recognition", "algorithm implementation"
            ]
            
            selected_difficulty = random.choice(difficulty_levels)
            selected_style = random.choice(problem_styles)
            
            prompt = f"""Create a programming practice problem for a student learning {topic}.

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

Requirements:
- Make it appropriate for {selected_difficulty} level
- Use a {selected_style} approach
- Include clear instructions
- Provide a specific, focused problem
- If it's a debug problem, include the buggy code
- If it's an optimization problem, provide the original code
- Make it engaging and educational
- Be creative and diverse - avoid repetitive problems

Format your response as:
PROBLEM: [The problem description and requirements]
CODE: [Any starter code if applicable, or "Write your code here:"]

IMPORTANT: If you include example outputs, format them as code blocks like this:
```
Example Output:
1
1 2
1 2 3
1 2 3 4
1 2 3 4 5
```

Keep it concise but clear and make it different from typical textbook problems."""
        else:
            # Use curriculum-based prompt with diversity
            # Add randomization for diversity even with curriculum
            difficulty_levels = ["beginner", "intermediate", "challenging"]
            problem_styles = [
                "real-world scenario", "mathematical calculation", "data processing", 
                "game logic", "text manipulation", "pattern recognition", "algorithm implementation"
            ]
            
            selected_difficulty = random.choice(difficulty_levels)
            selected_style = random.choice(problem_styles)
            
            prompt = f"""Create a 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}

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 to make it diverse
- If it's a debug problem, include the buggy code
- If it's an optimization problem, provide the original code
- Make it engaging and educational
- Be creative and diverse - avoid repetitive problems

Format your response as:
PROBLEM: [The problem description and requirements]
CODE: [Any starter code if applicable, or "Write your code here:"]

IMPORTANT: If you include example outputs, format them as code blocks like this:
```
Example Output:
1
1 2
1 2 3
1 2 3 4
1 2 3 4 5
```

Keep it concise but clear and aligned with the curriculum difficulty while being creative and diverse."""

        try:
            response = self.anthropic_client.messages.create(
                model="claude-3-5-haiku-20241022",
                max_tokens=1000,
                temperature=0.9,  # Higher temperature for more diversity
                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:
- Break it down in simple terms
- Use examples if the slide has them
- Make it step-by-step and easy to follow
- Add some helpful context if the slide is brief
- Use bullet points or lists to make it clear
- Make sure your answer directly addresses what they asked
- Include code examples when relevant
- Provide detailed explanations with examples
- Be comprehensive and educational
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=2000,
                    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



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")
                
                # 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])
        
        # 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]
            )

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