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

letta/schemas/agent.py

@@ -64,6 +64,9 @@ class AgentState(BaseAgent, validate_assignment=True):
     # tool rules
     tool_rules: Optional[List[BaseToolRule]] = Field(default=None, description="The list of tool rules.")
 
+    # tags
+    tags: Optional[List[str]] = Field(None, description="The tags associated with the agent.")
+
     # system prompt
     system: str = Field(..., description="The system prompt used by the agent.")
 
@@ -108,6 +111,7 @@ class CreateAgent(BaseAgent):
     memory: Optional[Memory] = Field(None, description="The in-context memory of the agent.")
     tools: Optional[List[str]] = Field(None, description="The tools used by the agent.")
     tool_rules: Optional[List[BaseToolRule]] = Field(None, description="The tool rules governing the agent.")
+    tags: Optional[List[str]] = Field(None, description="The tags associated with the agent.")
     system: Optional[str] = Field(None, description="The system prompt used by the agent.")
     agent_type: Optional[AgentType] = Field(None, description="The type of agent.")
     llm_config: Optional[LLMConfig] = Field(None, description="The LLM configuration used by the agent.")
@@ -148,6 +152,7 @@ class UpdateAgentState(BaseAgent):
     id: str = Field(..., description="The id of the agent.")
     name: Optional[str] = Field(None, description="The name of the agent.")
     tools: Optional[List[str]] = Field(None, description="The tools used by the agent.")
+    tags: Optional[List[str]] = Field(None, description="The tags associated with the agent.")
     system: Optional[str] = Field(None, description="The system prompt used by the agent.")
     llm_config: Optional[LLMConfig] = Field(None, description="The LLM configuration used by the agent.")
     embedding_config: Optional[EmbeddingConfig] = Field(None, description="The embedding configuration used by the agent.")

letta/schemas/agents_tags.py

@@ -0,0 +1,33 @@
+from datetime import datetime
+from typing import Optional
+
+from pydantic import Field
+
+from letta.schemas.letta_base import LettaBase
+
+
+class AgentsTagsBase(LettaBase):
+    __id_prefix__ = "agents_tags"
+
+
+class AgentsTags(AgentsTagsBase):
+    """
+    Schema representing the relationship between tags and agents.
+
+    Parameters:
+        agent_id (str): The ID of the associated agent.
+        tag_id (str): The ID of the associated tag.
+        tag_name (str): The name of the tag.
+        created_at (datetime): The date this relationship was created.
+    """
+
+    id: str = AgentsTagsBase.generate_id_field()
+    agent_id: str = Field(..., description="The ID of the associated agent.")
+    tag: str = Field(..., description="The name of the tag.")
+    created_at: Optional[datetime] = Field(None, description="The creation date of the association.")
+    updated_at: Optional[datetime] = Field(None, description="The update date of the tag.")
+    is_deleted: bool = Field(False, description="Whether this tag is deleted or not.")
+
+
+class AgentsTagsCreate(AgentsTagsBase):
+    tag: str = Field(..., description="The tag name.")

letta/schemas/block.py

@@ -18,7 +18,7 @@ class BaseBlock(LettaBase, validate_assignment=True):
     limit: int = Field(2000, description="Character limit of the block.")
 
     # template data (optional)
-    template_name: Optional[str] = Field(None, description="Name of the block if it is a template.")
+    template_name: Optional[str] = Field(None, description="Name of the block if it is a template.", alias="name")
     template: bool = Field(False, description="Whether the block is a template (e.g. saved human/persona options).")
 
     # context window label
@@ -58,11 +58,11 @@ class Block(BaseBlock):
     A Block represents a reserved section of the LLM's context window which is editable. `Block` objects contained in the `Memory` object, which is able to edit the Block values.
 
     Parameters:
-        name (str): The name of the block.
+        label (str): The label of the block (e.g. 'human', 'persona'). This defines a category for the block.
         value (str): The value of the block. This is the string that is represented in the context window.
         limit (int): The character limit of the block.
+        template_name (str): The name of the block template (if it is a template).
         template (bool): Whether the block is a template (e.g. saved human/persona options). Non-template blocks are not stored in the database and are ephemeral, while templated blocks are stored in the database.
-        label (str): The label of the block (e.g. 'human', 'persona'). This defines a category for the block.
         description (str): Description of the block.
         metadata_ (Dict): Metadata of the block.
         user_id (str): The unique identifier of the user associated with the block.

letta/schemas/letta_response.py

@@ -1,3 +1,6 @@
+import html
+import json
+import re
 from typing import List, Union
 
 from pydantic import BaseModel, Field
@@ -34,6 +37,113 @@ class LettaResponse(BaseModel):
             indent=4,
         )
 
