letta-nightly 0.6.38.dev20250312104155__py3-none-any.whl → 0.6.39.dev20250313162623__py3-none-any.whl

letta/server/rest_api/routers/v1/tools.py

@@ -1,4 +1,4 @@
-from typing import List, Optional
+from typing import List, Optional, Union
 
 from composio.client import ComposioClientError, HTTPError, NoItemsFound
 from composio.client.collections import ActionModel, AppModel
@@ -13,6 +13,7 @@ from fastapi import APIRouter, Body, Depends, Header, HTTPException
 
 from letta.errors import LettaToolCreateError
 from letta.helpers.composio_helpers import get_composio_api_key
+from letta.helpers.mcp_helpers import LocalServerConfig, MCPTool, SSEServerConfig
 from letta.log import get_logger
 from letta.orm.errors import UniqueConstraintViolationError
 from letta.schemas.letta_message import ToolReturnMessage
@@ -329,3 +330,72 @@ def add_composio_tool(
                 "composio_action_name": composio_action_name,
             },
         )
+
+
+# Specific routes for MCP
+@router.get("/mcp/servers", response_model=dict[str, Union[SSEServerConfig, LocalServerConfig]], operation_id="list_mcp_servers")
+def list_mcp_servers(server: SyncServer = Depends(get_letta_server), user_id: Optional[str] = Header(None, alias="user_id")):
+    """
+    Get a list of all configured MCP servers
+    """
+    actor = server.user_manager.get_user_or_default(user_id=user_id)
+    return server.get_mcp_servers()
+
+
+# NOTE: async because the MCP client/session calls are async
+# TODO: should we make the return type MCPTool, not Tool (since we don't have ID)?
+@router.get("/mcp/servers/{mcp_server_name}/tools", response_model=List[MCPTool], operation_id="list_mcp_tools_by_server")
+def list_mcp_tools_by_server(
+    mcp_server_name: str,
+    server: SyncServer = Depends(get_letta_server),
+    actor_id: Optional[str] = Header(None, alias="user_id"),
+):
+    """
+    Get a list of all tools for a specific MCP server
+    """
+    actor = server.user_manager.get_user_or_default(user_id=actor_id)
+    try:
+        return server.get_tools_from_mcp_server(mcp_server_name=mcp_server_name)
+    except ValueError as e:
+        # ValueError means that the MCP server name doesn't exist
+        raise HTTPException(
+            status_code=400,  # Bad Request
+            detail={
+                "code": "MCPServerNotFoundError",
+                "message": str(e),
+                "mcp_server_name": mcp_server_name,
+            },
+        )
+
+
+@router.post("/mcp/servers/{mcp_server_name}/{mcp_tool_name}", response_model=Tool, operation_id="add_mcp_tool")
+def add_mcp_tool(
+    mcp_server_name: str,
+    mcp_tool_name: str,
+    server: SyncServer = Depends(get_letta_server),
+    actor_id: Optional[str] = Header(None, alias="user_id"),
+):
+    """
+    Add a new MCP tool by server + tool name
+    """
+    actor = server.user_manager.get_user_or_default(user_id=actor_id)
+
+    available_tools = server.get_tools_from_mcp_server(mcp_server_name=mcp_server_name)
+    # See if the tool is in the avaialable list
+    mcp_tool = None
+    for tool in available_tools:
+        if tool.name == mcp_tool_name:
+            mcp_tool = tool
+            break
+    if not mcp_tool:
+        raise HTTPException(
+            status_code=400,  # Bad Request
+            detail={
+                "code": "MCPToolNotFoundError",
+                "message": f"Tool {mcp_tool_name} not found in MCP server {mcp_server_name} - available tools: {', '.join([tool.name for tool in available_tools])}",
+                "mcp_tool_name": mcp_tool_name,
+            },
+        )
+
+    tool_create = ToolCreate.from_mcp(mcp_server_name=mcp_server_name, mcp_tool=mcp_tool)
+    return server.tool_manager.create_or_update_mcp_tool(tool_create=tool_create, actor=actor)

letta/server/server.py

