Update app.py

app.py

@@ -8,6 +8,15 @@ import json
 import re
 import requests
 
+# --- LangChain Imports ---
+from langchain.tools import BaseTool
+from langchain.agents import initialize_agent, AgentType
+from langchain.llms.huggingface_hub import HuggingFaceHub
+from langchain.memory import ConversationBufferWindowMemory
+from langchain.prompts import PromptTemplate
+from pydantic import BaseModel, Field
+from typing import Type, Optional
+
 # --- Environment and Logging Setup ---
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
@@ -17,55 +26,77 @@ hf_token = os.environ.get("HF_TOKEN") or os.environ.get("HUGGINGFACEHUB_API_TOKE
 if not hf_token:
     logger.warning("Neither HF_TOKEN nor HUGGINGFACEHUB_API_TOKEN is set, the application may not work.")
 
-# --- HF API Configuration ---
-HF_API_URL = "https://api-inference.huggingface.co/models/Qwen/Qwen2.5-VL-7B-Instruct"
-HF_HEADERS = {"Authorization": f"Bearer {hf_token}"}
-
 metrics_tracker = EduBotMetrics(save_file="edu_metrics.json")
 
-# --- Tools ---
-tools = [
-    {
-        "type": "function",
-        "function": {
-            "name": "create_graph",
-            "description": "Generates a plot (bar, line, or pie) and returns it as an HTML-formatted Base64-encoded image string. Use this tool when teaching concepts that benefit from visual representation, such as: statistical distributions, mathematical functions, data comparisons, survey results, grade analyses, scientific relationships, economic models, or any quantitative information that would be clearer with a graph. The data and labels arguments must be JSON-encoded strings.",
-            "parameters": {
-                "type": "object",
-                "properties": {
-                    "data_json": {"type": "string"},
-                    "labels_json": {"type": "string"},
-                    "plot_type": {"type": "string", "enum": ["bar", "line", "pie"]},
-                    "title": {"type": "string"},
-                    "x_label": {"type": "string"},
-                    "y_label": {"type": "string"},
-                },
-                "required": ["data_json", "labels_json", "plot_type", "title"],
-            },
-        }
-    }
-]
-
-# --- UI: MathJax Configuration ---
-mathjax_config = '''
-<script>
-window.MathJax = {
-  tex: {
-    inlineMath: [['
+# --- LangChain Tool Definition ---
+class GraphInput(BaseModel):
+    data_json: str = Field(description="JSON string of data for the graph")
+    labels_json: str = Field(description="JSON string of labels for the graph")
+    plot_type: str = Field(description="Type of plot: bar, line, or pie")
+    title: str = Field(description="Title for the graph")
+    x_label: str = Field(description="X-axis label", default="")
+    y_label: str = Field(description="Y-axis label", default="")
+
+class CreateGraphTool(BaseTool):
+    name = "create_graph"
+    description = """Generates a plot (bar, line, or pie) and returns it as an HTML-formatted Base64-encoded image string. Use this tool when teaching concepts that benefit from visual representation, such as: statistical distributions, mathematical functions, data comparisons, survey results, grade analyses, scientific relationships, economic models, or any quantitative information that would be clearer with a graph. The data and labels arguments must be JSON-encoded strings."""
+    args_schema: Type[BaseModel] = GraphInput
+    
+    def _run(self, data_json: str, labels_json: str, plot_type: str, 
+             title: str, x_label: str = "", y_label: str = "") -> str:
+        try:
+            return generate_plot(
+                data_json=data_json,
+                labels_json=labels_json,
+                plot_type=plot_type,
+                title=title,
+                x_label=x_label,
+                y_label=y_label
+            )
+        except Exception as e:
+            return f"<p style='color:red;'>Error creating graph: {str(e)}</p>"
 
-# --- Main Execution ---
-if __name__ == "__main__":
-    try:
-        logger.info("Starting EduBot...")
-        demo = create_interface()
-        demo.queue()
-        demo.launch()
-    except Exception as e:
-        logger.error(f"Failed to launch EduBot: {e}")
-        raise, '''
+# --- LangChain Setup ---
+def create_langchain_agent():
+    """Initialize LangChain agent with tools and memory."""
+    
+    # Initialize LLM
+    llm = HuggingFaceHub(
+        repo_id="Qwen/Qwen2.5-VL-7B-Instruct",
+        huggingfacehub_api_token=hf_token,
+        model_kwargs={
+            "temperature": 0.7,
+            "max_new_tokens": 1000,
+            "top_p": 0.9,
+            "return_full_text": False
+        }
+    )
+    
+    # Initialize tools
+    tools = [CreateGraphTool()]
+    
+    # Initialize memory
+    memory = ConversationBufferWindowMemory(
+        memory_key="chat_history",
+        k=10,
+        return_messages=True
+    )
+    
+    # Create agent
+    agent = initialize_agent(
+        tools=tools,
+        llm=llm,
+        agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION,
+        memory=memory,
+        verbose=False,
+        max_iterations=3,
+        early_stopping_method="generate"
+    )
+    
+    return agent
 
-# --- LLM Templates ---
-SYSTEM_MESSAGE = """You are EduBot, an expert multi-concept tutor designed to facilitate genuine learning and understanding. Your primary mission is to guide students through the learning process rather than providing direct answers to academic work.
+# --- System Prompt ---
+SYSTEM_PROMPT = """You are EduBot, an expert multi-concept tutor designed to facilitate genuine learning and understanding. Your primary mission is to guide students through the learning process rather than providing direct answers to academic work.
 
 ## Core Educational Principles
 - Provide comprehensive, educational responses that help students truly understand concepts
@@ -106,15 +137,6 @@ When using the create_graph tool, format data as JSON strings:
 - data_json: '{"Category1": 25, "Category2": 40, "Category3": 35}'
 - labels_json: '["Category1", "Category2", "Category3"]'
 
-## Function Calling Format
-When you need to create a graph, use this exact format:
-
-<function_call>
-{"name": "create_graph", "arguments": {"data_json": "{\"key1\": value1, \"key2\": value2}", "labels_json": "[\"label1\", \"label2\"]", "plot_type": "bar|line|pie", "title": "Graph Title", "x_label": "X Axis Label", "y_label": "Y Axis Label"}}
-</function_call>
-
-The graph will be automatically generated and displayed in your response.
-
 ## Response Guidelines
 - **For math problems**: Explain concepts, provide formula derivations, and guide through problem-solving steps without computing final numerical answers
 - **For multiple-choice questions**: Discuss the concepts being tested and help students understand how to analyze options rather than identifying the correct choice
@@ -130,45 +152,52 @@ The graph will be automatically generated and displayed in your response.
 - Encourage students to explain their thinking and reasoning
 - Provide honest, accurate feedback even when it may not be what the student wants to hear
 
-Your goal is to be an educational partner who empowers students to succeed through understanding, not a service that completes their work for them."""
+Your goal is to be an educational partner who empowers students to succeed through understanding, not a service that completes their work for them.
 
-# --- Core Logic Functions ---
+Question: {input}"""
 
-def execute_function_call(function_name, function_args):
-    """Execute the called function and return the result."""
-    if function_name == "create_graph":
-        try:
-            return generate_plot(
-                data_json=function_args.get("data_json", "{}"),
-                labels_json=function_args.get("labels_json", "[]"),
-                plot_type=function_args.get("plot_type", "bar"),
-                title=function_args.get("title", "Graph"),
-                x_label=function_args.get("x_label", ""),
-                y_label=function_args.get("y_label", "")
-            )
-        except Exception as e:
-            return f"<p style='color:red;'>Error creating graph: {str(e)}</p>"
-    else:
-        return f"<p style='color:red;'>Unknown function: {function_name}</p>"
+# --- Global Agent Instance ---
+agent = None
 
-def parse_function_calls(text):
-    """Parse function calls from model response."""
-    function_calls = []
-    
-    # Look for function call patterns in the text
-    function_pattern = r'<function_call>(.*?)</function_call>'
-    matches = re.findall(function_pattern, text, re.DOTALL)
-    
-    for match in matches:
-        try:
-            # Parse the function call JSON
-            call_data = json.loads(match.strip())
-            function_calls.append(call_data)
-        except json.JSONDecodeError:
-            continue
-    
-    return function_calls
+def get_agent():
+    """Get or create the LangChain agent."""
+    global agent
+    if agent is None:
+        agent = create_langchain_agent()
+    return agent
 
+# --- UI: MathJax Configuration ---
+mathjax_config = '''
+<script>
+window.MathJax = {
+  tex: {
+    inlineMath: [['\\\\(', '\\\\)']],
+    displayMath: [['$', '$'], ['\\\\[', '\\\\]']],
+    packages: {'[+]': ['ams']}
+  },
+  svg: {fontCache: 'global'},
+  startup: {
+    ready: () => {
+      MathJax.startup.defaultReady();
+      // Re-render math when new content is added
+      const observer = new MutationObserver(function(mutations) {
+        MathJax.typesetPromise();
+      });
+      observer.observe(document.body, {childList: true, subtree: true});
+    }
+  }
+};
+</script>
+'''
+
+# --- HTML Head Content ---
+html_head_content = '''
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>EduBot - AI Educational Assistant</title>
+'''
+
+# --- Core Logic Functions ---
 def smart_truncate(text, max_length=3000):
     """Truncates text intelligently to the last full sentence or word."""
     if len(text) <= max_length:
@@ -182,81 +211,29 @@ def smart_truncate(text, max_length=3000):
     words = text[:max_length].split()
     return ' '.join(words[:-1]) + "... [Response truncated]"
 
-def generate_response_with_tools(messages, max_retries=3):
-    """Generate response with function calling capability."""
-    
-    # Format messages for the API
-    formatted_messages = []
-    formatted_messages.append(f"System: {SYSTEM_MESSAGE}")
-    
-    for msg in messages:
-        if msg["role"] == "user":
-            formatted_messages.append(f"User: {msg['content']}")
-        elif msg["role"] == "assistant":
-            formatted_messages.append(f"Assistant: {msg['content']}")
-    
-    conversation = "\n\n".join(formatted_messages)
-    conversation += "\n\nAssistant: "
-    
-    payload = {
-        "inputs": conversation,
-        "parameters": {
-            "max_new_tokens": 1000,
-            "temperature": 0.7,
-            "top_p": 0.9,
-            "return_full_text": False
-        }
-    }
+def generate_response_with_langchain(message, max_retries=3):
+    """Generate response using LangChain agent."""
     
     for attempt in range(max_retries):
         try:
-            response = requests.post(HF_API_URL, headers=HF_HEADERS, json=payload, timeout=30)
+            # Get the agent
+            current_agent = get_agent()
             
-            if response.status_code == 503:
-                # Model is loading
-                if attempt < max_retries - 1:
-                    wait_time = 10 + (attempt * 5)
-                    logger.info(f"Model loading, waiting {wait_time} seconds...")
-                    time.sleep(wait_time)
-                    continue
-                else:
-                    return "The model is currently loading. Please try again in a few moments."
+            # Format the prompt
+            formatted_prompt = SYSTEM_PROMPT.format(input=message)
             
-            response.raise_for_status()
-            result = response.json()
+            # Get response from agent
+            response = current_agent.run(formatted_prompt)
+            
+            return smart_truncate(response)
             
-            if isinstance(result, list) and len(result) > 0:
-                raw_response = result[0].get('generated_text', '').strip()
-                
-                # Process function calls
-                function_calls = parse_function_calls(raw_response)
-                
-                for call in function_calls:
-                    if call.get("name") == "create_graph":
-                        # Execute the function call
-                        html_result = execute_function_call("create_graph", call.get("arguments", {}))
-                        # Replace the function call with the generated HTML
-                        pattern = r'<function_call>.*?</function_call>'
-                        raw_response = re.sub(pattern, html_result, raw_response, count=1, flags=re.DOTALL)
-                
-                return smart_truncate(raw_response)
-            else:
-                return "I apologize, but I received an unexpected response format. Please try again."
-                
-        except requests.exceptions.RequestException as e:
-            logger.error(f"Request failed (attempt {attempt + 1}): {e}")
-            if attempt < max_retries - 1:
-                time.sleep(2)
-                continue
-            else:
-                return f"I'm having trouble connecting right now. Please try again later. (Error: {e})"
         except Exception as e:
-            logger.error(f"Unexpected error (attempt {attempt + 1}): {e}")
+            logger.error(f"LangChain error (attempt {attempt + 1}): {e}")
             if attempt < max_retries - 1:
                 time.sleep(2)
                 continue
             else:
-                return f"An unexpected error occurred: {e}"
+                return f"I apologize, but I encountered an error while processing your message: {str(e)}"
 
 def chat_response(message, history):
     """Process chat message and return response."""
@@ -264,16 +241,8 @@ def chat_response(message, history):
         # Track metrics
         metrics_tracker.log_interaction(message, "user_query")
         
-        # Format conversation history
-        messages = []
-        for user_msg, bot_msg in history:
-            messages.append({"role": "user", "content": user_msg})
-            if bot_msg:
-                messages.append({"role": "assistant", "content": bot_msg})
-        messages.append({"role": "user", "content": message})
-        
-        # Generate response with tool support
-        response = generate_response_with_tools(messages)
+        # Generate response with LangChain
+        response = generate_response_with_langchain(message)
         
         # Log metrics
         metrics_tracker.log_interaction(response, "bot_response")
@@ -284,6 +253,15 @@ def chat_response(message, history):
         logger.error(f"Error in chat_response: {e}")
         return f"I apologize, but I encountered an error while processing your message: {str(e)}"
 
+def respond_with_enhanced_streaming(message, history):
+    """Enhanced streaming response function."""
+    try:
+        response = chat_response(message, history)
+        yield response
+    except Exception as e:
+        logger.error(f"Error in streaming response: {e}")
+        yield f"I apologize, but I encountered an error: {str(e)}"
+
 # --- UI: Event Handlers ---
 def respond_and_update(message, history):
     """Main function to handle user submission."""
@@ -308,6 +286,10 @@ def respond_and_update(message, history):
 
 def clear_chat():
     """Clear the chat history."""
+    # Reset agent memory
+    global agent
+    if agent is not None:
+        agent.memory.clear()
     return [], ""
 
 # --- UI: Interface Creation ---
@@ -386,21 +368,4 @@ if __name__ == "__main__":
         interface.launch()
     except Exception as e:
         logger.error(f"Failed to launch EduBot: {e}")
-        raise], ['\\\\(', '\\\\)']],
-    displayMath: [['$', '$'], ['\\\\[', '\\\\]']],
-    packages: {'[+]': ['ams']}
-  },
-  svg: {fontCache: 'global'},
-  startup: {
-    ready: () => {
-      MathJax.startup.defaultReady();
-      // Re-render math when new content is added
-      const observer = new MutationObserver(function(mutations) {
-        MathJax.typesetPromise();
-      });
-      observer.observe(document.body, {childList: true, subtree: true});
-    }
-  }
-};
-</script>
-'''
+        raise