Update app.py

app.py

@@ -5,19 +5,28 @@ from langchain.schema import HumanMessage, SystemMessage
 from langchain.callbacks.base import BaseCallbackHandler
 import os
 import time
+import logging
+import re
 
-# Custom streaming callback for Gradio
+# Set up logging for better debugging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Custom streaming callback with improved behavior
 class GradioStreamingCallback(BaseCallbackHandler):
-    """Custom LangChain callback for streaming to Gradio"""
+    """Enhanced LangChain callback for streaming to Gradio"""
     
     def __init__(self):
         self.text = ""
         self.tokens = []
+        self.is_streaming = False
         
     def on_llm_start(self, serialized, prompts, **kwargs):
         """Called when LLM starts generating"""
         self.text = ""
         self.tokens = []
+        self.is_streaming = True
+        logger.info("LLM generation started")
     
     def on_llm_new_token(self, token: str, **kwargs):
         """Called when LLM generates a new token"""
@@ -27,70 +36,81 @@ class GradioStreamingCallback(BaseCallbackHandler):
     
     def on_llm_end(self, response, **kwargs):
         """Called when LLM finishes generating"""
-        pass
+        self.is_streaming = False
+        logger.info(f"LLM generation completed. Total tokens: {len(self.tokens)}")
     
     def on_llm_error(self, error, **kwargs):
         """Called when LLM encounters an error"""
+        self.is_streaming = False
+        logger.error(f"LLM error: {error}")
         self.text += f"\n[Error: {str(error)[:100]}]"
 
-# Set up LangChain model with streaming capabilities
+# Set up LangChain model with conservative settings
 llm = HuggingFaceEndpoint(
     repo_id="HuggingFaceH4/zephyr-7b-beta",
     temperature=0.7,
     top_p=0.9,
     repetition_penalty=1.1,
-    model_kwargs={"max_length": 1536},
+    model_kwargs={"max_length": 1024},  # More conservative
     huggingfacehub_api_token=os.getenv("HUGGINGFACEHUB_API_TOKEN")
 )
 
-# Enhanced prompt templates with streaming instructions
+# Enhanced prompt templates that use system_message parameter
 math_template = ChatPromptTemplate.from_messages([
-    ("system", """You are an expert math tutor. For every math problem:
-    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."""),
+    ("system", """{system_message}
+
+You are an expert math tutor. For every math problem:
+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."""),
     ("human", "{question}")
 ])
 
 research_template = ChatPromptTemplate.from_messages([
-    ("system", """You are a research skills mentor. Help students with:
-    - 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."""),
+    ("system", """{system_message}
+
+You are a research skills mentor. Help students with:
+- 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."""),
     ("human", "{question}")
 ])
 
 study_template = ChatPromptTemplate.from_messages([
-    ("system", """You are a study skills coach. Help students with:
-    - 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 comprehensive, personalized advice with practical examples and clear structure."""),
+    ("system", """{system_message}
+
+You are a study skills coach. Help students with:
+- 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 comprehensive, personalized advice with practical examples."""),
     ("human", "{question}")
 ])
 
 general_template = ChatPromptTemplate.from_messages([
-    ("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, thorough, and comprehensive. Structure responses clearly."""),
+    ("system", """{system_message}
+
+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, thorough, and comprehensive."""),
     ("human", "{question}")
 ])
 
@@ -111,68 +131,22 @@ def detect_subject(message):
     else:
         return general_template, "🎓 General Mode"
 
-def respond_with_langchain_streaming(
-    message,
-    history: list[tuple[str, str]],
-    system_message,
-    max_tokens,
-    temperature,
-    top_p,
-):
-    """Custom LangChain streaming implementation for Gradio"""
+def smart_truncate(text, max_length=3000):
+    """Intelligently truncate text at sentence boundaries"""
+    if len(text) <= max_length:
+        return text
     
-    try:
-        # Select appropriate template and mode
-        template, mode = detect_subject(message)
-        
-        # 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]}"
+    # Try to cut at last complete sentence
+    sentences = re.split(r'(?<=[.!?]) +', text[:max_length])
+    if len(sentences) > 1:
+        # Remove the last incomplete sentence
+        return ' '.join(sentences[:-1]) + "... [Response truncated - ask for continuation]"
+    else:
+        # Fallback to word boundary
+        words = text[:max_length].split()
+        return ' '.join(words[:-1]) + "... [Response truncated - ask for continuation]"
 
