Update app.py

app.py

@@ -4,7 +4,8 @@ import asyncio, json, os, sys
 from dotenv import load_dotenv
 from langchain_core.tools import Tool
 from langchain_groq import ChatGroq
-from langgraph.prebuilt import create_react_agent
+from langchain.agents import AgentExecutor, create_openai_functions_agent
+from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
 
 load_dotenv()
 
@@ -16,7 +17,7 @@ class MCPClient:
         self._lock = asyncio.Lock()
         self._cmd = [command] + args
         self._req_id = 0
-
+    
     async def _send_request(self, method: str, params: dict = None) -> dict:
         async with self._lock:
             self._req_id += 1
@@ -26,28 +27,34 @@ class MCPClient:
             while line := await self.process.stdout.readline():
                 response = json.loads(line)
                 if response.get("id") == self._req_id:
-                    if "error" in response: raise RuntimeError(f"Server error: {response['error']}")
+                    if "error" in response: 
+                        raise RuntimeError(f"Server error: {response['error']}")
                     return response["result"]
             raise ConnectionError("Server process closed unexpectedly.")
-
+    
     async def get_tools(self) -> list[Tool]:
-        self.process = await asyncio.create_subprocess_exec(*self._cmd, stdin=asyncio.subprocess.PIPE, stdout=asyncio.subprocess.PIPE)
+        self.process = await asyncio.create_subprocess_exec(
+            *self._cmd, 
+            stdin=asyncio.subprocess.PIPE, 
+            stdout=asyncio.subprocess.PIPE
+        )
         tool_schemas = await self._send_request("discover")
         return [
             Tool(
                 name=s['name'],
                 description=s['description'],
-                func=None,  # <-- CRITICAL FIX: Add func=None for async tools
+                func=None,
                 coroutine=self._create_tool_coro(s['name']),
                 args_schema=s['args_schema']
             ) for s in tool_schemas
         ]
-
+    
     def _create_tool_coro(self, tool_name: str):
         async def _tool_coro(tool_input):
             return await self._send_request("execute", {"tool_name": tool_name, "tool_args": tool_input})
         return _tool_coro
 
+
 # --- Global Agent Executor ---
 _agent_executor = None
 
@@ -55,34 +62,68 @@ async def get_agent_executor():
     """Initializes and returns the agent executor, ensuring it's a singleton."""
     global _agent_executor
     if _agent_executor is None:
-        if not os.getenv("GROQ_API_KEY"): raise ValueError("GROQ_API_KEY secret not set.")
+        if not os.getenv("GROQ_API_KEY"): 
+            raise ValueError("GROQ_API_KEY secret not set.")
+        
+        # Initialize MCP client and get tools
         client = MCPClient(command=sys.executable, args=["server.py"])
         tools = await client.get_tools()
-        model = ChatGroq(model="openai/gpt-oss-20b")
-        _agent_executor = create_react_agent(model, tools)
+        
+        # Initialize LLM
+        model = ChatGroq(model="llama3-groq-70b-8192-tool-use-preview", temperature=0)
+        
+        # Create prompt template for OpenAI Functions agent
+        prompt = ChatPromptTemplate.from_messages([
+            ("system", "You are a helpful assistant that provides information about gold and silver prices and forecasts."),
+            MessagesPlaceholder(variable_name="chat_history", optional=True),
+            ("human", "{input}"),
+            MessagesPlaceholder(variable_name="agent_scratchpad"),
+        ])
+        
+        # Create OpenAI Functions agent
+        agent = create_openai_functions_agent(model, tools, prompt)
+        
+        # Create AgentExecutor
+        _agent_executor = AgentExecutor(
+            agent=agent,
+            tools=tools,
+            verbose=False,
+            handle_parsing_errors=True,
+            max_iterations=5
+        )
+    
     return _agent_executor
 
+
 # --- Gradio Chat Logic ---
 async def respond_to_chat(message: str, history: list):
-    agent = await get_agent_executor()
-    # The new 'messages' format expects a list of dicts. We convert the history.
-    history_langchain_format = []
+    agent_executor = await get_agent_executor()
+    
+    # Convert Gradio history to LangChain message format
+    from langchain_core.messages import HumanMessage, AIMessage
+    
+    chat_history = []
     for human, ai in history:
-        history_langchain_format.append({"role": "user", "content": human})
-        history_langchain_format.append({"role": "assistant", "content": ai})
-    history_langchain_format.append({"role": "user", "content": message})
+        chat_history.append(HumanMessage(content=human))
+        chat_history.append(AIMessage(content=ai))
     
     try:
-        response = await agent.ainvoke({"messages": history_langchain_format})
-        return response['messages'][-1].content
+        # Invoke agent with input and chat history
+        response = await agent_executor.ainvoke({
+            "input": message,
+            "chat_history": chat_history
+        })
+        return response['output']
+    
     except Exception as e:
         print(f"ERROR: {e}", file=sys.stderr)
         return "Sorry, an error occurred while processing your request."
 
+
 # --- Gradio User Interface ---
 demo = gr.ChatInterface(
     fn=respond_to_chat,
-    title="Gold & Silver AI forefast",
+    title="Gold & Silver AI Forecast",
     description="Ask about live prices and future forecasts for gold and silver.",
     examples=["What's the price of silver today?", "Give me a 5-day forecast for gold."],
 )