letta-nightly 0.5.1.dev20241106104104__py3-none-any.whl → 0.5.2.dev20241107104040__py3-none-any.whl

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

@@ -41,6 +41,7 @@ router = APIRouter(prefix="/agents", tags=["agents"])
 @router.get("/", response_model=List[AgentState], operation_id="list_agents")
 def list_agents(
     name: Optional[str] = Query(None, description="Name of the agent"),
+    tags: Optional[List[str]] = Query(None, description="List of tags to filter agents by"),
     server: "SyncServer" = Depends(get_letta_server),
     user_id: Optional[str] = Header(None, alias="user_id"),  # Extract user_id from header, default to None if not present
 ):
@@ -50,7 +51,7 @@ def list_agents(
     """
     actor = server.get_user_or_default(user_id=user_id)
 
-    agents = server.list_agents(user_id=actor.id)
+    agents = server.list_agents(user_id=actor.id, tags=tags)
     # TODO: move this logic to the ORM
     if name:
         agents = [a for a in agents if a.name == name]
@@ -534,124 +535,3 @@ async def send_message_to_agent(
 
         traceback.print_exc()
         raise HTTPException(status_code=500, detail=f"{e}")
-
-
-##### MISSING #######
-
-# @router.post("/{agent_id}/command")
-# def run_command(
-# agent_id: "UUID",
-# command: "AgentCommandRequest",
-#
-# server: "SyncServer" = Depends(get_letta_server),
-# ):
-# """
-# Execute a command on a specified agent.
-
-# This endpoint receives a command to be executed on an agent. It uses the user and agent identifiers to authenticate and route the command appropriately.
-
-# Raises an HTTPException for any processing errors.
-# """
-# actor = server.get_current_user()
-#
-# response = server.run_command(user_id=actor.id,
-# agent_id=agent_id,
-# command=command.command)
-
-# return AgentCommandResponse(response=response)
-
-# @router.get("/{agent_id}/config")
-# def get_agent_config(
-# agent_id: "UUID",
-#
-# server: "SyncServer" = Depends(get_letta_server),
-# ):
-# """
-# Retrieve the configuration for a specific agent.
-
-# This endpoint fetches the configuration details for a given agent, identified by the user and agent IDs.
-# """
-# actor = server.get_current_user()
-#
-# if not server.ms.get_agent(user_id=actor.id, agent_id=agent_id):
-## agent does not exist
-# raise HTTPException(status_code=404, detail=f"Agent agent_id={agent_id} not found.")
-
-# agent_state = server.get_agent_config(user_id=actor.id, agent_id=agent_id)
-## get sources
-# attached_sources = server.list_attached_sources(agent_id=agent_id)
-
-## configs
-# llm_config = LLMConfig(**vars(agent_state.llm_config))
-# embedding_config = EmbeddingConfig(**vars(agent_state.embedding_config))
-
-# return GetAgentResponse(
-# agent_state=AgentState(
-# id=agent_state.id,
-# name=agent_state.name,
-# user_id=agent_state.user_id,
-# llm_config=llm_config,
-# embedding_config=embedding_config,
-# state=agent_state.state,
-# created_at=int(agent_state.created_at.timestamp()),
-# tools=agent_state.tools,
-# system=agent_state.system,
-# metadata=agent_state._metadata,
-# ),
-# last_run_at=None,  # TODO
-# sources=attached_sources,
-# )
-
-# @router.patch("/{agent_id}/rename", response_model=GetAgentResponse)
-# def update_agent_name(
-# agent_id: "UUID",
-# agent_rename: AgentRenameRequest,
-#
-# server: "SyncServer" = Depends(get_letta_server),
-# ):
-# """
-# Updates the name of a specific agent.
-
-# This changes the name of the agent in the database but does NOT edit the agent's persona.
-# """
-# valid_name = agent_rename.agent_name
-# actor = server.get_current_user()
-#
-# agent_state = server.rename_agent(user_id=actor.id, agent_id=agent_id, new_agent_name=valid_name)
-## get sources
-# attached_sources = server.list_attached_sources(agent_id=agent_id)
-# llm_config = LLMConfig(**vars(agent_state.llm_config))
-# embedding_config = EmbeddingConfig(**vars(agent_state.embedding_config))
-
-# return GetAgentResponse(
-# agent_state=AgentState(
-# id=agent_state.id,
-# name=agent_state.name,
-# user_id=agent_state.user_id,
-# llm_config=llm_config,
-# embedding_config=embedding_config,
-# state=agent_state.state,
-# created_at=int(agent_state.created_at.timestamp()),
-# tools=agent_state.tools,
-# system=agent_state.system,
-# ),
-# last_run_at=None,  # TODO
-# sources=attached_sources,
-# )
-
-
-# @router.get("/{agent_id}/archival/all", response_model=GetAgentArchivalMemoryResponse)
-# def get_agent_archival_memory_all(
-# agent_id: "UUID",
-#
-# server: "SyncServer" = Depends(get_letta_server),
-# ):
-# """
-# Retrieve the memories in an agent's archival memory store (non-paginated, returns all entries at once).
-# """
-# actor = server.get_current_user()
-#
-# archival_memories = server.get_all_archival_memories(user_id=actor.id, agent_id=agent_id)
-# print("archival_memories:", archival_memories)
-# archival_memory_objects = [ArchivalMemoryObject(id=passage["id"], contents=passage["contents"]) for passage in archival_memories]
-# return GetAgentArchivalMemoryResponse(archival_memory=archival_memory_objects)

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

@@ -104,7 +104,7 @@ def update_tool(
     Update an existing tool
     """
     actor = server.get_user_or_default(user_id=user_id)
-    return server.tool_manager.update_tool_by_id(tool_id, actor.id, request)
+    return server.tool_manager.update_tool_by_id(tool_id=tool_id, tool_update=request, actor=actor)
 
 
 @router.post("/add-base-tools", response_model=List[Tool], operation_id="add_base_tools")

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

@@ -3,7 +3,7 @@ from typing import TYPE_CHECKING, List, Optional
 from fastapi import APIRouter, Body, Depends, HTTPException, Query
 
 from letta.schemas.api_key import APIKey, APIKeyCreate
-from letta.schemas.user import User, UserCreate
+from letta.schemas.user import User, UserCreate, UserUpdate
 from letta.server.rest_api.utils import get_letta_server
 
 # from letta.server.schemas.users import (
@@ -56,6 +56,18 @@ def create_user(
     return user
 
 
+@router.put("/", tags=["admin"], response_model=User, operation_id="update_user")
+def update_user(
+    user: UserUpdate = Body(...),
+    server: "SyncServer" = Depends(get_letta_server),
+):
+    """
+    Update a user in the database
+    """
+    user = server.user_manager.update_user(user)
+    return user
+
+
 @router.delete("/", tags=["admin"], response_model=User, operation_id="delete_user")
 def delete_user(
     user_id: str = Query(..., description="The user_id key to be deleted."),

letta/server/server.py

@@ -82,6 +82,7 @@ from letta.schemas.source import Source, SourceCreate, SourceUpdate
 from letta.schemas.tool import Tool, ToolCreate
 from letta.schemas.usage import LettaUsageStatistics
 from letta.schemas.user import User
+from letta.services.agents_tags_manager import AgentsTagsManager
 from letta.services.organization_manager import OrganizationManager
 from letta.services.tool_manager import ToolManager
 from letta.services.user_manager import UserManager
@@ -248,6 +249,7 @@ class SyncServer(Server):
         self.organization_manager = OrganizationManager()
         self.user_manager = UserManager()
         self.tool_manager = ToolManager()
+        self.agents_tags_manager = AgentsTagsManager()
 
         # Make default user and org
         if init_with_default_org_and_user:
@@ -370,11 +372,15 @@ class SyncServer(Server):
             logger.debug(f"Creating an agent object")
             tool_objs = []
             for name in agent_state.tools:
-                tool_obj = self.tool_manager.get_tool_by_name(tool_name=name, actor=actor)
-                if not tool_obj:
-                    logger.exception(f"Tool {name} does not exist for user {user_id}")
-                    raise ValueError(f"Tool {name} does not exist for user {user_id}")
-                tool_objs.append(tool_obj)
+                # TODO: This should be a hard failure, but for migration reasons, we patch it for now
+                try:
+                    tool_obj = self.tool_manager.get_tool_by_name(tool_name=name, actor=actor)
+                    tool_objs.append(tool_obj)
+                except NoResultFound:
+                    warnings.warn(f"Tried to retrieve a tool with name {name} from the agent_state, but does not exist in tool db.")
+
+            # set agent_state tools to only the names of the available tools
+            agent_state.tools = [t.name for t in tool_objs]
 
             # Make sure the memory is a memory object
             assert isinstance(agent_state.memory, Memory)
@@ -804,12 +810,17 @@ class SyncServer(Server):
             llm_config = request.llm_config
             embedding_config = request.embedding_config
 
-            # get tools + make sure they exist
+            # get tools + only add if they exist
             tool_objs = []
             if request.tools:
                 for tool_name in request.tools:
-                    tool_obj = self.tool_manager.get_tool_by_name(tool_name=tool_name, actor=actor)
-                    tool_objs.append(tool_obj)
+                    try:
+                        tool_obj = self.tool_manager.get_tool_by_name(tool_name=tool_name, actor=actor)
+                        tool_objs.append(tool_obj)
+                    except NoResultFound:
+                        warnings.warn(f"Attempted to add a nonexistent tool {tool_name} to agent {request.name}, skipping.")
+            # reset the request.tools to only valid tools
+            request.tools = [t.name for t in tool_objs]
 
             assert request.memory is not None
             memory_functions = get_memory_functions(request.memory)
@@ -894,6 +905,7 @@ class SyncServer(Server):
 
         assert isinstance(agent.agent_state.memory, Memory), f"Invalid memory type: {type(agent_state.memory)}"
         # return AgentState
+
         return agent.agent_state
 
     def update_agent(
@@ -935,17 +947,26 @@ class SyncServer(Server):
             # Replace tools and also re-link
 
             # (1) get tools + make sure they exist
-            tool_objs = []
-            for tool_name in request.tools:
-                tool_obj = self.tool_manager.get_tool_by_name(tool_name=tool_name, actor=actor)
-                assert tool_obj, f"Tool {tool_name} does not exist"
-                tool_objs.append(tool_obj)
+            # Current and target tools as sets of tool names
+            current_tools = set(letta_agent.agent_state.tools)
+            target_tools = set(request.tools)
 
-            # (2) replace the list of tool names ("ids") inside the agent state
-            letta_agent.agent_state.tools = request.tools
+            # Calculate tools to add and remove
+            tools_to_add = target_tools - current_tools
+            tools_to_remove = current_tools - target_tools
 
-            # (3) then attempt to link the tools modules
-            letta_agent.link_tools(tool_objs)
+            # Fetch tool objects for those to add and remove
+            tools_to_add = [self.tool_manager.get_tool_by_name(tool_name=tool, actor=actor) for tool in tools_to_add]
+            tools_to_remove = [self.tool_manager.get_tool_by_name(tool_name=tool, actor=actor) for tool in tools_to_remove]
+
+            # update agent tool list
+            for tool in tools_to_remove:
+                self.remove_tool_from_agent(agent_id=request.id, tool_id=tool.id, user_id=actor.id)
+            for tool in tools_to_add:
+                self.add_tool_to_agent(agent_id=request.id, tool_id=tool.id, user_id=actor.id)
+
+            # reload agent
+            letta_agent = self._get_or_load_agent(agent_id=request.id)
 
         # configs
         if request.llm_config:
@@ -959,6 +980,19 @@ class SyncServer(Server):
         if request.metadata_:
             letta_agent.agent_state.metadata_ = request.metadata_
 
+        # Manage tag state
+        if request.tags is not None:
+            current_tags = set(self.agents_tags_manager.get_tags_for_agent(agent_id=letta_agent.agent_state.id, actor=actor))
+            target_tags = set(request.tags)
+
+            tags_to_add = target_tags - current_tags
+            tags_to_remove = current_tags - target_tags
+
+            for tag in tags_to_add:
+                self.agents_tags_manager.add_tag_to_agent(agent_id=letta_agent.agent_state.id, tag=tag, actor=actor)
+            for tag in tags_to_remove:
+                self.agents_tags_manager.delete_tag_from_agent(agent_id=letta_agent.agent_state.id, tag=tag, actor=actor)
+
         # save the agent
         assert isinstance(letta_agent.memory, Memory)
         save_agent(letta_agent, self.ms)
@@ -1069,16 +1103,19 @@ class SyncServer(Server):
         }
         return agent_config
 
-    def list_agents(
-        self,
-        user_id: str,
-    ) -> List[AgentState]:
+    def list_agents(self, user_id: str, tags: Optional[List[str]] = None) -> List[AgentState]:
         """List all available agents to a user"""
-        if self.user_manager.get_user_by_id(user_id=user_id) is None:
-            raise ValueError(f"User user_id={user_id} does not exist")
+        user = self.user_manager.get_user_by_id(user_id=user_id)
 
-        agents_states = self.ms.list_agents(user_id=user_id)
-        return agents_states
+        if tags is None:
+            agents_states = self.ms.list_agents(user_id=user_id)
+            return agents_states
+        else:
+            agent_ids = []
+            for tag in tags:
+                agent_ids += self.agents_tags_manager.get_agents_by_tag(tag=tag, actor=user)
+
+            return [self.get_agent_state(user_id=user.id, agent_id=agent_id) for agent_id in agent_ids]
 
     def get_blocks(
         self,
@@ -1150,18 +1187,6 @@ class SyncServer(Server):
             raise ValueError("Source does not exist")
         return existing_source.id
 
-    def get_agent(self, user_id: str, agent_id: Optional[str] = None, agent_name: Optional[str] = None):
-        """Get the agent state"""
-        return self.ms.get_agent(agent_id=agent_id, agent_name=agent_name, user_id=user_id)
-
-    # def get_user(self, user_id: str) -> User:
-    #     """Get the user"""
-    #     user = self.user_manager.get_user_by_id(user_id=user_id)
-    #     if user is None:
-    #         raise ValueError(f"User with user_id {user_id} does not exist")
-    #     else:
-    #         return user
-
     def get_agent_memory(self, agent_id: str) -> Memory:
         """Return the memory of an agent (core memory)"""
         agent = self._get_or_load_agent(agent_id=agent_id)
@@ -1379,8 +1404,7 @@ class SyncServer(Server):
 
     def get_agent_state(self, user_id: str, agent_id: Optional[str], agent_name: Optional[str] = None) -> Optional[AgentState]:
         """Return the config of an agent"""
-        if self.user_manager.get_user_by_id(user_id=user_id) is None:
-            raise ValueError(f"User user_id={user_id} does not exist")
+        user = self.user_manager.get_user_by_id(user_id=user_id)
         if agent_id:
             if self.ms.get_agent(agent_id=agent_id, user_id=user_id) is None:
                 return None
@@ -1393,7 +1417,11 @@ class SyncServer(Server):
         # Get the agent object (loaded in memory)
         letta_agent = self._get_or_load_agent(agent_id=agent_id)
         assert isinstance(letta_agent.memory, Memory)
-        return letta_agent.agent_state.model_copy(deep=True)
+        agent_state = letta_agent.agent_state.model_copy(deep=True)
+
+        # Load the tags in for the agent_state
+        agent_state.tags = self.agents_tags_manager.get_tags_for_agent(agent_id=agent_id, actor=user)
+        return agent_state
 
     def get_server_config(self, include_defaults: bool = False) -> dict:
         """Return the base config"""
@@ -1475,8 +1503,11 @@ class SyncServer(Server):
 
     def delete_agent(self, user_id: str, agent_id: str):
         """Delete an agent in the database"""
-        if self.user_manager.get_user_by_id(user_id=user_id) is None:
-            raise ValueError(f"User user_id={user_id} does not exist")
+        actor = self.user_manager.get_user_by_id(user_id=user_id)
+        # TODO: REMOVE THIS ONCE WE MIGRATE AGENTMODEL TO ORM MODEL
+        # TODO: EVENTUALLY WE GET AUTO-DELETES WHEN WE SPECIFY RELATIONSHIPS IN THE ORM
+        self.agents_tags_manager.delete_all_tags_from_agent(agent_id=agent_id, actor=actor)
+
         if self.ms.get_agent(agent_id=agent_id, user_id=user_id) is None:
             raise ValueError(f"Agent agent_id={agent_id} does not exist")
 

letta/services/agents_tags_manager.py

@@ -0,0 +1,64 @@
+from typing import List
+
+from letta.orm.agents_tags import AgentsTags as AgentsTagsModel
+from letta.orm.errors import NoResultFound
+from letta.schemas.agents_tags import AgentsTags as PydanticAgentsTags
+from letta.schemas.user import User as PydanticUser
+from letta.utils import enforce_types
+
+
+class AgentsTagsManager:
+    """Manager class to handle business logic related to Tags."""
+
+    def __init__(self):
+        from letta.server.server import db_context
+
+        self.session_maker = db_context
+
+    @enforce_types
+    def add_tag_to_agent(self, agent_id: str, tag: str, actor: PydanticUser) -> PydanticAgentsTags:
+        """Add a tag to an agent."""
+        with self.session_maker() as session:
+            # Check if the tag already exists for this agent
+            try:
+                agents_tags_model = AgentsTagsModel.read(db_session=session, agent_id=agent_id, tag=tag, actor=actor)
+                return agents_tags_model.to_pydantic()
+            except NoResultFound:
+                agents_tags = PydanticAgentsTags(agent_id=agent_id, tag=tag).model_dump(exclude_none=True)
+                new_tag = AgentsTagsModel(**agents_tags, organization_id=actor.organization_id)
+                new_tag.create(session, actor=actor)
+                return new_tag.to_pydantic()
+
+    @enforce_types
+    def delete_all_tags_from_agent(self, agent_id: str, actor: PydanticUser):
+        """Delete a tag from an agent. This is a permanent hard delete."""
+        tags = self.get_tags_for_agent(agent_id=agent_id, actor=actor)
+        for tag in tags:
+            self.delete_tag_from_agent(agent_id=agent_id, tag=tag, actor=actor)
+
+    @enforce_types
+    def delete_tag_from_agent(self, agent_id: str, tag: str, actor: PydanticUser):
+        """Delete a tag from an agent."""
+        with self.session_maker() as session:
+            try:
+                # Retrieve and delete the tag association
+                tag_association = AgentsTagsModel.read(db_session=session, agent_id=agent_id, tag=tag, actor=actor)
+                tag_association.hard_delete(session, actor=actor)
+            except NoResultFound:
+                raise ValueError(f"Tag '{tag}' not found for agent '{agent_id}'.")
+
+    @enforce_types
+    def get_agents_by_tag(self, tag: str, actor: PydanticUser) -> List[str]:
+        """Retrieve all agent IDs associated with a specific tag."""
+        with self.session_maker() as session:
+            # Query for all agents with the given tag
+            agents_with_tag = AgentsTagsModel.list(db_session=session, tag=tag, organization_id=actor.organization_id)
+            return [record.agent_id for record in agents_with_tag]
+
+    @enforce_types
+    def get_tags_for_agent(self, agent_id: str, actor: PydanticUser) -> List[str]:
+        """Retrieve all tags associated with a specific agent."""
+        with self.session_maker() as session:
+            # Query for all tags associated with the given agent
+            tags_for_agent = AgentsTagsModel.list(db_session=session, agent_id=agent_id, organization_id=actor.organization_id)
+            return [record.tag for record in tags_for_agent]

letta/services/tool_manager.py

@@ -35,9 +35,7 @@ class ToolManager:
     def create_or_update_tool(self, pydantic_tool: PydanticTool, actor: PydanticUser) -> PydanticTool:
         """Create a new tool based on the ToolCreate schema."""
         # Derive json_schema
-        derived_json_schema = pydantic_tool.json_schema or derive_openai_json_schema(
-            source_code=pydantic_tool.source_code, name=pydantic_tool.name
-        )
+        derived_json_schema = pydantic_tool.json_schema or derive_openai_json_schema(source_code=pydantic_tool.source_code)
         derived_name = pydantic_tool.name or derived_json_schema["name"]
 
         try:
@@ -105,7 +103,7 @@ class ToolManager:
             return [tool.to_pydantic() for tool in tools]
 
     @enforce_types
-    def update_tool_by_id(self, tool_id: str, tool_update: ToolUpdate, actor: PydanticUser) -> None:
+    def update_tool_by_id(self, tool_id: str, tool_update: ToolUpdate, actor: PydanticUser) -> PydanticTool:
         """Update a tool by its ID with the given ToolUpdate object."""
         with self.session_maker() as session:
             # Fetch the tool by ID
@@ -116,31 +114,24 @@ class ToolManager:
             for key, value in update_data.items():
                 setattr(tool, key, value)
 
-            # If source code is changed and a new json_schema is not provided, we want to auto-refresh the name and schema
-            # CAUTION: This will override any name/schema values the user passed in
+            # If source code is changed and a new json_schema is not provided, we want to auto-refresh the schema
             if "source_code" in update_data.keys() and "json_schema" not in update_data.keys():
                 pydantic_tool = tool.to_pydantic()
 
-                # Decide whether or not to reset name
-                # If name was not explicitly passed in as part of the update, then we auto-generate a new name based on source code
-                name = None
-                if "name" in update_data.keys():
-                    name = update_data["name"]
-                new_schema = derive_openai_json_schema(source_code=pydantic_tool.source_code, name=name)
+                update_data["name"] if "name" in update_data.keys() else None
+                new_schema = derive_openai_json_schema(source_code=pydantic_tool.source_code)
 
-                # The name will either be set (if explicit) or autogenerated from the source code
-                tool.name = new_schema["name"]
                 tool.json_schema = new_schema
 
             # Save the updated tool to the database
-            tool.update(db_session=session, actor=actor)
+            return tool.update(db_session=session, actor=actor)
 
     @enforce_types
     def delete_tool_by_id(self, tool_id: str, actor: PydanticUser) -> None:
         """Delete a tool by its ID."""
         with self.session_maker() as session:
             try:
-                tool = ToolModel.read(db_session=session, identifier=tool_id)
+                tool = ToolModel.read(db_session=session, identifier=tool_id, actor=actor)
                 tool.delete(db_session=session, actor=actor)
             except NoResultFound:
                 raise ValueError(f"Tool with id {tool_id} not found.")

{letta_nightly-0.5.1.dev20241106104104.dist-info → letta_nightly-0.5.2.dev20241107104040.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: letta-nightly
-Version: 0.5.1.dev20241106104104
+Version: 0.5.2.dev20241107104040
 Summary: Create LLM agents with long-term memory and custom tools
 License: Apache License
 Author: Letta Team
@@ -103,10 +103,13 @@ Description-Content-Type: text/markdown
 [![Discord](https://img.shields.io/discord/1161736243340640419?label=Discord&logo=discord&logoColor=5865F2&style=flat-square&color=5865F2)](https://discord.gg/letta)
 [![Twitter Follow](https://img.shields.io/badge/Follow-%40Letta__AI-1DA1F2?style=flat-square&logo=x&logoColor=white)](https://twitter.com/Letta_AI)
 [![arxiv 2310.08560](https://img.shields.io/badge/Research-2310.08560-B31B1B?logo=arxiv&style=flat-square)](https://arxiv.org/abs/2310.08560)
+
 [![Apache 2.0](https://img.shields.io/badge/License-Apache%202.0-silver?style=flat-square)](LICENSE)
 [![Release](https://img.shields.io/github/v/release/cpacker/MemGPT?style=flat-square&label=Release&color=limegreen)](https://github.com/cpacker/MemGPT/releases)
 [![GitHub](https://img.shields.io/github/stars/cpacker/MemGPT?style=flat-square&logo=github&label=Stars&color=gold)](https://github.com/cpacker/MemGPT)
 
+<a href="https://trendshift.io/repositories/3612" target="_blank"><img src="https://trendshift.io/api/badge/repositories/3612" alt="cpacker%2FMemGPT | Trendshift" style="width: 250px; height: 55px;" width="250" height="55"/></a>
+
 </div>
 
 > [!NOTE]