@@ -21,6 +21,15 @@ from letta.config import LettaConfig
 from letta.data_sources.connectors import DataConnector, load_data
 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,
+    LocalMCPClient,
+    LocalServerConfig,
+    MCPServerType,
+    MCPTool,
+    SSEMCPClient,
+    SSEServerConfig,
+)
 
 # TODO use custom interface
 from letta.interface import AgentInterface  # abstract
@@ -314,6 +323,31 @@ class SyncServer(Server):
         if model_settings.xai_api_key:
             self._enabled_providers.append(xAIProvider(api_key=model_settings.xai_api_key))
 
+        # For MCP
+        """Initialize the MCP clients (there may be multiple)"""
+        mcp_server_configs = self.get_mcp_servers()
+        self.mcp_clients: Dict[str, BaseMCPClient] = {}
+
+        for server_name, server_config in mcp_server_configs.items():
+            if server_config.type == MCPServerType.SSE:
+                self.mcp_clients[server_name] = SSEMCPClient()
+            elif server_config.type == MCPServerType.LOCAL:
+                self.mcp_clients[server_name] = LocalMCPClient()
+            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
+
+        # Print out the tools that are connected
+        for server_name, client in self.mcp_clients.items():
+            logger.info(f"Attempting to fetch tools from MCP server: {server_name}")
+            mcp_tools = client.list_tools()
+            logger.info(f"MCP tools connected: {', '.join([t.name for t in mcp_tools])}")
+            logger.debug(f"MCP tools: {', '.join([str(t) for t in mcp_tools])}")
+
     def load_agent(self, agent_id: str, actor: User, interface: Union[AgentInterface, None] = None) -> Agent:
         """Updated method to load agents from persisted storage"""
         agent_lock = self.per_agent_lock_manager.get_lock(agent_id)
@@ -322,7 +356,7 @@ class SyncServer(Server):
 
             interface = interface or self.default_interface_factory()
             if agent_state.agent_type == AgentType.memgpt_agent:
-                agent = Agent(agent_state=agent_state, interface=interface, user=actor)
+                agent = Agent(agent_state=agent_state, interface=interface, user=actor, mcp_clients=self.mcp_clients)
             elif agent_state.agent_type == AgentType.offline_memory_agent:
                 agent = OfflineMemoryAgent(agent_state=agent_state, interface=interface, user=actor)
             else:
@@ -601,11 +635,12 @@ class SyncServer(Server):
 
         if isinstance(message, Message):
             # Can't have a null text field
-            if message.text is None or len(message.text) == 0:
-                raise ValueError(f"Invalid input: '{message.text}'")
+            message_text = message.content[0].text
+            if message_text is None or len(message_text) == 0:
+                raise ValueError(f"Invalid input: '{message_text}'")
             # If the input begins with a command prefix, reject
-            elif message.text.startswith("/"):
-                raise ValueError(f"Invalid input: '{message.text}'")
+            elif message_text.startswith("/"):
+                raise ValueError(f"Invalid input: '{message_text}'")
 
         else:
             raise TypeError(f"Invalid input: '{message}' - type {type(message)}")
@@ -1172,6 +1207,68 @@ class SyncServer(Server):
         actions = self.get_composio_client(api_key=api_key).actions.get(apps=[composio_app_name])
         return actions
 
