Skip to content

armgit / letta

Public Imported from GitHub
0

Platform for stateful agents: AI with advanced memory that can learn and self-improve over time.

feat: Add common sense timeouts for MCP client (#1303)

Matthew Zhoua8142c7b67b2
diff --git a/letta/functions/mcp_client/base_client.py b/letta/functions/mcp_client/base_client.py
index 91d46d912..20ea92645 100644
--- a/letta/functions/mcp_client/base_client.py
+++ b/letta/functions/mcp_client/base_client.py
@@ -5,12 +5,14 @@ from mcp import ClientSession, Tool
from letta.functions.mcp_client.types import BaseServerConfig
from letta.log import get_logger
+from letta.settings import tool_settings
logger = get_logger(__name__)
class BaseMCPClient:
- def __init__(self):
+ def __init__(self, server_config: BaseServerConfig):
+ self.server_config = server_config
self.session: Optional[ClientSession] = None
self.stdio = None
self.write = None
@@ -18,30 +20,54 @@ class BaseMCPClient:
self.loop = asyncio.new_event_loop()
self.cleanup_funcs = []
- def connect_to_server(self, server_config: BaseServerConfig):
+ def connect_to_server(self):
asyncio.set_event_loop(self.loop)
- success = self._initialize_connection(server_config)
+ success = self._initialize_connection(self.server_config, timeout=tool_settings.mcp_connect_to_server_timeout)
if success:
- self.loop.run_until_complete(self.session.initialize())
- self.initialized = True
+ try:
+ self.loop.run_until_complete(
+ asyncio.wait_for(self.session.initialize(), timeout=tool_settings.mcp_connect_to_server_timeout)
+ )
+ self.initialized = True
+ except asyncio.TimeoutError:
+ raise RuntimeError(
+ f"Timed out while initializing session for MCP server {self.server_config.server_name} (timeout={tool_settings.mcp_connect_to_server_timeout}s)."
+ )
else:
raise RuntimeError(
- f"Connecting to MCP server failed. Please review your server config: {server_config.model_dump_json(indent=4)}"
+ f"Connecting to MCP server failed. Please review your server config: {self.server_config.model_dump_json(indent=4)}"
)
- def _initialize_connection(self, server_config: BaseServerConfig) -> bool:
+ def _initialize_connection(self, server_config: BaseServerConfig, timeout: float) -> bool:
raise NotImplementedError("Subclasses must implement _initialize_connection")
def list_tools(self) -> List[Tool]:
self._check_initialized()
- response = self.loop.run_until_complete(self.session.list_tools())
- return response.tools
+ try:
+ response = self.loop.run_until_complete(
+ asyncio.wait_for(self.session.list_tools(), timeout=tool_settings.mcp_list_tools_timeout)
+ )
+ return response.tools
+ except asyncio.TimeoutError:
+ # Could log, throw a custom exception, etc.
+ logger.error(
+ f"Timed out while listing tools for MCP server {self.server_config.server_name} (timeout={tool_settings.mcp_list_tools_timeout}s)."
+ )
+ return []
def execute_tool(self, tool_name: str, tool_args: dict) -> Tuple[str, bool]:
self._check_initialized()
- result = self.loop.run_until_complete(self.session.call_tool(tool_name, tool_args))
- return str(result.content), result.isError
+ try:
+ result = self.loop.run_until_complete(
+ asyncio.wait_for(self.session.call_tool(tool_name, tool_args), timeout=tool_settings.mcp_execute_tool_timeout)
+ )
+ return str(result.content), result.isError
+ except asyncio.TimeoutError:
+ logger.error(
+ f"Timed out while executing tool '{tool_name}' for MCP server {self.server_config.server_name} (timeout={tool_settings.mcp_execute_tool_timeout}s)."
+ )
+ return "", True
def _check_initialized(self):
if not self.initialized:
diff --git a/letta/functions/mcp_client/sse_client.py b/letta/functions/mcp_client/sse_client.py
index daf31367a..d06f955dd 100644
--- a/letta/functions/mcp_client/sse_client.py
+++ b/letta/functions/mcp_client/sse_client.py
@@ -1,21 +1,33 @@
+import asyncio
+
from mcp import ClientSession
from mcp.client.sse import sse_client
from letta.functions.mcp_client.base_client import BaseMCPClient
from letta.functions.mcp_client.types import SSEServerConfig
+from letta.log import get_logger
# see: https://modelcontextprotocol.io/quickstart/user
MCP_CONFIG_TOPLEVEL_KEY = "mcpServers"
+logger = get_logger(__name__)
+
class SSEMCPClient(BaseMCPClient):
- def _initialize_connection(self, server_config: SSEServerConfig) -> bool:
- sse_cm = sse_client(url=server_config.server_url)
- sse_transport = self.loop.run_until_complete(sse_cm.__aenter__())
- self.stdio, self.write = sse_transport
- self.cleanup_funcs.append(lambda: self.loop.run_until_complete(sse_cm.__aexit__(None, None, None)))
+ def _initialize_connection(self, server_config: SSEServerConfig, timeout: float) -> bool:
+ try:
+ sse_cm = sse_client(url=server_config.server_url)
+ sse_transport = self.loop.run_until_complete(asyncio.wait_for(sse_cm.__aenter__(), timeout=timeout))
+ self.stdio, self.write = sse_transport
+ self.cleanup_funcs.append(lambda: self.loop.run_until_complete(sse_cm.__aexit__(None, None, None)))
- session_cm = ClientSession(self.stdio, self.write)
- self.session = self.loop.run_until_complete(session_cm.__aenter__())
- self.cleanup_funcs.append(lambda: self.loop.run_until_complete(session_cm.__aexit__(None, None, None)))
- return True
+ session_cm = ClientSession(self.stdio, self.write)
+ self.session = self.loop.run_until_complete(asyncio.wait_for(session_cm.__aenter__(), timeout=timeout))
+ self.cleanup_funcs.append(lambda: self.loop.run_until_complete(session_cm.__aexit__(None, None, None)))
+ return True
+ except asyncio.TimeoutError:
+ logger.error(f"Timed out while establishing SSE connection (timeout={timeout}s).")
+ return False
+ except Exception:
+ logger.exception("Exception occurred while initializing SSE client session.")
+ return False
diff --git a/letta/functions/mcp_client/stdio_client.py b/letta/functions/mcp_client/stdio_client.py
index b79608894..d526beb81 100644
--- a/letta/functions/mcp_client/stdio_client.py
+++ b/letta/functions/mcp_client/stdio_client.py
@@ -1,3 +1,4 @@
+import asyncio
import sys
from contextlib import asynccontextmanager
@@ -16,19 +17,23 @@ logger = get_logger(__name__)
class StdioMCPClient(BaseMCPClient):
- def _initialize_connection(self, server_config: StdioServerConfig) -> bool:
+ def _initialize_connection(self, server_config: StdioServerConfig, timeout: float) -> bool:
try:
server_params = StdioServerParameters(command=server_config.command, args=server_config.args)
stdio_cm = forked_stdio_client(server_params)
- stdio_transport = self.loop.run_until_complete(stdio_cm.__aenter__())
+ stdio_transport = self.loop.run_until_complete(asyncio.wait_for(stdio_cm.__aenter__(), timeout=timeout))
self.stdio, self.write = stdio_transport
self.cleanup_funcs.append(lambda: self.loop.run_until_complete(stdio_cm.__aexit__(None, None, None)))
session_cm = ClientSession(self.stdio, self.write)
- self.session = self.loop.run_until_complete(session_cm.__aenter__())
+ self.session = self.loop.run_until_complete(asyncio.wait_for(session_cm.__aenter__(), timeout=timeout))
self.cleanup_funcs.append(lambda: self.loop.run_until_complete(session_cm.__aexit__(None, None, None)))
return True
+ except asyncio.TimeoutError:
+ logger.error(f"Timed out while establishing stdio connection (timeout={timeout}s).")
+ return False
except Exception:
+ logger.exception("Exception occurred while initializing stdio client session.")
return False
diff --git a/letta/server/server.py b/letta/server/server.py
index 4b199853f..4faabd677 100644
--- a/letta/server/server.py
+++ b/letta/server/server.py
@@ -332,14 +332,14 @@ class SyncServer(Server):
for server_name, server_config in mcp_server_configs.items():
if server_config.type == MCPServerType.SSE:
- self.mcp_clients[server_name] = SSEMCPClient()
+ self.mcp_clients[server_name] = SSEMCPClient(server_config)
elif server_config.type == MCPServerType.STDIO:
- self.mcp_clients[server_name] = StdioMCPClient()
+ self.mcp_clients[server_name] = StdioMCPClient(server_config)
else:
raise ValueError(f"Invalid MCP server config: {server_config}")
try:
- self.mcp_clients[server_name].connect_to_server(server_config)
+ self.mcp_clients[server_name].connect_to_server()
except Exception as e:
logger.error(e)
self.mcp_clients.pop(server_name)
@@ -1331,7 +1331,7 @@ class SyncServer(Server):
def add_mcp_server_to_config(
self, server_config: Union[SSEServerConfig, StdioServerConfig], allow_upsert: bool = True
- ) -> dict[str, Union[SSEServerConfig, StdioServerConfig]]:
+ ) -> List[Union[SSEServerConfig, StdioServerConfig]]:
"""Add a new server config to the MCP config file"""
# TODO implement non-flatfile mechanism
@@ -1358,13 +1358,13 @@ class SyncServer(Server):
# Attempt to initialize the connection to the server
if server_config.type == MCPServerType.SSE:
- new_mcp_client = SSEMCPClient()
+ new_mcp_client = SSEMCPClient(server_config)
elif server_config.type == MCPServerType.STDIO:
- new_mcp_client = StdioMCPClient()
+ new_mcp_client = StdioMCPClient(server_config)
else:
raise ValueError(f"Invalid MCP server config: {server_config}")
try:
- new_mcp_client.connect_to_server(server_config)
+ new_mcp_client.connect_to_server()
except:
logger.exception(f"Failed to connect to MCP server: {server_config.server_name}")
raise RuntimeError(f"Failed to connect to MCP server: {server_config.server_name}")
diff --git a/letta/settings.py b/letta/settings.py
index 81c9f2ff8..5acfd532e 100644
--- a/letta/settings.py
+++ b/letta/settings.py
@@ -18,7 +18,10 @@ class ToolSettings(BaseSettings):
# Local Sandbox configurations
local_sandbox_dir: Optional[str] = None
- # MCP read from config file
+ # MCP settings
+ mcp_connect_to_server_timeout: float = 15.0
+ mcp_list_tools_timeout: float = 10.0
+ mcp_execute_tool_timeout: float = 60.0
mcp_read_from_config: bool = True # if False, will throw if attempting to read/write from file