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):
        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 type"""
        if not self.anthropic_client:
            return "LLM not available. Please check your API key.", ""
        
        # 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"
        }
        
        prompt = f"""Create a programming practice problem for a student learning {topic}.

Problem Type: {problem_types.get(internal_type, internal_type)}

Requirements:
- Make it appropriate for beginners to intermediate level
- 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

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

Keep it concise but clear."""

        try:
            response = self.anthropic_client.messages.create(
                model="claude-3-5-haiku-20241022",
                max_tokens=1000,
                temperature=0.7,
                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 analyze_student_code(self, topic, problem_type, problem_description, student_code):
        """Analyze student's code and provide feedback"""
        if not self.anthropic_client:
            return "LLM not available. Please check your API key."
        
        # 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"
        }
        
        prompt = f"""Analyze this student's code for a {topic} practice problem.

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

Student's Code:
{student_code}

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

Please provide:
1. A detailed analysis of their code
2. What they did well
3. Areas for improvement
4. If applicable, the correct solution or fixes
5. Helpful tips and explanations

Be encouraging but honest. Focus on learning and improvement."""

        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)}"

# --- 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
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=1500,
                    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()

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"""
    analysis = practice_assistant.analyze_student_code(topic, problem_type, problem_description, student_code)
    return 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():
        # 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("#### 📊 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=[analysis_output]
            )

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