letta-nightly 0.4.1.dev20241004104123__py3-none-any.whl → 0.4.1.dev20241005104008__py3-none-any.whl

letta/client/client.py

@@ -272,6 +272,8 @@ class RESTClient(AbstractClient):
         token: str,
         api_prefix: str = "v1",
         debug: bool = False,
+        default_llm_config: Optional[LLMConfig] = None,
+        default_embedding_config: Optional[EmbeddingConfig] = None,
     ):
         """
         Initializes a new instance of Client class.
@@ -280,11 +282,14 @@ class RESTClient(AbstractClient):
             auto_save (bool): Whether to automatically save changes.
             user_id (str): The user ID.
             debug (bool): Whether to print debug information.
+            default
         """
         super().__init__(debug=debug)
         self.base_url = base_url
         self.api_prefix = api_prefix
         self.headers = {"accept": "application/json", "authorization": f"Bearer {token}"}
+        self._default_llm_config = default_llm_config
+        self._default_embedding_config = default_embedding_config
 
     def list_agents(self) -> List[AgentState]:
         response = requests.get(f"{self.base_url}/{self.api_prefix}/agents", headers=self.headers)
@@ -315,8 +320,8 @@ class RESTClient(AbstractClient):
         self,
         name: Optional[str] = None,
         # model configs
-        embedding_config: Optional[EmbeddingConfig] = None,
-        llm_config: Optional[LLMConfig] = None,
+        embedding_config: EmbeddingConfig = None,
+        llm_config: LLMConfig = None,
         # memory
         memory: Memory = ChatMemory(human=get_human_text(DEFAULT_HUMAN), persona=get_persona_text(DEFAULT_PERSONA)),
         # system
@@ -364,6 +369,10 @@ class RESTClient(AbstractClient):
             tool = self.create_tool(func, name=func_name, tags=["memory", "letta-base"], update=True)
             tool_names.append(tool.name)
 
+        # check if default configs are provided
+        assert embedding_config or self._default_embedding_config, f"Embedding config must be provided"
+        assert llm_config or self._default_llm_config, f"LLM config must be provided"
+
         # create agent
         request = CreateAgent(
             name=name,
@@ -372,8 +381,8 @@ class RESTClient(AbstractClient):
             memory=memory,
             tools=tool_names,
             system=system,
-            llm_config=llm_config,
-            embedding_config=embedding_config,
+            llm_config=llm_config if llm_config else self._default_llm_config,
+            embedding_config=embedding_config if embedding_config else self._default_embedding_config,
         )
 
         response = requests.post(f"{self.base_url}/{self.api_prefix}/agents", json=request.model_dump(), headers=self.headers)
@@ -1326,6 +1335,48 @@ class RESTClient(AbstractClient):
             raise ValueError(f"Failed to get tool: {response.text}")
         return response.json()
 
+    def set_default_llm_config(self, llm_config: LLMConfig):
+        """
+        Set the default LLM configuration
+
+        Args:
+            llm_config (LLMConfig): LLM configuration
+        """
+        self._default_llm_config = llm_config
+
+    def set_default_embedding_config(self, embedding_config: EmbeddingConfig):
+        """
+        Set the default embedding configuration
+
+        Args:
+            embedding_config (EmbeddingConfig): Embedding configuration
+        """
+        self._default_embedding_config = embedding_config
+
+    def list_llm_configs(self) -> List[LLMConfig]:
+        """
+        List available LLM configurations
+
+        Returns:
+            configs (List[LLMConfig]): List of LLM configurations
+        """
+        response = requests.get(f"{self.base_url}/{self.api_prefix}/models", headers=self.headers)
+        if response.status_code != 200:
+            raise ValueError(f"Failed to list LLM configs: {response.text}")
+        return [LLMConfig(**config) for config in response.json()]
+
+    def list_embedding_configs(self) -> List[EmbeddingConfig]:
+        """
+        List available embedding configurations
+
+        Returns:
+            configs (List[EmbeddingConfig]): List of embedding configurations
+        """
+        response = requests.get(f"{self.base_url}/{self.api_prefix}/models/embedding", headers=self.headers)
+        if response.status_code != 200:
+            raise ValueError(f"Failed to list embedding configs: {response.text}")
+        return [EmbeddingConfig(**config) for config in response.json()]
+
 
 class LocalClient(AbstractClient):
     """
@@ -1344,6 +1395,8 @@ class LocalClient(AbstractClient):
         auto_save: bool = False,
         user_id: Optional[str] = None,
         debug: bool = False,
+        default_llm_config: Optional[LLMConfig] = None,
+        default_embedding_config: Optional[EmbeddingConfig] = None,
     ):
         """
         Initializes a new instance of Client class.
