Upload app.py

app.py

@@ -103,12 +103,11 @@ class CurriculumChatbot:
             self.llm = HuggingFacePipeline(pipeline=pipe)
             
             # Warm and engaging prompt templates
-            qa_template = """You are a friendly and encouraging programming tutor. A student has asked: {question}
+            qa_template = """Answer this question: {question}
 
-Here's the relevant curriculum content to help answer their question:
-{filled_context}
+Using this information: {filled_context}
 
-Please provide a warm, encouraging answer that directly answers their question using the curriculum content. Use a conversational tone and explain the concepts clearly."""
+Provide a helpful, friendly answer."""
             
             self.qa_prompt = PromptTemplate(
                 input_variables=["question", "filled_context"],
@@ -131,12 +130,11 @@ Please select the most relevant slide (filename.pdf - Page X) that would best he
             self.slide_selection_chain = self.slide_selection_prompt | self.llm
             
             # Warm and detailed focused QA template
-            focused_qa_template = """You are a friendly and encouraging programming tutor. A student has asked: {question}
+            focused_qa_template = """Answer this question: {question}
 
-Here's the curriculum slide content to help answer their question:
-{slide_content}
+Using this information: {slide_content}
 
-Please provide a warm, encouraging answer that directly answers their question about the slide content. Use a conversational tone and explain the concepts clearly."""
+Provide a helpful, friendly answer."""
             
             self.focused_qa_prompt = PromptTemplate(
                 input_variables=["question", "slide_content"],
@@ -145,6 +143,8 @@ Please provide a warm, encouraging answer that directly answers their question a
             self.focused_qa_chain = self.focused_qa_prompt | self.llm
             
             print("✅ Optimized model loaded successfully!")
+            print(f"🔍 LLM object: {self.llm}")
+            print(f"🔍 Focused QA chain: {self.focused_qa_chain}")
         except Exception as e:
             print(f"Warning: Could not load optimized model: {e}")
             print("Falling back to basic search mode...")
@@ -191,283 +191,72 @@ Please provide a warm, encouraging answer that directly answers their question a
         return "\n".join(slides_text)
 
     def chat(self, query):
-        """Comprehensive chat function with LLM answers and slide navigation"""
-        # Check cache first for faster responses
-        if query in self.response_cache:
-            print("✅ Using cached response")
-            return self.response_cache[query]
+        """Simplified chat function with vector search, LLM analysis, and slide display"""
         
-        # First, try to find relevant curriculum content
-        results = self.vector_db.similarity_search(query, k=3)  # Reduced from 5 to 3 for speed
+        # 1. Vector Search - Find relevant slides
+        results = self.vector_db.similarity_search(query, k=3)
         
-        # Check if query is curriculum-related
-        curriculum_relevance_score = 0
-        if results:
-            # Calculate relevance score based on similarity and content relevance
-            relevant_results = []
-            for result in results:
-                content = result.page_content.lower()
-                query_terms = query.lower().split()
-                
-                # Check if any query terms appear in the content
-                term_matches = sum(1 for term in query_terms if len(term) > 2 and term in content)
-                
-                # Only consider results that have some relevance to the query
-                if term_matches > 0 or len(content.strip()) > 50:
-                    relevant_results.append(result)
-            
-            curriculum_relevance_score = len(relevant_results)
-            results = relevant_results  # Use only relevant results
-            
-            # Debug: Print what we found
-            print(f"Query: {query}")
-            print(f"Found {len(results)} relevant results:")
-            for i, result in enumerate(results[:3]):
-                print(f"  {i+1}. {result.metadata['filename']} - Page {result.metadata['page_number']}")
-                print(f"     Content: {result.page_content[:100]}...")
+        if not results:
+            return "I couldn't find relevant content in the curriculum for this question.", None, None, []
         
-        # Use LLM to analyze top 5 slides and select the best one for teaching
-        best_slide_content = ""
-        best_result = None
-        if curriculum_relevance_score > 0 and self.slide_selection_chain and not self.fast_mode:
-            try:
-                # Prepare slide contents for LLM analysis
-                slide_contents = []
-                for i, result in enumerate(results[:5]):  # Top 5 results
-                    filename = result.metadata["filename"]
-                    page_num = result.metadata["page_number"]
-                    content = result.page_content
-                    slide_contents.append(f"Slide {i+1}: {filename} - Page {page_num}\nContent: {content}\n")
-                
-                slide_contents_text = "\n".join(slide_contents)
-                
-                # Use LLM to select the best slide
-                slide_response = self.slide_selection_chain.invoke({
-                    "question": query, 
-                    "slide_contents": slide_contents_text
-                })
-                
-                # Extract filename and page from response
-                slide_response = slide_response.strip()
-                if "<|eot_id|>" in slide_response:
-                    slide_response = slide_response.split("<|eot_id|>")[-1].strip()
-                
-                # Parse the response to get filename and page
-                match = re.search(r'(.+\.pdf)\s*-\s*Page\s*(\d+)', slide_response)
-                if match:
-                    filename = match.group(1)
-                    page_num = int(match.group(2))
-                    
-                    # Find the corresponding result
-                    for result in results:
-                        if (result.metadata["filename"] == filename and 
-                            result.metadata["page_number"] == page_num):
-                            best_result = result
-                            best_slide_content = result.page_content
-                            break
-                    
-                    # If LLM selection failed, fall back to first result
-                    if not best_result:
-                        best_result = results[0]
-                        best_slide_content = results[0].page_content
-                else:
-                    # Fallback to first result if parsing failed
-                    best_result = results[0]
-                    best_slide_content = results[0].page_content
-                    
-            except Exception as e:
-                print(f"Error in LLM slide selection: {e}")
-                # Fallback to first result
-                best_result = results[0]
-                best_slide_content = results[0].page_content
-        else:
-            # Fallback without LLM
-            if curriculum_relevance_score > 0:
-                best_result = results[0]
-                best_slide_content = results[0].page_content
+        # Debug: Show what we found
+        print(f"Query: {query}")
+        print(f"Found {len(results)} relevant slides:")
+        for i, result in enumerate(results):
+            print(f"  {i+1}. {result.metadata['filename']} - Page {result.metadata['page_number']}")
         
-        # Generate focused LLM answer using the most relevant slide
-        if self.focused_qa_chain and curriculum_relevance_score > 0 and not self.fast_mode:
+        # 2. LLM Check - Analyze slides and generate answer
+        best_result = results[0]
+        best_slide_content = best_result.page_content
+        
+        if self.focused_qa_chain and not self.fast_mode:
             try:
+                print(f"🔍 Calling LLM with question: {query}")
+                
                 answer = self.focused_qa_chain.invoke({
                     "question": query, 
                     "slide_content": best_slide_content
                 })
                 
-                # Debug: Print what the LLM returned
-                print(f"LLM Raw Response: {answer[:200]}...")
+                print(f"LLM Response: {answer[:100]}...")
                 
                 # Clean up the answer
                 answer = answer.strip()
                 if "<|eot_id|>" in answer:
                     answer = answer.split("<|eot_id|>")[-1].strip()
                 
-                # Remove any prompt artifacts
-                if answer.startswith("Answer:"):
-                    answer = answer[7:].strip()
-                if answer.startswith("Provide a clear, educational answer based on this slide:"):
-                    answer = answer[58:].strip()
-                
-                # If LLM response is too short or problematic, show slide content with explanation
-                if len(answer.strip()) < 30:
-                    slide_info = f"📄 **Slide Reference:** {best_result.metadata['filename']} - Page {best_result.metadata['page_number']}"
-                    answer = f"{slide_info}\n\n**Slide Content:**\n{best_slide_content}\n\n*Note: Here's the relevant curriculum content to help answer your question.*"
-                
-            except Exception as e:
-                print(f"Error generating focused answer: {e}")
-                # Show slide content with explanation
-                slide_info = f"📄 **Slide Reference:** {best_result.metadata['filename']} - Page {best_result.metadata['page_number']}"
-                answer = f"{slide_info}\n\n**Slide Content:**\n{best_slide_content}\n\n*Note: Here's the relevant curriculum content to help answer your question.*"
-        
-        elif self.qa_chain and not self.fast_mode:
-            # Fallback to general LLM if focused chain fails
-            try:
-                if curriculum_relevance_score > 0:
-                    context = "\n\n".join([result.page_content for result in results])
-                    filled_context = f"Here's the relevant curriculum content from the student's course materials:\n{context}\n\nPlease provide a warm, encouraging answer that directly uses this curriculum content to help the student understand the concept."
-                else:
-                    filled_context = "Note: This question is not covered in the current curriculum. Please provide a friendly, general programming answer that encourages the student's curiosity."
-                
-                answer = self.qa_chain.invoke({
-                    "question": query, 
-                    "filled_context": filled_context
-                })
-                
-                # Clean up the answer
-                answer = answer.strip()
-                if "<|eot_id|>" in answer:
-                    answer = answer.split("<|eot_id|>")[-1].strip()
-                if answer.startswith("Answer:"):
-                    answer = answer[7:].strip()
-                if answer.startswith("Provide a clear, educational answer explaining the concept:"):
-                    answer = answer[58:].strip()
-                
-                # If answer is too short, show slide content
-                if len(answer.strip()) < 30:
-                    if curriculum_relevance_score > 0:
-                        slide_info = f"📄 **Slide Reference:** {best_result.metadata['filename']} - Page {best_result.metadata['page_number']}"
-                        answer = f"{slide_info}\n\n**Slide Content:**\n{best_slide_content}\n\n*Note: Here's the relevant curriculum content to help answer your question.*"
-                    else:
-                        answer = "I'm sorry, I couldn't generate a proper answer right now. Please try rephrasing your question - sometimes a different way of asking helps! 😊"
-                
-                # Add warning if not in curriculum
-                if curriculum_relevance_score == 0:
-                    answer = "💡 **Note: This topic isn't covered in your current curriculum, but here's a helpful answer:**\n\n" + answer
-                
             except Exception as e:
                 print(f"Error generating answer: {e}")
-                if curriculum_relevance_score > 0:
-                    slide_info = f"📄 **Slide Reference:** {best_result.metadata['filename']} - Page {best_result.metadata['page_number']}"
-                    answer = f"{slide_info}\n\n**Slide Content:**\n{best_slide_content}\n\n*Note: Here's the relevant curriculum content to help answer your question.*"
-                else:
-                    answer = "I'm sorry, I couldn't generate an answer at the moment. Please try rephrasing your question - sometimes a different approach helps! 😊"
+                answer = f"📄 **Slide Reference:** {best_result.metadata['filename']} - Page {best_result.metadata['page_number']}\n\n**Slide Content:**\n{best_slide_content}"
         else:
-            # If no LLM available
-            if curriculum_relevance_score > 0:
-                slide_info = f"📄 **Slide Reference:** {best_result.metadata['filename']} - Page {best_result.metadata['page_number']}"
-                answer = f"{slide_info}\n\n**Great question! Here's what your curriculum teaches:**\n\n{best_slide_content}\n\n*Note: AI generation is not available, but here's the relevant curriculum content to help you learn!* 🌟"
-            else:
-                answer = "I couldn't find any programming-related content in the curriculum for this question. This appears to be about something outside the scope of your programming course. Try asking about programming concepts like variables, loops, functions, or other topics covered in your curriculum! 😊"
+            # Fallback to slide content
+            answer = f"📄 **Slide Reference:** {best_result.metadata['filename']} - Page {best_result.metadata['page_number']}\n\n**Slide Content:**\n{best_slide_content}"
         
-        # Get the most relevant slide and its neighboring pages
+        # 3. Slide Output - Get relevant slides
         relevant_slides = []
-        if curriculum_relevance_score > 0:
-            # Get multiple relevant results to find the best one
-            best_result = results[0]
-            filename = best_result.metadata["filename"]
-            page_number = best_result.metadata["page_number"]
-            
-            # Get the specific PDF and its pages
-            if filename in self.pdf_files:
-                pdf_path = self.pdf_files[filename]
-                doc = fitz.open(pdf_path)
-                total_pages = len(doc)
-                doc.close()
-                
-                # Find the best content page by analyzing all results
-                target_page = page_number
-                best_content_score = 0
-                
-                # Check all search results for the best content page
-                for result in results:
-                    if result.metadata["filename"] == filename:
-                        page_num = result.metadata["page_number"]
-                        page_text = self.pdf_pages[filename].get(page_num, "")
-                        text_length = len(page_text.strip())
-                        
-                        # Score based on text length and relevance
-                        content_score = text_length
-                        if text_length > 100:  # Prefer content pages over title slides
-                            content_score += 500
-                        
-                        if content_score > best_content_score:
-                            best_content_score = content_score
-                            target_page = page_num
-                
-                # If we still have a title slide, look for better content in the same PDF
-                page_text = self.pdf_pages[filename].get(target_page, "")
-                if len(page_text.strip()) < 150:  # Still a title slide
-                    # Search for pages with the query terms
-                    query_terms = query.lower().split()
-                    best_match_score = 0
-                    
-                    for page_num in range(1, total_pages + 1):
-                        if page_num in self.pdf_pages[filename]:
-                            text = self.pdf_pages[filename][page_num].lower()
-                            text_length = len(text.strip())
-                            
-                            # Count how many query terms appear in this page
-                            match_score = sum(1 for term in query_terms if term in text)
-                            
-                            # Prefer pages with both query terms and good content
-                            if match_score > 0 and text_length > 200:
-                                total_score = match_score * 1000 + text_length
-                                if total_score > best_match_score:
-                                    best_match_score = total_score
-                                    target_page = page_num
-                
-                # Get the target page and neighboring pages (2 before, 2 after)
-                start_page = max(1, target_page - 2)
-                end_page = min(total_pages, target_page + 2)
-                
-                # Use a set to track unique slides and avoid duplicates
-                seen_slides = set()
-                
-                for page_num in range(start_page, end_page + 1):
-                    img = self.get_pdf_page_image(pdf_path, page_num)
-                    if img:
-                        slide_key = f"{filename}-{page_num}"
-                        if slide_key not in seen_slides:
-                            seen_slides.add(slide_key)
-                            if page_num == target_page:
-                                # Highlight the most relevant page
-                                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:
-                # Fallback if filename not found
-                recommended_slide = None
-                recommended_label = None
-        else:
-            # If no curriculum content, provide a helpful response
-            relevant_slides = []
-            recommended_slide = None
-            recommended_label = None
-        
-        # Cache the response for future use
-        self.response_cache[query] = (answer, recommended_slide, recommended_label, relevant_slides)
+        filename = best_result.metadata["filename"]
+        page_number = best_result.metadata["page_number"]
         
-        # Limit cache size to prevent memory issues
-        if len(self.response_cache) > 50:
-            # Remove oldest entries
-            oldest_key = next(iter(self.response_cache))
-            del self.response_cache[oldest_key]
+        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 target page and neighboring pages (2 before, 2 after)
+            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))
         
-        return answer, recommended_slide, recommended_label, relevant_slides
+        return answer, relevant_slides[0][0] if relevant_slides else None, relevant_slides[0][1] if relevant_slides else None, relevant_slides
 
 # --- Gradio UI ---
 chatbot = CurriculumChatbot(fast_mode=False)  # Enable AI mode by default