letta-nightly 0.6.40.dev20250314173529__tar.gz → 0.6.40.dev20250314222759__tar.gz

{letta_nightly-0.6.40.dev20250314173529 → letta_nightly-0.6.40.dev20250314222759}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: letta-nightly
-Version: 0.6.40.dev20250314173529
+Version: 0.6.40.dev20250314222759
 Summary: Create LLM agents with long-term memory and custom tools
 License: Apache License
 Author: Letta Team

{letta_nightly-0.6.40.dev20250314173529 → letta_nightly-0.6.40.dev20250314222759}/letta/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.6.39"
+__version__ = "0.6.40"
 
 # import clients
 from letta.client.client import LocalClient, RESTClient, create_client

{letta_nightly-0.6.40.dev20250314173529 → letta_nightly-0.6.40.dev20250314222759}/letta/agent.py

@@ -22,11 +22,11 @@ from letta.errors import ContextWindowExceededError
 from letta.functions.ast_parsers import coerce_dict_args_by_annotations, get_function_annotations_from_source
 from letta.functions.functions import get_function_from_module
 from letta.functions.helpers import execute_composio_action, generate_composio_action_from_func_name
+from letta.functions.mcp_client.base_client import BaseMCPClient
 from letta.helpers import ToolRulesSolver
 from letta.helpers.composio_helpers import get_composio_api_key
 from letta.helpers.datetime_helpers import get_utc_time
 from letta.helpers.json_helpers import json_dumps, json_loads
-from letta.helpers.mcp_helpers import BaseMCPClient
 from letta.interface import AgentInterface
 from letta.llm_api.helpers import calculate_summarizer_cutoff, get_token_counts_for_messages, is_context_overflow_error
 from letta.llm_api.llm_api_tools import create

letta_nightly-0.6.40.dev20250314222759/letta/functions/mcp_client/base_client.py

@@ -0,0 +1,61 @@
+import asyncio
+from typing import List, Optional, Tuple
+
+from mcp import ClientSession, Tool
+
+from letta.functions.mcp_client.types import BaseServerConfig
+from letta.log import get_logger
+
+logger = get_logger(__name__)
+
+
+class BaseMCPClient:
+    def __init__(self):
+        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, server_config: BaseServerConfig):
+        asyncio.set_event_loop(self.loop)
+        success = self._initialize_connection(server_config)
+
+        if success:
+            self.loop.run_until_complete(self.session.initialize())
+            self.initialized = True
+        else:
+            raise RuntimeError(
+                f"Connecting to MCP server failed. Please review your server config: {server_config.model_dump_json(indent=4)}"
+            )
+
+    def _initialize_connection(self, server_config: BaseServerConfig) -> 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
+
+    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
+
+    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.")

letta_nightly-0.6.40.dev20250314222759/letta/functions/mcp_client/sse_client.py

@@ -0,0 +1,21 @@
+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
+
+# see: https://modelcontextprotocol.io/quickstart/user
+MCP_CONFIG_TOPLEVEL_KEY = "mcpServers"
+
+
+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)))
+
+        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

letta_nightly-0.6.40.dev20250314222759/letta/functions/mcp_client/stdio_client.py

@@ -0,0 +1,103 @@
+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) -> 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__())
+            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.cleanup_funcs.append(lambda: self.loop.run_until_complete(session_cm.__aexit__(None, None, None)))
+            return True
+        except Exception:
+            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

letta_nightly-0.6.40.dev20250314222759/letta/functions/mcp_client/types.py