@@ -1359,6 +1412,11 @@ class LocalClient(AbstractClient):
         letta.utils.DEBUG = debug
         logging.getLogger().setLevel(logging.CRITICAL)
 
+        # save default model config
+        self._default_llm_config = default_llm_config
+        self._default_embedding_config = default_embedding_config
+
+        # create server
         self.interface = QueuingInterface(debug=debug)
         self.server = SyncServer(default_interface_factory=lambda: self.interface)
 
@@ -1405,8 +1463,8 @@ class LocalClient(AbstractClient):
         self,
         name: Optional[str] = None,
         # model configs
-        embedding_config: Optional[EmbeddingConfig] = None,
-        llm_config: Optional[LLMConfig] = None,
+        embedding_config: EmbeddingConfig = None,
+        llm_config: LLMConfig = None,
         # memory
         memory: Memory = ChatMemory(human=get_human_text(DEFAULT_HUMAN), persona=get_persona_text(DEFAULT_PERSONA)),
         # system
@@ -1453,6 +1511,10 @@ class LocalClient(AbstractClient):
 
         self.interface.clear()
 
+        # check if default configs are provided
+        assert embedding_config or self._default_embedding_config, f"Embedding config must be provided"
+        assert llm_config or self._default_llm_config, f"LLM config must be provided"
+
         # create agent
         agent_state = self.server.create_agent(
             CreateAgent(
@@ -1462,8 +1524,8 @@ class LocalClient(AbstractClient):
                 memory=memory,
                 tools=tool_names,
                 system=system,
-                llm_config=llm_config,
-                embedding_config=embedding_config,
+                llm_config=llm_config if llm_config else self._default_llm_config,
+                embedding_config=embedding_config if embedding_config else self._default_embedding_config,
             ),
             user_id=self.user_id,
         )
