Replaced Old Metrics

app.py

@@ -1,6 +1,5 @@
 import gradio as gr
 from graph_tool import generate_plot
-from metrics import MimirMetrics
 import os
 
 # Updated environment variables
@@ -12,6 +11,7 @@ from dotenv import load_dotenv
 import logging
 import re
 import json
+from datetime import datetime
 from typing import Annotated, Sequence, TypedDict, List, Optional, Any, Type
 from pydantic import BaseModel, Field
 
@@ -36,16 +36,42 @@ HF_TOKEN = os.getenv("HF_TOKEN") or os.getenv("HUGGINGFACEHUB_API_TOKEN")
 print("Environment variables loaded.")
 
 # --- Environment and Logging Setup ---
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
+# Create a custom logger for metrics
+def setup_metrics_logger():
+    """Setup a simple file logger for human-readable metrics"""
+    logger = logging.getLogger('metrics')
+    logger.setLevel(logging.INFO)
+    
+    # Avoid duplicate handlers
+    if logger.handlers:
+        return logger
+    
+    # Create file handler
+    log_file = 'performance_metrics.log'
+    handler = logging.FileHandler(log_file)
+    
+    # Create formatter for clean output
+    formatter = logging.Formatter('%(message)s')
+    handler.setFormatter(formatter)
+    
+    logger.addHandler(handler)
+    return logger
+
+# Initialize the logger
+metrics_logger = setup_metrics_logger()
+
+def log_metric(message):
+    """Log a human-readable metric message with automatic timestamp"""
+    current_time = datetime.now()
+    timestamped_message = f"{message} | Logged: {current_time:%Y-%m-%d %H:%M:%S}"
+    metrics_logger.info(timestamped_message)
+    logger.info(timestamped_message)  # Also log to console using info.logger
 
 # Support both token names for flexibility
 hf_token = HF_TOKEN
 if not hf_token:
     logger.warning("Neither HF_TOKEN nor HUGGINGFACEHUB_API_TOKEN is set, the application may not work.")
 
-metrics_tracker = MimirMetrics(save_file="Mimir_metrics.json")
-
 # --- LangGraph State Definition ---
 class EducationalAgentState(TypedDict):
     messages: Annotated[Sequence[BaseMessage], add_messages]
@@ -83,6 +109,7 @@ def Create_Graph_Tool(graph_config: str) -> str:
     Always create meaningful educational data that illustrates the concept you're teaching.
     Include educational_context to explain why the visualization helps learning.
     """
+    start_create_graph_tool_time = time.perf_counter()
     try:
         # Validate it's proper JSON
         config = json.loads(graph_config)
@@ -106,8 +133,13 @@ def Create_Graph_Tool(graph_config: str) -> str:
     except Exception as e:
         logger.error(f"Error in graph generation: {e}")
         return f'<p style="color:red;">Error creating graph: {str(e)}</p>'
+    end_create_graph_tool_time = time.perf_counter()
+    graph_create_graph_tool_time = end_create_graph_tool_time - start_create_graph_tool_time
+
+    log_metric(f"Graph tool creation time: {graph_create_graph_tool_time:0.4f} seconds. Timestamp: {current_time:%Y-%m-%d %H:%M:%S}")
 
 # --- Tool Decision Engine (Updated for LangGraph) ---
+start_graph_decision_time = time.perf_counter()
 class Tool_Decision_Engine:
     """Uses LLM to intelligently decide when visualization tools would be beneficial"""
     
@@ -173,6 +205,10 @@ Decision:"""
             # Default to no tools if decision fails
             return False
 
+end_graph_decision_time = time.perf_counter()
+graph_decision_time = end_graph_decision_time - start_graph_decision_time
+
+log_metric(f"Tool decision time: {graph_decision_time:0.4f} seconds. Timestamp: {current_time:%Y-%m-%d %H:%M:%S}")
 # --- 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.
 ## Core Educational Principles
@@ -227,6 +263,7 @@ class Qwen25SmallLLM(Runnable):
     def __init__(self, model_path: str = "Qwen/Qwen2.5-3B-Instruct", use_4bit: bool = True):
         super().__init__()
         logger.info(f"Loading model: {model_path} (use_4bit={use_4bit})")
+        start_Loading_Model_time = time.perf_counter()
 
         try:
             # Load tokenizer
@@ -253,7 +290,10 @@ class Qwen25SmallLLM(Runnable):
                 )
             else:
                 self._load_fallback_model(model_path)
+        end_Loading_Model_time = time.perf_counter()
+        Loading_Model_time = end_Loading_Model_time - start_Loading_Model_time
 