+    def _repr_html_(self):
+        def get_formatted_content(msg):
+            if msg.message_type == "internal_monologue":
+                return f'<div class="content"><span class="internal-monologue">{html.escape(msg.internal_monologue)}</span></div>'
+            elif msg.message_type == "function_call":
+                args = format_json(msg.function_call.arguments)
+                return f'<div class="content"><span class="function-name">{html.escape(msg.function_call.name)}</span>({args})</div>'
+            elif msg.message_type == "function_return":
+
+                return_value = format_json(msg.function_return)
+                # return f'<div class="status-line">Status: {html.escape(msg.status)}</div><div class="content">{return_value}</div>'
+                return f'<div class="content">{return_value}</div>'
+            elif msg.message_type == "user_message":
+                if is_json(msg.message):
+                    return f'<div class="content">{format_json(msg.message)}</div>'
+                else:
+                    return f'<div class="content">{html.escape(msg.message)}</div>'
+            elif msg.message_type in ["assistant_message", "system_message"]:
+                return f'<div class="content">{html.escape(msg.message)}</div>'
+            else:
+                return f'<div class="content">{html.escape(str(msg))}</div>'
+
+        def is_json(string):
+            try:
+                json.loads(string)
+                return True
+            except ValueError:
+                return False
+
+        def format_json(json_str):
+            try:
+                parsed = json.loads(json_str)
+                formatted = json.dumps(parsed, indent=2, ensure_ascii=False)
+                formatted = formatted.replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;")
+                formatted = formatted.replace("\n", "<br>").replace("  ", "&nbsp;&nbsp;")
+                formatted = re.sub(r'(".*?"):', r'<span class="json-key">\1</span>:', formatted)
+                formatted = re.sub(r': (".*?")', r': <span class="json-string">\1</span>', formatted)
+                formatted = re.sub(r": (\d+)", r': <span class="json-number">\1</span>', formatted)
+                formatted = re.sub(r": (true|false)", r': <span class="json-boolean">\1</span>', formatted)
+                return formatted
+            except json.JSONDecodeError:
+                return html.escape(json_str)
+
+        html_output = """
+        <style>
+            .message-container, .usage-container {
+                font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+                max-width: 800px;
+                margin: 20px auto;
+                background-color: #1e1e1e;
+                border-radius: 8px;
+                overflow: hidden;
+                color: #d4d4d4;
+            }
+            .message, .usage-stats {
+                padding: 10px 15px;
+                border-bottom: 1px solid #3a3a3a;
+            }
+            .message:last-child, .usage-stats:last-child {
+                border-bottom: none;
+            }
+            .title {
+                font-weight: bold;
+                margin-bottom: 5px;
+                color: #ffffff;
+                text-transform: uppercase;
+                font-size: 0.9em;
+            }
+            .content {
+                background-color: #2d2d2d;
+                border-radius: 4px;
+                padding: 5px 10px;
+                font-family: 'Consolas', 'Courier New', monospace;
+                white-space: pre-wrap;
+            }
+            .json-key, .function-name, .json-boolean { color: #9cdcfe; }
+            .json-string { color: #ce9178; }
+            .json-number { color: #b5cea8; }
+            .internal-monologue { font-style: italic; }
+        </style>
+        <div class="message-container">
+        """
+
+        for msg in self.messages:
+            content = get_formatted_content(msg)
+            title = msg.message_type.replace("_", " ").upper()
+            html_output += f"""
+            <div class="message">
+                <div class="title">{title}</div>
+                {content}
+            </div>
+            """
+        html_output += "</div>"
+
+        # Formatting the usage statistics
+        usage_html = json.dumps(self.usage.model_dump(), indent=2)
+        html_output += f"""
+        <div class="usage-container">
+            <div class="usage-stats">
+                <div class="title">USAGE STATISTICS</div>
+                <div class="content">{format_json(usage_html)}</div>
+            </div>
+        </div>
+        """
+
+        return html_output
+
 
 # The streaming response is either [DONE], [DONE_STEP], [DONE], an error, or a LettaMessage
 LettaStreamingResponse = Union[LettaMessage, MessageStreamStatus, LettaUsageStatistics]

letta/schemas/llm_config.py

@@ -13,7 +13,7 @@ class LLMConfig(BaseModel):
         model_endpoint (str): The endpoint for the model.
         model_wrapper (str): The wrapper for the model. This is used to wrap additional text around the input/output of the model. This is useful for text-to-text completions, such as the Completions API in OpenAI.
         context_window (int): The context window size for the model.