@@ -1592,7 +1654,7 @@ class LocalClient(AbstractClient):
     # memory
     def get_in_context_memory(self, agent_id: str) -> Memory:
         """
-        Get the in-contxt (i.e. core) memory of an agent
+        Get the in-context (i.e. core) memory of an agent
 
         Args:
             agent_id (str): ID of the agent
@@ -2363,7 +2425,37 @@ class LocalClient(AbstractClient):
         return self.server.delete_block(id)
 
     def set_default_llm_config(self, llm_config: LLMConfig):
-        self.server.server_llm_config = llm_config
+        """
+        Set the default LLM configuration for agents.
+
+        Args:
+            llm_config (LLMConfig): LLM configuration
+        """
+        self._default_llm_config = llm_config
 
     def set_default_embedding_config(self, embedding_config: EmbeddingConfig):
-        self.server.server_embedding_config = embedding_config
+        """
+        Set the default embedding configuration for agents.
+
+        Args:
+            embedding_config (EmbeddingConfig): Embedding configuration
+        """
+        self._default_embedding_config = embedding_config
+
+    def list_llm_configs(self) -> List[LLMConfig]:
+        """
+        List available LLM configurations
+
+        Returns:
+            configs (List[LLMConfig]): List of LLM configurations
+        """
+        return self.server.list_llm_models()
+
+    def list_embedding_configs(self) -> List[EmbeddingConfig]:
+        """
+        List available embedding configurations
+
+        Returns:
+            configs (List[EmbeddingConfig]): List of embedding configurations
+        """
+        return self.server.list_embedding_models()

letta/config.py

@@ -55,10 +55,10 @@ class LettaConfig:
     human: str = DEFAULT_HUMAN
 
     # model parameters
-    default_llm_config: LLMConfig = None
+    # default_llm_config: LLMConfig = None
 
     # embedding parameters
-    default_embedding_config: EmbeddingConfig = None
+    # default_embedding_config: EmbeddingConfig = None
 
     # NONE OF THIS IS CONFIG ↓↓↓↓↓
     # @norton120 these are the metdadatastore
@@ -130,42 +130,42 @@ class LettaConfig:
             # read existing config
             config.read(config_path)
 
-            # Handle extraction of nested LLMConfig and EmbeddingConfig
-            llm_config_dict = {
-                # Extract relevant LLM configuration from the config file
-                "model": get_field(config, "model", "model"),
-                "model_endpoint": get_field(config, "model", "model_endpoint"),
-                "model_endpoint_type": get_field(config, "model", "model_endpoint_type"),
-                "model_wrapper": get_field(config, "model", "model_wrapper"),
-                "context_window": get_field(config, "model", "context_window"),
-            }
-            embedding_config_dict = {
-                # Extract relevant Embedding configuration from the config file
-                "embedding_endpoint": get_field(config, "embedding", "embedding_endpoint"),
-                "embedding_model": get_field(config, "embedding", "embedding_model"),
-                "embedding_endpoint_type": get_field(config, "embedding", "embedding_endpoint_type"),
-                "embedding_dim": get_field(config, "embedding", "embedding_dim"),
-                "embedding_chunk_size": get_field(config, "embedding", "embedding_chunk_size"),
-            }
-            # Remove null values
-            llm_config_dict = {k: v for k, v in llm_config_dict.items() if v is not None}
-            embedding_config_dict = {k: v for k, v in embedding_config_dict.items() if v is not None}
+            ## Handle extraction of nested LLMConfig and EmbeddingConfig
+            # llm_config_dict = {
+            #    # Extract relevant LLM configuration from the config file
+            #    "model": get_field(config, "model", "model"),
+            #    "model_endpoint": get_field(config, "model", "model_endpoint"),
+            #    "model_endpoint_type": get_field(config, "model", "model_endpoint_type"),
+            #    "model_wrapper": get_field(config, "model", "model_wrapper"),
+            #    "context_window": get_field(config, "model", "context_window"),
+            # }
+            # embedding_config_dict = {
+            #    # Extract relevant Embedding configuration from the config file
+            #    "embedding_endpoint": get_field(config, "embedding", "embedding_endpoint"),
+            #    "embedding_model": get_field(config, "embedding", "embedding_model"),
+            #    "embedding_endpoint_type": get_field(config, "embedding", "embedding_endpoint_type"),
+            #    "embedding_dim": get_field(config, "embedding", "embedding_dim"),
+            #    "embedding_chunk_size": get_field(config, "embedding", "embedding_chunk_size"),
+            # }
+            ## Remove null values
+            # llm_config_dict = {k: v for k, v in llm_config_dict.items() if v is not None}
+            # embedding_config_dict = {k: v for k, v in embedding_config_dict.items() if v is not None}
             # Correct the types that aren't strings
-            if "context_window" in llm_config_dict and llm_config_dict["context_window"] is not None:
-                llm_config_dict["context_window"] = int(llm_config_dict["context_window"])
-            if "embedding_dim" in embedding_config_dict and embedding_config_dict["embedding_dim"] is not None:
-                embedding_config_dict["embedding_dim"] = int(embedding_config_dict["embedding_dim"])
-            if "embedding_chunk_size" in embedding_config_dict and embedding_config_dict["embedding_chunk_size"] is not None:
-                embedding_config_dict["embedding_chunk_size"] = int(embedding_config_dict["embedding_chunk_size"])
-            # Construct the inner properties
-            llm_config = LLMConfig(**llm_config_dict)
-            embedding_config = EmbeddingConfig(**embedding_config_dict)
+            # if "context_window" in llm_config_dict and llm_config_dict["context_window"] is not None:
+            #    llm_config_dict["context_window"] = int(llm_config_dict["context_window"])
+            # if "embedding_dim" in embedding_config_dict and embedding_config_dict["embedding_dim"] is not None:
+            #    embedding_config_dict["embedding_dim"] = int(embedding_config_dict["embedding_dim"])
+            # if "embedding_chunk_size" in embedding_config_dict and embedding_config_dict["embedding_chunk_size"] is not None:
+            #    embedding_config_dict["embedding_chunk_size"] = int(embedding_config_dict["embedding_chunk_size"])
+            ## Construct the inner properties
+            # llm_config = LLMConfig(**llm_config_dict)
+            # embedding_config = EmbeddingConfig(**embedding_config_dict)
 
             # Everything else
             config_dict = {
                 # Two prepared configs
-                "default_llm_config": llm_config,
-                "default_embedding_config": embedding_config,
+                # "default_llm_config": llm_config,
+                # "default_embedding_config": embedding_config,
                 # Agent related
                 "preset": get_field(config, "defaults", "preset"),
                 "persona": get_field(config, "defaults", "persona"),
@@ -212,53 +212,53 @@ class LettaConfig:
         set_field(config, "defaults", "human", self.human)
 
         # model defaults
-        set_field(config, "model", "model", self.default_llm_config.model)
-        set_field(config, "model", "model_endpoint", self.default_llm_config.model_endpoint)
-        set_field(
-            config,
-            "model",
-            "model_endpoint_type",
-            self.default_llm_config.model_endpoint_type,
-        )
-        set_field(config, "model", "model_wrapper", self.default_llm_config.model_wrapper)
-        set_field(
-            config,
-            "model",
-            "context_window",
-            str(self.default_llm_config.context_window),
-        )
-
-        # embeddings
-        set_field(
-            config,
-            "embedding",
-            "embedding_endpoint_type",
-            self.default_embedding_config.embedding_endpoint_type,
-        )
-        set_field(
-            config,
-            "embedding",
-            "embedding_endpoint",
-            self.default_embedding_config.embedding_endpoint,
-        )
-        set_field(
-            config,
-            "embedding",
-            "embedding_model",
-            self.default_embedding_config.embedding_model,
-        )
-        set_field(
-            config,
-            "embedding",
-            "embedding_dim",
-            str(self.default_embedding_config.embedding_dim),
-        )
-        set_field(
-            config,
-            "embedding",
-            "embedding_chunk_size",
-            str(self.default_embedding_config.embedding_chunk_size),
-        )
+        # set_field(config, "model", "model", self.default_llm_config.model)
+        ##set_field(config, "model", "model_endpoint", self.default_llm_config.model_endpoint)
+        # set_field(
+        #    config,
+        #    "model",
+        #    "model_endpoint_type",
+        #    self.default_llm_config.model_endpoint_type,
+        # )
+        # set_field(config, "model", "model_wrapper", self.default_llm_config.model_wrapper)
+        # set_field(
+        #    config,
+        #    "model",
+        #    "context_window",
+        #    str(self.default_llm_config.context_window),
+        # )
+
+        ## embeddings
+        # set_field(
+        #    config,
+        #    "embedding",
+        #    "embedding_endpoint_type",
+        #    self.default_embedding_config.embedding_endpoint_type,
+        # )
+        # set_field(
+        #    config,
+        #    "embedding",
+        #    "embedding_endpoint",
+        #    self.default_embedding_config.embedding_endpoint,
+        # )
+        # set_field(
+        #    config,
+        #    "embedding",
+        #    "embedding_model",
+        #    self.default_embedding_config.embedding_model,
+        # )
+        # set_field(
+        #    config,
+        #    "embedding",
+        #    "embedding_dim",
+        #    str(self.default_embedding_config.embedding_dim),
+        # )
+        # set_field(
+        #    config,
+        #    "embedding",
+        #    "embedding_chunk_size",
+        #    str(self.default_embedding_config.embedding_chunk_size),
+        # )
 
         # archival storage
         set_field(config, "archival_storage", "type", self.archival_storage_type)

letta/constants.py

@@ -46,6 +46,12 @@ BASE_TOOLS = [
     "archival_memory_search",
 ]
 
+# The name of the tool used to send message to the user
+# May not be relevant in cases where the agent has multiple ways to message to user (send_imessage, send_discord_mesasge, ...)
+# or in cases where the agent has no concept of messaging a user (e.g. a workflow agent)
+DEFAULT_MESSAGE_TOOL = "send_message"
+DEFAULT_MESSAGE_TOOL_KWARG = "message"
+
 # LOGGER_LOG_LEVEL is use to convert Text to Logging level value for logging mostly for Cli input to setting level
 LOGGER_LOG_LEVELS = {"CRITICAL": CRITICAL, "ERROR": ERROR, "WARN": WARN, "WARNING": WARNING, "INFO": INFO, "DEBUG": DEBUG, "NOTSET": NOTSET}
 

letta/credentials.py

@@ -23,7 +23,7 @@ class LettaCredentials:
     google_ai_service_endpoint: Optional[str] = None
 
     # anthropic config
-    anthropic_key: Optional[str] = None
+    anthropic_key: Optional[str] = os.getenv("ANTHROPIC_API_KEY")
 
     # cohere config
     cohere_key: Optional[str] = None
@@ -31,6 +31,10 @@ class LettaCredentials:
     # azure config
     azure_auth_type: str = "api_key"
     azure_key: Optional[str] = None
+
+    # groq config
+    groq_key: Optional[str] = os.getenv("GROQ_API_KEY")
+
     # base llm / model
     azure_version: Optional[str] = None
     azure_endpoint: Optional[str] = None
@@ -77,6 +81,8 @@ class LettaCredentials:
                 "anthropic_key": get_field(config, "anthropic", "key"),
                 # cohere
                 "cohere_key": get_field(config, "cohere", "key"),
+                # groq
+                "groq_key": get_field(config, "groq", "key"),
                 # open llm
                 "openllm_auth_type": get_field(config, "openllm", "auth_type"),
                 "openllm_key": get_field(config, "openllm", "key"),
@@ -119,6 +125,9 @@ class LettaCredentials:
         # cohere
         set_field(config, "cohere", "key", self.cohere_key)
 
+        # groq
+        set_field(config, "groq", "key", self.groq_key)
+
         # openllm config
         set_field(config, "openllm", "auth_type", self.openllm_auth_type)
         set_field(config, "openllm", "key", self.openllm_key)

letta/errors.py

@@ -1,8 +1,20 @@
-class LLMError(Exception):
-    """Base class for all LLM-related errors."""
+import json
+from typing import TYPE_CHECKING, List, Optional, Union
 
+# Avoid circular imports
+if TYPE_CHECKING:
+    from letta.schemas.message import Message
 
-class LLMJSONParsingError(LLMError):
+
+class LettaError(Exception):
+    """Base class for all Letta related errors."""
+
+
+class LLMError(LettaError):
+    pass
+
+
+class LLMJSONParsingError(LettaError):
     """Exception raised for errors in the JSON parsing process."""
 
     def __init__(self, message="Error parsing JSON generated by LLM"):
@@ -10,7 +22,7 @@ class LLMJSONParsingError(LLMError):
         super().__init__(self.message)
 
 
-class LocalLLMError(LLMError):
+class LocalLLMError(LettaError):
     """Generic catch-all error for local LLM problems"""
 
     def __init__(self, message="Encountered an error while running local LLM"):
@@ -18,9 +30,55 @@ class LocalLLMError(LLMError):
         super().__init__(self.message)
 
 
-class LocalLLMConnectionError(LLMError):
+class LocalLLMConnectionError(LettaError):
     """Error for when local LLM cannot be reached with provided IP/port"""
 
     def __init__(self, message="Could not connect to local LLM"):
         self.message = message
         super().__init__(self.message)
+
+
+class LettaMessageError(LettaError):
+    """Base error class for handling message-related errors."""
+
+    messages: List[Union["Message", "LettaMessage"]]
+    default_error_message: str = "An error occurred with the message."
+
+    def __init__(self, *, messages: List[Union["Message", "LettaMessage"]], explanation: Optional[str] = None) -> None:
+        error_msg = self.construct_error_message(messages, self.default_error_message, explanation)
+        super().__init__(error_msg)
+        self.messages = messages
+
+    @staticmethod
+    def construct_error_message(messages: List[Union["Message", "LettaMessage"]], error_msg: str, explanation: Optional[str] = None) -> str:
+        """Helper method to construct a clean and formatted error message."""
+        if explanation:
+            error_msg += f" (Explanation: {explanation})"
+
+        # Pretty print out message JSON
+        message_json = json.dumps([message.model_dump_json(indent=4) for message in messages], indent=4)
+        return f"{error_msg}\n\n{message_json}"
+
+
+class MissingFunctionCallError(LettaMessageError):
+    """Error raised when a message is missing a function call."""
+
+    default_error_message = "The message is missing a function call."
+
+
+class InvalidFunctionCallError(LettaMessageError):
+    """Error raised when a message uses an invalid function call."""
+
+    default_error_message = "The message uses an invalid function call or has improper usage of a function call."
+
+
+class MissingInnerMonologueError(LettaMessageError):
+    """Error raised when a message is missing an inner monologue."""
+
+    default_error_message = "The message is missing an inner monologue."
+
+
+class InvalidInnerMonologueError(LettaMessageError):
+    """Error raised when a message has a malformed inner monologue."""
+
+    default_error_message = "The message has a malformed inner monologue."