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()