Update app.py

app.py

@@ -36,63 +36,102 @@ if not hf_token:
 
 metrics_tracker = MimirMetrics(save_file="Mimir_metrics.json")
 
-# --- 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", default="[]")
-    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):
+from langchain.tools import Tool
+import json
+
+def create_educational_graph_tool():
+    """
+    Creates a graph tool for the AI to autonomously generate educational visualizations.
+    """
+    
+    def graph_wrapper(graph_config: str) -> str:
+        """
+        Wrapper that calls your generate_plot function with the JSON config.
+        
+        Args:
+            graph_config (str): JSON string with plot configuration
+        
+        Returns:
+            str: HTML with embedded graph
+        """
+        try:
+            # Validate it's proper JSON
+            config = json.loads(graph_config)
+            
+            # Add educational context if provided
+            educational_context = config.get("educational_context", "")
+            
+            # Call your generate_plot function (which now takes single JSON input)
+            graph_html = generate_plot(graph_config)
+            
+            # Add educational context if provided
+            if educational_context:
+                context_html = f'<div style="margin: 10px 0; padding: 10px; background: #f8f9fa; border-left: 4px solid #007bff; font-style: italic;">💡 {educational_context}</div>'
+                return context_html + graph_html
+            
+            return graph_html
+            
+        except json.JSONDecodeError as e:
+            logger.error(f"Invalid JSON provided to graph tool: {e}")
+            return '<p style="color:red;">Graph generation failed - invalid JSON format</p>'
+        except Exception as e:
+            logger.error(f"Error in graph generation: {e}")
+            return f'<p style="color:red;">Error creating graph: {str(e)}</p>'
+    
+    return Tool(
+        name="create_graph",
+        description="""Create educational graphs and charts to help explain concepts to students.
+        
+        Use this tool when teaching concepts that would benefit from visual representation, such as:
+        - Mathematical functions and relationships (quadratic equations, exponential growth)
+        - Statistical distributions and data analysis (normal curves, survey results)
+        - Scientific trends and comparisons (temperature changes, population growth)
+        - Economic models and business metrics (profit over time, market shares)
+        - Grade distributions or performance analysis (test score ranges)
+        - Any quantitative concept that's clearer with visualization
+        
+        Input should be a JSON string with this structure:
+        {
+            "data": {"Category A": 25, "Category B": 40, "Category C": 35},
+            "plot_type": "bar",
+            "title": "Student Performance by Subject", 
+            "x_label": "Subjects",
+            "y_label": "Average Score",
+            "educational_context": "This visualization helps students see performance patterns across subjects"
+        }
+        
+        Plot types:
+        - "bar": Best for comparing categories, showing distributions, or discrete data
+        - "line": Best for showing trends over time or continuous relationships  
+        - "pie": Best for showing parts of a whole or proportions
+        
+        Always create meaningful educational data that illustrates the concept you're teaching.
+        Include educational_context to explain why the visualization helps learning.
+        
+        Examples of when to use:
+        - Student asks about probability → Create histogram showing dice roll outcomes
+        - Teaching compound interest → Line chart showing money growth over time
+        - Explaining survey methods → Pie chart of sample demographic breakdown
+        - Discussing functions → Line plot comparing linear vs exponential growth
+        - Analyzing test performance → Bar chart of score distributions
+        """,
+        func=graph_wrapper
+    )
+
+# If you want to keep using your existing CreateGraphTool approach, 
+# update it to work with the new single-input generate_plot function:
+class CreateGraphToolFixed(BaseTool):
     name: str = "create_graph"
-    description: str = """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. 
-
-REQUIRED FORMAT:
-- data_json: A JSON dictionary where keys are category names and values are numbers
-  Example: '{"Math": 85, "Science": 92, "English": 78}'
-- labels_json: A JSON list, only needed for pie charts if you want custom labels different from the data keys. For bar/line charts, use empty list: '[]'
-  Example for pie: '["Mathematics", "Science", "English Literature"]'
-  Example for bar/line: '[]'
-
-EXAMPLES:
-Bar chart: data_json='{"Q1": 1000, "Q2": 1200, "Q3": 950}', labels_json='[]'
-Line chart: data_json='{"Jan": 100, "Feb": 120, "Mar": 110}', labels_json='[]' 
-Pie chart: data_json='{"A": 30, "B": 45, "C": 25}', labels_json='["Category A", "Category B", "Category C"]'
-
-Always use proper JSON formatting with quotes around keys and string values."""
-    args_schema: Type[BaseModel] = GraphInput
+    description: str = """Generate educational graphs to supplement explanations. Create realistic data that illustrates educational concepts."""
     
-    def _run(self, data_json: str, labels_json: str = "[]", plot_type: str = "bar", 
-             title: str = "Chart", x_label: str = "", y_label: str = "") -> str:
+    def _run(self, tool_input: str) -> str:
+        """Single input version that works with your updated generate_plot function."""
         try:
-            # Validate JSON format before passing to generate_plot
-            import json
-            try:
-                data_parsed = json.loads(data_json)
-                labels_parsed = json.loads(labels_json)
-                
-                # Validate data structure
-                if not isinstance(data_parsed, dict):
-                    return "<p style='color:red;'>data_json must be a JSON dictionary with string keys and numeric values.</p>"
-                    
-                if not isinstance(labels_parsed, list):
-                    return "<p style='color:red;'>labels_json must be a JSON list (use [] if no custom labels needed).</p>"
-                    
-            except json.JSONDecodeError as json_error:
-                return f"<p style='color:red;'>Invalid JSON format: {str(json_error)}. Ensure proper JSON formatting with quotes.</p>"
-            
-            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
-            )
+            # tool_input should be the JSON config string
+            return generate_plot(tool_input)
         except Exception as e:
-            return f"<p style='color:red;'>Error creating graph: {str(e)}</p>"
+            logger.error(f"Error in graph tool: {e}")
+            return f'<p style="color:red;">Error creating graph: {str(e)}</p>'
 
 
 # --- System Prompt ---
@@ -404,35 +443,6 @@ class Qwen25SmallLLM(LLM):
     @property
     def _llm_type(self) -> str:
         return "qwen25_small"
-    
-def create_langchain_agent():
-    """Creates the LangChain agent with educational graph capabilities."""
-    logger.info("Creating educational LangChain agent...")
-    
-    # Use the smaller local model
-    llm = Qwen25SmallLLM()
-    
-    # Use the educational graph tool
-    tools = [create_educational_graph_tool()]
-    memory = ConversationBufferWindowMemory(
-        memory_key="chat_history",
-        k=10,
-        return_messages=True
-    )
-    
-    # Use standard agent type
-    agent = initialize_agent(
-        tools=tools,
-        llm=llm,
-        agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION,
-        memory=memory,
-        verbose=False,  # Set to True for debugging
-        max_iterations=3,
-        early_stopping_method="generate"
-    )
-    
-    logger.info("Educational LangChain agent created successfully!")
-    return agent
 
 # Example of how the AI should use the tool
 def example_usage_for_ai():