-# Alternative: Simulated Streaming (More Reliable)
-def respond_with_simulated_streaming(
+def respond_with_enhanced_streaming(
     message,
     history: list[tuple[str, str]],
     system_message,
@@ -180,7 +154,7 @@ def respond_with_simulated_streaming(
     temperature,
     top_p,
 ):
-    """Simulated streaming that chunks a complete LangChain response"""
+    """Enhanced LangChain implementation with proper system message handling"""
     
     try:
         # Select template and get mode
@@ -192,66 +166,135 @@ def respond_with_simulated_streaming(
         # Show initial mode
         yield f"*{mode}*\n\nGenerating response..."
         
-        # Get complete response from LangChain (no streaming)
-        response = chain.invoke({"question": message})
+        # Get complete response from LangChain with system message
+        logger.info(f"Processing {mode} query: {message[:50]}...")
         
-        # Clean the response
-        if len(response) > 4000:
-            response = response[:4000] + "... [Response truncated - ask for continuation]"
+        response = chain.invoke({
+            "question": message,
+            "system_message": system_message or "You are EduBot, an AI learning assistant."
+        })
+        
+        # Smart truncation at sentence boundaries
+        response = smart_truncate(response, max_length=3000)
         
         # Simulate streaming by chunking the response
         words = response.split()
         partial_response = f"*{mode}*\n\n"
         
-        # Stream word by word
+        # Stream word by word for better UX
         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
+            # Update every 4 words for smooth streaming effect
+            if i % 4 == 0:
                 yield partial_response
-                time.sleep(0.05)  # Small delay for streaming effect
+                time.sleep(0.03)  # Slightly faster streaming
         
         # Final complete response
-        yield f"*{mode}*\n\n{response}"
+        final_response = f"*{mode}*\n\n{response}"
+        logger.info(f"Response completed. Length: {len(response)} characters")
+        yield final_response
         
     except Exception as e:
-        yield f"Sorry, I encountered an error: {str(e)[:200]}"
+        logger.exception("Error in LangChain response generation")
+        yield f"Sorry, I encountered an error: {str(e)[:150]}"
+
+# Create enhanced Gradio interface with custom theme
+custom_theme = gr.themes.Soft(
+    primary_hue="blue",
+    secondary_hue="green",
+    neutral_hue="slate",
+).set(
+    body_background_fill="linear-gradient(45deg, #f0f9ff, #ecfdf5)",
+    button_primary_background_fill="#2563eb",
+    button_primary_text_color="white",
+)
 
-# Create Gradio interface with custom streaming
+# Create the main interface
 demo = gr.ChatInterface(
-    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",
+    respond_with_enhanced_streaming,
+    title="🎓 EduBot | AI Learning Assistant",
+    description="""
+    **Your comprehensive AI tutor powered by LangChain!**
+    
+    🔧 **Technical Features:**
+    • Dynamic prompt templates based on question type
+    • LangChain chain composition with `|` operator  
+    • Smart response truncation at sentence boundaries
+    • Enhanced error handling and logging
+    
+    📚 **Educational Modes:**
+    • 🧮 **Math Mode** - Step-by-step problem solving with detailed explanations
+    • 🔍 **Research Mode** - Source finding, evaluation, and citation guidance
+    • 📚 **Study Mode** - Learning strategies and exam preparation techniques
+    • 🎓 **General Mode** - Comprehensive educational support
+    
+    💡 **Tip:** Try asking detailed questions for thorough explanations!
+    """,
     examples=[
-        ["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?"]
+        ["Solve the quadratic equation x² + 5x + 6 = 0 with complete step-by-step explanations"],
+        ["How do I conduct a comprehensive literature review for my psychology research paper?"],
+        ["Create a detailed study schedule for my calculus and chemistry final exams"],
+        ["Explain derivatives in calculus with real-world applications and examples"],
+        ["How do I properly format citations in APA style with detailed guidelines?"]
     ],
     additional_inputs=[
         gr.Textbox(
-            value="You are EduBot, powered by advanced LangChain streaming capabilities.",
-            label="System message",
-            visible=False  
+            value="You are EduBot, an expert AI learning assistant. Provide comprehensive, educational responses that help students truly understand concepts.",
+            label="Custom System Message",
+            placeholder="Customize how EduBot behaves...",
+            lines=2,
+            visible=True  # Make it visible so users can customize
+        ),
+        gr.Slider(
+            minimum=1, 
+            maximum=1024, 
+            value=600, 
+            step=1, 
+            label="Max Tokens",
+            info="Higher values = longer responses"
+        ),
+        gr.Slider(
+            minimum=0.1, 
+            maximum=2.0, 
+            value=0.7, 
+            step=0.1, 
+            label="Temperature",
+            info="Higher values = more creative responses"
         ),
-        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.9,
             step=0.05,
-            label="Top-p (nucleus sampling)",
+            label="Top-p",
+            info="Controls response diversity"
         ),
     ],
-    theme=gr.themes.Soft(
-        primary_hue="blue",
-        secondary_hue="green"
+    theme=custom_theme,
+    chatbot=gr.Chatbot(
+        height=500,
+        show_copy_button=True,
+        avatar_images=["👤", "🎓"],
+        bubble_full_width=False,
+        show_share_button=True,
+        placeholder="Hi! I'm EduBot. What would you like to learn today? 📚"
+    ),
+    textbox=gr.Textbox(
+        placeholder="Ask me about math, research, study strategies, or any educational topic...",
+        container=False,
+        scale=7
     ),
+    retry_btn="🔄 Retry",
+    undo_btn="↩️ Undo",
+    clear_btn="🗑️ Clear",
 )
 
 if __name__ == "__main__":
-    demo.launch()
+    logger.info("Starting EduBot application...")
+    demo.launch(
+        share=False,  # Set to True if you want a public link
+        show_error=True,
+        favicon_path=None,
+        show_api=False
+    )