letta-nightly 0.6.1.dev20241205211219__py3-none-any.whl → 0.6.1.dev20241207104149__py3-none-any.whl

letta/functions/function_sets/base.py

@@ -1,3 +1,4 @@
+from datetime import datetime
 from typing import Optional
 
 from letta.agent import Agent
@@ -38,7 +39,7 @@ Returns:
 """
 
 
-def pause_heartbeats(self: Agent, minutes: int) -> Optional[str]:
+def pause_heartbeats(self: "Agent", minutes: int) -> Optional[str]:
     import datetime
 
     from letta.constants import MAX_PAUSE_HEARTBEATS
@@ -56,7 +57,7 @@ def pause_heartbeats(self: Agent, minutes: int) -> Optional[str]:
 pause_heartbeats.__doc__ = pause_heartbeats_docstring
 
 
-def conversation_search(self: Agent, query: str, page: Optional[int] = 0) -> Optional[str]:
+def conversation_search(self: "Agent", query: str, page: Optional[int] = 0) -> Optional[str]:
     """
     Search prior conversation history using case-insensitive string matching.
 
@@ -80,7 +81,15 @@ def conversation_search(self: Agent, query: str, page: Optional[int] = 0) -> Opt
     except:
         raise ValueError(f"'page' argument must be an integer")
     count = RETRIEVAL_QUERY_DEFAULT_PAGE_SIZE
-    results, total = self.persistence_manager.recall_memory.text_search(query, count=count, start=page * count)
+    # TODO: add paging by page number. currently cursor only works with strings.
+    # original: start=page * count
+    results = self.message_manager.list_user_messages_for_agent(
+        agent_id=self.agent_state.id,
+        actor=self.user,
+        query_text=query,
+        limit=count,
+    )
+    total = len(results)
     num_pages = math.ceil(total / count) - 1  # 0 index
     if len(results) == 0:
         results_str = f"No results found."
@@ -91,7 +100,7 @@ def conversation_search(self: Agent, query: str, page: Optional[int] = 0) -> Opt
     return results_str
 
 
-def conversation_search_date(self: Agent, start_date: str, end_date: str, page: Optional[int] = 0) -> Optional[str]:
+def conversation_search_date(self: "Agent", start_date: str, end_date: str, page: Optional[int] = 0) -> Optional[str]:
     """
     Search prior conversation history using a date range.
 
@@ -112,10 +121,29 @@ def conversation_search_date(self: Agent, start_date: str, end_date: str, page:
         page = 0
     try:
         page = int(page)
+        if page < 0:
+            raise ValueError
     except:
         raise ValueError(f"'page' argument must be an integer")
+
+    # Convert date strings to datetime objects
+    try:
+        start_datetime = datetime.strptime(start_date, "%Y-%m-%d").replace(hour=0, minute=0, second=0, microsecond=0)
+        end_datetime = datetime.strptime(end_date, "%Y-%m-%d").replace(hour=23, minute=59, second=59, microsecond=999999)
+    except ValueError:
+        raise ValueError("Dates must be in the format 'YYYY-MM-DD'")
+
     count = RETRIEVAL_QUERY_DEFAULT_PAGE_SIZE
-    results, total = self.persistence_manager.recall_memory.date_search(start_date, end_date, count=count, start=page * count)
+    results = self.message_manager.list_user_messages_for_agent(
+        # TODO: add paging by page number. currently cursor only works with strings.
+        agent_id=self.agent_state.id,
+        actor=self.user,
+        start_date=start_datetime,
+        end_date=end_datetime,
+        limit=count,
+        # start_date=start_date, end_date=end_date, limit=count, start=page * count
+    )
+    total = len(results)
     num_pages = math.ceil(total / count) - 1  # 0 index
     if len(results) == 0:
         results_str = f"No results found."
@@ -126,7 +154,7 @@ def conversation_search_date(self: Agent, start_date: str, end_date: str, page:
     return results_str
 
 
-def archival_memory_insert(self: Agent, content: str) -> Optional[str]:
+def archival_memory_insert(self: "Agent", content: str) -> Optional[str]:
     """
     Add to archival memory. Make sure to phrase the memory contents such that it can be easily queried later.
 