@@ -0,0 +1,48 @@
+from enum import Enum
+from typing import List, Optional
+
+from mcp import Tool
+from pydantic import BaseModel, Field
+
+
+class MCPTool(Tool):
+    """A simple wrapper around MCP's tool definition (to avoid conflict with our own)"""
+
+
+class MCPServerType(str, Enum):
+    SSE = "sse"
+    STDIO = "stdio"
+
+
+class BaseServerConfig(BaseModel):
+    server_name: str = Field(..., description="The name of the server")
+    type: MCPServerType
+
+
+class SSEServerConfig(BaseServerConfig):
+    type: MCPServerType = MCPServerType.SSE
+    server_url: str = Field(..., description="The URL of the server (MCP SSE client will connect to this URL)")
+
+    def to_dict(self) -> dict:
+        values = {
+            "transport": "sse",
+            "url": self.server_url,
+        }
+        return values
+
+
+class StdioServerConfig(BaseServerConfig):
+    type: MCPServerType = MCPServerType.STDIO
+    command: str = Field(..., description="The command to run (MCP 'local' client will run this command)")
+    args: List[str] = Field(..., description="The arguments to pass to the command")
+    env: Optional[dict[str, str]] = Field(None, description="Environment variables to set")
+
+    def to_dict(self) -> dict:
+        values = {
+            "transport": "stdio",
+            "command": self.command,
+            "args": self.args,
+        }
+        if self.env is not None:
+            values["env"] = self.env
+        return values

{letta_nightly-0.6.40.dev20250314173529 → letta_nightly-0.6.40.dev20250314222759}/letta/functions/schema_generator.py

@@ -6,7 +6,7 @@ from composio.client.collections import ActionParametersModel
 from docstring_parser import parse
 from pydantic import BaseModel
 
-from letta.helpers.mcp_helpers import MCPTool
+from letta.functions.mcp_client.types import MCPTool
 
 
 def is_optional(annotation):

{letta_nightly-0.6.40.dev20250314173529 → letta_nightly-0.6.40.dev20250314222759}/letta/schemas/tool.py

@@ -17,12 +17,12 @@ from letta.functions.helpers import (
     generate_mcp_tool_wrapper,
     generate_model_from_args_json_schema,
 )
+from letta.functions.mcp_client.types import MCPTool
 from letta.functions.schema_generator import (
     generate_schema_from_args_schema_v2,
     generate_tool_schema_for_composio,
     generate_tool_schema_for_mcp,
 )
-from letta.helpers.mcp_helpers import MCPTool
 from letta.log import get_logger
 from letta.orm.enums import ToolType
 from letta.schemas.letta_base import LettaBase

{letta_nightly-0.6.40.dev20250314173529 → letta_nightly-0.6.40.dev20250314222759}/letta/server/rest_api/routers/v1/tools.py

