letta-nightly 0.5.2.dev20241118104226__py3-none-any.whl → 0.5.3.dev20241120010849__py3-none-any.whl

letta/metadata.py

@@ -4,23 +4,13 @@ import os
 import secrets
 from typing import List, Optional
 
-from sqlalchemy import (
-    BIGINT,
-    JSON,
-    Boolean,
-    Column,
-    DateTime,
-    Index,
-    String,
-    TypeDecorator,
-)
+from sqlalchemy import JSON, Column, DateTime, Index, String, TypeDecorator
 from sqlalchemy.sql import func
 
 from letta.config import LettaConfig
 from letta.orm.base import Base
 from letta.schemas.agent import AgentState
 from letta.schemas.api_key import APIKey
-from letta.schemas.block import Block, Human, Persona
 from letta.schemas.embedding_config import EmbeddingConfig
 from letta.schemas.enums import JobStatus
 from letta.schemas.job import Job
@@ -269,63 +259,6 @@ class AgentSourceMappingModel(Base):
         return f"<AgentSourceMapping(user_id='{self.user_id}', agent_id='{self.agent_id}', source_id='{self.source_id}')>"
 
 
-class BlockModel(Base):
-    __tablename__ = "block"
-    __table_args__ = {"extend_existing": True}
-
-    id = Column(String, primary_key=True, nullable=False)
-    value = Column(String, nullable=False)
-    limit = Column(BIGINT)
-    template_name = Column(String, nullable=True, default=None)
-    template = Column(Boolean, default=False)  # True: listed as possible human/persona
-    label = Column(String, nullable=False)
-    metadata_ = Column(JSON)
-    description = Column(String)
-    user_id = Column(String)
-    Index(__tablename__ + "_idx_user", user_id),
-
-    def __repr__(self) -> str:
-        return f"<Block(id='{self.id}', template_name='{self.template_name}', template='{self.template_name}', label='{self.label}', user_id='{self.user_id}')>"
-
-    def to_record(self) -> Block:
-        if self.label == "persona":
-            return Persona(
-                id=self.id,
-                value=self.value,
-                limit=self.limit,
-                template_name=self.template_name,
-                template=self.template,
-                label=self.label,
-                metadata_=self.metadata_,
-                description=self.description,
-                user_id=self.user_id,
-            )
-        elif self.label == "human":
-            return Human(
-                id=self.id,
-                value=self.value,
-                limit=self.limit,
-                template_name=self.template_name,
-                template=self.template,
-                label=self.label,
-                metadata_=self.metadata_,
-                description=self.description,
-                user_id=self.user_id,
-            )
-        else:
-            return Block(
-                id=self.id,
-                value=self.value,
-                limit=self.limit,
-                template_name=self.template_name,
-                template=self.template,
-                label=self.label,
-                metadata_=self.metadata_,
-                description=self.description,
-                user_id=self.user_id,
-            )
-
-
 class JobModel(Base):
     __tablename__ = "jobs"
     __table_args__ = {"extend_existing": True}
@@ -425,27 +358,6 @@ class MetadataStore:
             session.add(AgentModel(**fields))
             session.commit()
 
-    @enforce_types
-    def create_block(self, block: Block):
-        with self.session_maker() as session:
-            # TODO: fix?
-            # we are only validating that more than one template block
-            # with a given name doesn't exist.
-            if (
-                session.query(BlockModel)
-                .filter(BlockModel.template_name == block.template_name)
-                .filter(BlockModel.user_id == block.user_id)
-                .filter(BlockModel.template == True)
-                .filter(BlockModel.label == block.label)
-                .count()
-                > 0
-            ):
-
-                raise ValueError(f"Block with name {block.template_name} already exists")
-
-            session.add(BlockModel(**vars(block)))
-            session.commit()
-
     @enforce_types
     def update_agent(self, agent: AgentState):
         with self.session_maker() as session:
@@ -457,28 +369,6 @@ class MetadataStore:
             session.query(AgentModel).filter(AgentModel.id == agent.id).update(fields)
             session.commit()
 
