Update graph_tool.py

graph_tool.py

@@ -94,35 +94,60 @@ def Create_Graph_Tool(graph_config: str) -> str:
         logger.error(f"Error in graph generation: {e}")
         return f'<p style="color:red;">Error creating graph: {str(e)}</p>'
 
-# --- Tool Control Logic ---
-class Tool_Manager:
-    """Manages when tools should be available"""
+# --- Tool Decision Engine ---
+class Tool_Decision_Engine:
+    """Uses LLM to intelligently decide when visualization tools would be beneficial"""
     
-    def __init__(self):
-        self.graph_keywords = [
-            'graph', 'chart', 'plot', 'visualiz', 'diagram', 'show me',
-            'data', 'statistic', 'trend', 'distribution', 'comparison'
-        ]
-    
-    def needs_visualization(self, query: str) -> bool:
-        """Determine if query requires visualization tools"""
-        query_lower = query.lower()
-        
-        # Check for explicit visualization requests
-        visualization_patterns = [
-            r'\b(graph|chart|plot|visualiz)\w*',
-            r'\bshow\s+me\s+(a\s+)?(graph|chart)',
-            r'\b(data|statistic)\w*\s+(analys|visual)',
-            r'\bcreate\s+(a\s+)?(graph|chart|diagram)',
-            r'\bmake\s+(a\s+)?(graph|chart)',
-            r'\bdraw\s+(a\s+)?(graph|chart)'
-        ]
-        
-        for pattern in visualization_patterns:
-            if re.search(pattern, query_lower):
-                return True
-        
-        return False
+    def __init__(self, llm):
+        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.
+
+Query: "{query}"
+
+Consider these factors:
+1. Would visualization make a concept clearer or easier to understand?
+2. Does the topic involve data, relationships, comparisons, or trends?
+3. Could a graph help illustrate abstract concepts concretely?
+4. For practice questions, would including visual elements be educational?
+
+Examples that BENEFIT from visualization:
+- Explaining mathematical functions or statistical concepts
+- Creating practice questions that involve data interpretation
+- Teaching about scientific trends or relationships
+- Comparing quantities, performance, or outcomes
+- Illustrating economic principles or business metrics
+
+Examples that do NOT need visualization:
+- Simple definitions or explanations
+- General conversation or greetings
+- Text-based study strategies
+- Qualitative discussions without data
+
+Answer with exactly: YES or NO
+
+Decision:"""
+
+    def should_use_visualization(self, query: str) -> bool:
+        """Use LLM reasoning to determine if visualization would be beneficial"""
+        try:
+            # Create decision prompt
+            decision_query = self.decision_prompt.format(query=query)
+            
+            # Get LLM decision
+            decision_response = self.decision_llm.invoke(decision_query)
+            
+            # Parse response - look for YES/NO
+            decision_text = decision_response.strip().upper()
+            
+            # Log the decision for debugging
+            logger.info(f"Tool decision for '{query[:50]}...': {decision_text}")
+            
+            return "YES" in decision_text and "NO" not in decision_text
+            
+        except Exception as e:
+            logger.error(f"Error in tool decision making: {e}")
+            # Default to no tools if decision fails
+            return False
 
 # --- System Prompt ---
 SYSTEM_PROMPT = """You are Mimir, 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.
@@ -267,11 +292,11 @@ class Qwen25SmallLLM:
 
 # --- Modern Agent Implementation ---
 class Educational_Agent:
-    """Modern LangChain agent with proper tool control"""
+    """Modern LangChain agent with LLM-based tool decision making"""
     
     def __init__(self):
         self.llm = Qwen25SmallLLM(model_path="Qwen/Qwen2.5-3B-Instruct")
-        self.tool_manager = Tool_Manager()
+        self.tool_decision_engine = Tool_Decision_Engine(self.llm)
         self.memory = ConversationBufferWindowMemory(
             memory_key="chat_history",
             return_messages=True,
@@ -279,8 +304,8 @@ class Educational_Agent:
         )
         
     def should_use_tools(self, query: str) -> bool:
-        """Determine if this query needs visualization tools"""
-        return self.tool_manager.needs_visualization(query)
+        """Use LLM reasoning to determine if tools are needed"""
+        return self.tool_decision_engine.should_use_visualization(query)
     
     def create_prompt_template(self, has_tools: bool = False):
         """Create prompt template based on whether tools are available"""