-        put_inner_thoughts_in_kwargs (bool): Puts 'inner_thoughts' as a kwarg in the function call if this is set to True. This helps with function calling performance and also the generation of inner thoughts.
+        put_inner_thoughts_in_kwargs (bool): Puts `inner_thoughts` as a kwarg in the function call if this is set to True. This helps with function calling performance and also the generation of inner thoughts.
     """
 
     # TODO: 🤮 don't default to a vendor! bug city!
@@ -67,6 +67,12 @@ class LLMConfig(BaseModel):
 
     @classmethod
     def default_config(cls, model_name: str):
+        """
+        Convinience function to generate a default `LLMConfig` from a model name. Only some models are supported in this function.
+
+        Args:
+            model_name (str): The name of the model (gpt-4, gpt-4o-mini, letta).
+        """
         if model_name == "gpt-4":
             return cls(
                 model="gpt-4",

letta/schemas/memory.py

@@ -106,6 +106,10 @@ class Memory(BaseModel, validate_assignment=True):
             # New format
             obj.prompt_template = state["prompt_template"]
             for key, value in state["memory"].items():
+                # TODO: This is migration code, please take a look at a later time to get rid of this
+                if "name" in value:
+                    value["template_name"] = value["name"]
+                    value.pop("name")
                 obj.memory[key] = Block(**value)
         else:
             # Old format (pre-template)

letta/schemas/organization.py

@@ -4,16 +4,16 @@ from typing import Optional
 from pydantic import Field
 
 from letta.schemas.letta_base import LettaBase
-from letta.utils import get_utc_time
+from letta.utils import create_random_username, get_utc_time
 
 
 class OrganizationBase(LettaBase):
-    __id_prefix__ = "organization"
+    __id_prefix__ = "org"
 
 
 class Organization(OrganizationBase):
-    id: str = Field(..., description="The id of the organization.")
-    name: str = Field(..., description="The name of the organization.")
+    id: str = OrganizationBase.generate_id_field()
+    name: str = Field(create_random_username(), description="The name of the organization.")
     created_at: Optional[datetime] = Field(default_factory=get_utc_time, description="The creation date of the organization.")
 
 

letta/schemas/tool.py

@@ -1,6 +1,5 @@
 from typing import Dict, List, Optional
 
-from composio import LogLevel
 from pydantic import Field
 
 from letta.functions.helpers import (
@@ -33,21 +32,21 @@ class Tool(BaseTool):
 
     """
 
-    id: str = Field(..., description="The id of the tool.")
+    id: str = BaseTool.generate_id_field()
     description: Optional[str] = Field(None, description="The description of the tool.")
     source_type: Optional[str] = Field(None, description="The type of the source code.")
     module: Optional[str] = Field(None, description="The module of the function.")
-    organization_id: str = Field(..., description="The unique identifier of the organization associated with the tool.")
-    name: str = Field(..., description="The name of the function.")
-    tags: List[str] = Field(..., description="Metadata tags.")
+    organization_id: Optional[str] = Field(None, description="The unique identifier of the organization associated with the tool.")
+    name: Optional[str] = Field(None, description="The name of the function.")
+    tags: List[str] = Field([], description="Metadata tags.")
 
     # code
     source_code: str = Field(..., description="The source code of the function.")
-    json_schema: Dict = Field(default_factory=dict, description="The JSON schema of the function.")
+    json_schema: Optional[Dict] = Field(None, description="The JSON schema of the function.")
 
     # metadata fields
-    created_by_id: str = Field(..., description="The id of the user that made this Tool.")
-    last_updated_by_id: str = Field(..., description="The id of the user that made this Tool.")
+    created_by_id: Optional[str] = Field(None, description="The id of the user that made this Tool.")
+    last_updated_by_id: Optional[str] = Field(None, description="The id of the user that made this Tool.")
 
     def to_dict(self):
         """
@@ -68,7 +67,7 @@ class ToolCreate(LettaBase):
     tags: List[str] = Field([], description="Metadata tags.")
     module: Optional[str] = Field(None, description="The source code of the function.")
     source_code: str = Field(..., description="The source code of the function.")
-    source_type: str = Field(..., description="The source type of the function.")
+    source_type: str = Field("python", description="The source type of the function.")
     json_schema: Optional[Dict] = Field(
         None, description="The JSON schema of the function (auto-generated from source_code if not provided)"
     )
@@ -86,6 +85,7 @@ class ToolCreate(LettaBase):
         Returns:
             Tool: A Letta Tool initialized with attributes derived from the Composio tool.
         """
+        from composio import LogLevel
         from composio_langchain import ComposioToolSet
 
         composio_toolset = ComposioToolSet(logging_level=LogLevel.ERROR)