@@ -136,11 +164,11 @@ def archival_memory_insert(self: Agent, content: str) -> Optional[str]:
     Returns:
         Optional[str]: None is always returned as this function does not produce a response.
     """
-    self.persistence_manager.archival_memory.insert(content)
+    self.archival_memory.insert(content)
     return None
 
 
-def archival_memory_search(self: Agent, query: str, page: Optional[int] = 0) -> Optional[str]:
+def archival_memory_search(self: "Agent", query: str, page: Optional[int] = 0) -> Optional[str]:
     """
     Search archival memory using semantic (embedding-based) search.
 
@@ -163,7 +191,7 @@ def archival_memory_search(self: Agent, query: str, page: Optional[int] = 0) ->
     except:
         raise ValueError(f"'page' argument must be an integer")
     count = RETRIEVAL_QUERY_DEFAULT_PAGE_SIZE
-    results, total = self.persistence_manager.archival_memory.search(query, count=count, start=page * count)
+    results, total = self.archival_memory.search(query, count=count, start=page * count)
     num_pages = math.ceil(total / count) - 1  # 0 index
     if len(results) == 0:
         results_str = f"No results found."

letta/main.py

@@ -190,8 +190,8 @@ def run_agent_loop(
                 elif user_input.lower() == "/memory":
                     print(f"\nDumping memory contents:\n")
                     print(f"{letta_agent.agent_state.memory.compile()}")
-                    print(f"{letta_agent.persistence_manager.archival_memory.compile()}")
-                    print(f"{letta_agent.persistence_manager.recall_memory.compile()}")
+                    print(f"{letta_agent.archival_memory.compile()}")
+                    print(f"{letta_agent.recall_memory.compile()}")
                     continue
 
                 elif user_input.lower() == "/model":

letta/memory.py

@@ -67,14 +67,12 @@ def summarize_messages(
             + message_sequence_to_summarize[cutoff:]
         )
 
-    dummy_user_id = agent_state.user_id
+    agent_state.user_id
     dummy_agent_id = agent_state.id
     message_sequence = []
-    message_sequence.append(Message(user_id=dummy_user_id, agent_id=dummy_agent_id, role=MessageRole.system, text=summary_prompt))
-    message_sequence.append(
-        Message(user_id=dummy_user_id, agent_id=dummy_agent_id, role=MessageRole.assistant, text=MESSAGE_SUMMARY_REQUEST_ACK)
-    )
-    message_sequence.append(Message(user_id=dummy_user_id, agent_id=dummy_agent_id, role=MessageRole.user, text=summary_input))
+    message_sequence.append(Message(agent_id=dummy_agent_id, role=MessageRole.system, text=summary_prompt))
+    message_sequence.append(Message(agent_id=dummy_agent_id, role=MessageRole.assistant, text=MESSAGE_SUMMARY_REQUEST_ACK))
+    message_sequence.append(Message(agent_id=dummy_agent_id, role=MessageRole.user, text=summary_input))
 
     # TODO: We need to eventually have a separate LLM config for the summarizer LLM
     llm_config_no_inner_thoughts = agent_state.llm_config.model_copy(deep=True)
@@ -252,82 +250,6 @@ class DummyRecallMemory(RecallMemory):
             return matches, len(matches)
 
 
-class BaseRecallMemory(RecallMemory):
-    """Recall memory based on base functions implemented by storage connectors"""
-
-    def __init__(self, agent_state, restrict_search_to_summaries=False):
-        # If true, the pool of messages that can be queried are the automated summaries only
-        # (generated when the conversation window needs to be shortened)
-        self.restrict_search_to_summaries = restrict_search_to_summaries
-        from letta.agent_store.storage import StorageConnector
-
-        self.agent_state = agent_state
-
-        # create embedding model
-        self.embed_model = embedding_model(agent_state.embedding_config)
-        self.embedding_chunk_size = agent_state.embedding_config.embedding_chunk_size
-
-        # create storage backend
-        self.storage = StorageConnector.get_recall_storage_connector(user_id=agent_state.user_id, agent_id=agent_state.id)
-        # TODO: have some mechanism for cleanup otherwise will lead to OOM
-        self.cache = {}
-
-    def get_all(self, start=0, count=None):
-        start = 0 if start is None else int(start)
-        count = 0 if count is None else int(count)
-        results = self.storage.get_all(start, count)
-        results_json = [message.to_openai_dict() for message in results]
-        return results_json, len(results)
-
-    def text_search(self, query_string, count=None, start=None):
-        start = 0 if start is None else int(start)
-        count = 0 if count is None else int(count)
-        results = self.storage.query_text(query_string, count, start)
-        results_json = [message.to_openai_dict_search_results() for message in results]
-        return results_json, len(results)
-
-    def date_search(self, start_date, end_date, count=None, start=None):
-        start = 0 if start is None else int(start)
-        count = 0 if count is None else int(count)
-        results = self.storage.query_date(start_date, end_date, count, start)
-        results_json = [message.to_openai_dict_search_results() for message in results]
-        return results_json, len(results)
-
-    def compile(self) -> str:
-        total = self.storage.size()
-        system_count = self.storage.size(filters={"role": "system"})
-        user_count = self.storage.size(filters={"role": "user"})
-        assistant_count = self.storage.size(filters={"role": "assistant"})
-        function_count = self.storage.size(filters={"role": "function"})
-        other_count = total - (system_count + user_count + assistant_count + function_count)
-
-        memory_str = (
-            f"Statistics:"
-            + f"\n{total} total messages"
-            + f"\n{system_count} system"
-            + f"\n{user_count} user"
-            + f"\n{assistant_count} assistant"
-            + f"\n{function_count} function"
-            + f"\n{other_count} other"
-        )
-        return f"\n### RECALL MEMORY ###" + f"\n{memory_str}"
-
-    def insert(self, message: Message):
-        self.storage.insert(message)
-
-    def insert_many(self, messages: List[Message]):
-        self.storage.insert_many(messages)
-
-    def save(self):
-        self.storage.save()
-
-    def __len__(self):
-        return self.storage.size()
-
-    def count(self) -> int:
-        return len(self)
-
-
 class EmbeddingArchivalMemory(ArchivalMemory):
     """Archival memory with embedding based search"""
 

letta/metadata.py

@@ -14,7 +14,6 @@ from letta.schemas.api_key import APIKey
 from letta.schemas.embedding_config import EmbeddingConfig
 from letta.schemas.enums import ToolRuleType
 from letta.schemas.llm_config import LLMConfig
-from letta.schemas.openai.chat_completions import ToolCall, ToolCallFunction
 from letta.schemas.tool_rule import ChildToolRule, InitToolRule, TerminalToolRule
 from letta.schemas.user import User
 from letta.services.per_agent_lock_manager import PerAgentLockManager
@@ -66,40 +65,6 @@ class EmbeddingConfigColumn(TypeDecorator):
         return value
 
 
-class ToolCallColumn(TypeDecorator):
-
-    impl = JSON
-    cache_ok = True
-
-    def load_dialect_impl(self, dialect):
-        return dialect.type_descriptor(JSON())
-
-    def process_bind_param(self, value, dialect):
-        if value:
-            values = []
-            for v in value:
-                if isinstance(v, ToolCall):
-                    values.append(v.model_dump())
-                else:
-                    values.append(v)
-            return values
-
-        return value
-
-    def process_result_value(self, value, dialect):
-        if value:
-            tools = []
-            for tool_value in value:
-                if "function" in tool_value:
-                    tool_call_function = ToolCallFunction(**tool_value["function"])
-                    del tool_value["function"]
-                else:
-                    tool_call_function = None
-                tools.append(ToolCall(function=tool_call_function, **tool_value))
-            return tools
-        return value
-
-
 # TODO: eventually store providers?
 # class Provider(Base):
 #    __tablename__ = "providers"

letta/o1_agent.py

@@ -20,7 +20,7 @@ def send_thinking_message(self: "Agent", message: str) -> Optional[str]:
     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])
