Update app.py

app.py

@@ -368,15 +368,20 @@ class Qwen25SmallLLM(Runnable):
 class Educational_Agent:
     """Modern LangGraph-based educational agent"""
     
-start_init_and_langgraph_time = time.perf_counter()
-
     def __init__(self):
+        start_init_and_langgraph_time = time.perf_counter()
+        current_time = datetime.now()
+        
         self.llm = Qwen25SmallLLM(model_path="Qwen/Qwen2.5-1.5B-Instruct", use_4bit=True)
         self.tool_decision_engine = Tool_Decision_Engine(self.llm)
         
         # Create LangGraph workflow
         self.app = self._create_langgraph_workflow()
         
+        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}")
+        
     def _create_langgraph_workflow(self):
         """Create the LangGraph workflow"""
         # Define tools
@@ -401,6 +406,9 @@ start_init_and_langgraph_time = time.perf_counter()
 
         def call_model(state: EducationalAgentState) -> dict:
             """Call the model with tool decision logic"""
+            start_call_model_time = time.perf_counter()
+            current_time = datetime.now()
+            
             messages = state["messages"]
             
             # Get the user's query from the last human message
@@ -468,19 +476,36 @@ Otherwise, provide a regular educational response.
                                     "id": "tool_call_1"
                                 }]
                             )
+                            
+                            end_call_model_time = time.perf_counter()
+                            call_model_time = end_call_model_time - start_call_model_time
+                            log_metric(f"Call model time (with tools): {call_model_time:0.4f} seconds. Timestamp: {current_time:%Y-%m-%d %H:%M:%S}")
+                            
                             return {"messages": [tool_call_message]}
                 
                 # Regular response without tools
                 response = model_with_tools.invoke(enhanced_messages)
+                
+                end_call_model_time = time.perf_counter()
+                call_model_time = end_call_model_time - start_call_model_time
+                log_metric(f"Call model time (no tools): {call_model_time:0.4f} seconds. Timestamp: {current_time:%Y-%m-%d %H:%M:%S}")
+                
                 return {"messages": [AIMessage(content=response)]}
                 
             except Exception as e:
                 logger.error(f"Error in model call: {e}")
+                end_call_model_time = time.perf_counter()
+                call_model_time = end_call_model_time - start_call_model_time
+                log_metric(f"Call model time (error): {call_model_time:0.4f} seconds. Timestamp: {current_time:%Y-%m-%d %H:%M:%S}")
+                
                 error_response = AIMessage(content=f"I encountered an error: {str(e)}")
                 return {"messages": [error_response]}
         
         def handle_tools(state: EducationalAgentState) -> dict:
             """Handle tool execution"""
+            start_handle_tools_time = time.perf_counter()
+            current_time = datetime.now()
+            
             try:
                 messages = state["messages"]
                 last_message = messages[-1]
@@ -497,13 +522,26 @@ Otherwise, provide a regular educational response.
                             content=result,
                             tool_call_id=tool_call["id"]
                         )
+                        
+                        end_handle_tools_time = time.perf_counter()
+                        handle_tools_time = end_handle_tools_time - start_handle_tools_time
+                        log_metric(f"Handle tools time: {handle_tools_time:0.4f} seconds. Timestamp: {current_time:%Y-%m-%d %H:%M:%S}")
+                        
                         return {"messages": [tool_message]}
                 
                 # If no valid tool call, return empty
+                end_handle_tools_time = time.perf_counter()
+                handle_tools_time = end_handle_tools_time - start_handle_tools_time
+                log_metric(f"Handle tools time (no valid call): {handle_tools_time:0.4f} seconds. Timestamp: {current_time:%Y-%m-%d %H:%M:%S}")
+                
                 return {"messages": []}
                 
             except Exception as e:
                 logger.error(f"Error in tool execution: {e}")
+                end_handle_tools_time = time.perf_counter()
+                handle_tools_time = end_handle_tools_time - start_handle_tools_time
+                log_metric(f"Handle tools time (error): {handle_tools_time:0.4f} seconds. Timestamp: {current_time:%Y-%m-%d %H:%M:%S}")
+                
                 error_msg = ToolMessage(
                     content=f"Tool execution failed: {str(e)}",
                     tool_call_id="error"
@@ -537,6 +575,9 @@ Otherwise, provide a regular educational response.
     
     def chat(self, message: str, thread_id: str = "default") -> str:
         """Main chat interface"""
+        start_chat_time = time.perf_counter()
+        current_time = datetime.now()
+        
         try:
             config = {"configurable": {"thread_id": thread_id}}
             
@@ -562,12 +603,21 @@ Otherwise, provide a regular educational response.
                     response_parts.append(msg.content)
             
             if response_parts:
-                return "\n\n".join(response_parts)
+                final_response = "\n\n".join(response_parts)
             else:
-                return "I apologize, but I couldn't generate a proper response."
+                final_response = "I apologize, but I couldn't generate a proper response."
+            
+            end_chat_time = time.perf_counter()
+            chat_time = end_chat_time - start_chat_time
+            log_metric(f"Complete chat time: {chat_time:0.4f} seconds. Response length: {len(final_response)} chars. Timestamp: {current_time:%Y-%m-%d %H:%M:%S}")
+            
+            return final_response
                 
         except Exception as e:
             logger.error(f"Error in LangGraph chat: {e}")
+            end_chat_time = time.perf_counter()
+            chat_time = end_chat_time - start_chat_time
+            log_metric(f"Complete chat time (error): {chat_time:0.4f} seconds. Timestamp: {current_time:%Y-%m-%d %H:%M:%S}")
             return f"I apologize, but I encountered an error: {str(e)}"
 
 # --- Global Agent Instance ---