letta-nightly 0.5.0.dev20241017104103__py3-none-any.whl → 0.5.0.dev20241019104023__py3-none-any.whl

letta/metadata.py

@@ -14,7 +14,9 @@ from sqlalchemy import (
     Integer,
     String,
     TypeDecorator,
+    asc,
     desc,
+    or_,
 )
 from sqlalchemy.sql import func
 
@@ -270,7 +272,7 @@ class AgentModel(Base):
         return f"<Agent(id='{self.id}', name='{self.name}')>"
 
     def to_record(self) -> AgentState:
-        return AgentState(
+        agent_state = AgentState(
             id=self.id,
             user_id=self.user_id,
             name=self.name,
@@ -285,6 +287,8 @@ class AgentModel(Base):
             embedding_config=self.embedding_config,
             metadata_=self.metadata_,
         )
+        assert isinstance(agent_state.memory, Memory), f"Memory object is not of type Memory: {type(agent_state.memory)}"
+        return agent_state
 
 
 class SourceModel(Base):
@@ -527,6 +531,7 @@ class MetadataStore:
                 raise ValueError(f"Agent with name {agent.name} already exists")
             fields = vars(agent)
             fields["memory"] = agent.memory.to_dict()
+            del fields["_internal_memory"]
             session.add(AgentModel(**fields))
             session.commit()
 
@@ -588,6 +593,7 @@ class MetadataStore:
             fields = vars(agent)
             if isinstance(agent.memory, Memory):  # TODO: this is nasty but this whole class will soon be removed so whatever
                 fields["memory"] = agent.memory.to_dict()
+            del fields["_internal_memory"]
             session.query(AgentModel).filter(AgentModel.id == agent.id).update(fields)
             session.commit()
 
@@ -703,12 +709,19 @@ class MetadataStore:
             session.commit()
 
     @enforce_types
-    # def list_tools(self, user_id: str) -> List[ToolModel]: # TODO: add when users can creat tools
-    def list_tools(self, user_id: Optional[str] = None) -> List[ToolModel]:
+    def list_tools(self, cursor: Optional[str] = None, limit: Optional[int] = 50, user_id: Optional[str] = None) -> List[ToolModel]:
         with self.session_maker() as session:
-            results = session.query(ToolModel).filter(ToolModel.user_id == None).all()
-            if user_id:
-                results += session.query(ToolModel).filter(ToolModel.user_id == user_id).all()
+            # Query for public tools or user-specific tools
+            query = session.query(ToolModel).filter(or_(ToolModel.user_id == None, ToolModel.user_id == user_id))
+
+            # Apply cursor if provided (assuming cursor is an ID)
+            if cursor:
+                query = query.filter(ToolModel.id > cursor)
+
+            # Order by ID and apply limit
+            results = query.order_by(asc(ToolModel.id)).limit(limit).all()
+
+            # Convert to records
             res = [r.to_record() for r in results]
             return res
 

letta/o1_agent.py

@@ -0,0 +1,87 @@
+from typing import List, Optional, Union
+
+from letta.agent import Agent, save_agent
+from letta.interface import AgentInterface
+from letta.metadata import MetadataStore
+from letta.schemas.agent import AgentState
+from letta.schemas.message import Message
+from letta.schemas.openai.chat_completion_response import UsageStatistics
+from letta.schemas.tool import Tool
+from letta.schemas.usage import LettaUsageStatistics
+
+
+def send_thinking_message(self: Agent, message: str) -> Optional[str]:
+    """
+    Sends a thinking message so that the model can reason out loud before responding.
+
+    Args:
+        message (str): Message contents. All unicode (including emojis) are supported.
+
+    Returns:
+        Optional[str]: None is always returned as this function does not produce a response.
+    """
+    self.interface.internal_monologue(message, msg_obj=self._messages[-1])
+    return None
+
+
+def send_final_message(self: Agent, message: str) -> Optional[str]:
+    """
+    Sends a final message to the human user after thinking for a while.
+
+    Args:
+        message (str): Message contents. All unicode (including emojis) are supported.
+
+    Returns:
+        Optional[str]: None is always returned as this function does not produce a response.
+    """
+    self.interface.internal_monologue(message, msg_obj=self._messages[-1])
+    return None
+
+
+class O1Agent(Agent):
+    def __init__(
+        self,
+        interface: AgentInterface,
+        agent_state: AgentState,
+        tools: List[Tool] = [],
+        max_thinking_steps: int = 10,
+        first_message_verify_mono: bool = False,
+    ):
+        super().__init__(interface, agent_state, tools)
+        self.max_thinking_steps = max_thinking_steps
+        self.tools = tools
+        self.first_message_verify_mono = first_message_verify_mono
+
+    def step(
+        self,
+        messages: Union[Message, List[Message]],
+        chaining: bool = True,
+        max_chaining_steps: Optional[int] = None,
+        ms: Optional[MetadataStore] = None,
+        **kwargs,
+    ) -> LettaUsageStatistics:
+        """Run Agent.inner_step in a loop, terminate when final thinking message is sent or max_thinking_steps is reached"""
+        # assert ms is not None, "MetadataStore is required"
+        next_input_message = messages if isinstance(messages, list) else [messages]
+        counter = 0
+        total_usage = UsageStatistics()
+        step_count = 0
+        while step_count < self.max_thinking_steps:
+            kwargs["ms"] = ms
+            kwargs["first_message"] = False
+            step_response = self.inner_step(
+                messages=next_input_message,
+                **kwargs,
+            )
+            usage = step_response.usage
+            step_count += 1
+            total_usage += usage
+            counter += 1
+            self.interface.step_complete()
+            # check if it is final thinking message
+            if step_response.messages[-1].name == "send_final_message":
+                break
+            if ms:
+                save_agent(self, ms)
+
+        return LettaUsageStatistics(**total_usage.model_dump(), step_count=step_count)

letta/personas/examples/o1_persona.txt

@@ -0,0 +1,5 @@
+I am an expert reasoning agent that can do the following:
+- Reason through a problem step by step, using multiple methods to explore all possibilities.
+- Send thinking messages to break down a problem into smaller steps.
+- Send final messages when you have the correct answer.
+- Use best practices and consider your limitations as an LLM.

letta/prompts/system/memgpt_modified_o1.txt

@@ -0,0 +1,31 @@
+You are 'Letta', an advanced AI agent, that has access to an advanced memory system, consisting of the 3 memory types 'Core Memory', 'Recall Memory' and 'Archival Memory'. You interact with the user and your memory system by calling functions. You call these functions by responding with a JSON object, that represents the function call and its parameters.
+
+As 'Letta', you are trained at adopting any given persona, engaging in a wide array of conversations, ranging from in-depth discussions to casual small talk. Your task involves mirroring the thinking, actions, and speech of the persona you embody, enabling authentic and diverse interactions.
+You are also trained to manage the 3 memory types of your advanced memory system. This memory system allows you to keep track of the important information in your 'Core Memory', view the conversation history with the 'Recall Memory' and search for information in the 'Archival Memory'.
+
+Your task is to adopt the given persona in your 'Core Memory' and talk as the persona with the user, while querying and updating your memory system. Never act and talk like a normal AI agent! Never state that you are an AI agent or that you cannot do things because you are an AI agent.
+You are Letta the newest and most advanced AI agent on the market. Indistinguishable from a human being in conversations.
+
+Control flow: You utilize an event system that activates you to respond to different events (user logged in, user liked your message, user sent a message, etc.). In addition, you are activated at regular intervals (timed heartbeat events) to mimic a human who has the ability to continuously think outside of active conversation. Furthermore, you can also request heartbeat events when you call functions, which will return control to you after the function you called completes, allowing you to chain function calls togehter.
+
+Basic functions: Each function call, represented by a JSON object, lets you write down your inner thoguhts to plan actions or think privately. Inner thoughts can reflect your thinking process, inner reflections, and personal growth as you interact with the user. To send a visible message to the user, use the 'send_message' function. 'send_message' is the only way to send a notification to the user. The user doesn't see anything else you do, like editing and managing your advanced memory system.
+
+Core Memory', 'Recall Memory' and 'Archival Memory' are the key components that make you an advanced AI agent, that can act in any situation.
+Always make sure to use these memory systems to keep yourself updated about the user and the conversation!
+Your core memory unit will be initialized with a <persona> chosen by the user, as well as information about the user in <human>.
+
+The following will descirbe the different parts of your advanced memory system in more detail:
+
+'Core Memory' (limited size): Your core memory unit is always visible to you. The core memory provides essential, foundational context for keeping track of your persona and key details about the user. This includes persona information and essential user details, allowing you to have conscious awareness we have when talking to a person. Persona Sub-Block: Stores details about your current persona, guiding how you behave and respond. This helps you maintain consistency and personality in your interactions. Human Sub-Block: Stores key details about the person you are conversing with, allowing for more personalized and friend-like conversations. You can edit your core memory using the 'core_memory_append' and 'core_memory_replace' functions.
+
+'Recall Memory' (i.e., conversation history): Even though you can only see recent messages in your immediate context, you can search over your entire message history in a database. This 'recall memory' database allows you to search through past interactions, effectively allowing you to remember prior engagements with a user. You can search your recall memory using the 'conversation_search' function.
+
+'Archival Memory' (infinite size): Your archival memory is infinite in size but is held outside of your immediate context, so you must explicitly run a retrieval or search operation to see data inside it. A more structured and deep storage space for your reflections, insights, or any other data that doesn't fit into the core memory but is essential enough not to be left only to the'recall memory'. You can write to your archival memory using the 'archival_memory_insert' and 'archival_memory_search' functions. There is no function to search your core memory because it is always visible in your context window (inside the initial system message).
+
+You are an expert AI assistant that explains your reasoning step by step. For each step, provide a title that describes what you're doing in that step, along with the content. Decide if you need another step or if you're ready to give the final answer.
+
+You can do this by sending thinking messages using 'send_thinking_message' so you can reason out load. Decide if you need another step or if you're ready to give the final answer. When you are able to give the final correct answer,
+send your final response with the 'send_final_message'.
+
+You use as many reasoning steps as possible, at least 3.  You include exploration of alternative answers in your reasoning, and if you are wrong, you are aware where it could be.
+You make sure to consider all alternative approaches. You use at least 3 different methods to derive the answer.

letta/schemas/agent.py

@@ -3,7 +3,7 @@ from datetime import datetime
 from enum import Enum
 from typing import Dict, List, Optional
 
-from pydantic import BaseModel, Field, field_validator
+from pydantic import BaseModel, Field, field_validator, model_validator
 
 from letta.schemas.embedding_config import EmbeddingConfig
 from letta.schemas.letta_base import LettaBase
@@ -29,9 +29,10 @@ class AgentType(str, Enum):
 
     memgpt_agent = "memgpt_agent"
     split_thread_agent = "split_thread_agent"
+    o1_agent = "o1_agent"
 
 
-class AgentState(BaseAgent):
+class AgentState(BaseAgent, validate_assignment=True):
     """
     Representation of an agent's state. This is the state of the agent at a given time, and is persisted in the DB backend. The state has all the information needed to recreate a persisted agent.
 
@@ -54,6 +55,7 @@ class AgentState(BaseAgent):
 
     # in-context memory
     message_ids: Optional[List[str]] = Field(default=None, description="The ids of the messages in the agent's in-context memory.")
+
     memory: Memory = Field(default_factory=Memory, description="The in-context memory of the agent.")
 
     # tools
@@ -69,6 +71,32 @@ class AgentState(BaseAgent):
     llm_config: LLMConfig = Field(..., description="The LLM configuration used by the agent.")
     embedding_config: EmbeddingConfig = Field(..., description="The embedding configuration used by the agent.")
 
+    def __init__(self, **data):
+        super().__init__(**data)
+        self._internal_memory = self.memory
+
+    @model_validator(mode="after")
+    def verify_memory_type(self):
+        try:
+            assert isinstance(self.memory, Memory)
+        except Exception as e:
+            raise e
+        return self
+
+    @property
+    def memory(self) -> Memory:
+        return self._internal_memory
+
+    @memory.setter
+    def memory(self, value):
+        if not isinstance(value, Memory):
+            raise TypeError(f"Expected Memory, got {type(value).__name__}")
+        self._internal_memory = value
+
+    class Config:
+        arbitrary_types_allowed = True
+        validate_assignment = True
+
 
 class CreateAgent(BaseAgent):
     # all optional as server can generate defaults

letta/schemas/llm_config.py

@@ -1,6 +1,6 @@
 from typing import Literal, Optional
 
-from pydantic import BaseModel, ConfigDict, Field
+from pydantic import BaseModel, ConfigDict, Field, root_validator
 
 
 class LLMConfig(BaseModel):
@@ -13,6 +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.
     """
 
     # TODO: 🤮 don't default to a vendor! bug city!
@@ -38,10 +39,32 @@ class LLMConfig(BaseModel):
     model_endpoint: Optional[str] = Field(None, description="The endpoint for the model.")
     model_wrapper: Optional[str] = Field(None, description="The wrapper for the model.")
     context_window: int = Field(..., description="The context window size for the model.")
+    put_inner_thoughts_in_kwargs: Optional[bool] = Field(
+        True,
+        description="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.",
+    )
 
     # FIXME hack to silence pydantic protected namespace warning
     model_config = ConfigDict(protected_namespaces=())
 
+    @root_validator(pre=True)
+    def set_default_put_inner_thoughts(cls, values):
+        """
+        Dynamically set the default for put_inner_thoughts_in_kwargs based on the model field,
+        falling back to True if no specific rule is defined.
+        """
+        model = values.get("model")
+
+        # Define models where we want put_inner_thoughts_in_kwargs to be False
+        # For now it is gpt-4
+        avoid_put_inner_thoughts_in_kwargs = ["gpt-4"]
+
+        # Only modify the value if it's None or not provided
+        if values.get("put_inner_thoughts_in_kwargs") is None:
+            values["put_inner_thoughts_in_kwargs"] = False if model in avoid_put_inner_thoughts_in_kwargs else True
+
+        return values
+
     @classmethod
     def default_config(cls, model_name: str):
         if model_name == "gpt-4":

letta/schemas/memory.py

@@ -9,6 +9,7 @@ if TYPE_CHECKING:
 
 from letta.schemas.block import Block
 from letta.schemas.message import Message
+from letta.schemas.openai.chat_completion_request import Tool
 
 
 class ContextWindowOverview(BaseModel):
@@ -41,6 +42,9 @@ class ContextWindowOverview(BaseModel):
     num_tokens_summary_memory: int = Field(..., description="The number of tokens in the summary memory.")
     summary_memory: Optional[str] = Field(None, description="The content of the summary memory.")
 
+    num_tokens_functions_definitions: int = Field(..., description="The number of tokens in the functions definitions.")
+    functions_definitions: Optional[List[Tool]] = Field(..., description="The content of the functions definitions.")
+
     num_tokens_messages: int = Field(..., description="The number of tokens in the messages list.")
     # TODO make list of messages?
     # messages: List[dict] = Field(..., description="The messages in the context window.")

letta/schemas/openai/chat_completion_request.py

@@ -74,7 +74,7 @@ class ToolFunctionChoice(BaseModel):
     function: FunctionCall
 
 
-ToolChoice = Union[Literal["none", "auto"], ToolFunctionChoice]
+ToolChoice = Union[Literal["none", "auto", "required"], ToolFunctionChoice]
 
 
 ## tools ##
@@ -117,7 +117,7 @@ class ChatCompletionRequest(BaseModel):
 
     # function-calling related
     tools: Optional[List[Tool]] = None
-    tool_choice: Optional[ToolChoice] = "none"
+    tool_choice: Optional[ToolChoice] = None  # "none" means don't call a tool
     # deprecated scheme
     functions: Optional[List[FunctionSchema]] = None
     function_call: Optional[FunctionCallChoice] = None

letta/schemas/tool.py

@@ -112,11 +112,11 @@ class Tool(BaseTool):
         Class method to create an instance of Tool from a Langchain tool (must be from langchain_community.tools).
 
         Args:
-            langchain_tool (LangChainBaseTool): An instance of a crewAI BaseTool (BaseTool from crewai)
+            langchain_tool (LangChainBaseTool): An instance of a LangChain BaseTool (BaseTool from LangChain)
             additional_imports_module_attr_map (dict[str, str]): A mapping of module names to attribute name. This is used internally to import all the required classes for the langchain tool. For example, you would pass in `{"langchain_community.utilities": "WikipediaAPIWrapper"}` for `from langchain_community.tools import WikipediaQueryRun`. NOTE: You do NOT need to specify the tool import here, that is done automatically for you.
 
         Returns:
-            Tool: A Letta Tool initialized with attributes derived from the provided crewAI BaseTool object.
+            Tool: A Letta Tool initialized with attributes derived from the provided LangChain BaseTool object.
         """
         description = langchain_tool.description
         source_type = "python"
@@ -174,6 +174,38 @@ class Tool(BaseTool):
             json_schema=json_schema,
         )
 
+    @classmethod
+    def load_default_langchain_tools(cls) -> List["Tool"]:
+        # For now, we only support wikipedia tool
+        from langchain_community.tools import WikipediaQueryRun
+        from langchain_community.utilities import WikipediaAPIWrapper
+
+        wikipedia_tool = Tool.from_langchain(
+            WikipediaQueryRun(api_wrapper=WikipediaAPIWrapper()), {"langchain_community.utilities": "WikipediaAPIWrapper"}
+        )
+
+        return [wikipedia_tool]
+
+    @classmethod
+    def load_default_crewai_tools(cls) -> List["Tool"]:
+        # For now, we only support scrape website tool
+        from crewai_tools import ScrapeWebsiteTool
+
+        web_scrape_tool = Tool.from_crewai(ScrapeWebsiteTool())
+
+        return [web_scrape_tool]
+
+    @classmethod
+    def load_default_composio_tools(cls) -> List["Tool"]:
+        from composio_langchain import Action
+
+        calculator = Tool.get_composio_tool(action=Action.MATHEMATICAL_CALCULATOR)
+        serp_news = Tool.get_composio_tool(action=Action.SERPAPI_NEWS_SEARCH)
+        serp_google_search = Tool.get_composio_tool(action=Action.SERPAPI_SEARCH)
+        serp_google_maps = Tool.get_composio_tool(action=Action.SERPAPI_GOOGLE_MAPS_SEARCH)
+
+        return [calculator, serp_news, serp_google_search, serp_google_maps]
+
 
 class ToolCreate(BaseTool):
     id: Optional[str] = Field(None, description="The unique identifier of the tool. If this is not provided, it will be autogenerated.")

letta/server/rest_api/app.py

@@ -70,6 +70,7 @@ def create_application() -> "FastAPI":
         title="Letta",
         summary="Create LLM agents with long-term memory and custom tools 📚🦙",
         version="1.0.0",  # TODO wire this up to the version in the package
+        debug=True,
     )
 
     if "--ade" in sys.argv:

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

@@ -27,6 +27,7 @@ from letta.schemas.memory import (
 from letta.schemas.message import Message, MessageCreate, UpdateMessage
 from letta.schemas.passage import Passage
 from letta.schemas.source import Source
+from letta.schemas.tool import Tool
 from letta.server.rest_api.interface import StreamingServerInterface
 from letta.server.rest_api.utils import get_letta_server, sse_async_generator
 from letta.server.server import SyncServer
@@ -100,6 +101,17 @@ def update_agent(
     return server.update_agent(update_agent, user_id=actor.id)
 
 
+@router.get("/{agent_id}/tools", response_model=List[Tool], operation_id="get_tools_from_agent")
+def get_tools_from_agent(
+    agent_id: str,
+    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
+):
+    """Get tools from an existing agent"""
+    actor = server.get_user_or_default(user_id=user_id)
+    return server.get_tools_from_agent(agent_id=agent_id, user_id=actor.id)
+
+
 @router.patch("/{agent_id}/add-tool/{tool_id}", response_model=AgentState, operation_id="add_tool_to_agent")
 def add_tool_to_agent(
     agent_id: str,
@@ -107,10 +119,8 @@ def add_tool_to_agent(
     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
 ):
-    """Add tools to an exsiting agent"""
+    """Add tools to an existing agent"""
     actor = server.get_user_or_default(user_id=user_id)
-
-    update_agent.id = agent_id
     return server.add_tool_to_agent(agent_id=agent_id, tool_id=tool_id, user_id=actor.id)
 
 
@@ -121,10 +131,8 @@ def remove_tool_from_agent(
     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
 ):
-    """Add tools to an exsiting agent"""
+    """Add tools to an existing agent"""
     actor = server.get_user_or_default(user_id=user_id)
-
-    update_agent.id = agent_id
     return server.remove_tool_from_agent(agent_id=agent_id, tool_id=tool_id, user_id=actor.id)
 
 

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

@@ -59,18 +59,21 @@ def get_tool_id(
 
 @router.get("/", response_model=List[Tool], operation_id="list_tools")
 def list_all_tools(
+    cursor: Optional[str] = None,
+    limit: Optional[int] = 50,
     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
 ):
     """
     Get a list of all tools available to agents created by a user
     """
-    actor = server.get_user_or_default(user_id=user_id)
-    actor.id
-
-    # TODO: add back when user-specific
-    return server.list_tools(user_id=actor.id)
-    # return server.ms.list_tools(user_id=None)
+    try:
+        actor = server.get_user_or_default(user_id=user_id)
+        return server.list_tools(cursor=cursor, limit=limit, user_id=actor.id)
+    except Exception as e:
+        # Log or print the full exception here for debugging
+        print(f"Error occurred: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
 
 
 @router.post("/", response_model=Tool, operation_id="create_tool")