letta-nightly 0.6.37.dev20250311104150__py3-none-any.whl → 0.6.39.dev20250313104142__py3-none-any.whl

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

@@ -13,13 +13,12 @@ from letta.constants import DEFAULT_MESSAGE_TOOL, DEFAULT_MESSAGE_TOOL_KWARG
 from letta.log import get_logger
 from letta.orm.errors import NoResultFound
 from letta.schemas.agent import AgentState, CreateAgent, UpdateAgent
-from letta.schemas.block import Block, BlockUpdate, CreateBlock  # , BlockLabelUpdate, BlockLimitUpdate
+from letta.schemas.block import Block, BlockUpdate
 from letta.schemas.job import JobStatus, JobUpdate, LettaRequestConfig
-from letta.schemas.letta_message import LettaMessageUnion
+from letta.schemas.letta_message import LettaMessageUnion, LettaMessageUpdateUnion
 from letta.schemas.letta_request import LettaRequest, LettaStreamingRequest
 from letta.schemas.letta_response import LettaResponse
 from letta.schemas.memory import ContextWindowOverview, CreateArchivalMemory, Memory
-from letta.schemas.message import Message, MessageUpdate
 from letta.schemas.passage import Passage, PassageUpdate
 from letta.schemas.run import Run
 from letta.schemas.source import Source
@@ -54,7 +53,7 @@ def list_agents(
     project_id: Optional[str] = Query(None, description="Search agents by project id"),
     template_id: Optional[str] = Query(None, description="Search agents by template id"),
     base_template_id: Optional[str] = Query(None, description="Search agents by base template id"),
-    identifier_id: Optional[str] = Query(None, description="Search agents by identifier id"),
+    identity_id: Optional[str] = Query(None, description="Search agents by identifier id"),
     identifier_keys: Optional[List[str]] = Query(None, description="Search agents by identifier keys"),
 ):
     """
@@ -85,7 +84,7 @@ def list_agents(
         tags=tags,
         match_all_tags=match_all_tags,
         identifier_keys=identifier_keys,
-        identifier_id=identifier_id,
+        identity_id=identity_id,
         **kwargs,
     )
     return agents
@@ -119,6 +118,7 @@ async def upload_agent_serialized(
         True,
         description="If set to True, existing tools can get their source code overwritten by the uploaded tool definitions. Note that Letta core tools can never be updated externally.",
     ),
+    project_id: Optional[str] = Query(None, description="The project ID to associate the uploaded agent with."),
 ):
     """
     Upload a serialized agent JSON file and recreate the agent in the system.