+        log_metric(f"Model Load time: {Loading_Model_time:0.4f} seconds. Timestamp: {current_time:%Y-%m-%d %H:%M:%S}")
         except Exception as e:
             logger.warning(f"Quantized load failed, falling back: {e}")
             self._load_fallback_model(model_path)
@@ -322,6 +362,8 @@ class Qwen25SmallLLM(Runnable):
 class Educational_Agent:
     """Modern LangGraph-based educational agent"""
     
+start_init_and_langgraph_time = time.perf_counter()
+
     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)
@@ -556,6 +598,11 @@ window.MathJax = {
 </script>
 '''
 
+end_init_and_langgraph_time = time.perf_counter()
+init_and_langgraph_time = end_init_and_langgraph_time - start_init_and_langgraph_time
+
+log_metric(f"Init and LangGraph workflow setup time: {init_and_langgraph_time:0.4f} seconds. Timestamp: {current_time:%Y-%m-%d %H:%M:%S}")
+
 # --- HTML Head Content ---
 html_head_content = '''
 <meta charset="utf-8">
@@ -581,6 +628,7 @@ window.addEventListener('DOMContentLoaded', function () {
 '''
 
 # --- Core Logic Functions ---
+start_smart_truncate_time = time.perf_counter()
 def smart_truncate(text, max_length=3000):
     """Truncates text intelligently to the last full sentence or word."""
     if len(text) <= max_length:
@@ -593,7 +641,13 @@ def smart_truncate(text, max_length=3000):
     # Otherwise, split by word
     words = text[:max_length].split()
     return ' '.join(words[:-1]) + "... [Response truncated]"
+    
+end_smart_truncate_time = time.perf_counter()
+smart_truncate_time = end_smart_truncate_time - start_smart_truncate_time
+
+log_metric(f"Smart Truncate time: {smart_truncate_time:0.4f} seconds. Timestamp: {current_time:%Y-%m-%d %H:%M:%S}")
 
+start_generate_response_with_agent_time = time.perf_counter()
 def generate_response_with_agent(message, max_retries=3):
     """Generate response using LangGraph agent."""
     
@@ -614,6 +668,12 @@ def generate_response_with_agent(message, max_retries=3):
                 continue
             else:
                 return f"I apologize, but I encountered an error while processing your message: {str(e)}"
+end_generate_response_with_agent_time = time.perf_counter()
+generate_response_with_agent_time = end_generate_response_with_agent_time - start_generate_response_with_agent_time
+
+log_metric(f"Smart Truncate time: {generate_response_with_agent_time:0.4f} seconds. Timestamp: {current_time:%Y-%m-%d %H:%M:%S}")
+
+start_chat_response_time = time.perf_counter()
 
 def chat_response(message, history=None):
     """Process chat message and return response."""
@@ -657,6 +717,11 @@ def chat_response(message, history=None):
     except Exception as e:
         logger.error(f"Error in chat_response: {e}")
         return f"I apologize, but I encountered an error while processing your message: {str(e)}"
+        
+end_chat_response_time = time.perf_counter()
+chat_response_time = end_chat_response_time - start_chat_response_time
+
+log_metric(f"Smart Truncate time: {chat_response_time:0.4f} seconds. Timestamp: {current_time:%Y-%m-%d %H:%M:%S}")
 
 def respond_and_update(message, history):
     """Main function to handle user submission."""
@@ -679,6 +744,7 @@ def clear_chat():
     # We could clear by using a new thread_id, but for now we'll keep it simple
     return [], ""
 
+start_agent_warmup_time = time.perf_counter()
 def warmup_agent():
     """Warm up the agent with a test query to preload everything."""
     logger.info("Warming up LangGraph agent with test query...")
@@ -691,8 +757,14 @@ def warmup_agent():
         
     except Exception as e:
         logger.error(f"LangGraph agent warmup failed: {e}")
+        
+end_agent_warmup_time = time.perf_counter()
+agent_warmup_time = end_agent_warmup_time - start_agent_warmup_time
+
+log_metric(f"Smart Truncate time: {agent_warmup_time:0.4f} seconds. Timestamp: {current_time:%Y-%m-%d %H:%M:%S}")
 
 # --- UI: Interface Creation ---
+start_create_interface_time = time.perf_counter()
 def create_interface():
     """Creates and configures the complete Gradio interface."""
     
@@ -760,6 +832,11 @@ def create_interface():
         
         return demo
 
+end_create_interface_time = time.perf_counter()
+create_interface_time = end_create_interfacep_time - start_create_interface_time
+
+log_metric(f"Smart Truncate time: {create_interface_time:0.4f} seconds. Timestamp: {current_time:%Y-%m-%d %H:%M:%S}")
+
 # --- Main Execution ---
 if __name__ == "__main__":
     try: