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.

LET-4053: chore: clean up old mcp client code

jnjpngfb6ecfc575f2
diff --git a/letta/functions/mcp_client/__init__.py b/letta/functions/mcp_client/__init__.py
deleted file mode 100644
index e69de29bb..000000000
diff --git a/letta/functions/mcp_client/base_client.py b/letta/functions/mcp_client/base_client.py
deleted file mode 100644
index 55d16f20a..000000000
--- a/letta/functions/mcp_client/base_client.py
+++ /dev/null
@@ -1,156 +0,0 @@
-from letta.log import get_logger
-
-logger = get_logger(__name__)
-
-
-# class BaseMCPClient:
-# def __init__(self, server_config: BaseServerConfig):
-# self.server_config = server_config
-# self.session: Optional[ClientSession] = None
-# self.stdio = None
-# self.write = None
-# self.initialized = False
-# self.loop = asyncio.new_event_loop()
-# self.cleanup_funcs = []
-#
-# def connect_to_server(self):
-# asyncio.set_event_loop(self.loop)
-# success = self._initialize_connection(self.server_config, timeout=tool_settings.mcp_connect_to_server_timeout)
-#
-# if success:
-# 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 MCPTimeoutError("initializing session", self.server_config.server_name, tool_settings.mcp_connect_to_server_timeout)
-# else:
-# raise RuntimeError(
-# 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, timeout: float) -> bool:
-# raise NotImplementedError("Subclasses must implement _initialize_connection")
-#
-# def list_tools(self) -> List[MCPTool]:
-# self._check_initialized()
-# 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:
-# logger.error(
-# f"Timed out while listing tools for MCP server {self.server_config.server_name} (timeout={tool_settings.mcp_list_tools_timeout}s)."
-# )
-# raise MCPTimeoutError("listing tools", self.server_config.server_name, tool_settings.mcp_list_tools_timeout)
-#
-# def execute_tool(self, tool_name: str, tool_args: dict) -> Tuple[str, bool]:
-# self._check_initialized()
-# 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)
-# )
-#
-# parsed_content = []
-# for content_piece in result.content:
-# if isinstance(content_piece, TextContent):
-# parsed_content.append(content_piece.text)
-# print("parsed_content (text)", parsed_content)
-# else:
-# parsed_content.append(str(content_piece))
-# print("parsed_content (other)", parsed_content)
-#
-# if len(parsed_content) > 0:
-# final_content = " ".join(parsed_content)
-# else:
-# # TODO move hardcoding to constants
-# final_content = "Empty response from tool"
-#
-# return final_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)."
-# )
-# raise MCPTimeoutError(f"executing tool '{tool_name}'", self.server_config.server_name, tool_settings.mcp_execute_tool_timeout)
-#
-# def _check_initialized(self):
-# if not self.initialized:
-# logger.error("MCPClient has not been initialized")
-# raise RuntimeError("MCPClient has not been initialized")
-#
-# def cleanup(self):
-# try:
-# for cleanup_func in self.cleanup_funcs:
-# cleanup_func()
-# self.initialized = False
-# if not self.loop.is_closed():
-# self.loop.close()
-# except Exception as e:
-# logger.warning(e)
-# finally:
-# logger.info("Cleaned up MCP clients on shutdown.")
-#
-#
-# class BaseAsyncMCPClient:
-# def __init__(self, server_config: BaseServerConfig):
-# self.server_config = server_config
-# self.session: Optional[ClientSession] = None
-# self.stdio = None
-# self.write = None
-# self.initialized = False
-# self.cleanup_funcs = []
-#
-# async def connect_to_server(self):
-#
-# success = await self._initialize_connection(self.server_config, timeout=tool_settings.mcp_connect_to_server_timeout)
-#
-# if success:
-# self.initialized = True
-# else:
-# raise RuntimeError(
-# f"Connecting to MCP server failed. Please review your server config: {self.server_config.model_dump_json(indent=4)}"
-# )
-#
-# async def list_tools(self) -> List[MCPTool]:
-# self._check_initialized()
-# response = await self.session.list_tools()
-# return response.tools
-#
-# async def execute_tool(self, tool_name: str, tool_args: dict) -> Tuple[str, bool]:
-# self._check_initialized()
-# result = await self.session.call_tool(tool_name, tool_args)
-#
-# parsed_content = []
-# for content_piece in result.content:
-# if isinstance(content_piece, TextContent):
-# parsed_content.append(content_piece.text)
-# else:
-# parsed_content.append(str(content_piece))
-#
-# if len(parsed_content) > 0:
-# final_content = " ".join(parsed_content)
-# else:
-# # TODO move hardcoding to constants
-# final_content = "Empty response from tool"
-#
-# return final_content, result.isError
-#
-# def _check_initialized(self):
-# if not self.initialized:
-# logger.error("MCPClient has not been initialized")
-# raise RuntimeError("MCPClient has not been initialized")
-#
-# async def cleanup(self):
-# try:
-# for cleanup_func in self.cleanup_funcs:
-# cleanup_func()
-# self.initialized = False
-# if not self.loop.is_closed():
-# self.loop.close()
-# except Exception as e:
-# logger.warning(e)
-# finally:
-# logger.info("Cleaned up MCP clients on shutdown.")
-#
diff --git a/letta/functions/mcp_client/sse_client.py b/letta/functions/mcp_client/sse_client.py
deleted file mode 100644
index 01ad0b157..000000000
--- a/letta/functions/mcp_client/sse_client.py
+++ /dev/null
@@ -1,51 +0,0 @@
-# import asyncio
-#
-# from mcp import ClientSession
-# from mcp.client.sse import sse_client
-#
-# from letta.functions.mcp_client.base_client import BaseAsyncMCPClient, BaseMCPClient
-# from letta.functions.mcp_client.types import SSEServerConfig
-# from letta.log import get_logger
-#
-## see: https://modelcontextprotocol.io/quickstart/user
-#
-# logger = get_logger(__name__)
-
-
-# class SSEMCPClient(BaseMCPClient):
-# 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(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
-#
-#
-# class AsyncSSEMCPClient(BaseAsyncMCPClient):
-#
-# async def _initialize_connection(self, server_config: SSEServerConfig, timeout: float) -> bool:
-# try:
-# sse_cm = sse_client(url=server_config.server_url)
-# sse_transport = await sse_cm.__aenter__()
-# self.stdio, self.write = sse_transport
-# self.cleanup_funcs.append(lambda: sse_cm.__aexit__(None, None, None))
-#
-# session_cm = ClientSession(self.stdio, self.write)
-# self.session = await session_cm.__aenter__()
-# self.cleanup_funcs.append(lambda: session_cm.__aexit__(None, None, None))
-# return True
-# 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
deleted file mode 100644
index be06b637f..000000000
--- a/letta/functions/mcp_client/stdio_client.py
+++ /dev/null
@@ -1,109 +0,0 @@
-# import asyncio
-# import sys
-# from contextlib import asynccontextmanager
-#
-# import anyio
-# import anyio.lowlevel
-# import mcp.types as types
-# from anyio.streams.text import TextReceiveStream
-# from mcp import ClientSession, StdioServerParameters
-# from mcp.client.stdio import get_default_environment
-#
-# from letta.functions.mcp_client.base_client import BaseMCPClient
-# from letta.functions.mcp_client.types import StdioServerConfig
-# from letta.log import get_logger
-#
-# logger = get_logger(__name__)
-
-
-# class StdioMCPClient(BaseMCPClient):
-# def _initialize_connection(self, server_config: StdioServerConfig, timeout: float) -> bool:
-# try:
-# server_params = StdioServerParameters(command=server_config.command, args=server_config.args, env=server_config.env)
-# stdio_cm = forked_stdio_client(server_params)
-# 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(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
-#
-#
-# @asynccontextmanager
-# async def forked_stdio_client(server: StdioServerParameters):
-# """
-# Client transport for stdio: this will connect to a server by spawning a
-# process and communicating with it over stdin/stdout.
-# """
-# read_stream_writer, read_stream = anyio.create_memory_object_stream(0)
-# write_stream, write_stream_reader = anyio.create_memory_object_stream(0)
-#
-# try:
-# process = await anyio.open_process(
-# [server.command, *server.args],
-# env=server.env or get_default_environment(),
-# stderr=sys.stderr, # Consider logging stderr somewhere instead of silencing it
-# )
-# except OSError as exc:
-# raise RuntimeError(f"Failed to spawn process: {server.command} {server.args}") from exc
-#
-# async def stdout_reader():
-# assert process.stdout, "Opened process is missing stdout"
-# buffer = ""
-# try:
-# async with read_stream_writer:
-# async for chunk in TextReceiveStream(
-# process.stdout,
-# encoding=server.encoding,
-# errors=server.encoding_error_handler,
-# ):
-# lines = (buffer + chunk).split("\n")
-# buffer = lines.pop()
-# for line in lines:
-# try:
-# message = types.JSONRPCMessage.model_validate_json(line)
-# except Exception as exc:
-# await read_stream_writer.send(exc)
-# continue
-# await read_stream_writer.send(message)
-# except anyio.ClosedResourceError:
-# await anyio.lowlevel.checkpoint()
-#
-# async def stdin_writer():
-# assert process.stdin, "Opened process is missing stdin"
-# try:
-# async with write_stream_reader:
-# async for message in write_stream_reader:
-# json = message.model_dump_json(by_alias=True, exclude_none=True)
-# await process.stdin.send(
-# (json + "\n").encode(
-# encoding=server.encoding,
-# errors=server.encoding_error_handler,
-# )
-# )
-# except anyio.ClosedResourceError:
-# await anyio.lowlevel.checkpoint()
-#
-# async def watch_process_exit():
-# returncode = await process.wait()
-# if returncode != 0:
-# raise RuntimeError(f"Subprocess exited with code {returncode}. Command: {server.command} {server.args}")
-#
-# async with anyio.create_task_group() as tg, process:
-# tg.start_soon(stdout_reader)
-# tg.start_soon(stdin_writer)
-# tg.start_soon(watch_process_exit)
-#
-# with anyio.move_on_after(0.2):
-# await anyio.sleep_forever()
-#
-# yield read_stream, write_stream
-#