+    # MCP wrappers
+    # TODO support both command + SSE servers (via config)
+    def get_mcp_servers(self) -> dict[str, Union[SSEServerConfig, LocalServerConfig]]:
+        """List the MCP servers in the config (doesn't test that they are actually working)"""
+        mcp_server_list = {}
+
+        # Attempt to read from ~/.letta/mcp_config.json
+        mcp_config_path = os.path.join(constants.LETTA_DIR, constants.MCP_CONFIG_NAME)
+        if os.path.exists(mcp_config_path):
+            with open(mcp_config_path, "r") as f:
+
+                try:
+                    mcp_config = json.load(f)
+                except Exception as e:
+                    logger.error(f"Failed to parse MCP config file ({mcp_config_path}) as json: {e}")
+                    return mcp_server_list
+
+                # Proper formatting is "mcpServers" key at the top level,
+                # then a dict with the MCP server name as the key,
+                # with the value being the schema from StdioServerParameters
+                if "mcpServers" in mcp_config:
+                    for server_name, server_params_raw in mcp_config["mcpServers"].items():
+
+                        # No support for duplicate server names
+                        if server_name in mcp_server_list:
+                            logger.error(f"Duplicate MCP server name found (skipping): {server_name}")
+                            continue
+
+                        if "url" in server_params_raw:
+                            # Attempt to parse the server params as an SSE server
+                            try:
+                                server_params = SSEServerConfig(
+                                    server_name=server_name,
+                                    server_url=server_params_raw["url"],
+                                )
+                                mcp_server_list[server_name] = server_params
+                            except Exception as e:
+                                logger.error(f"Failed to parse server params for MCP server {server_name} (skipping): {e}")
+                                continue
+                        else:
+                            # Attempt to parse the server params as a StdioServerParameters
+                            try:
+                                server_params = LocalServerConfig(
+                                    server_name=server_name,
+                                    command=server_params_raw["command"],
+                                    args=server_params_raw.get("args", []),
+                                )
+                                mcp_server_list[server_name] = server_params
+                            except Exception as e:
+                                logger.error(f"Failed to parse server params for MCP server {server_name} (skipping): {e}")
+                                continue
+
+        # If the file doesn't exist, return empty dictionary
+        return mcp_server_list
+
+    def get_tools_from_mcp_server(self, mcp_server_name: str) -> List[MCPTool]:
+        """List the tools in an MCP server. Requires a client to be created."""
+        if mcp_server_name not in self.mcp_clients:
+            raise ValueError(f"No client was created for MCP server: {mcp_server_name}")
+
+        return self.mcp_clients[mcp_server_name].list_tools()
+
     @trace_method
     async def send_message_to_agent(
         self,

letta/services/agent_manager.py

@@ -337,6 +337,7 @@ class AgentManager:
         match_all_tags: bool = False,
         query_text: Optional[str] = None,
         identifier_keys: Optional[List[str]] = None,
+        identity_id: Optional[str] = None,
         **kwargs,
     ) -> List[PydanticAgentState]:
         """
@@ -353,6 +354,7 @@ class AgentManager:
                 organization_id=actor.organization_id if actor else None,
                 query_text=query_text,
                 identifier_keys=identifier_keys,
+                identity_id=identity_id,
                 **kwargs,
             )
 

letta/services/block_manager.py

@@ -64,6 +64,8 @@ class BlockManager:
         label: Optional[str] = None,
         is_template: Optional[bool] = None,
         template_name: Optional[str] = None,
+        identifier_keys: Optional[List[str]] = None,
+        identity_id: Optional[str] = None,
         id: Optional[str] = None,
         after: Optional[str] = None,
         limit: Optional[int] = 50,
@@ -81,7 +83,14 @@ class BlockManager:
             if id:
                 filters["id"] = id
 
-            blocks = BlockModel.list(db_session=session, after=after, limit=limit, **filters)
+            blocks = BlockModel.list(
+                db_session=session,
+                after=after,
+                limit=limit,
+                identifier_keys=identifier_keys,
+                identity_id=identity_id,
+                **filters,
+            )
 
             return [block.to_pydantic() for block in blocks]
 

letta/services/identity_manager.py

@@ -5,6 +5,7 @@ from sqlalchemy.exc import NoResultFound
 from sqlalchemy.orm import Session
 
 from letta.orm.agent import Agent as AgentModel
+from letta.orm.block import Block as BlockModel
 from letta.orm.identity import Identity as IdentityModel
 from letta.schemas.identity import Identity as PydanticIdentity
 from letta.schemas.identity import IdentityCreate, IdentityType, IdentityUpdate
@@ -58,9 +59,24 @@ class IdentityManager:
     @enforce_types
     def create_identity(self, identity: IdentityCreate, actor: PydanticUser) -> PydanticIdentity:
         with self.session_maker() as session:
-            new_identity = IdentityModel(**identity.model_dump(exclude={"agent_ids"}, exclude_unset=True))
+            new_identity = IdentityModel(**identity.model_dump(exclude={"agent_ids", "block_ids"}, exclude_unset=True))
             new_identity.organization_id = actor.organization_id
-            self._process_agent_relationship(session=session, identity=new_identity, agent_ids=identity.agent_ids, allow_partial=False)
+            self._process_relationship(
+                session=session,
+                identity=new_identity,
+                relationship_name="agents",
+                model_class=AgentModel,
+                item_ids=identity.agent_ids,
+                allow_partial=False,
+            )
+            self._process_relationship(
+                session=session,
+                identity=new_identity,
+                relationship_name="blocks",
+                model_class=BlockModel,
+                item_ids=identity.block_ids,
+                allow_partial=False,
+            )
             new_identity.create(session, actor=actor)
             return new_identity.to_pydantic()
 
@@ -124,9 +140,26 @@ class IdentityManager:
                 new_properties = existing_identity.properties + [prop.model_dump() for prop in identity.properties]
                 existing_identity.properties = new_properties
 
-        self._process_agent_relationship(
-            session=session, identity=existing_identity, agent_ids=identity.agent_ids, allow_partial=False, replace=replace
-        )
+        if identity.agent_ids is not None:
+            self._process_relationship(
+                session=session,
+                identity=existing_identity,
+                relationship_name="agents",
+                model_class=AgentModel,
+                item_ids=identity.agent_ids,
+                allow_partial=False,
+                replace=replace,
+            )
+        if identity.block_ids is not None:
+            self._process_relationship(
+                session=session,
+                identity=existing_identity,
+                relationship_name="blocks",
+                model_class=BlockModel,
+                item_ids=identity.block_ids,
+                allow_partial=False,
+                replace=replace,
+            )
         existing_identity.update(session, actor=actor)
         return existing_identity.to_pydantic()
 
@@ -141,26 +174,33 @@ class IdentityManager:
             session.delete(identity)
             session.commit()
 
-    def _process_agent_relationship(
-        self, session: Session, identity: IdentityModel, agent_ids: List[str], allow_partial=False, replace=True
+    def _process_relationship(
+        self,
+        session: Session,
+        identity: PydanticIdentity,
+        relationship_name: str,
+        model_class,
+        item_ids: List[str],
+        allow_partial=False,
+        replace=True,
     ):
-        current_relationship = getattr(identity, "agents", [])
-        if not agent_ids:
+        current_relationship = getattr(identity, relationship_name, [])
+        if not item_ids:
             if replace:
-                setattr(identity, "agents", [])
+                setattr(identity, relationship_name, [])
             return
 
         # Retrieve models for the provided IDs
-        found_items = session.query(AgentModel).filter(AgentModel.id.in_(agent_ids)).all()
+        found_items = session.query(model_class).filter(model_class.id.in_(item_ids)).all()
 
         # Validate all items are found if allow_partial is False
-        if not allow_partial and len(found_items) != len(agent_ids):
-            missing = set(agent_ids) - {item.id for item in found_items}
+        if not allow_partial and len(found_items) != len(item_ids):
+            missing = set(item_ids) - {item.id for item in found_items}
             raise NoResultFound(f"Items not found in agents: {missing}")
 
         if replace:
             # Replace the relationship
-            setattr(identity, "agents", found_items)
+            setattr(identity, relationship_name, found_items)
         else:
             # Extend the relationship (only add new items)
             current_ids = {item.id for item in current_relationship}

letta/services/summarizer/summarizer.py

@@ -96,7 +96,7 @@ class Summarizer:
         )
 
         messages = await self.summarizer_agent.step(UserMessage(content=summary_request_text))
-        current_summary = "\n".join([m.text for m in messages])
+        current_summary = "\n".join([m.content[0].text for m in messages])
         current_summary = f"{self.summary_prefix}{current_summary}"
 
         return updated_in_context_messages, current_summary, True

letta/services/tool_manager.py

@@ -56,6 +56,12 @@ class ToolManager:
 
         return tool
 
+    @enforce_types
+    def create_or_update_mcp_tool(self, tool_create: ToolCreate, actor: PydanticUser) -> PydanticTool:
+        return self.create_or_update_tool(
+            PydanticTool(tool_type=ToolType.EXTERNAL_MCP, name=tool_create.json_schema["name"], **tool_create.model_dump()), actor
+        )
+
     @enforce_types
     def create_or_update_composio_tool(self, tool_create: ToolCreate, actor: PydanticUser) -> PydanticTool:
         return self.create_or_update_tool(

letta/settings.py

@@ -119,18 +119,17 @@ class ModelSettings(BaseSettings):
 
 env_cors_origins = os.getenv("ACCEPTABLE_ORIGINS")
 
-cors_origins = (
-    [
-        "http://letta.localhost",
-        "http://localhost:8283",
-        "http://localhost:8083",
-        "http://localhost:3000",
-        "http://localhost:4200",
-    ]
-    + [env_cors_origins]
-    if env_cors_origins
-    else []
-)
+cors_origins = [
+    "http://letta.localhost",
+    "http://localhost:8283",
+    "http://localhost:8083",
+    "http://localhost:3000",
+    "http://localhost:4200",
+]
+
+# attach the env_cors_origins to the cors_origins if it exists
+if env_cors_origins:
+    cors_origins.extend(env_cors_origins.split(","))
 
 # read pg_uri from ~/.letta/pg_uri or set to none, this is to support Letta Desktop
 default_pg_uri = None

{letta_nightly-0.6.38.dev20250312104155.dist-info → letta_nightly-0.6.39.dev20250313162623.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: letta-nightly
-Version: 0.6.38.dev20250312104155
+Version: 0.6.39.dev20250313162623
 Summary: Create LLM agents with long-term memory and custom tools
 License: Apache License
 Author: Letta Team
@@ -32,7 +32,7 @@ Requires-Dist: colorama (>=0.4.6,<0.5.0)
 Requires-Dist: composio-core (>=0.7.7,<0.8.0)
 Requires-Dist: composio-langchain (>=0.7.7,<0.8.0)
 Requires-Dist: datamodel-code-generator[http] (>=0.25.0,<0.26.0) ; extra == "desktop" or extra == "all"
-Requires-Dist: datasets (>=2.14.6,<3.0.0) ; extra == "dev" or extra == "desktop" or extra == "all"
+Requires-Dist: datasets (>=2.14.6,<3.0.0)
 Requires-Dist: demjson3 (>=3.0.6,<4.0.0)
 Requires-Dist: docker (>=7.1.0,<8.0.0) ; extra == "external-tools" or extra == "desktop" or extra == "all"
 Requires-Dist: docstring-parser (>=0.16,<0.17)
@@ -50,11 +50,12 @@ Requires-Dist: isort (>=5.13.2,<6.0.0) ; extra == "dev" or extra == "all"
 Requires-Dist: jinja2 (>=3.1.5,<4.0.0)
 Requires-Dist: langchain (>=0.3.7,<0.4.0) ; extra == "external-tools" or extra == "desktop" or extra == "all"
 Requires-Dist: langchain-community (>=0.3.7,<0.4.0) ; extra == "external-tools" or extra == "desktop" or extra == "all"
-Requires-Dist: letta_client (>=0.1.54,<0.2.0)
+Requires-Dist: letta_client (>=0.1.65,<0.2.0)
 Requires-Dist: llama-index (>=0.12.2,<0.13.0)
 Requires-Dist: llama-index-embeddings-openai (>=0.3.1,<0.4.0)
 Requires-Dist: locust (>=2.31.5,<3.0.0) ; extra == "dev" or extra == "desktop" or extra == "all"
 Requires-Dist: marshmallow-sqlalchemy (>=1.4.1,<2.0.0)
+Requires-Dist: mcp (>=1.3.0,<2.0.0)
 Requires-Dist: nltk (>=3.8.1,<4.0.0)
 Requires-Dist: numpy (>=1.26.2,<2.0.0)
 Requires-Dist: openai (>=1.60.0,<2.0.0)