Spaces:
Sleeping
Sleeping
| import gradio as gr | |
| import os | |
| 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 | |
| from dotenv import load_dotenv | |
| # Load environment variables from .env file | |
| load_dotenv() | |
| # --- 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() | |
| def gradio_chat(query): | |
| """Gradio chat interface""" | |
| answer, relevant_slides, recommended_slide, recommended_label = assistant.chat(query) | |
| return answer, relevant_slides | |
| 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 answers!") | |
| 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 | |
| submit.click(fn=gradio_chat, inputs=[question], outputs=[answer, gallery]) | |
| question.submit(fn=gradio_chat, inputs=[question], outputs=[answer, gallery]) | |
| if __name__ == "__main__": | |
| demo.launch() |