-    @enforce_types
-    def update_block(self, block: Block):
-        with self.session_maker() as session:
-            session.query(BlockModel).filter(BlockModel.id == block.id).update(vars(block))
-            session.commit()
-
-    @enforce_types
-    def update_or_create_block(self, block: Block):
-        with self.session_maker() as session:
-            existing_block = session.query(BlockModel).filter(BlockModel.id == block.id).first()
-            if existing_block:
-                session.query(BlockModel).filter(BlockModel.id == block.id).update(vars(block))
-            else:
-                session.add(BlockModel(**vars(block)))
-            session.commit()
-
-    @enforce_types
-    def delete_block(self, block_id: str):
-        with self.session_maker() as session:
-            session.query(BlockModel).filter(BlockModel.id == block_id).delete()
-            session.commit()
-
     @enforce_types
     def delete_agent(self, agent_id: str):
         with self.session_maker() as session:
@@ -513,50 +403,6 @@ class MetadataStore:
             assert len(results) == 1, f"Expected 1 result, got {len(results)}"  # should only be one result
             return results[0].to_record()
 
-    @enforce_types
-    def get_block(self, block_id: str) -> Optional[Block]:
-        with self.session_maker() as session:
-            results = session.query(BlockModel).filter(BlockModel.id == block_id).all()
-            if len(results) == 0:
-                return None
-            assert len(results) == 1, f"Expected 1 result, got {len(results)}"
-            return results[0].to_record()
-
-    @enforce_types
-    def get_blocks(
-        self,
-        user_id: Optional[str],
-        label: Optional[str] = None,
-        template: Optional[bool] = None,
-        template_name: Optional[str] = None,
-        id: Optional[str] = None,
-    ) -> Optional[List[Block]]:
-        """List available blocks"""
-        with self.session_maker() as session:
-            query = session.query(BlockModel)
-
-            if user_id:
-                query = query.filter(BlockModel.user_id == user_id)
-
-            if label:
-                query = query.filter(BlockModel.label == label)
-
-            if template_name:
-                query = query.filter(BlockModel.template_name == template_name)
-
-            if id:
-                query = query.filter(BlockModel.id == id)
-
-            if template:
-                query = query.filter(BlockModel.template == template)
-
-            results = query.all()
-
-            if len(results) == 0:
-                return None
-
-            return [r.to_record() for r in results]
-
     # agent source metadata
     @enforce_types
     def attach_source(self, user_id: str, agent_id: str, source_id: str):

letta/o1_agent.py

@@ -8,6 +8,7 @@ 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
+from letta.schemas.user import User
 
 
 def send_thinking_message(self: "Agent", message: str) -> Optional[str]:
@@ -43,11 +44,12 @@ class O1Agent(Agent):
         self,
         interface: AgentInterface,
         agent_state: AgentState,
+        user: User,
         tools: List[Tool] = [],
         max_thinking_steps: int = 10,
         first_message_verify_mono: bool = False,
     ):
-        super().__init__(interface, agent_state, tools)
+        super().__init__(interface, agent_state, tools, user)
         self.max_thinking_steps = max_thinking_steps
         self.tools = tools
         self.first_message_verify_mono = first_message_verify_mono

letta/orm/__init__.py

@@ -1,4 +1,5 @@
 from letta.orm.base import Base
+from letta.orm.block import Block
 from letta.orm.file import FileMetadata
 from letta.orm.organization import Organization
 from letta.orm.source import Source

letta/orm/block.py

@@ -0,0 +1,44 @@
+from typing import TYPE_CHECKING, Optional, Type
+
+from sqlalchemy import JSON, BigInteger, Integer
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from letta.orm.mixins import OrganizationMixin
+from letta.orm.sqlalchemy_base import SqlalchemyBase
+from letta.schemas.block import Block as PydanticBlock
+from letta.schemas.block import Human, Persona
+
+if TYPE_CHECKING:
+    from letta.orm.organization import Organization
+
+
+class Block(OrganizationMixin, SqlalchemyBase):
+    """Blocks are sections of the LLM context, representing a specific part of the total Memory"""
+
+    __tablename__ = "block"
+    __pydantic_model__ = PydanticBlock
+
+    template_name: Mapped[Optional[str]] = mapped_column(
+        nullable=True, doc="the unique name that identifies a block in a human-readable way"
+    )
+    description: Mapped[Optional[str]] = mapped_column(nullable=True, doc="a description of the block for context")
+    label: Mapped[str] = mapped_column(doc="the type of memory block in use, ie 'human', 'persona', 'system'")
+    is_template: Mapped[bool] = mapped_column(
+        doc="whether the block is a template (e.g. saved human/persona options as baselines for other templates)", default=False
+    )
+    value: Mapped[str] = mapped_column(doc="Text content of the block for the respective section of core memory.")
+    limit: Mapped[BigInteger] = mapped_column(Integer, default=2000, doc="Character limit of the block.")
+    metadata_: Mapped[Optional[dict]] = mapped_column(JSON, default={}, doc="arbitrary information related to the block.")
+
+    # relationships
+    organization: Mapped[Optional["Organization"]] = relationship("Organization")
+
+    def to_pydantic(self) -> Type:
+        match self.label:
+            case "human":
+                Schema = Human
+            case "persona":
+                Schema = Persona
+            case _:
+                Schema = PydanticBlock
+        return Schema.model_validate(self)