@@ -216,3 +216,7 @@ class ToolUpdate(LettaBase):
     json_schema: Optional[Dict] = Field(
         None, description="The JSON schema of the function (auto-generated from source_code if not provided)"
     )
+
+    class Config:
+        extra = "ignore"  # Allows extra fields without validation errors
+        # TODO: Remove this, and clean usage of ToolUpdate everywhere else

letta/schemas/tool_rule.py

@@ -11,15 +11,25 @@ class BaseToolRule(LettaBase):
 
 
 class ToolRule(BaseToolRule):
+    """
+    A ToolRule represents a tool that can be invoked by the agent.
+    """
+
     type: str = Field("ToolRule")
     children: List[str] = Field(..., description="The children tools that can be invoked.")
 
 
 class InitToolRule(BaseToolRule):
+    """
+    Represents the initial tool rule configuration.
+    """
+
     type: str = Field("InitToolRule")
-    """Represents the initial tool rule configuration."""
 
 
 class TerminalToolRule(BaseToolRule):
+    """
+    Represents a terminal tool rule configuration where if this tool gets called, it must end the agent loop.
+    """
+
     type: str = Field("TerminalToolRule")
-    """Represents a terminal tool rule configuration where if this tool gets called, it must end the agent loop."""

letta/schemas/user.py

@@ -21,7 +21,7 @@ class User(UserBase):
         created_at (datetime): The creation date of the user.
     """
 
-    id: str = Field(..., description="The id of the user.")
+    id: str = UserBase.generate_id_field()
     organization_id: Optional[str] = Field(OrganizationManager.DEFAULT_ORG_ID, description="The organization id of the user")
     name: str = Field(..., description="The name of the user.")
     created_at: Optional[datetime] = Field(default_factory=datetime.utcnow, description="The creation date of the user.")

letta/server/rest_api/app.py

@@ -8,6 +8,7 @@ import uvicorn
 from fastapi import FastAPI
 from starlette.middleware.cors import CORSMiddleware
 
+from letta.__init__ import __version__
 from letta.constants import ADMIN_PREFIX, API_PREFIX, OPENAI_API_PREFIX
 from letta.schemas.letta_response import LettaResponse
 from letta.server.constants import REST_DEFAULT_PORT
@@ -66,6 +67,7 @@ def create_application() -> "FastAPI":
     """the application start routine"""
     # global server
     # server = SyncServer(default_interface_factory=lambda: interface())
+    print(f"\n[[ Letta server // v{__version__} ]]")
 
     app = FastAPI(
         swagger_ui_parameters={"docExpansion": "none"},
@@ -78,6 +80,7 @@ def create_application() -> "FastAPI":
 
     if "--ade" in sys.argv:
         settings.cors_origins.append("https://app.letta.com")
+        print(f"▶ View using ADE at: https://app.letta.com/local-project/agents")
 
     app.add_middleware(
         CORSMiddleware,
@@ -179,7 +182,7 @@ def start_server(
         # Add the handler to the logger
         server_logger.addHandler(stream_handler)
 
-    print(f"Running: uvicorn server:app --host {host or 'localhost'} --port {port or REST_DEFAULT_PORT}")
+    print(f"▶ Server running at: http://{host or 'localhost'}:{port or REST_DEFAULT_PORT}\n")
     uvicorn.run(
         app,
         host=host or "localhost",

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

@@ -40,6 +40,8 @@ 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
 ):
@@ -49,7 +51,11 @@ def list_agents(
     """
     actor = server.get_user_or_default(user_id=user_id)
 
-    return 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]
+    return agents
 
 
 @router.get("/{agent_id}/context", response_model=ContextWindowOverview, operation_id="get_agent_context_window")
@@ -529,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/organizations.py

@@ -38,7 +38,8 @@ def create_org(
     """
     Create a new org in the database
     """
-    org = server.organization_manager.create_organization(name=request.name)
+    org = Organization(**request.model_dump())
+    org = server.organization_manager.create_organization(pydantic_org=org)
     return org
 
 

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

@@ -89,7 +89,8 @@ def create_tool(
     actor = server.get_user_or_default(user_id=user_id)
 
     # Send request to create the tool
-    return server.tool_manager.create_or_update_tool(tool_create=request, actor=actor)
+    tool = Tool(**request.model_dump())
+    return server.tool_manager.create_or_update_tool(pydantic_tool=tool, actor=actor)
 
 
 @router.patch("/{tool_id}", response_model=Tool, operation_id="update_tool")
@@ -103,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 (
@@ -51,8 +51,20 @@ def create_user(
     """
     Create a new user in the database
     """
+    user = User(**request.model_dump())
+    user = server.user_manager.create_user(user)
+    return user
+
 
-    user = server.user_manager.create_user(request)
+@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