@@ -12,8 +12,8 @@ from composio.exceptions import (
 from fastapi import APIRouter, Body, Depends, Header, HTTPException
 
 from letta.errors import LettaToolCreateError
+from letta.functions.mcp_client.types import MCPTool, SSEServerConfig, StdioServerConfig
 from letta.helpers.composio_helpers import get_composio_api_key
-from letta.helpers.mcp_helpers import MCPTool, SSEServerConfig, StdioServerConfig
 from letta.log import get_logger
 from letta.orm.errors import UniqueConstraintViolationError
 from letta.schemas.letta_message import ToolReturnMessage

{letta_nightly-0.6.40.dev20250314173529 → letta_nightly-0.6.40.dev20250314222759}/letta/server/server.py

@@ -20,18 +20,12 @@ from letta.agent import Agent, save_agent
 from letta.config import LettaConfig
 from letta.data_sources.connectors import DataConnector, load_data
 from letta.dynamic_multi_agent import DynamicMultiAgent
+from letta.functions.mcp_client.base_client import BaseMCPClient
+from letta.functions.mcp_client.sse_client import MCP_CONFIG_TOPLEVEL_KEY, SSEMCPClient
+from letta.functions.mcp_client.stdio_client import StdioMCPClient
+from letta.functions.mcp_client.types import MCPServerType, MCPTool, SSEServerConfig, StdioServerConfig
 from letta.helpers.datetime_helpers import get_utc_time
 from letta.helpers.json_helpers import json_dumps, json_loads
-from letta.helpers.mcp_helpers import (
-    MCP_CONFIG_TOPLEVEL_KEY,
-    BaseMCPClient,
-    MCPServerType,
-    MCPTool,
-    SSEMCPClient,
-    SSEServerConfig,
-    StdioMCPClient,
-    StdioServerConfig,
-)
 
 # TODO use custom interface
 from letta.interface import AgentInterface  # abstract
@@ -343,11 +337,12 @@ class SyncServer(Server):
                 self.mcp_clients[server_name] = StdioMCPClient()
             else:
                 raise ValueError(f"Invalid MCP server config: {server_config}")
+
             try:
                 self.mcp_clients[server_name].connect_to_server(server_config)
-            except:
-                logger.exception(f"Failed to connect to MCP server: {server_name}")
-                raise
+            except Exception as e:
+                logger.error(e)
+                self.mcp_clients.pop(server_name)
 
         # Print out the tools that are connected
         for server_name, client in self.mcp_clients.items():

{letta_nightly-0.6.40.dev20250314173529 → letta_nightly-0.6.40.dev20250314222759}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "letta-nightly"
-version = "0.6.40.dev20250314173529"
+version = "0.6.40.dev20250314222759"
 packages = [
     {include = "letta"},
 ]

letta_nightly-0.6.40.dev20250314173529/letta/helpers/mcp_helpers.py

@@ -1,129 +0,0 @@
-import asyncio
-from enum import Enum
-from typing import List, Optional, Tuple
-
-from mcp import ClientSession, StdioServerParameters, Tool
-from mcp.client.sse import sse_client
-from mcp.client.stdio import stdio_client
-from pydantic import BaseModel, Field
-
-from letta.log import get_logger
-
-logger = get_logger(__name__)
-
-# see: https://modelcontextprotocol.io/quickstart/user
-MCP_CONFIG_TOPLEVEL_KEY = "mcpServers"
-
-
-class MCPTool(Tool):
-    """A simple wrapper around MCP's tool definition (to avoid conflict with our own)"""
-
-
-class MCPServerType(str, Enum):
-    SSE = "sse"
-    STDIO = "stdio"
-
-
-class BaseServerConfig(BaseModel):
-    server_name: str = Field(..., description="The name of the server")
-    type: MCPServerType
-
-
-class SSEServerConfig(BaseServerConfig):
-    type: MCPServerType = MCPServerType.SSE
-    server_url: str = Field(..., description="The URL of the server (MCP SSE client will connect to this URL)")
-
-    def to_dict(self) -> dict:
-        values = {
-            "transport": "sse",
-            "url": self.server_url,
-        }
-        return values
-
-
-class StdioServerConfig(BaseServerConfig):
-    type: MCPServerType = MCPServerType.STDIO
-    command: str = Field(..., description="The command to run (MCP 'local' client will run this command)")
-    args: List[str] = Field(..., description="The arguments to pass to the command")
-    env: Optional[dict[str, str]] = Field(None, description="Environment variables to set")
-
-    def to_dict(self) -> dict:
-        values = {
-            "transport": "stdio",
-            "command": self.command,
-            "args": self.args,
-        }
-        if self.env is not None:
-            values["env"] = self.env
-        return values
-
-
-class BaseMCPClient:
-    def __init__(self):
-        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, server_config: BaseServerConfig):
-        asyncio.set_event_loop(self.loop)
-        self._initialize_connection(server_config)
-        self.loop.run_until_complete(self.session.initialize())
-        self.initialized = True
-
-    def _initialize_connection(self, server_config: BaseServerConfig):
-        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
-
-    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
-
-    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 StdioMCPClient(BaseMCPClient):
-    def _initialize_connection(self, server_config: StdioServerConfig):
-        server_params = StdioServerParameters(command=server_config.command, args=server_config.args)
-        stdio_cm = stdio_client(server_params)
-        stdio_transport = self.loop.run_until_complete(stdio_cm.__aenter__())
-        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.cleanup_funcs.append(lambda: self.loop.run_until_complete(session_cm.__aexit__(None, None, None)))
-
-
-class SSEMCPClient(BaseMCPClient):
-    def _initialize_connection(self, server_config: SSEServerConfig):
-        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)))
-
-        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)))