letta/orm/organization.py

@@ -23,6 +23,7 @@ class Organization(SqlalchemyBase):
     # relationships
     users: Mapped[List["User"]] = relationship("User", back_populates="organization", cascade="all, delete-orphan")
     tools: Mapped[List["Tool"]] = relationship("Tool", back_populates="organization", cascade="all, delete-orphan")
+    blocks: Mapped[List["Block"]] = relationship("Block", back_populates="organization", cascade="all, delete-orphan")
     sources: Mapped[List["Source"]] = relationship("Source", back_populates="organization", cascade="all, delete-orphan")
     agents_tags: Mapped[List["AgentsTags"]] = relationship("AgentsTags", back_populates="organization", cascade="all, delete-orphan")
     files: Mapped[List["FileMetadata"]] = relationship("FileMetadata", back_populates="organization", cascade="all, delete-orphan")

letta/providers.py

@@ -2,7 +2,7 @@ from typing import List, Optional
 
 from pydantic import BaseModel, Field, model_validator
 
-from letta.constants import LLM_MAX_TOKENS
+from letta.constants import LLM_MAX_TOKENS, MIN_CONTEXT_WINDOW
 from letta.llm_api.azure_openai import (
     get_azure_chat_completions_endpoint,
     get_azure_embeddings_endpoint,
@@ -67,10 +67,15 @@ class OpenAIProvider(Provider):
         extra_params = {"supported_parameters": "tools"} if "openrouter.ai" in self.base_url else None
         response = openai_get_model_list(self.base_url, api_key=self.api_key, extra_params=extra_params)
 
-        assert "data" in response, f"OpenAI model query response missing 'data' field: {response}"
+        # TogetherAI's response is missing the 'data' field
+        # assert "data" in response, f"OpenAI model query response missing 'data' field: {response}"
+        if "data" in response:
+            data = response["data"]
+        else:
+            data = response
 
         configs = []
-        for model in response["data"]:
+        for model in data:
             assert "id" in model, f"OpenAI model missing 'id' field: {model}"
             model_name = model["id"]
 
@@ -82,6 +87,32 @@ class OpenAIProvider(Provider):
 
             if not context_window_size:
                 continue
+
+            # TogetherAI includes the type, which we can use to filter out embedding models
+            if self.base_url == "https://api.together.ai/v1":
+                if "type" in model and model["type"] != "chat":
+                    continue
+
+                # for TogetherAI, we need to skip the models that don't support JSON mode / function calling
+                # requests.exceptions.HTTPError: HTTP error occurred: 400 Client Error: Bad Request for url: https://api.together.ai/v1/chat/completions | Status code: 400, Message: {
+                #   "error": {
+                #     "message": "mistralai/Mixtral-8x7B-v0.1 is not supported for JSON mode/function calling",
+                #     "type": "invalid_request_error",
+                #     "param": null,
+                #     "code": "constraints_model"
+                #   }
+                # }
+                if "config" not in model:
+                    continue
+                if "chat_template" not in model["config"]:
+                    continue
+                if model["config"]["chat_template"] is None:
+                    continue
+                if "tools" not in model["config"]["chat_template"]:
+                    continue
+                # if "config" in data and "chat_template" in data["config"] and "tools" not in data["config"]["chat_template"]:
+                # continue
+
             configs.append(
                 LLMConfig(model=model_name, model_endpoint_type="openai", model_endpoint=self.base_url, context_window=context_window_size)
             )
@@ -325,6 +356,113 @@ class GroqProvider(OpenAIProvider):
         raise NotImplementedError
 
 
+class TogetherProvider(OpenAIProvider):
+    """TogetherAI provider that uses the /completions API
+
+    TogetherAI can also be used via the /chat/completions API
+    by settings OPENAI_API_KEY and OPENAI_API_BASE to the TogetherAI API key
+    and API URL, however /completions is preferred because their /chat/completions
+    function calling support is limited.
+    """
+
+    name: str = "together"
+    base_url: str = "https://api.together.ai/v1"
+    api_key: str = Field(..., description="API key for the TogetherAI API.")
+    default_prompt_formatter: str = Field(..., description="Default prompt formatter (aka model wrapper) to use on vLLM /completions API.")
+
+    def list_llm_models(self) -> List[LLMConfig]:
+        from letta.llm_api.openai import openai_get_model_list
+
+        response = openai_get_model_list(self.base_url, api_key=self.api_key)
+
+        # TogetherAI's response is missing the 'data' field
+        # assert "data" in response, f"OpenAI model query response missing 'data' field: {response}"
+        if "data" in response:
+            data = response["data"]
+        else:
+            data = response
+
+        configs = []
+        for model in data:
+            assert "id" in model, f"TogetherAI model missing 'id' field: {model}"
+            model_name = model["id"]
+
+            if "context_length" in model:
+                # Context length is returned in OpenRouter as "context_length"
+                context_window_size = model["context_length"]
+            else:
+                context_window_size = self.get_model_context_window_size(model_name)
+
+            # We need the context length for embeddings too
+            if not context_window_size:
+                continue
+
+            # Skip models that are too small for Letta
+            if context_window_size <= MIN_CONTEXT_WINDOW:
+                continue
+
+            # TogetherAI includes the type, which we can use to filter for embedding models
+            if "type" in model and model["type"] not in ["chat", "language"]:
+                continue
+
+            configs.append(
+                LLMConfig(
+                    model=model_name,
+                    model_endpoint_type="together",
+                    model_endpoint=self.base_url,
+                    model_wrapper=self.default_prompt_formatter,
+                    context_window=context_window_size,
+                )
+            )
+
+        return configs
+
+    def list_embedding_models(self) -> List[EmbeddingConfig]:
+        # TODO renable once we figure out how to pass API keys through properly
+        return []
+
+        # from letta.llm_api.openai import openai_get_model_list
+
+        # response = openai_get_model_list(self.base_url, api_key=self.api_key)
+
+        # # TogetherAI's response is missing the 'data' field
+        # # assert "data" in response, f"OpenAI model query response missing 'data' field: {response}"
+        # if "data" in response:
+        #     data = response["data"]
+        # else:
+        #     data = response
+
+        # configs = []
+        # for model in data:
+        #     assert "id" in model, f"TogetherAI model missing 'id' field: {model}"
+        #     model_name = model["id"]
+
+        #     if "context_length" in model:
+        #         # Context length is returned in OpenRouter as "context_length"
+        #         context_window_size = model["context_length"]
+        #     else:
+        #         context_window_size = self.get_model_context_window_size(model_name)
+
+        #     if not context_window_size:
+        #         continue
+
+        #     # TogetherAI includes the type, which we can use to filter out embedding models
+        #     if "type" in model and model["type"] not in ["embedding"]:
+        #         continue
+
+        #     configs.append(
+        #         EmbeddingConfig(
+        #             embedding_model=model_name,
+        #             embedding_endpoint_type="openai",
+        #             embedding_endpoint=self.base_url,
+        #             embedding_dim=context_window_size,
+        #             embedding_chunk_size=300,  # TODO: change?
+        #         )
+        #     )
+
+        # return configs
+
+
 class GoogleAIProvider(Provider):
     # gemini
     api_key: str = Field(..., description="API key for the Google AI API.")

letta/schemas/block.py

@@ -14,36 +14,30 @@ class BaseBlock(LettaBase, validate_assignment=True):
     __id_prefix__ = "block"
 
     # data value
-    value: Optional[str] = Field(None, description="Value of the block.")
+    value: str = Field(..., description="Value of the block.")
     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.", alias="name")
-    template: bool = Field(False, description="Whether the block is a template (e.g. saved human/persona options).")
+    is_template: bool = Field(False, description="Whether the block is a template (e.g. saved human/persona options).")
 
     # context window label
-    label: str = Field(None, description="Label of the block (e.g. 'human', 'persona') in the context window.")
+    label: Optional[str] = Field(None, description="Label of the block (e.g. 'human', 'persona') in the context window.")
 
     # metadata
     description: Optional[str] = Field(None, description="Description of the block.")
     metadata_: Optional[dict] = Field({}, description="Metadata of the block.")
 
-    # associated user/agent
-    user_id: Optional[str] = Field(None, description="The unique identifier of the user associated with the block.")
-
     @model_validator(mode="after")
     def verify_char_limit(self) -> Self:
-        try:
-            assert len(self) <= self.limit
-        except AssertionError:
-            error_msg = f"Edit failed: Exceeds {self.limit} character limit (requested {len(self)}) - {str(self)}."
+        if len(self.value) > self.limit:
+            error_msg = f"Edit failed: Exceeds {self.limit} character limit (requested {len(self.value)}) - {str(self)}."
             raise ValueError(error_msg)
-        except Exception as e:
-            raise e
+
         return self
 
-    def __len__(self):
-        return len(self.value)
+    # def __len__(self):
+    #     return len(self.value)
 
     def __setattr__(self, name, value):
         """Run validation if self.value is updated"""
@@ -52,6 +46,9 @@ class BaseBlock(LettaBase, validate_assignment=True):
             # run validation
             self.__class__.model_validate(self.model_dump(exclude_unset=True))
 
+    class Config:
+        extra = "ignore"  # Ignores extra fields
+
 
 class Block(BaseBlock):
     """
@@ -61,15 +58,22 @@ class Block(BaseBlock):
         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.
+        is_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.
         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.
         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.
     """
 
     id: str = BaseBlock.generate_id_field()
-    value: str = Field(..., description="Value of the block.")
+
+    # associated user/agent
+    organization_id: Optional[str] = Field(None, description="The unique identifier of the organization associated with the block.")
+
+    # default orm fields
+    created_by_id: Optional[str] = Field(None, description="The id of the user that made this Block.")
+    last_updated_by_id: Optional[str] = Field(None, description="The id of the user that last updated this Block.")
 
 
 class Human(Block):
@@ -84,41 +88,42 @@ class Persona(Block):
     label: str = "persona"
 
 
-class CreateBlock(BaseBlock):
+class BlockCreate(BaseBlock):
     """Create a block"""
 
-    template: bool = True
+    is_template: bool = True
     label: str = Field(..., description="Label of the block.")
 
 
-class CreatePersona(BaseBlock):
+class CreatePersona(BlockCreate):
     """Create a persona block"""
 
-    template: bool = True
     label: str = "persona"
 
 
-class CreateHuman(BaseBlock):
+class CreateHuman(BlockCreate):
     """Create a human block"""
 
-    template: bool = True
     label: str = "human"
 
 
-class UpdateBlock(BaseBlock):
+class BlockUpdate(BaseBlock):
     """Update a block"""
 
-    id: str = Field(..., description="The unique identifier of the block.")
     limit: Optional[int] = Field(2000, description="Character limit of the block.")
+    value: Optional[str] = Field(None, description="Value of the block.")
+
+    class Config:
+        extra = "ignore"  # Ignores extra fields
 
 
-class UpdatePersona(UpdateBlock):
+class UpdatePersona(BlockUpdate):
     """Update a persona block"""
 
     label: str = "persona"
 
 
-class UpdateHuman(UpdateBlock):
+class UpdateHuman(BlockUpdate):
     """Update a human block"""
 
     label: str = "human"

letta/schemas/letta_base.py

@@ -77,6 +77,6 @@ class LettaBase(BaseModel):
         """
         _ = values  # for SCA
         if isinstance(v, UUID):
-            logger.warning("Bare UUIDs are deprecated, please use the full prefixed id!")
+            logger.warning(f"Bare UUIDs are deprecated, please use the full prefixed id ({cls.__id_prefix__})!")
             return f"{cls.__id_prefix__}-{v}"
         return v

letta/schemas/llm_config.py

@@ -35,6 +35,7 @@ class LLMConfig(BaseModel):
         "vllm",
         "hugging-face",
         "mistral",
+        "together",  # completions endpoint
     ] = Field(..., description="The endpoint type for the model.")
     model_endpoint: Optional[str] = Field(None, description="The endpoint for the model.")
     model_wrapper: Optional[str] = Field(None, description="The wrapper for the model.")

letta/schemas/openai/chat_completion_response.py

@@ -46,6 +46,7 @@ class Choice(BaseModel):
     index: int
     message: Message
     logprobs: Optional[Dict[str, Union[List[MessageContentLogProb], None]]] = None
+    seed: Optional[int] = None  # found in TogetherAI
 
 
 class UsageStatistics(BaseModel):