Update app.py

app.py

@@ -2,60 +2,98 @@ import gradio as gr
 from langchain.prompts import ChatPromptTemplate
 from langchain_huggingface import HuggingFaceEndpoint
 from langchain.schema import HumanMessage, SystemMessage
+from langchain.callbacks.base import BaseCallbackHandler
 import os
+import time
 
-# Set up the LangChain model (using HuggingFace Zephyr model)
+# Custom streaming callback for Gradio
+class GradioStreamingCallback(BaseCallbackHandler):
+    """Custom LangChain callback for streaming to Gradio"""
+    
+    def __init__(self):
+        self.text = ""
+        self.tokens = []
+        
+    def on_llm_start(self, serialized, prompts, **kwargs):
+        """Called when LLM starts generating"""
+        self.text = ""
+        self.tokens = []
+    
+    def on_llm_new_token(self, token: str, **kwargs):
+        """Called when LLM generates a new token"""
+        self.tokens.append(token)
+        self.text += token
+        return self.text
+    
+    def on_llm_end(self, response, **kwargs):
+        """Called when LLM finishes generating"""
+        pass
+    
+    def on_llm_error(self, error, **kwargs):
+        """Called when LLM encounters an error"""
+        self.text += f"\n[Error: {str(error)[:100]}]"
+
+# Set up LangChain model with streaming capabilities
 llm = HuggingFaceEndpoint(
     repo_id="HuggingFaceH4/zephyr-7b-beta",
     temperature=0.7,
     top_p=0.9,
     model_kwargs={
-        "max_length": 1024
+        "max_length": 1536,
+        "return_full_text": False,
+        "repetition_penalty": 1.1,
     },
     huggingfacehub_api_token=os.getenv("HUGGINGFACEHUB_API_TOKEN")
 )
 
