letta-nightly 0.1.7.dev20241001104147__tar.gz → 0.1.7.dev20241003104113__tar.gz

{letta_nightly-0.1.7.dev20241001104147 → letta_nightly-0.1.7.dev20241003104113}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: letta-nightly
-Version: 0.1.7.dev20241001104147
+Version: 0.1.7.dev20241003104113
 Summary: Create LLM agents with long-term memory and custom tools
 License: Apache License
 Author: Letta Team
@@ -12,8 +12,8 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Provides-Extra: autogen
-Provides-Extra: crewai-tools
 Provides-Extra: dev
+Provides-Extra: external-tools
 Provides-Extra: milvus
 Provides-Extra: ollama
 Provides-Extra: postgres
@@ -23,11 +23,13 @@ Provides-Extra: tests
 Requires-Dist: autoflake (>=2.3.0,<3.0.0) ; extra == "dev"
 Requires-Dist: black[jupyter] (>=24.2.0,<25.0.0) ; extra == "dev"
 Requires-Dist: chromadb (>=0.4.24,<0.5.0)
-Requires-Dist: crewai (>=0.41.1,<0.42.0) ; extra == "crewai-tools"
-Requires-Dist: crewai-tools (>=0.8.3,<0.9.0) ; extra == "crewai-tools"
+Requires-Dist: composio-core (>=0.5.28,<0.6.0) ; extra == "external-tools"
+Requires-Dist: composio-langchain (>=0.5.28,<0.6.0) ; extra == "external-tools"
+Requires-Dist: crewai (>=0.41.1,<0.42.0) ; extra == "external-tools"
+Requires-Dist: crewai-tools (>=0.8.3,<0.9.0) ; extra == "external-tools"
 Requires-Dist: datasets (>=2.14.6,<3.0.0) ; extra == "dev"
 Requires-Dist: demjson3 (>=3.0.6,<4.0.0)
-Requires-Dist: docker (>=7.1.0,<8.0.0) ; extra == "crewai-tools"
+Requires-Dist: docker (>=7.1.0,<8.0.0) ; extra == "external-tools"
 Requires-Dist: docstring-parser (>=0.16,<0.17)
 Requires-Dist: docx2txt (>=0.8,<0.9)
 Requires-Dist: fastapi (>=0.104.1,<0.105.0) ; extra == "server"
@@ -36,6 +38,8 @@ Requires-Dist: httpx (>=0.27.2,<0.28.0)
 Requires-Dist: httpx-sse (>=0.4.0,<0.5.0)
 Requires-Dist: isort (>=5.13.2,<6.0.0) ; extra == "dev"
 Requires-Dist: jinja2 (>=3.1.4,<4.0.0)
+Requires-Dist: langchain (>=0.2.16,<0.3.0) ; extra == "external-tools"
+Requires-Dist: langchain-community (>=0.2.17,<0.3.0) ; extra == "external-tools"
 Requires-Dist: llama-index (>=0.11.9,<0.12.0)
 Requires-Dist: llama-index-embeddings-ollama (>=0.3.1,<0.4.0) ; extra == "ollama"
 Requires-Dist: llama-index-embeddings-openai (>=0.2.5,<0.3.0)
@@ -70,7 +74,7 @@ Requires-Dist: tqdm (>=4.66.1,<5.0.0)
 Requires-Dist: typer[all] (>=0.9.0,<0.10.0)
 Requires-Dist: uvicorn (>=0.24.0.post1,<0.25.0) ; extra == "server"
 Requires-Dist: websockets (>=12.0,<13.0) ; extra == "server"
-Requires-Dist: wikipedia (>=1.4.0,<2.0.0) ; extra == "tests"
+Requires-Dist: wikipedia (>=1.4.0,<2.0.0) ; extra == "external-tools" or extra == "tests"
 Description-Content-Type: text/markdown
 
 # Letta (previously MemGPT)
