Update app.py

app.py

@@ -1,33 +1,44 @@
+# app.py
+
 import gradio as gr
 import asyncio, json, os, sys
 from dotenv import load_dotenv
 from langchain_core.tools import Tool
-from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
-from langchain_core.messages import HumanMessage, AIMessage
-from langchain.agents import initialize_agent, AgentType
-from langchain.agents.agent_executor import AgentExecutor
 from langchain_groq import ChatGroq
+from langgraph.prebuilt import create_react_agent
 
 load_dotenv()
 
-# --- MCP Client ---
+# --- Compact MCP Client ---
 class MCPClient:
+    """Manages and communicates with a single tool server subprocess."""
+
     def __init__(self, command: str, args: list):
-        self.process, self._lock, self._cmd, self._req_id = None, asyncio.Lock(), [command] + args, 0
-    
+        self.process: asyncio.subprocess.Process = None
+        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
-            request = {"jsonrpc": "2.0", "method": method, "params": params or {}, "id": self._req_id}
+            request = {
+                "jsonrpc": "2.0",
+                "method": method,
+                "params": params or {},
+                "id": self._req_id,
+            }
             self.process.stdin.write(json.dumps(request).encode() + b'\n')
             await self.process.stdin.drain()
+
             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,
@@ -39,72 +50,70 @@ class MCPClient:
             Tool(
                 name=s['name'],
                 description=s['description'],
-                func=None,
+                func=None,  # <-- CRITICAL FIX: Add func=None for async tools
                 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 await self._send_request(
+                "execute",
+                {"tool_name": tool_name, "tool_args": tool_input}
+            )
         return _tool_coro
 
-# --- Agent Executor ---
+
+# --- Global Agent Executor ---
 _agent_executor = None
 
 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 not set.")
+            raise ValueError("GROQ_API_KEY secret not set.")
         client = MCPClient(command=sys.executable, args=["server.py"])
         tools = await client.get_tools()
-        model = ChatGroq(model="llama3-groq-70b-8192-tool-use-preview", temperature=0)
-
-        prompt = ChatPromptTemplate.from_messages([
-            ("system", "You are a helpful assistant for gold and silver price information and forecasts."),
-            MessagesPlaceholder(variable_name="chat_history", optional=True),
-            ("human", "{input}"),
-            MessagesPlaceholder(variable_name="agent_scratchpad"),
-        ])
-
-        # 🔧 only this line changed from create_openai_functions_agent(...)
-        agent = create_tool_calling_agent(llm=model, tools=tools, prompt=prompt)
-
-        _agent_executor = AgentExecutor(
-            agent=agent,
-            tools=tools,
-            verbose=False,
-            handle_parsing_errors=True,
-            max_iterations=5,
-        )
+        model = ChatGroq(model="openai/gpt-oss-20b")
+        _agent_executor = create_react_agent(model, tools)
     return _agent_executor
 
-# --- Chat Handler ---
+
+# --- Gradio Chat Logic ---
 async def respond_to_chat(message: str, history: list):
     agent = await get_agent_executor()
-    chat_history = [
-        msg
-        for human, ai in history
-        for msg in (HumanMessage(content=human), AIMessage(content=ai))
-    ]
+
+    # Convert history to LangChain format
+    history_langchain_format = []
+    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})
+
     try:
-        response = await agent.ainvoke({"input": message, "chat_history": chat_history})
-        return response["output"]
+        response = await agent.ainvoke({"messages": history_langchain_format})
+        return response['messages'][-1].content
     except Exception as e:
         print(f"ERROR: {e}", file=sys.stderr)
         return "Sorry, an error occurred while processing your request."
 
-# --- Gradio UI ---
+
+# --- Gradio User Interface ---
 demo = gr.ChatInterface(
     fn=respond_to_chat,
     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."],
+    examples=[
+        "What's the price of silver today?",
+        "Give me a 5-day forecast for gold."
+    ]
 )
 
+
+# --- Start the App ---
 if __name__ == "__main__":
     demo.launch()
-