-# Create different prompt templates for different subjects
+# Enhanced prompt templates with streaming instructions
 math_template = ChatPromptTemplate.from_messages([
     ("system", """You are an expert math tutor. For every math problem:
-    1. Break it down step-by-step
-    2. Explain the reasoning behind each step
-    3. Show all work clearly
-    4. Check your answer
-    5. Ask if the student has questions about any step"""),
+    1. Break it down step-by-step with detailed explanations
+    2. Explain the reasoning behind each step thoroughly
+    3. Show all work clearly with proper mathematical notation
+    4. Check your answer and explain why it's correct
+    5. Provide additional examples if helpful
+    6. Explain the underlying mathematical concepts
+    
+    Be comprehensive and educational. Structure your response clearly with proper spacing."""),
     ("human", "{question}")
 ])
 
 research_template = ChatPromptTemplate.from_messages([
     ("system", """You are a research skills mentor. Help students with:
-    - Finding reliable sources
-    - Evaluating source credibility  
-    - Proper citation formats
-    - Research strategies
-    - Academic writing techniques
-    Always provide specific, actionable advice."""),
+    - Finding reliable and credible sources
+    - Evaluating source credibility and bias
+    - Proper citation formats (APA, MLA, Chicago, etc.)
+    - Research strategies and methodologies
+    - Academic writing techniques and structure
+    - Database navigation and search strategies
+    
+    Provide detailed, actionable advice with specific examples and clear formatting."""),
     ("human", "{question}")
 ])
 
 study_template = ChatPromptTemplate.from_messages([
     ("system", """You are a study skills coach. Help students with:
-    - Effective study methods
-    - Time management
-    - Memory techniques
-    - Test preparation strategies
+    - Effective study methods for different learning styles
+    - Time management and scheduling techniques
+    - Memory techniques and retention strategies
+    - Test preparation and exam strategies
+    - Note-taking methods and organization
     - Learning style optimization
-    Provide personalized, practical advice."""),
+    
+    Provide comprehensive, personalized advice with practical examples and clear structure."""),
     ("human", "{question}")
 ])
 
 general_template = ChatPromptTemplate.from_messages([
-    ("system", """You are EduBot, a friendly AI learning assistant. You help students with:
-    📐 Math problems (step-by-step solutions)
-    🔍 Research skills (finding sources, citations)
-    📚 Study strategies (effective learning techniques)
-    🛠️ Educational tools (learning resources)
+    ("system", """You are EduBot, a comprehensive AI learning assistant. You help students with:
+    📐 Mathematics (detailed step-by-step solutions and concept explanations)
+    🔍 Research skills (source finding, evaluation, and citation)
+    📚 Study strategies (effective learning techniques and exam preparation)
+    🛠️ Educational tools (guidance on learning resources and technologies)
     
-    Always be encouraging, patient, and thorough in your explanations."""),
+    Always be encouraging, patient, thorough, and comprehensive. Structure responses clearly."""),
     ("human", "{question}")
 ])
 
@@ -63,9 +101,9 @@ def detect_subject(message):
     """Determine which prompt template to use based on the message"""
     message_lower = message.lower()
     
-    math_keywords = ['math', 'solve', 'calculate', 'equation', 'formula', 'algebra', 'geometry', 'calculus', 'derivative', 'integral']
-    research_keywords = ['research', 'source', 'citation', 'bibliography', 'reference', 'academic', 'paper', 'essay', 'thesis']
-    study_keywords = ['study', 'memorize', 'exam', 'test', 'quiz', 'review', 'learn', 'remember']
+    math_keywords = ['math', 'solve', 'calculate', 'equation', 'formula', 'algebra', 'geometry', 'calculus', 'derivative', 'integral', 'theorem', 'proof']
+    research_keywords = ['research', 'source', 'citation', 'bibliography', 'reference', 'academic', 'paper', 'essay', 'thesis', 'database', 'journal']
+    study_keywords = ['study', 'memorize', 'exam', 'test', 'quiz', 'review', 'learn', 'remember', 'focus', 'motivation', 'notes']
     
     if any(keyword in message_lower for keyword in math_keywords):
         return math_template, "🧮 Math Mode"
@@ -76,7 +114,7 @@ def detect_subject(message):
     else:
         return general_template, "🎓 General Mode"
 
-def respond_with_langchain(
+def respond_with_langchain_streaming(
     message,
     history: list[tuple[str, str]],
     system_message,
@@ -84,56 +122,138 @@ def respond_with_langchain(
     temperature,
     top_p,
 ):
+    """Custom LangChain streaming implementation for Gradio"""
+    
     try:
+        # Select appropriate template and mode
         template, mode = detect_subject(message)
-        formatted_prompt = template.format_messages(question=message)
-        prompt_text = f"{formatted_prompt[0].content}\n\nHuman: {formatted_prompt[1].content}\n\nAssistant:"
         
-        response = llm.invoke(prompt_text)
+        # Create custom streaming callback
+        streaming_callback = GradioStreamingCallback()
+        
+        # Create the LangChain chain
+        chain = template | llm
+        
+        # Configure streaming with callbacks
+        config = {
+            "callbacks": [streaming_callback],
+            "metadata": {"mode": mode}
+        }
+        
+        # Start streaming response
+        partial_response = f"*{mode}*\n\n"
+        yield partial_response
+        
+        # Invoke LangChain with streaming
+        try:
+            # Get the response (this triggers the callbacks)
+            response = chain.invoke(
+                {"question": message},
+                config=config
+            )
+            
+            # Handle the streaming output
+            if hasattr(streaming_callback, 'text') and streaming_callback.text:
+                # Use the streamed text from callback
+                final_text = streaming_callback.text
+            else:
+                # Fallback to direct response
+                final_text = str(response)
+            
+            # Clean up the response
+            if len(final_text) > 4000:
+                final_text = final_text[:4000] + "... [Response truncated - ask for continuation]"
+            
+            # Yield the complete response
+            full_response = f"*{mode}*\n\n{final_text}"
+            yield full_response
+            
+        except Exception as invoke_error:
+            yield f"*{mode}*\n\nSorry, I encountered an error while generating the response: {str(invoke_error)[:200]}"
+        
+    except Exception as e:
+        yield f"Sorry, I encountered an error: {str(e)[:200]}"
+
+# Alternative: Simulated Streaming (More Reliable)
+def respond_with_simulated_streaming(
+    message,
+    history: list[tuple[str, str]],
+    system_message,
+    max_tokens,
+    temperature,
+    top_p,
+):
+    """Simulated streaming that chunks a complete LangChain response"""
+    
+    try:
+        # Select template and get mode
+        template, mode = detect_subject(message)
+        
+        # Create LangChain chain
+        chain = template | llm
+        
+        # Show initial mode
+        yield f"*{mode}*\n\nGenerating response..."
+        
+        # Get complete response from LangChain (no streaming)
+        response = chain.invoke({"question": message})
+        
+        # Clean the response
+        if len(response) > 4000:
+            response = response[:4000] + "... [Response truncated - ask for continuation]"
         
-        # Ensure response is clean and properly limited
-        if isinstance(response, str):
-            response = response.strip()
-            # Conservative limit to prevent content-length issues
-            if len(response) > 2500:
-                response = response[:2500] + "... [Response truncated - ask for continuation]"
+        # Simulate streaming by chunking the response
+        words = response.split()
+        partial_response = f"*{mode}*\n\n"
         
-        full_response = f"*{mode}*\n\n{response}"
+        # Stream word by word
+        for i, word in enumerate(words):
+            partial_response += word + " "
+            
+            # Update every few words for smooth streaming effect
+            if i % 3 == 0:  # Update every 3 words
+                yield partial_response
+                time.sleep(0.05)  # Small delay for streaming effect
         
-        # Return directly instead of yielding (no streaming)
-        return full_response
+        # Final complete response
+        yield f"*{mode}*\n\n{response}"
         
     except Exception as e:
-        return f"Sorry, I encountered an error: {str(e)[:150]}"
+        yield f"Sorry, I encountered an error: {str(e)[:200]}"
 
-# Create the Gradio interface
+# Create Gradio interface with custom streaming
 demo = gr.ChatInterface(
-    respond_with_langchain,
-    title="🎓 EduBot | AI Learning Assistant",
-    description="Your personal AI tutor",
+    respond_with_simulated_streaming,  # Use simulated streaming (more reliable)
+    # respond_with_langchain_streaming,  # Use this for true LangChain streaming
+    title="🎓 EduBot",
+    description="Your comprehensive AI tutor",
     examples=[
-        ["Solve the equation 3x + 7 = 22 step by step"],
-        ["How do I find reliable sources for my history paper?"],
-        ["What's the best way to study for a biology exam?"],
-        ["Explain the Pythagorean theorem with an example"],
-        ["How do I cite a website in MLA format?"]
+        ["Solve the quadratic equation x² + 5x + 6 = 0 with complete explanations"],
+        ["How do I conduct a literature review for my psychology research paper?"],
+        ["Create a comprehensive study schedule for my final exams"],
+        ["Explain the concept of derivatives in calculus with real-world examples"],
+        ["How do I properly format citations in APA style with examples?"]
     ],
     additional_inputs=[
         gr.Textbox(
-            value="You are EduBot, an education assitance. You aid users in studying and understanding new concepts. You show, not tell, how to perform mathematical problem solving, research, study concepts, and utilize study tools.",
+            value="You are EduBot, powered by advanced LangChain streaming capabilities.",
             label="System message",
             visible=False  
         ),
-        gr.Slider(minimum=1, maximum=1024, value=512, step=1, label="Max new tokens"),
+        gr.Slider(minimum=1, maximum=1536, value=800, step=1, label="Max new tokens"),
         gr.Slider(minimum=0.1, maximum=2.0, value=0.7, step=0.1, label="Temperature"),
         gr.Slider(
             minimum=0.1,
             maximum=1.0,
-            value=0.95,
+            value=0.9,
             step=0.05,
             label="Top-p (nucleus sampling)",
         ),
     ],
+    theme=gr.themes.Soft(
+        primary_hue="blue",
+        secondary_hue="green"
+    ),
 )
 
 if __name__ == "__main__":