@@ -79,13 +83,13 @@ Description-Content-Type: text/markdown
 [![arxiv 2310.08560](https://img.shields.io/badge/arXiv-2310.08560-B31B1B?logo=arxiv&style=flat-square)](https://arxiv.org/abs/2310.08560)
 
 > [!NOTE]
-> **Looking for MemGPT?**
+> **Looking for MemGPT?** You're in the right place!
 >
-> The MemGPT package and Docker image have been renamed to `letta` to clarify the distinction between **MemGPT agents** and the API server / runtime that runs LLM agents as *services*.
+> The MemGPT package and Docker image have been renamed to `letta` to clarify the distinction between MemGPT agents and the API server / runtime that runs LLM agents as *services*.
 >
-> You use the **Letta framework** to create **MemGPT agents**. Read more about the relationship between MemGPT and Letta [here](https://www.letta.com/blog/memgpt-and-letta).
+> You use the **Letta _framework_** to create **MemGPT _agents_**. Read more about the relationship between MemGPT and Letta [here](https://www.letta.com/blog/memgpt-and-letta).
 
-See [documentation](https://docs.letta.com/introduction) for setup and usage.
+Visit our [documentation page](https://docs.letta.com) for information on setup and usage.
 
 ## How to Get Involved
 * **Contribute to the Project**: Interested in contributing? Start by reading our [Contribution Guidelines](https://github.com/cpacker/MemGPT/tree/main/CONTRIBUTING.md).

{letta_nightly-0.1.7.dev20241001104147 → letta_nightly-0.1.7.dev20241003104113}/README.md

@@ -4,13 +4,13 @@
 [![arxiv 2310.08560](https://img.shields.io/badge/arXiv-2310.08560-B31B1B?logo=arxiv&style=flat-square)](https://arxiv.org/abs/2310.08560)
 
 > [!NOTE]
-> **Looking for MemGPT?**
+> **Looking for MemGPT?** You're in the right place!
 >
-> The MemGPT package and Docker image have been renamed to `letta` to clarify the distinction between **MemGPT agents** and the API server / runtime that runs LLM agents as *services*.
+> The MemGPT package and Docker image have been renamed to `letta` to clarify the distinction between MemGPT agents and the API server / runtime that runs LLM agents as *services*.
 >
-> You use the **Letta framework** to create **MemGPT agents**. Read more about the relationship between MemGPT and Letta [here](https://www.letta.com/blog/memgpt-and-letta).
+> You use the **Letta _framework_** to create **MemGPT _agents_**. Read more about the relationship between MemGPT and Letta [here](https://www.letta.com/blog/memgpt-and-letta).
 
-See [documentation](https://docs.letta.com/introduction) for setup and usage.
+Visit our [documentation page](https://docs.letta.com) for information on setup and usage.
 
 ## How to Get Involved
 * **Contribute to the Project**: Interested in contributing? Start by reading our [Contribution Guidelines](https://github.com/cpacker/MemGPT/tree/main/CONTRIBUTING.md).

{letta_nightly-0.1.7.dev20241001104147 → letta_nightly-0.1.7.dev20241003104113}/letta/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.1.17"
+__version__ = "0.1.7"
 
 # import clients
 from letta.client.admin import Admin

{letta_nightly-0.1.7.dev20241001104147 → letta_nightly-0.1.7.dev20241003104113}/letta/agent.py

@@ -237,10 +237,8 @@ class Agent(BaseAgent):
         self.agent_state = agent_state
         assert isinstance(self.agent_state.memory, Memory), f"Memory object is not of type Memory: {type(self.agent_state.memory)}"
 
-        try:
-            self.link_tools(tools)
-        except Exception as e:
-            raise ValueError(f"Encountered an error while trying to link agent tools during initialization:\n{str(e)}")
+        # link tools
+        self.link_tools(tools)
 
         # gpt-4, gpt-3.5-turbo, ...
         self.model = self.agent_state.llm_config.model
@@ -345,16 +343,18 @@ class Agent(BaseAgent):
         env = {}
         env.update(globals())
         for tool in tools:
-            # WARNING: name may not be consistent?
-            if tool.module:  # execute the whole module
-                exec(tool.module, env)
-            else:
-                exec(tool.source_code, env)
-            from pprint import pprint
+            try:
+                # WARNING: name may not be consistent?
+                if tool.module:  # execute the whole module
+                    exec(tool.module, env)
+                else:
+                    exec(tool.source_code, env)
 
-            pprint(tool.json_schema)
-            self.functions_python[tool.name] = env[tool.json_schema["name"]]
-            self.functions.append(tool.json_schema)
+                self.functions_python[tool.json_schema["name"]] = env[tool.json_schema["name"]]
+                self.functions.append(tool.json_schema)
+            except Exception as e:
+                warnings.warn(f"WARNING: tool {tool.name} failed to link")
+                print(e)
         assert all([callable(f) for k, f in self.functions_python.items()]), self.functions_python
 
     def _load_messages_from_recall(self, message_ids: List[str]) -> List[Message]:
@@ -551,18 +551,19 @@ class Agent(BaseAgent):
             )  # extend conversation with assistant's reply
             printd(f"Function call message: {messages[-1]}")
 
-            # The content if then internal monologue, not chat
-            self.interface.internal_monologue(response_message.content, msg_obj=messages[-1])
+            if response_message.content:
+                # The content if then internal monologue, not chat
+                self.interface.internal_monologue(response_message.content, msg_obj=messages[-1])
 
             # Step 3: call the function
             # Note: the JSON response may not always be valid; be sure to handle errors
-
-            # Failure case 1: function name is wrong
             function_call = (
                 response_message.function_call if response_message.function_call is not None else response_message.tool_calls[0].function
             )
             function_name = function_call.name
             printd(f"Request to call function {function_name} with tool_call_id: {tool_call_id}")
+
+            # Failure case 1: function name is wrong
             try:
                 function_to_call = self.functions_python[function_name]
             except KeyError:
@@ -1117,48 +1118,10 @@ class Agent(BaseAgent):
     def add_function(self, function_name: str) -> str:
         # TODO: refactor
         raise NotImplementedError
-        # if function_name in self.functions_python.keys():
-        #    msg = f"Function {function_name} already loaded"
-        #    printd(msg)
-        #    return msg
-
-        # available_functions = load_all_function_sets()
-        # if function_name not in available_functions.keys():
-        #    raise ValueError(f"Function {function_name} not found in function library")
-
-        # self.functions.append(available_functions[function_name]["json_schema"])
-        # self.functions_python[function_name] = available_functions[function_name]["python_function"]
-
-        # msg = f"Added function {function_name}"
-        ## self.save()
-        # self.update_state()
-        # printd(msg)
-        # return msg
 
     def remove_function(self, function_name: str) -> str:
         # TODO: refactor
         raise NotImplementedError
-        # if function_name not in self.functions_python.keys():
-        #    msg = f"Function {function_name} not loaded, ignoring"
-        #    printd(msg)
-        #    return msg
-
-        ## only allow removal of user defined functions
-        # user_func_path = Path(USER_FUNCTIONS_DIR)
-        # func_path = Path(inspect.getfile(self.functions_python[function_name]))
-        # is_subpath = func_path.resolve().parts[: len(user_func_path.resolve().parts)] == user_func_path.resolve().parts
-
-        # if not is_subpath:
-        #    raise ValueError(f"Function {function_name} is not user defined and cannot be removed")
-
-        # self.functions = [f_schema for f_schema in self.functions if f_schema["name"] != function_name]
-        # self.functions_python.pop(function_name)
-
-        # msg = f"Removed function {function_name}"
-        ## self.save()
-        # self.update_state()
-        # printd(msg)
-        # return msg
 
     def update_state(self) -> AgentState:
         message_ids = [msg.id for msg in self._messages]

{letta_nightly-0.1.7.dev20241001104147 → letta_nightly-0.1.7.dev20241003104113}/letta/client/client.py

@@ -1562,7 +1562,7 @@ class LocalClient(AbstractClient):
 
     def get_agent(self, agent_id: str) -> AgentState:
         """
-        Get an agent's state by it's ID.
+        Get an agent's state by its ID.
 
         Args:
             agent_id (str): ID of the agent

{letta_nightly-0.1.7.dev20241001104147 → letta_nightly-0.1.7.dev20241003104113}/letta/functions/functions.py

@@ -1,17 +1,12 @@
 import importlib
 import inspect
 import os
-import sys
 from textwrap import dedent  # remove indentation
 from types import ModuleType
 
-from letta.constants import CLI_WARNING_PREFIX, LETTA_DIR
+from letta.constants import CLI_WARNING_PREFIX
 from letta.functions.schema_generator import generate_schema
 
-USER_FUNCTIONS_DIR = os.path.join(LETTA_DIR, "functions")
-
-sys.path.append(USER_FUNCTIONS_DIR)
-
 
 def parse_source_code(func) -> str:
     """Parse the source code of a function and remove indendation"""
@@ -68,24 +63,6 @@ def validate_function(module_name, module_full_path):
     return True, None
 
 
-def write_function(module_name: str, function_name: str, function_code: str):
-    """Write a function to a file in the user functions directory"""
-    # Create the user functions directory if it doesn't exist
-    if not os.path.exists(USER_FUNCTIONS_DIR):
-        os.makedirs(USER_FUNCTIONS_DIR)
-
-    # Write the function to a file
-    file_path = os.path.join(USER_FUNCTIONS_DIR, f"{module_name}.py")
-    with open(file_path, "w", encoding="utf-8") as f:
-        f.write(function_code)
-    succ, error = validate_function(module_name, file_path)
-
-    # raise error if function cannot be loaded
-    if not succ:
-        raise ValueError(error)
-    return file_path
-
-
 def load_function_file(filepath: str) -> dict:
     file = os.path.basename(filepath)
     module_name = file[:-3]  # Remove '.py' from filename

{letta_nightly-0.1.7.dev20241001104147 → letta_nightly-0.1.7.dev20241003104113}/letta/functions/helpers.py

@@ -3,21 +3,40 @@ from typing import Any, Optional, Union
 from pydantic import BaseModel
 
 
-def generate_langchain_tool_wrapper(tool: "LangChainBaseTool", additional_imports_module_attr_map: dict = None) -> tuple[str, str]:
+def generate_composio_tool_wrapper(action: "ActionType") -> tuple[str, str]:
+    # Instantiate the object
+    tool_instantiation_str = f"composio_toolset.get_tools(actions=[Action.{action.name}])[0]"
+
+    # Generate func name
+    func_name = f"run_{action.name}"
+
+    wrapper_function_str = f"""
+def {func_name}(**kwargs):
+    if 'self' in kwargs:
+        del kwargs['self']
+    from composio import Action, App, Tag
+    from composio_langchain import ComposioToolSet
+
+    composio_toolset = ComposioToolSet()
+    tool = {tool_instantiation_str}
+    tool.func(**kwargs)
+    """
+
+    # Compile safety check
+    assert_code_gen_compilable(wrapper_function_str)
+
+    return func_name, wrapper_function_str
+
+
+def generate_langchain_tool_wrapper(
+    tool: "LangChainBaseTool", additional_imports_module_attr_map: dict[str, str] = None
+) -> tuple[str, str]:
     tool_name = tool.__class__.__name__
     import_statement = f"from langchain_community.tools import {tool_name}"
     extra_module_imports = generate_import_code(additional_imports_module_attr_map)
 
     # Safety check that user has passed in all required imports:
-    current_class_imports = {tool_name}
-    if additional_imports_module_attr_map:
-        current_class_imports.update(set(additional_imports_module_attr_map.values()))
-    required_class_imports = set(find_required_class_names_for_import(tool))
-
-    if not current_class_imports.issuperset(required_class_imports):
-        err_msg = f"[ERROR] You are missing module_attr pairs in `additional_imports_module_attr_map`. Currently, you have imports for {current_class_imports}, but the required classes for import are {required_class_imports}"
-        print(err_msg)
-        raise RuntimeError(err_msg)
+    assert_all_classes_are_imported(tool, additional_imports_module_attr_map)
 
     tool_instantiation = f"tool = {generate_imported_tool_instantiation_call_str(tool)}"
     run_call = f"return tool._run(**kwargs)"
@@ -34,12 +53,21 @@ def {func_name}(**kwargs):
     {tool_instantiation}
     {run_call}
 """
+
+    # Compile safety check
+    assert_code_gen_compilable(wrapper_function_str)
+
     return func_name, wrapper_function_str
 
 
-def generate_crewai_tool_wrapper(tool: "CrewAIBaseTool") -> tuple[str, str]:
+def generate_crewai_tool_wrapper(tool: "CrewAIBaseTool", additional_imports_module_attr_map: dict[str, str] = None) -> tuple[str, str]:
     tool_name = tool.__class__.__name__
     import_statement = f"from crewai_tools import {tool_name}"
+    extra_module_imports = generate_import_code(additional_imports_module_attr_map)
+
+    # Safety check that user has passed in all required imports:
+    assert_all_classes_are_imported(tool, additional_imports_module_attr_map)
+
     tool_instantiation = f"tool = {generate_imported_tool_instantiation_call_str(tool)}"
     run_call = f"return tool._run(**kwargs)"
     func_name = f"run_{tool_name.lower()}"
@@ -49,13 +77,42 @@ def generate_crewai_tool_wrapper(tool: "CrewAIBaseTool") -> tuple[str, str]:
 def {func_name}(**kwargs):
     if 'self' in kwargs:
         del kwargs['self']
+    import importlib
     {import_statement}
+    {extra_module_imports}
     {tool_instantiation}
     {run_call}
 """
+
+    # Compile safety check
+    assert_code_gen_compilable(wrapper_function_str)
+
     return func_name, wrapper_function_str
 
 
+def assert_code_gen_compilable(code_str):
+    try:
+        compile(code_str, "<string>", "exec")
+    except SyntaxError as e:
+        print(f"Syntax error in code: {e}")
+
+
+def assert_all_classes_are_imported(
+    tool: Union["LangChainBaseTool", "CrewAIBaseTool"], additional_imports_module_attr_map: dict[str, str]
+) -> None:
+    # Safety check that user has passed in all required imports:
+    tool_name = tool.__class__.__name__
+    current_class_imports = {tool_name}
+    if additional_imports_module_attr_map:
+        current_class_imports.update(set(additional_imports_module_attr_map.values()))
+    required_class_imports = set(find_required_class_names_for_import(tool))
+
+    if not current_class_imports.issuperset(required_class_imports):
+        err_msg = f"[ERROR] You are missing module_attr pairs in `additional_imports_module_attr_map`. Currently, you have imports for {current_class_imports}, but the required classes for import are {required_class_imports}"
+        print(err_msg)
+        raise RuntimeError(err_msg)
+
+
 def find_required_class_names_for_import(obj: Union["LangChainBaseTool", "CrewAIBaseTool", BaseModel]) -> list[str]:
     """
     Finds all the class names for required imports when instantiating the `obj`.
@@ -113,7 +170,7 @@ def generate_imported_tool_instantiation_call_str(obj: Any) -> Optional[str]:
         # e.g. {arg}={value}
         # The reason why this is recursive, is because the value can be another BaseModel that we need to stringify
         model_name = obj.__class__.__name__
-        fields = dict(obj)
+        fields = obj.dict()
         # Generate code for each field, skipping empty or None values
         field_assignments = []
         for arg, value in fields.items():
@@ -152,6 +209,11 @@ def generate_imported_tool_instantiation_call_str(obj: Any) -> Optional[str]:
         print(
             f"[WARNING] Skipping parsing unknown class {obj.__class__.__name__} (does not inherit from the Pydantic BaseModel and is not a basic Python type)"
         )
+        if obj.__class__.__name__ == "function":
+            import inspect
+
+            print(inspect.getsource(obj))
+
         return None
 
 

{letta_nightly-0.1.7.dev20241001104147 → letta_nightly-0.1.7.dev20241003104113}/letta/llm_api/openai.py

@@ -419,6 +419,8 @@ def openai_chat_completions_request(
     try:
         response = requests.post(url, headers=headers, json=data)
         printd(f"response = {response}, response.text = {response.text}")
+        # print(json.dumps(data, indent=4))
+        # raise requests.exceptions.HTTPError
         response.raise_for_status()  # Raises HTTPError for 4XX/5XX status
 
         response = response.json()  # convert to dict from string

{letta_nightly-0.1.7.dev20241001104147 → letta_nightly-0.1.7.dev20241003104113}/letta/schemas/block.py

@@ -46,15 +46,7 @@ class BaseBlock(LettaBase, validate_assignment=True):
         return self
 
     def __len__(self):
-        return len(str(self))
-
-    def __str__(self) -> str:
-        if isinstance(self.value, list):
-            return ",".join(self.value)
-        elif isinstance(self.value, str):
-            return self.value
-        else:
-            return ""
+        return len(self.value)
 
     def __setattr__(self, name, value):
         """Run validation if self.value is updated"""

letta_nightly-0.1.7.dev20241003104113/letta/schemas/health.py

@@ -0,0 +1,10 @@
+from pydantic import BaseModel
+
+
+class Health(BaseModel):
+    """
+    Health check response body
+    """
+
+    version: str
+    status: str

{letta_nightly-0.1.7.dev20241001104147 → letta_nightly-0.1.7.dev20241003104113}/letta/schemas/tool.py

@@ -3,6 +3,7 @@ from typing import Dict, List, Optional
 from pydantic import Field
 
 from letta.functions.helpers import (
+    generate_composio_tool_wrapper,
     generate_crewai_tool_wrapper,
     generate_langchain_tool_wrapper,
 )
@@ -57,6 +58,54 @@ class Tool(BaseTool):
             )
         )
 
+    @classmethod
+    def get_composio_tool(
+        cls,
+        action: "ActionType",
+    ) -> "Tool":
+        """
+        Class method to create an instance of Letta-compatible Composio Tool.
+        Check https://docs.composio.dev/introduction/intro/overview to look at options for get_composio_tool
+
+        This function will error if we find more than one tool, or 0 tools.
+
+        Args:
+            action ActionType: A action name to filter tools by.
+        Returns:
+            Tool: A Letta Tool initialized with attributes derived from the Composio tool.
+        """
+        from composio_langchain import ComposioToolSet
+
+        composio_toolset = ComposioToolSet()
+        composio_tools = composio_toolset.get_tools(actions=[action])
+
+        assert len(composio_tools) > 0, "User supplied parameters do not match any Composio tools"
+        assert len(composio_tools) == 1, f"User supplied parameters match too many Composio tools; {len(composio_tools)} > 1"
+
+        composio_tool = composio_tools[0]
+
+        description = composio_tool.description
+        source_type = "python"
+        tags = ["composio"]
+        wrapper_func_name, wrapper_function_str = generate_composio_tool_wrapper(action)
+        json_schema = generate_schema_from_args_schema(composio_tool.args_schema, name=wrapper_func_name, description=description)
+
+        # append heartbeat (necessary for triggering another reasoning step after this tool call)
+        json_schema["parameters"]["properties"]["request_heartbeat"] = {
+            "type": "boolean",
+            "description": "Request an immediate heartbeat after function execution. Set to 'true' if you want to send a follow-up message or run a follow-up function.",
+        }
+        json_schema["parameters"]["required"].append("request_heartbeat")
+
+        return cls(
+            name=wrapper_func_name,
+            description=description,
+            source_type=source_type,
+            tags=tags,
+            source_code=wrapper_function_str,
+            json_schema=json_schema,
+        )
+
     @classmethod
     def from_langchain(cls, langchain_tool: "LangChainBaseTool", additional_imports_module_attr_map: dict[str, str] = None) -> "Tool":
         """
@@ -93,7 +142,7 @@ class Tool(BaseTool):
         )
 
     @classmethod
-    def from_crewai(cls, crewai_tool: "CrewAIBaseTool") -> "Tool":
+    def from_crewai(cls, crewai_tool: "CrewAIBaseTool", additional_imports_module_attr_map: dict[str, str] = None) -> "Tool":
         """
         Class method to create an instance of Tool from a crewAI BaseTool object.
 
@@ -106,7 +155,7 @@ class Tool(BaseTool):
         description = crewai_tool.description
         source_type = "python"
         tags = ["crew-ai"]
-        wrapper_func_name, wrapper_function_str = generate_crewai_tool_wrapper(crewai_tool)
+        wrapper_func_name, wrapper_function_str = generate_crewai_tool_wrapper(crewai_tool, additional_imports_module_attr_map)
         json_schema = generate_schema_from_args_schema(crewai_tool.args_schema, name=wrapper_func_name, description=description)
 
         # append heartbeat (necessary for triggering another reasoning step after this tool call)
@@ -128,7 +177,7 @@ class Tool(BaseTool):
 
 class ToolCreate(BaseTool):
     name: Optional[str] = Field(None, description="The name of the function (auto-generated from source_code if not provided).")
-    tags: List[str] = Field(..., description="Metadata tags.")
+    tags: List[str] = Field([], description="Metadata tags.")
     source_code: str = Field(..., description="The source code of the function.")
     json_schema: Optional[Dict] = Field(
         None, description="The JSON schema of the function (auto-generated from source_code if not provided)"

{letta_nightly-0.1.7.dev20241001104147 → letta_nightly-0.1.7.dev20241003104113}/letta/server/rest_api/routers/v1/__init__.py

@@ -1,5 +1,6 @@
 from letta.server.rest_api.routers.v1.agents import router as agents_router
 from letta.server.rest_api.routers.v1.blocks import router as blocks_router
+from letta.server.rest_api.routers.v1.health import router as health_router
 from letta.server.rest_api.routers.v1.jobs import router as jobs_router
 from letta.server.rest_api.routers.v1.llms import router as llm_router
 from letta.server.rest_api.routers.v1.sources import router as sources_router
@@ -12,4 +13,5 @@ ROUTERS = [
     llm_router,
     blocks_router,
     jobs_router,
+    health_router,
 ]

letta_nightly-0.1.7.dev20241003104113/letta/server/rest_api/routers/v1/health.py

@@ -0,0 +1,20 @@
+from typing import TYPE_CHECKING
+
+from fastapi import APIRouter
+
+from letta.cli.cli import version
+from letta.schemas.health import Health
+
+if TYPE_CHECKING:
+    pass
+
+router = APIRouter(prefix="/health", tags=["health"])
+
+
+# Health check
+@router.get("/", response_model=Health, operation_id="health_check")
+def health_check():
+    return Health(
+        version=version(),
+        status="ok",
+    )