@@ -129,7 +129,11 @@ async def upload_agent_serialized(
         serialized_data = await file.read()
         agent_json = json.loads(serialized_data)
         new_agent = server.agent_manager.deserialize(
-            serialized_agent=agent_json, actor=actor, append_copy_suffix=append_copy_suffix, override_existing_tools=override_existing_tools
+            serialized_agent=agent_json,
+            actor=actor,
+            append_copy_suffix=append_copy_suffix,
+            override_existing_tools=override_existing_tools,
+            project_id=project_id,
         )
         return new_agent
 
@@ -526,20 +530,20 @@ def list_messages(
     )
 
 
-@router.patch("/{agent_id}/messages/{message_id}", response_model=Message, operation_id="modify_message")
+@router.patch("/{agent_id}/messages/{message_id}", response_model=LettaMessageUpdateUnion, operation_id="modify_message")
 def modify_message(
     agent_id: str,
     message_id: str,
-    request: MessageUpdate = Body(...),
+    request: LettaMessageUpdateUnion = Body(...),
     server: "SyncServer" = Depends(get_letta_server),
     actor_id: Optional[str] = Header(None, alias="user_id"),  # Extract user_id from header, default to None if not present
 ):
     """
     Update the details of a message associated with an agent.
     """
-    # TODO: Get rid of agent_id here, it's not really relevant
+    # TODO: support modifying tool calls/returns
     actor = server.user_manager.get_user_or_default(user_id=actor_id)
-    return server.message_manager.update_message_by_id(message_id=message_id, message_update=request, actor=actor)
+    return server.message_manager.update_message_by_letta_message(message_id=message_id, letta_message_update=request, actor=actor)
 
 
 @router.post(

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

@@ -20,11 +20,15 @@ def list_blocks(
     label: Optional[str] = Query(None, description="Labels to include (e.g. human, persona)"),
     templates_only: bool = Query(True, description="Whether to include only templates"),
     name: Optional[str] = Query(None, description="Name of the block"),
+    identity_id: Optional[str] = Query(None, description="Search agents by identifier id"),
+    identifier_keys: Optional[List[str]] = Query(None, description="Search agents by identifier keys"),
     server: SyncServer = Depends(get_letta_server),
     actor_id: Optional[str] = Header(None, alias="user_id"),  # Extract user_id from header, default to None if not present
 ):
     actor = server.user_manager.get_user_or_default(user_id=actor_id)
-    return server.block_manager.get_blocks(actor=actor, label=label, is_template=templates_only, template_name=name)
+    return server.block_manager.get_blocks(
+        actor=actor, label=label, is_template=templates_only, template_name=name, identity_id=identity_id, identifier_keys=identifier_keys
+    )
 
 
 @router.post("/", response_model=Block, operation_id="create_block")

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

@@ -20,6 +20,7 @@ def list_steps(
     start_date: Optional[str] = Query(None, description='Return steps after this ISO datetime (e.g. "2025-01-29T15:01:19-08:00")'),
     end_date: Optional[str] = Query(None, description='Return steps before this ISO datetime (e.g. "2025-01-29T15:01:19-08:00")'),
     model: Optional[str] = Query(None, description="Filter by the name of the model used for the step"),
+    agent_id: Optional[str] = Query(None, description="Filter by the ID of the agent that performed the step"),
     server: SyncServer = Depends(get_letta_server),
     actor_id: Optional[str] = Header(None, alias="user_id"),
 ):
@@ -42,6 +43,7 @@ def list_steps(
         limit=limit,
         order=order,
         model=model,
+        agent_id=agent_id,
     )
 
 

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/rest_api/routers/v1/voice.py

@@ -2,7 +2,7 @@ from typing import TYPE_CHECKING, Optional
 
 import httpx
 import openai
-from fastapi import APIRouter, Body, Depends, Header, HTTPException
+from fastapi import APIRouter, Body, Depends, Header
 from fastapi.responses import StreamingResponse
 from openai.types.chat.completion_create_params import CompletionCreateParams
 
@@ -22,7 +22,7 @@ logger = get_logger(__name__)
 
 
 @router.post(
-    "/chat/completions",
+    "/{agent_id}/chat/completions",
     response_model=None,
     operation_id="create_voice_chat_completions",
     responses={
@@ -35,16 +35,13 @@ logger = get_logger(__name__)
     },
 )
 async def create_voice_chat_completions(
+    agent_id: str,
     completion_request: CompletionCreateParams = Body(...),
     server: "SyncServer" = Depends(get_letta_server),
     user_id: Optional[str] = Header(None, alias="user_id"),
 ):
     actor = server.user_manager.get_user_or_default(user_id=user_id)
 
-    agent_id = str(completion_request.get("user", None))
-    if agent_id is None:
-        raise HTTPException(status_code=400, detail="Must pass agent_id in the 'user' field")
-
     # Also parse the user's new input
     input_message = UserMessage(**get_messages_from_completion_request(completion_request)[-1])
 

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,11 +354,55 @@ class AgentManager:
                 organization_id=actor.organization_id if actor else None,
                 query_text=query_text,
                 identifier_keys=identifier_keys,
+                identity_id=identity_id,
                 **kwargs,
             )
 
             return [agent.to_pydantic() for agent in agents]
 
+    @enforce_types
+    def list_agents_matching_tags(
+        self,
+        actor: PydanticUser,
+        match_all: List[str],
+        match_some: List[str],
+        limit: Optional[int] = 50,
+    ) -> List[PydanticAgentState]:
+        """
+        Retrieves agents in the same organization that match all specified `match_all` tags
+        and at least one tag from `match_some`. The query is optimized for efficiency by
+        leveraging indexed filtering and aggregation.
+
+        Args:
+            actor (PydanticUser): The user requesting the agent list.
+            match_all (List[str]): Agents must have all these tags.
+            match_some (List[str]): Agents must have at least one of these tags.
+            limit (Optional[int]): Maximum number of agents to return.
+
+        Returns:
+            List[PydanticAgentState: The filtered list of matching agents.
+        """
+        with self.session_maker() as session:
+            query = select(AgentModel).where(AgentModel.organization_id == actor.organization_id)
+
+            if match_all:
+                # Subquery to find agent IDs that contain all match_all tags
+                subquery = (
+                    select(AgentsTags.agent_id)
+                    .where(AgentsTags.tag.in_(match_all))
+                    .group_by(AgentsTags.agent_id)
+                    .having(func.count(AgentsTags.tag) == literal(len(match_all)))
+                )
+                query = query.where(AgentModel.id.in_(subquery))
+
+            if match_some:
+                # Ensures agents match at least one tag in match_some
+                query = query.join(AgentsTags).where(AgentsTags.tag.in_(match_some))
+
+            query = query.group_by(AgentModel.id).limit(limit)
+
+            return list(session.execute(query).scalars())
+
     @enforce_types
     def get_agent_by_id(self, agent_id: str, actor: PydanticUser) -> PydanticAgentState:
         """Fetch an agent by its ID."""
@@ -401,7 +446,12 @@ class AgentManager:
 
     @enforce_types
     def deserialize(
-        self, serialized_agent: dict, actor: PydanticUser, append_copy_suffix: bool = True, override_existing_tools: bool = True
+        self,
+        serialized_agent: dict,
+        actor: PydanticUser,
+        append_copy_suffix: bool = True,
+        override_existing_tools: bool = True,
+        project_id: Optional[str] = None,
     ) -> PydanticAgentState:
         tool_data_list = serialized_agent.pop("tools", [])
 
@@ -410,7 +460,9 @@ class AgentManager:
             agent = schema.load(serialized_agent, session=session)
             if append_copy_suffix:
                 agent.name += "_copy"
-            agent.create(session, actor=actor)
+            if project_id:
+                agent.project_id = project_id
+            agent = agent.create(session, actor=actor)
             pydantic_agent = agent.to_pydantic()
 
         # Need to do this separately as there's some fancy upsert logic that SqlAlchemy cannot handle
@@ -548,6 +600,7 @@ class AgentManager:
             system_prompt=agent_state.system,
             in_context_memory=agent_state.memory,
             in_context_memory_last_edit=memory_edit_timestamp,
+            recent_passages=self.list_passages(actor=actor, agent_id=agent_id, ascending=False, limit=10),
         )
 
         diff = united_diff(curr_system_message_openai["content"], new_system_message_str)
