Update app.py

app.py

@@ -12,29 +12,226 @@ import re
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
-# Custom streaming callback with improved behavior
-class GradioStreamingCallback(BaseCallbackHandler):
-    """Enhanced LangChain callback for streaming to Gradio"""
+# 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": 1024},
+    huggingfacehub_api_token=os.getenv("HUGGINGFACEHUB_API_TOKEN")
+)
+
+# Enhanced prompt templates that use system_message parameter
+math_template = ChatPromptTemplate.from_messages([
+    ("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", """{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", """{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", """{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}")
+])
+
+def detect_subject(message):
+    """Determine which prompt template to use based on the message"""
+    message_lower = message.lower()
     
-    def __init__(self):
-        self.text = ""
-        self.tokens = []
-        self.is_streaming = False
+    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"
+    elif any(keyword in message_lower for keyword in research_keywords):
+        return research_template, "🔍 Research Mode"
+    elif any(keyword in message_lower for keyword in study_keywords):
+        return study_template, "📚 Study Mode"
+    else:
+        return general_template, "🎓 General Mode"
+
+def smart_truncate(text, max_length=3000):
+    """Intelligently truncate text at sentence boundaries"""
+    if len(text) <= max_length:
+        return text
+    
+    # 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]"
+
+def respond_with_enhanced_streaming(
+    message,
+    history: list[tuple[str, str]],
+    system_message,
+    max_tokens,
+    temperature,
+    top_p,
+):
+    """Enhanced LangChain implementation with proper system message handling"""
+    
+    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 with system message
+        logger.info(f"Processing {mode} query: {message[:50]}...")
+        
+        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 for better UX
+        for i, word in enumerate(words):
+            partial_response += word + " "
+            
+            # Update every 4 words for smooth streaming effect
+            if i % 4 == 0:
+                yield partial_response
+                time.sleep(0.03)  # Slightly faster streaming
         
-    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")
+        # Final complete response
+        final_response = f"*{mode}*\n\n{response}"
+        logger.info(f"Response completed. Length: {len(response)} characters")
+        yield final_response
+        
+    except Exception as e:
+        logger.exception("Error in LangChain response generation")
+        yield f"Sorry, I encountered an error: {str(e)[:150]}"
+
+# Create enhanced Gradio interface (simplified for compatibility)
+demo = gr.ChatInterface(
+    respond_with_enhanced_streaming,
+    title="🎓 EduBot | AI Learning Assistant",
+    description="""
+    **Your comprehensive AI tutor powered by LangChain!**
     
-    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
+    🔧 **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
     
-    def on_llm_end(self, response, **kwargs):
+    💡 **Tip:** Try asking detailed questions for thorough explanations!
+    """,
+    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, 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
+        ),
+        gr.Slider(
+            minimum=1, 
+            maximum=1024, 
+            value=600, 
+            step=1, 
+            label="Max 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"
+        ),
+    ],
+    theme=gr.themes.Soft(
+        primary_hue="blue",
+        secondary_hue="green"
+    )
+)
+
+if __name__ == "__main__":
+    logger.info("Starting EduBot application...")
+    demo.launch()    def on_llm_end(self, response, **kwargs):
         """Called when LLM finishes generating"""
         self.is_streaming = False
         logger.info(f"LLM generation completed. Total tokens: {len(self.tokens)}")