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

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)
@@ -824,7 +835,7 @@ class SyncServer(Server):
                 source_type = "python"
                 tags = ["memory", "memgpt-base"]
                 tool = self.tool_manager.create_or_update_tool(
-                    ToolCreate(
+                    Tool(
                         source_code=source_code,
                         source_type=source_type,
                         tags=tags,
@@ -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")
 
@@ -1766,7 +1797,7 @@ class SyncServer(Server):
             tool_creates += ToolCreate.load_default_composio_tools()
         for tool_create in tool_creates:
             try:
-                self.tool_manager.create_or_update_tool(tool_create, actor=actor)
+                self.tool_manager.create_or_update_tool(Tool(**tool_create.model_dump()), actor=actor)
             except Exception as e:
                 warnings.warn(f"An error occurred while creating tool {tool_create}: {e}")
                 warnings.warn(traceback.format_exc())

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/organization_manager.py

@@ -3,13 +3,13 @@ from typing import List, Optional
 from letta.orm.errors import NoResultFound
 from letta.orm.organization import Organization as OrganizationModel
 from letta.schemas.organization import Organization as PydanticOrganization
-from letta.utils import create_random_username, enforce_types
+from letta.utils import enforce_types
 
 
 class OrganizationManager:
     """Manager class to handle business logic related to Organizations."""
 
-    DEFAULT_ORG_ID = "organization-00000000-0000-4000-8000-000000000000"
+    DEFAULT_ORG_ID = "org-00000000-0000-4000-8000-000000000000"
     DEFAULT_ORG_NAME = "default_org"
 
     def __init__(self):
@@ -37,10 +37,10 @@ class OrganizationManager:
                 raise ValueError(f"Organization with id {org_id} not found.")
 
     @enforce_types
-    def create_organization(self, name: Optional[str] = None) -> PydanticOrganization:
+    def create_organization(self, pydantic_org: PydanticOrganization) -> PydanticOrganization:
         """Create a new organization. If a name is provided, it is used, otherwise, a random one is generated."""
         with self.session_maker() as session:
-            org = OrganizationModel(name=name if name else create_random_username())
+            org = OrganizationModel(**pydantic_org.model_dump())
             org.create(session)
             return org.to_pydantic()
 

letta/services/tool_manager.py

@@ -7,10 +7,9 @@ from letta.functions.functions import derive_openai_json_schema, load_function_s
 
 # TODO: Remove this once we translate all of these to the ORM
 from letta.orm.errors import NoResultFound
-from letta.orm.organization import Organization as OrganizationModel
 from letta.orm.tool import Tool as ToolModel
 from letta.schemas.tool import Tool as PydanticTool
-from letta.schemas.tool import ToolCreate, ToolUpdate
+from letta.schemas.tool import ToolUpdate
 from letta.schemas.user import User as PydanticUser
 from letta.utils import enforce_types, printd
 
@@ -33,20 +32,18 @@ class ToolManager:
         self.session_maker = db_context
 
     @enforce_types
-    def create_or_update_tool(self, tool_create: ToolCreate, actor: PydanticUser) -> PydanticTool:
+    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 = tool_create.json_schema or derive_openai_json_schema(
-            source_code=tool_create.source_code, name=tool_create.name
-        )
-        derived_name = tool_create.name or derived_json_schema["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:
             # NOTE: We use the organization id here
             # This is important, because even if it's a different user, adding the same tool to the org should not happen
             tool = self.get_tool_by_name(tool_name=derived_name, actor=actor)
             # Put to dict and remove fields that should not be reset
-            update_data = tool_create.model_dump(exclude={"module"}, exclude_unset=True)
+            update_data = pydantic_tool.model_dump(exclude={"module"}, exclude_unset=True, exclude_none=True)
             # Remove redundant update fields
             update_data = {key: value for key, value in update_data.items() if getattr(tool, key) != value}
 
@@ -55,22 +52,24 @@ class ToolManager:
                 self.update_tool_by_id(tool.id, ToolUpdate(**update_data), actor)
             else:
                 printd(
-                    f"`create_or_update_tool` was called with user_id={actor.id}, organization_id={actor.organization_id}, name={tool_create.name}, but found existing tool with nothing to update."
+                    f"`create_or_update_tool` was called with user_id={actor.id}, organization_id={actor.organization_id}, name={pydantic_tool.name}, but found existing tool with nothing to update."
                 )
         except NoResultFound:
-            tool_create.json_schema = derived_json_schema
-            tool_create.name = derived_name
-            tool = self.create_tool(tool_create, actor=actor)
+            pydantic_tool.json_schema = derived_json_schema
+            pydantic_tool.name = derived_name
+            tool = self.create_tool(pydantic_tool, actor=actor)
 
         return tool
 
     @enforce_types
-    def create_tool(self, tool_create: ToolCreate, actor: PydanticUser) -> PydanticTool:
+    def create_tool(self, pydantic_tool: PydanticTool, actor: PydanticUser) -> PydanticTool:
         """Create a new tool based on the ToolCreate schema."""
         # Create the tool
         with self.session_maker() as session:
-            create_data = tool_create.model_dump()
-            tool = ToolModel(**create_data, organization_id=actor.organization_id)  # Unpack everything directly into ToolModel
+            # Set the organization id at the ORM layer
+            pydantic_tool.organization_id = actor.organization_id
+            tool_data = pydantic_tool.model_dump()
+            tool = ToolModel(**tool_data)
             tool.create(session, actor=actor)
 
         return tool.to_pydantic()
@@ -99,12 +98,12 @@ class ToolManager:
                 db_session=session,
                 cursor=cursor,
                 limit=limit,
-                _organization_id=OrganizationModel.get_uid_from_identifier(actor.organization_id),
+                organization_id=actor.organization_id,
             )
             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
@@ -115,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.")
@@ -176,7 +168,7 @@ class ToolManager:
                 # create to tool
                 tools.append(
                     self.create_or_update_tool(
-                        ToolCreate(
+                        PydanticTool(
                             name=name,
                             tags=tags,
                             source_type="python",

letta/services/user_manager.py

@@ -4,7 +4,7 @@ from letta.orm.errors import NoResultFound
 from letta.orm.organization import Organization as OrganizationModel
 from letta.orm.user import User as UserModel
 from letta.schemas.user import User as PydanticUser
-from letta.schemas.user import UserCreate, UserUpdate
+from letta.schemas.user import UserUpdate
 from letta.services.organization_manager import OrganizationManager
 from letta.utils import enforce_types
 
@@ -42,10 +42,10 @@ class UserManager:
             return user.to_pydantic()
 
     @enforce_types
-    def create_user(self, user_create: UserCreate) -> PydanticUser:
+    def create_user(self, pydantic_user: PydanticUser) -> PydanticUser:
         """Create a new user if it doesn't already exist."""
         with self.session_maker() as session:
-            new_user = UserModel(**user_create.model_dump())
+            new_user = UserModel(**pydantic_user.model_dump())
             new_user.create(session)
             return new_user.to_pydantic()
 

{letta_nightly-0.5.1.dev20241105104128.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.dev20241105104128
+Version: 0.5.2.dev20241107104040
 Summary: Create LLM agents with long-term memory and custom tools
 License: Apache License
 Author: Letta Team
@@ -99,14 +99,17 @@ Description-Content-Type: text/markdown
 </h3>
 
 **👾 Letta** is an open source framework for building stateful LLM applications. You can use Letta to build **stateful agents** with advanced reasoning capabilities and transparent long-term memory. The Letta framework is white box and model-agnostic.
-  
+
 [![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]