+    self.interface.internal_monologue(message)
     return None
 
 
@@ -34,7 +34,7 @@ def send_final_message(self: "Agent", message: str) -> Optional[str]:
     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])
+    self.interface.internal_monologue(message)
     return None
 
 
@@ -62,10 +62,15 @@ class O1Agent(Agent):
         """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:
+            # This is hacky but we need to do this for now
+            for m in next_input_message:
+                m.id = m._generate_id()
+
             kwargs["ms"] = ms
             kwargs["first_message"] = False
             step_response = self.inner_step(

letta/offline_memory_agent.py

@@ -0,0 +1,180 @@
+from typing import List, Optional, Union
+
+from letta.agent import Agent, AgentState, save_agent
+from letta.interface import AgentInterface
+from letta.metadata import MetadataStore
+from letta.orm import User
+from letta.schemas.message import Message
+from letta.schemas.openai.chat_completion_response import UsageStatistics
+from letta.schemas.usage import LettaUsageStatistics
+
+
+def trigger_rethink_memory(agent_state: "AgentState", message: Optional[str]) -> Optional[str]:  # type: ignore
+    """
+    Called if and only when user says the word trigger_rethink_memory". It will trigger the re-evaluation of the memory.
+
+    Args:
+        message (Optional[str]): Description of what aspect of the memory should be re-evaluated.
+
+    """
+    from letta import create_client
+
+    client = create_client()
+    agents = client.list_agents()
+    for agent in agents:
+        if agent.agent_type == "offline_memory_agent":
+            client.user_message(agent_id=agent.id, message=message)
+
+
+def trigger_rethink_memory_convo(agent_state: "AgentState", message: Optional[str]) -> Optional[str]:  # type: ignore
+    """
+    Called if and only when user says the word "trigger_rethink_memory". It will trigger the re-evaluation of the memory.
+
+    Args:
+        message (Optional[str]): Description of what aspect of the memory should be re-evaluated.
+
+    """
+    from letta import create_client
+
+    client = create_client()
+    recent_convo = "".join([str(message) for message in agent_state.messages])[
+        -2000:
+    ]  # TODO: make a better representation of the convo history
+    agent_state.memory.update_block_value(label="conversation_block", value=recent_convo)
+
+    client = create_client()
+    agents = client.list_agents()
+    for agent in agents:
+        if agent.agent_type == "offline_memory_agent":
+            client.user_message(agent_id=agent.id, message=message)
+
+
+def rethink_memory_convo(agent_state: "AgentState", new_memory: str, target_block_label: Optional[str], source_block_label: Optional[str]) -> Optional[str]:  # type: ignore
+    """
+    Re-evaluate the memory in block_name, integrating new and updated facts. Replace outdated information with the most likely truths, avoiding redundancy with original memories. Ensure consistency with other memory blocks.
+
+    Args:
+        new_memory (str): The new memory with information integrated from the memory block. If there is no new information, then this should be the same as the content in the source block.
+        source_block_label (str): The name of the block to integrate information from. None if all the information has been integrated to terminate the loop. This can by any block.
+        target_block_label (str): The name of the block to write to. This should be chat_agent_human_new or chat_agent_persona_new.
+
+    Returns:
+        Optional[str]: None is always returned as this function does not produce a response.
+    """
+    if target_block_label is not None:
+        if agent_state.memory.get_block(target_block_label) is None:
+            agent_state.memory.create_block(label=target_block_label, value=new_memory)
+        agent_state.memory.update_block_value(label=target_block_label, value=new_memory)
+    return None
+
+
+def rethink_memory(agent_state: "AgentState", new_memory: str, target_block_label: Optional[str], source_block_label: Optional[str]) -> Optional[str]:  # type: ignore
+    """
+    Re-evaluate the memory in block_name, integrating new and updated facts.
+    Replace outdated information with the most likely truths, avoiding redundancy with original memories.
+    Ensure consistency with other memory blocks.
+
+    Args:
+        new_memory (str): The new memory with information integrated from the memory block. If there is no new information, then this should be the same as the content in the source block.
+        source_block_label (str): The name of the block to integrate information from. None if all the information has been integrated to terminate the loop.
+        target_block_label (str): The name of the block to write to.
+    Returns:
+        Optional[str]: None is always returned as this function does not produce a response.
+    """
+
+    if target_block_label is not None:
+        if agent_state.memory.get_block(target_block_label) is None:
+            agent_state.memory.create_block(label=target_block_label, value=new_memory)
+        agent_state.memory.update_block_value(label=target_block_label, value=new_memory)
+    return None
+
+
+def finish_rethinking_memory(agent_state: "AgentState") -> Optional[str]:  # type: ignore
+    """
+    This function is called when the agent is done rethinking the memory.
+
+    Returns:
+        Optional[str]: None is always returned as this function does not produce a response.
+    """
+    return None
+
+
+def finish_rethinking_memory_convo(agent_state: "AgentState") -> Optional[str]:  # type: ignore
+    """
+    This function is called when the agent is done rethinking the memory.
+
+    Returns:
+        Optional[str]: None is always returned as this function does not produce a response.
+    """
+    from letta import create_client
+
+    client = create_client()
+    agents = client.list_agents()
+
+    agent_state.memory.update_block_value("chat_agent_human", agent_state.memory.get_block("chat_agent_human_new").value)
+    agent_state.memory.update_block_value("chat_agent_persona", agent_state.memory.get_block("chat_agent_persona_new").value)
+    for agent in agents:
+        if agent.name == "conversation_agent":
+            agent.memory.update_block_value(label="chat_agent_human", value=agent_state.memory.get_block("chat_agent_human_new").value)
+            agent.memory.update_block_value(label="chat_agent_persona", value=agent_state.memory.get_block("chat_agent_persona_new").value)
+
+    return None
+
+
+class OfflineMemoryAgent(Agent):
+    def __init__(
+        self,
+        interface: AgentInterface,
+        agent_state: AgentState,
+        user: User = None,
+        # extras
+        first_message_verify_mono: bool = False,
+        max_memory_rethinks: int = 10,
+    ):
+        super().__init__(interface, agent_state, user)
+        self.first_message_verify_mono = first_message_verify_mono
+        self.max_memory_rethinks = max_memory_rethinks
+
+    def step(
+        self,
+        messages: Union[Message, List[Message]],
+        chaining: bool = True,
+        max_chaining_steps: Optional[int] = None,
+        ms: Optional[MetadataStore] = None,
+        **kwargs,
+    ) -> LettaUsageStatistics:
+        """Go through what is currently in memory core memory and integrate information."""
+        next_input_message = messages if isinstance(messages, list) else [messages]
+        counter = 0
+        total_usage = UsageStatistics()
+        step_count = 0
+
+        while counter < self.max_memory_rethinks:
+            # This is hacky but we need to do this for now
+            # TODO: REMOVE THIS
+            for m in next_input_message:
+                m.id = m._generate_id()
+
+            kwargs["ms"] = ms
+            kwargs["first_message"] = False
+            step_response = self.inner_step(
+                messages=next_input_message,
+                **kwargs,
+            )
+            for message in step_response.messages:
+                if message.tool_calls:
+                    for tool_call in message.tool_calls:
+                        # check if the function name is "finish_rethinking_memory"
+                        if tool_call.function.name == "finish_rethinking_memory":
+                            counter = self.max_memory_rethinks
+                            break
+            usage = step_response.usage
+            step_count += 1
+            total_usage += usage
+            counter += 1
+            self.interface.step_complete()
+
+            if ms:
+                save_agent(self, ms)
+
+        return LettaUsageStatistics(**total_usage.model_dump(), step_count=step_count)

letta/orm/__init__.py

@@ -1,10 +1,13 @@
+from letta.orm.agents_tags import AgentsTags
 from letta.orm.base import Base
 from letta.orm.block import Block
 from letta.orm.blocks_agents import BlocksAgents
 from letta.orm.file import FileMetadata
 from letta.orm.job import Job
+from letta.orm.message import Message
 from letta.orm.organization import Organization
 from letta.orm.sandbox_config import SandboxConfig, SandboxEnvironmentVariable
 from letta.orm.source import Source
 from letta.orm.tool import Tool
+from letta.orm.tools_agents import ToolsAgents
 from letta.orm.user import User

letta/orm/file.py

@@ -1,4 +1,4 @@
-from typing import TYPE_CHECKING, Optional
+from typing import TYPE_CHECKING, Optional, List
 
 from sqlalchemy import Integer, String
 from sqlalchemy.orm import Mapped, mapped_column, relationship

letta/orm/message.py

@@ -0,0 +1,66 @@
+from datetime import datetime
+from typing import Optional
+
+from sqlalchemy import JSON, DateTime, TypeDecorator
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from letta.orm.mixins import AgentMixin, OrganizationMixin
+from letta.orm.sqlalchemy_base import SqlalchemyBase
+from letta.schemas.message import Message as PydanticMessage
+from letta.schemas.openai.chat_completions import ToolCall, ToolCallFunction
+
+
+class ToolCallColumn(TypeDecorator):
+
+    impl = JSON
+    cache_ok = True
+
+    def load_dialect_impl(self, dialect):
+        return dialect.type_descriptor(JSON())
+
+    def process_bind_param(self, value, dialect):
+        if value:
+            values = []
+            for v in value:
+                if isinstance(v, ToolCall):
+                    values.append(v.model_dump())
+                else:
+                    values.append(v)
+            return values
+
+        return value
+
+    def process_result_value(self, value, dialect):
+        if value:
+            tools = []
+            for tool_value in value:
+                if "function" in tool_value:
+                    tool_call_function = ToolCallFunction(**tool_value["function"])
+                    del tool_value["function"]
+                else:
+                    tool_call_function = None
+                tools.append(ToolCall(function=tool_call_function, **tool_value))
+            return tools
+        return value
+
+
+class Message(SqlalchemyBase, OrganizationMixin, AgentMixin):
+    """Defines data model for storing Message objects"""
+
+    __tablename__ = "messages"
+    __table_args__ = {"extend_existing": True}
+    __pydantic_model__ = PydanticMessage
+
+    id: Mapped[str] = mapped_column(primary_key=True, doc="Unique message identifier")
+    role: Mapped[str] = mapped_column(doc="Message role (user/assistant/system/tool)")
+    text: Mapped[Optional[str]] = mapped_column(nullable=True, doc="Message content")
+    model: Mapped[Optional[str]] = mapped_column(nullable=True, doc="LLM model used")
+    name: Mapped[Optional[str]] = mapped_column(nullable=True, doc="Name for multi-agent scenarios")
+    tool_calls: Mapped[ToolCall] = mapped_column(ToolCallColumn, doc="Tool call information")
+    tool_call_id: Mapped[Optional[str]] = mapped_column(nullable=True, doc="ID of the tool call")
+    created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), default=datetime.utcnow)
+
+    # Relationships
+    # TODO: Add in after Agent ORM is created
+    # agent: Mapped["Agent"] = relationship("Agent", back_populates="messages", lazy="selectin")
+    organization: Mapped["Organization"] = relationship("Organization", back_populates="messages", lazy="selectin")

letta/orm/mixins.py

@@ -31,6 +31,22 @@ class UserMixin(Base):
     user_id: Mapped[str] = mapped_column(String, ForeignKey("users.id"))
 
 
+class AgentMixin(Base):
+    """Mixin for models that belong to an agent."""
+
+    __abstract__ = True
+
+    agent_id: Mapped[str] = mapped_column(String, ForeignKey("agents.id"))
+
+
+class FileMixin(Base):
+    """Mixin for models that belong to a file."""
+
+    __abstract__ = True
+
+    file_id: Mapped[str] = mapped_column(String, ForeignKey("files.id"))
+
+
 class SourceMixin(Base):
     """Mixin for models (e.g. file) that belong to a source."""
 

letta/orm/organization.py

@@ -33,6 +33,7 @@ class Organization(SqlalchemyBase):
     sandbox_environment_variables: Mapped[List["SandboxEnvironmentVariable"]] = relationship(
         "SandboxEnvironmentVariable", back_populates="organization", cascade="all, delete-orphan"
     )
+    messages: Mapped[List["Message"]] = relationship("Message", back_populates="organization", cascade="all, delete-orphan")
 
     # TODO: Map these relationships later when we actually make these models
     # below is just a suggestion