@@ -718,7 +771,9 @@ class AgentManager:
             # Commit the changes
             agent.update(session, actor=actor)
 
-        # Add system messsage alert to agent
+        # Force rebuild of system prompt so that the agent is updated with passage count
+        # and recent passages and add system message alert to agent
+        self.rebuild_system_prompt(agent_id=agent_id, actor=actor, force=True)
         self.append_system_message(
             agent_id=agent_id,
             content=DATA_SOURCE_ATTACH_ALERT,

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/helpers/agent_manager_helper.py

@@ -13,6 +13,7 @@ from letta.schemas.agent import AgentState, AgentType
 from letta.schemas.enums import MessageRole
 from letta.schemas.memory import Memory
 from letta.schemas.message import Message, MessageCreate, TextContent
+from letta.schemas.passage import Passage as PydanticPassage
 from letta.schemas.tool_rule import ToolRule
 from letta.schemas.user import User
 from letta.system import get_initial_boot_messages, get_login_event
@@ -99,7 +100,10 @@ def derive_system_message(agent_type: AgentType, system: Optional[str] = None):
 
 # TODO: This code is kind of wonky and deserves a rewrite
 def compile_memory_metadata_block(
-    memory_edit_timestamp: datetime.datetime, previous_message_count: int = 0, archival_memory_size: int = 0
+    memory_edit_timestamp: datetime.datetime,
+    previous_message_count: int = 0,
+    archival_memory_size: int = 0,
+    recent_passages: List[PydanticPassage] = None,
 ) -> str:
     # Put the timestamp in the local timezone (mimicking get_local_time())
     timestamp_str = memory_edit_timestamp.astimezone().strftime("%Y-%m-%d %I:%M:%S %p %Z%z").strip()
@@ -110,6 +114,11 @@ def compile_memory_metadata_block(
             f"### Memory [last modified: {timestamp_str}]",
             f"{previous_message_count} previous messages between you and the user are stored in recall memory (use functions to access them)",
             f"{archival_memory_size} total memories you created are stored in archival memory (use functions to access them)",
+            (
+                f"Most recent archival passages {len(recent_passages)} recent passages: {[passage.text for passage in recent_passages]}"
+                if recent_passages is not None
+                else ""
+            ),
             "\nCore memory shown below (limited in size, additional information stored in archival / recall memory):",
         ]
     )
@@ -146,6 +155,7 @@ def compile_system_message(
     template_format: Literal["f-string", "mustache", "jinja2"] = "f-string",
     previous_message_count: int = 0,
     archival_memory_size: int = 0,
+    recent_passages: Optional[List[PydanticPassage]] = None,
 ) -> str:
     """Prepare the final/full system message that will be fed into the LLM API
 
@@ -170,6 +180,7 @@ def compile_system_message(
             memory_edit_timestamp=in_context_memory_last_edit,
             previous_message_count=previous_message_count,
             archival_memory_size=archival_memory_size,
+            recent_passages=recent_passages,
         )
         full_memory_string = memory_metadata_string + "\n" + in_context_memory.compile()