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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: letta-nightly
-Version: 0.1.7.dev20240929104004
+Version: 0.1.7.dev20241001104147
 Summary: Create LLM agents with long-term memory and custom tools
 License: Apache License
 Author: Letta Team
@@ -19,6 +19,7 @@ Provides-Extra: ollama
 Provides-Extra: postgres
 Provides-Extra: qdrant
 Provides-Extra: server
+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)
@@ -69,6 +70,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"
 Description-Content-Type: text/markdown
 
 # Letta (previously MemGPT)

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

@@ -350,7 +350,10 @@ class Agent(BaseAgent):
                 exec(tool.module, env)
             else:
                 exec(tool.source_code, env)
-            self.functions_python[tool.name] = env[tool.name]
+            from pprint import pprint
+
+            pprint(tool.json_schema)
+            self.functions_python[tool.name] = env[tool.json_schema["name"]]
             self.functions.append(tool.json_schema)
         assert all([callable(f) for k, f in self.functions_python.items()]), self.functions_python
 

{letta_nightly-0.1.7.dev20240929104004 → letta_nightly-0.1.7.dev20241001104147}/letta/cli/cli.py

@@ -464,7 +464,6 @@ def run(
     # read user id from config
     ms = MetadataStore(config)
     client = create_client()
-    client.user_id
 
     # determine agent to use, if not provided
     if not yes and not agent:

{letta_nightly-0.1.7.dev20240929104004 → letta_nightly-0.1.7.dev20241001104147}/letta/cli/cli_load.py

@@ -18,56 +18,6 @@ from letta.data_sources.connectors import DirectoryConnector
 
 app = typer.Typer()
 
-# NOTE: not supported due to llama-index breaking things (please reach out if you still need it)
-# @app.command("index")
-# def load_index(
-#    name: Annotated[str, typer.Option(help="Name of dataset to load.")],
-#    dir: Annotated[Optional[str], typer.Option(help="Path to directory containing index.")] = None,
-#    user_id: Annotated[Optional[uuid.UUID], typer.Option(help="User ID to associate with dataset.")] = None,
-# ):
-#    """Load a LlamaIndex saved VectorIndex into Letta"""
-#    if user_id is None:
-#        config = LettaConfig.load()
-#        user_id = uuid.UUID(config.anon_clientid)
-#
-#    try:
-#        # load index data
-#        storage_context = StorageContext.from_defaults(persist_dir=dir)
-#        loaded_index = load_index_from_storage(storage_context)
-#
-#        # hacky code to extract out passages/embeddings (thanks a lot, llama index)
-#        embed_dict = loaded_index._vector_store._data.embedding_dict
-#        node_dict = loaded_index._docstore.docs
-#
-#        # create storage connector
-#        config = LettaConfig.load()
-#        if user_id is None:
-#            user_id = uuid.UUID(config.anon_clientid)
-#
-#        passages = []
-#        for node_id, node in node_dict.items():
-#            vector = embed_dict[node_id]
-#            node.embedding = vector
-#            # assume embedding are the same as config
-#            passages.append(
-#                Passage(
-#                    text=node.text,
-#                    embedding=np.array(vector),
-#                    embedding_dim=config.default_embedding_config.embedding_dim,
-#                    embedding_model=config.default_embedding_config.embedding_model,
-#                )
-#            )
-#            assert config.default_embedding_config.embedding_dim == len(
-#                vector
-#            ), f"Expected embedding dimension {config.default_embedding_config.embedding_dim}, got {len(vector)}"
-#
-#        if len(passages) == 0:
-#            raise ValueError(f"No passages found in index {dir}")
-#
-#        insert_passages_into_source(passages, name, user_id, config)
-#    except ValueError as e:
-#        typer.secho(f"Failed to load index from provided information.\n{e}", fg=typer.colors.RED)
-
 
 default_extensions = ".txt,.md,.pdf"
 

{letta_nightly-0.1.7.dev20240929104004 → letta_nightly-0.1.7.dev20241001104147}/letta/config.py

@@ -2,7 +2,6 @@ import configparser
 import inspect
 import json
 import os
-import uuid
 from dataclasses import dataclass
 from typing import Optional
 
@@ -14,6 +13,7 @@ from letta.constants import (
     DEFAULT_HUMAN,
     DEFAULT_PERSONA,
     DEFAULT_PRESET,
+    DEFAULT_USER_ID,
     LETTA_DIR,
 )
 from letta.log import get_logger
@@ -45,7 +45,7 @@ def set_field(config, section, field, value):
 @dataclass
 class LettaConfig:
     config_path: str = os.getenv("MEMGPT_CONFIG_PATH") or os.path.join(LETTA_DIR, "config")
-    anon_clientid: str = str(uuid.UUID(int=0))
+    anon_clientid: str = DEFAULT_USER_ID
 
     # preset
     preset: str = DEFAULT_PRESET  # TODO: rename to system prompt
@@ -100,10 +100,6 @@ class LettaConfig:
         # self.context_window = int(self.context_window)
         pass
 
-    @staticmethod
-    def generate_uuid() -> str:
-        return uuid.UUID(int=uuid.getnode()).hex
-
     @classmethod
     def load(cls, llm_config: Optional[LLMConfig] = None, embedding_config: Optional[EmbeddingConfig] = None) -> "LettaConfig":
         # avoid circular import
@@ -199,8 +195,7 @@ class LettaConfig:
         # assert llm_config is not None, "LLM config must be provided if config does not exist"
 
         # create new config
-        anon_clientid = LettaConfig.generate_uuid()
-        config = cls(anon_clientid=anon_clientid, config_path=config_path)
+        config = cls(config_path=config_path)
 
         config.create_config_dir()  # create dirs
 
@@ -284,8 +279,6 @@ class LettaConfig:
         set_field(config, "version", "letta_version", letta.__version__)
 
         # client
-        if not self.anon_clientid:
-            self.anon_clientid = self.generate_uuid()
         set_field(config, "client", "anon_clientid", self.anon_clientid)
 
         # always make sure all directories are present

letta_nightly-0.1.7.dev20241001104147/letta/functions/helpers.py

@@ -0,0 +1,175 @@
+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]:
+    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)
+
+    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()}"
+
+    # Combine all parts into the wrapper function
+    wrapper_function_str = f"""
+def {func_name}(**kwargs):
+    if 'self' in kwargs:
+        del kwargs['self']
+    import importlib
+    {import_statement}
+    {extra_module_imports}
+    {tool_instantiation}
+    {run_call}
+"""
+    return func_name, wrapper_function_str
+
+
+def generate_crewai_tool_wrapper(tool: "CrewAIBaseTool") -> tuple[str, str]:
+    tool_name = tool.__class__.__name__
+    import_statement = f"from crewai_tools import {tool_name}"
+    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()}"
+
+    # Combine all parts into the wrapper function
+    wrapper_function_str = f"""
+def {func_name}(**kwargs):
+    if 'self' in kwargs:
+        del kwargs['self']
+    {import_statement}
+    {tool_instantiation}
+    {run_call}
+"""
+    return func_name, wrapper_function_str
+
+
+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`.
+    NOTE: This does not return the full import path, only the class name.
+
+    We accomplish this by running BFS and deep searching all the BaseModel objects in the obj parameters.
+    """
+    class_names = {obj.__class__.__name__}
+    queue = [obj]
+
+    while queue:
+        # Get the current object we are inspecting
+        curr_obj = queue.pop()
+
+        # Collect all possible candidates for BaseModel objects
+        candidates = []
+        if is_base_model(curr_obj):
+            # If it is a base model, we get all the values of the object parameters
+            # i.e., if obj('b' = <class A>), we would want to inspect <class A>
+            fields = dict(curr_obj)
+            # Generate code for each field, skipping empty or None values
+            candidates = list(fields.values())
+        elif isinstance(curr_obj, dict):
+            # If it is a dictionary, we get all the values
+            # i.e., if obj = {'a': 3, 'b': <class A>}, we would want to inspect <class A>
+            candidates = list(curr_obj.values())
+        elif isinstance(curr_obj, list):
+            # If it is a list, we inspect all the items in the list
+            # i.e., if obj = ['a', 3, None, <class A>], we would want to inspect <class A>
+            candidates = curr_obj
+
+        # Filter out all candidates that are not BaseModels
+        # In the list example above, ['a', 3, None, <class A>], we want to filter out 'a', 3, and None
+        candidates = filter(lambda x: is_base_model(x), candidates)
+
+        # Classic BFS here
+        for c in candidates:
+            c_name = c.__class__.__name__
+            if c_name not in class_names:
+                class_names.add(c_name)
+                queue.append(c)
+
+    return list(class_names)
+
+
+def generate_imported_tool_instantiation_call_str(obj: Any) -> Optional[str]:
+    if isinstance(obj, (int, float, str, bool, type(None))):
+        # This is the base case
+        # If it is a basic Python type, we trivially return the string version of that value
+        # Handle basic types
+        return repr(obj)
+    elif is_base_model(obj):
+        # Otherwise, if it is a BaseModel
+        # We want to pull out all the parameters, and reformat them into strings
+        # 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)
+        # Generate code for each field, skipping empty or None values
+        field_assignments = []
+        for arg, value in fields.items():
+            python_string = generate_imported_tool_instantiation_call_str(value)
+            if python_string:
+                field_assignments.append(f"{arg}={python_string}")
+
+        assignments = ", ".join(field_assignments)
+        return f"{model_name}({assignments})"
+    elif isinstance(obj, dict):
+        # Inspect each of the items in the dict and stringify them
+        # This is important because the dictionary may contain other BaseModels
+        dict_items = []
+        for k, v in obj.items():
+            python_string = generate_imported_tool_instantiation_call_str(v)
+            if python_string:
+                dict_items.append(f"{repr(k)}: {python_string}")
+
+        joined_items = ", ".join(dict_items)
+        return f"{{{joined_items}}}"
+    elif isinstance(obj, list):
+        # Inspect each of the items in the list and stringify them
+        # This is important because the list may contain other BaseModels
+        list_items = [generate_imported_tool_instantiation_call_str(v) for v in obj]
+        filtered_list_items = list(filter(None, list_items))
+        list_items = ", ".join(filtered_list_items)
+        return f"[{list_items}]"
+    else:
+        # Otherwise, if it is none of the above, that usually means it is a custom Python class that is NOT a BaseModel
+        # Thus, we cannot get enough information about it to stringify it
+        # This may cause issues, but we are making the assumption that any of these custom Python types are handled correctly by the parent library, such as LangChain or CrewAI
+        # An example would be that WikipediaAPIWrapper has an argument that is a wikipedia (pip install wikipedia) object
+        # We cannot stringify this easily, but WikipediaAPIWrapper handles the setting of this parameter internally
+        # This assumption seems fair to me, since usually they are external imports, and LangChain and CrewAI should be bundling those as module-level imports within the tool
+        # We throw a warning here anyway and provide the class name
+        print(
+            f"[WARNING] Skipping parsing unknown class {obj.__class__.__name__} (does not inherit from the Pydantic BaseModel and is not a basic Python type)"
+        )
+        return None
+
+
+def is_base_model(obj: Any):
+    from crewai_tools.tools.base_tool import BaseModel as CrewAiBaseModel
+    from langchain_core.pydantic_v1 import BaseModel as LangChainBaseModel
+
+    return isinstance(obj, BaseModel) or isinstance(obj, LangChainBaseModel) or isinstance(obj, CrewAiBaseModel)
+
+
+def generate_import_code(module_attr_map: Optional[dict]):
+    if not module_attr_map:
+        return ""
+
+    code_lines = []
+    for module, attr in module_attr_map.items():
+        module_name = module.split(".")[-1]
+        code_lines.append(f"# Load the module\n    {module_name} = importlib.import_module('{module}')")
+        code_lines.append(f"    # Access the {attr} from the module")
+        code_lines.append(f"    {attr} = getattr({module_name}, '{attr}')")
+    return "\n".join(code_lines)

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

@@ -1,6 +1,5 @@
 import inspect
-import typing
-from typing import Any, Dict, Optional, Type, get_args, get_origin
+from typing import Any, Dict, Optional, Type, Union, get_args, get_origin
 
 from docstring_parser import parse
 from pydantic import BaseModel
@@ -8,7 +7,7 @@ from pydantic import BaseModel
 
 def is_optional(annotation):
     # Check if the annotation is a Union
-    if getattr(annotation, "__origin__", None) is typing.Union:
+    if getattr(annotation, "__origin__", None) is Union:
         # Check if None is one of the options in the Union
         return type(None) in annotation.__args__
     return False
@@ -164,42 +163,3 @@ def generate_schema_from_args_schema(
     }
 
     return function_call_json
-
-
-def generate_langchain_tool_wrapper(tool_name: str) -> str:
-    import_statement = f"from langchain_community.tools import {tool_name}"
-
-    # NOTE: this will fail for tools like 'wikipedia = WikipediaQueryRun(api_wrapper=WikipediaAPIWrapper())' since it needs to pass an argument to the tool instantiation
-    # https://python.langchain.com/v0.1/docs/integrations/tools/wikipedia/
-    tool_instantiation = f"tool = {tool_name}()"
-    run_call = f"return tool._run(**kwargs)"
-    func_name = f"run_{tool_name.lower()}"
-
-    # Combine all parts into the wrapper function
-    wrapper_function_str = f"""
-def {func_name}(**kwargs):
-    if 'self' in kwargs:
-        del kwargs['self']
-    {import_statement}
-    {tool_instantiation}
-    {run_call}
-"""
-    return func_name, wrapper_function_str
-
-
-def generate_crewai_tool_wrapper(tool_name: str) -> str:
-    import_statement = f"from crewai_tools import {tool_name}"
-    tool_instantiation = f"tool = {tool_name}()"
-    run_call = f"return tool._run(**kwargs)"
-    func_name = f"run_{tool_name.lower()}"
-
-    # Combine all parts into the wrapper function
-    wrapper_function_str = f"""
-def {func_name}(**kwargs):
-    if 'self' in kwargs:
-        del kwargs['self']
-    {import_statement}
-    {tool_instantiation}
-    {run_call}
-"""
-    return func_name, wrapper_function_str

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

@@ -2,11 +2,11 @@ from typing import Dict, List, Optional
 
 from pydantic import Field
 
-from letta.functions.schema_generator import (
+from letta.functions.helpers import (
     generate_crewai_tool_wrapper,
     generate_langchain_tool_wrapper,
-    generate_schema_from_args_schema,
 )
+from letta.functions.schema_generator import generate_schema_from_args_schema
 from letta.schemas.letta_base import LettaBase
 from letta.schemas.openai.chat_completions import ToolCall
 
@@ -58,12 +58,13 @@ class Tool(BaseTool):
         )
 
     @classmethod
-    def from_langchain(cls, langchain_tool) -> "Tool":
+    def from_langchain(cls, langchain_tool: "LangChainBaseTool", additional_imports_module_attr_map: dict[str, str] = None) -> "Tool":
         """
         Class method to create an instance of Tool from a Langchain tool (must be from langchain_community.tools).
 
         Args:
-            langchain_tool (LangchainTool): An instance of a crewAI BaseTool (BaseTool from crewai)
+            langchain_tool (LangChainBaseTool): An instance of a crewAI BaseTool (BaseTool from crewai)
+            additional_imports_module_attr_map (dict[str, str]): A mapping of module names to attribute name. This is used internally to import all the required classes for the langchain tool. For example, you would pass in `{"langchain_community.utilities": "WikipediaAPIWrapper"}` for `from langchain_community.tools import WikipediaQueryRun`. NOTE: You do NOT need to specify the tool import here, that is done automatically for you.
 
         Returns:
             Tool: A Letta Tool initialized with attributes derived from the provided crewAI BaseTool object.
@@ -72,7 +73,7 @@ class Tool(BaseTool):
         source_type = "python"
         tags = ["langchain"]
         # NOTE: langchain tools may come from different packages
-        wrapper_func_name, wrapper_function_str = generate_langchain_tool_wrapper(langchain_tool.__class__.__name__)
+        wrapper_func_name, wrapper_function_str = generate_langchain_tool_wrapper(langchain_tool, additional_imports_module_attr_map)
         json_schema = generate_schema_from_args_schema(langchain_tool.args_schema, name=wrapper_func_name, description=description)
 
         # append heartbeat (necessary for triggering another reasoning step after this tool call)
@@ -92,7 +93,7 @@ class Tool(BaseTool):
         )
 
     @classmethod
-    def from_crewai(cls, crewai_tool) -> "Tool":
+    def from_crewai(cls, crewai_tool: "CrewAIBaseTool") -> "Tool":
         """
         Class method to create an instance of Tool from a crewAI BaseTool object.
 
@@ -102,11 +103,10 @@ class Tool(BaseTool):
         Returns:
             Tool: A Letta Tool initialized with attributes derived from the provided crewAI BaseTool object.
         """
-        crewai_tool.name
         description = crewai_tool.description
         source_type = "python"
         tags = ["crew-ai"]
-        wrapper_func_name, wrapper_function_str = generate_crewai_tool_wrapper(crewai_tool.__class__.__name__)
+        wrapper_func_name, wrapper_function_str = generate_crewai_tool_wrapper(crewai_tool)
         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)

{letta_nightly-0.1.7.dev20240929104004 → letta_nightly-0.1.7.dev20241001104147}/letta/server/server.py

@@ -1441,10 +1441,6 @@ class SyncServer(Server):
             logger.exception(f"Failed to delete agent {agent_id} via ID with:\n{str(e)}")
             raise ValueError(f"Failed to delete agent {agent_id} in database")
 
-    def authenticate_user(self) -> str:
-        # TODO: Implement actual authentication to enable multi user setup
-        return str(LettaConfig.load().anon_clientid)
-
     def api_key_to_user(self, api_key: str) -> str:
         """Decode an API key to a user"""
         user = self.ms.get_user_from_api_key(api_key=api_key)
@@ -1752,7 +1748,7 @@ class SyncServer(Server):
 
             # TODO: not sure if this always works
             func = env[functions[-1]]
-            json_schema = generate_schema(func, request.name)
+            json_schema = generate_schema(func)
         else:
             # provided by client
             json_schema = request.json_schema
@@ -1973,19 +1969,6 @@ class SyncServer(Server):
                 return current_user
 
         return self.get_default_user()
-        ## NOTE: same code as local client to get the default user
-        # config = LettaConfig.load()
-        # user_id = config.anon_clientid
-        # user = self.get_user(user_id)
-
-        # if not user:
-        #    user = self.create_user(UserCreate())
-
-        #    # # update config
-        #    config.anon_clientid = str(user.id)
-        #    config.save()
-
-        # return user
 
     def list_models(self) -> List[LLMConfig]:
         """List available models"""

{letta_nightly-0.1.7.dev20240929104004 → letta_nightly-0.1.7.dev20241001104147}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "letta-nightly"
-version = "0.1.7.dev20240929104004"
+version = "0.1.7.dev20241001104147"
 packages = [
     {include = "letta"}
 ]
@@ -71,6 +71,7 @@ llama-index = "^0.11.9"
 llama-index-embeddings-openai = "^0.2.5"
 llama-index-embeddings-ollama = "^0.3.1"
 #llama-index-embeddings-huggingface = {version = "^0.2.0", optional = true}
+wikipedia = {version = "^1.4.0", optional = true}
 
 [tool.poetry.extras]
 #local = ["llama-index-embeddings-huggingface"]
@@ -82,6 +83,7 @@ autogen = ["pyautogen"]
 qdrant = ["qdrant-client"]
 ollama = ["llama-index-embeddings-ollama"]
 crewai-tools = ["crewai", "docker", "crewai-tools"]
+tests = ["wikipedia"]
 
 [tool.poetry.group.dev.dependencies]
 black = "^24.4.2"