Update app.py

app.py

@@ -99,6 +99,7 @@ class Tool_Decision_Engine:
     """Uses LLM to intelligently decide when visualization tools would be beneficial"""
     
     def __init__(self, llm):
+        self.conversation_history = []
         self.decision_llm = llm
         self.decision_prompt = """Analyze this educational query and determine if creating a graph, chart, or visual representation would significantly enhance learning and understanding.
 
@@ -292,10 +293,7 @@ class Educational_Agent:
     def __init__(self):
         self.llm = Qwen25SmallLLM(model_path="Qwen/Qwen2.5-1.5B-Instruct", use_4bit=True)
         self.tool_decision_engine = Tool_Decision_Engine(self.llm)
-        self.memory = ConversationBufferWindowMemory(
-            memory_key="chat_history",
-            return_messages=True,
-            k=5
+        self.conversation_history = []
         )
         
     def should_use_tools(self, query: str) -> bool:
@@ -315,57 +313,66 @@ class Educational_Agent:
         ])
     
     def process_with_tools(self, query: str) -> str:
-        """Process query with tools available"""
-        try:
-            # Create agent with tools
-            tools = [Create_Graph_Tool]
-            
-            # Use create_react_agent for better control
-            agent = create_react_agent(
-                self.llm,
-                tools,
-                state_modifier=self.create_prompt_template(has_tools=True)
-            )
-            
-            response = agent.invoke({"messages": [HumanMessage(content=query)]})
-            
-            # Extract the final message content
-            if response and "messages" in response:
-                final_message = response["messages"][-1]
-                if hasattr(final_message, 'content'):
-                    return final_message.content
-                else:
-                    return str(final_message)
-            
-            return str(response)
-            
-        except Exception as e:
-            logger.error(f"Error in tool processing: {e}")
-            return f"I apologize, but I encountered an error while processing your request: {str(e)}"
-    
-    def process_without_tools(self, query: str) -> str:
-        """Process query without tools"""
-        try:
-            response = self.llm.invoke(query)
-            return response
-        except Exception as e:
-            logger.error(f"Error in normal processing: {e}")
-            return f"I apologize, but I encountered an error: {str(e)}"
-    
-    def chat(self, message: str) -> str:
-        """Main chat interface with conditional tool usage"""
-        try:
-            # Determine if tools are needed
-            if self.should_use_tools(message):
-                logger.info("Query requires visualization - enabling tools")
-                return self.process_with_tools(message)
-            else:
-                logger.info("Query doesn't need tools - responding normally")
-                return self.process_without_tools(message)
-                
-        except Exception as e:
-            logger.error(f"Error in chat processing: {e}")
-            return f"I apologize, but I encountered an error: {str(e)}"
+   """Process query with tools available using traditional agent"""
+   try:
+       # Create agent with tools using traditional approach
+       tools = [Create_Graph_Tool]
+       
+       # Create memory for this agent instance
+       memory = ConversationBufferWindowMemory(
+           memory_key="chat_history",
+           return_messages=True
+       )
+       
+       # Add conversation history to memory
+       for exchange in self.conversation_history:
+           if exchange.startswith("User: "):
+               memory.chat_memory.add_user_message(exchange[6:])
+           elif exchange.startswith("Assistant: "):
+               memory.chat_memory.add_ai_message(exchange[11:])
+       
+       # Use traditional agent with better prompting
+       agent = initialize_agent(
+           tools=tools,
+           llm=self.llm,
+           agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION,
+           memory=memory,
+           verbose=True,
+           handle_parsing_errors=True,
+           agent_kwargs={
+               "prefix": SYSTEM_PROMPT + "\n\nYou have access to graph creation tools. Use them when visualization would genuinely help explain concepts. Think carefully about whether a tool is needed before using it.\n\n"
+           }
+       )
+       
+       response = agent.run(query)
+       
+       # Store the exchange
+       self.conversation_history.append(f"User: {query}")
+       self.conversation_history.append(f"Assistant: {response}")
+       
+       return response
+       
+   except Exception as e:
+       logger.error(f"Error in tool processing: {e}")
+       return f"I apologize, but I encountered an error while processing your request: {str(e)}"
+
+def process_without_tools(self, query: str) -> str:
+   """Process query without tools"""
+   try:
+       # Include recent conversation in prompt
+       context = "\n".join(self.conversation_history[-8:]) if self.conversation_history else ""
+       full_prompt = f"Recent conversation:\n{context}\n\nCurrent query: {query}" if context else query
+       
+       response = self.llm.invoke(full_prompt)
+       
+       # Store the exchange
+       self.conversation_history.append(f"User: {query}")
+       self.conversation_history.append(f"Assistant: {response}")
+       
+       return response
+   except Exception as e:
+       logger.error(f"Error in normal processing: {e}")
+       return f"I apologize, but I encountered an error: {str(e)}"
 
 # --- Global Agent Instance ---
 agent = None