letta-nightly 0.1.7.dev20240924104148__py3-none-any.whl

letta/embeddings.py

@@ -0,0 +1,218 @@
+import os
+import uuid
+from typing import Any, List, Optional
+
+import numpy as np
+
+# from llama_index.core.base.embeddings import BaseEmbedding
+# from llama_index.core.embeddings import BaseEmbedding
+# from llama_index.core.base.embeddings.base import BaseEmbedding
+# from llama_index.bridge.pydantic import PrivateAttr
+# from llama_index.embeddings.base import BaseEmbedding
+# from llama_index.embeddings.huggingface_utils import format_text
+import tiktoken
+from llama_index.core import Document as LlamaIndexDocument
+
+# from llama_index.core.base.embeddings import BaseEmbedding
+from llama_index.core.node_parser import SentenceSplitter
+
+from letta.constants import (
+    EMBEDDING_TO_TOKENIZER_DEFAULT,
+    EMBEDDING_TO_TOKENIZER_MAP,
+    MAX_EMBEDDING_DIM,
+)
+from letta.credentials import LettaCredentials
+from letta.schemas.embedding_config import EmbeddingConfig
+from letta.utils import is_valid_url, printd
+
+
+def parse_and_chunk_text(text: str, chunk_size: int) -> List[str]:
+    parser = SentenceSplitter(chunk_size=chunk_size)
+    llama_index_docs = [LlamaIndexDocument(text=text)]
+    nodes = parser.get_nodes_from_documents(llama_index_docs)
+    return [n.text for n in nodes]
+
+
+def truncate_text(text: str, max_length: int, encoding) -> str:
+    # truncate the text based on max_length and encoding
+    encoded_text = encoding.encode(text)[:max_length]
+    return encoding.decode(encoded_text)
+
+
+def check_and_split_text(text: str, embedding_model: str) -> List[str]:
+    """Split text into chunks of max_length tokens or less"""
+
+    if embedding_model in EMBEDDING_TO_TOKENIZER_MAP:
+        encoding = tiktoken.get_encoding(EMBEDDING_TO_TOKENIZER_MAP[embedding_model])
+    else:
+        print(f"Warning: couldn't find tokenizer for model {embedding_model}, using default tokenizer {EMBEDDING_TO_TOKENIZER_DEFAULT}")
+        encoding = tiktoken.get_encoding(EMBEDDING_TO_TOKENIZER_DEFAULT)
+
+    num_tokens = len(encoding.encode(text))
+
+    # determine max length
+    if hasattr(encoding, "max_length"):
+        # TODO(fix) this is broken
+        max_length = encoding.max_length
+    else:
+        # TODO: figure out the real number
+        printd(f"Warning: couldn't find max_length for tokenizer {embedding_model}, using default max_length 8191")
+        max_length = 8191
+
+    # truncate text if too long
+    if num_tokens > max_length:
+        print(f"Warning: text is too long ({num_tokens} tokens), truncating to {max_length} tokens.")
+        # First, apply any necessary formatting
+        formatted_text = format_text(text, embedding_model)
+        # Then truncate
+        text = truncate_text(formatted_text, max_length, encoding)
+
+    return [text]
+
+
+class EmbeddingEndpoint:
+    """Implementation for OpenAI compatible endpoint"""
+
+    # """ Based off llama index https://github.com/run-llama/llama_index/blob/a98bdb8ecee513dc2e880f56674e7fd157d1dc3a/llama_index/embeddings/text_embeddings_inference.py """
+
+    # _user: str = PrivateAttr()
+    # _timeout: float = PrivateAttr()
+    # _base_url: str = PrivateAttr()
+
+    def __init__(
+        self,
+        model: str,
+        base_url: str,
+        user: str,
+        timeout: float = 60.0,
+        **kwargs: Any,
+    ):
+        if not is_valid_url(base_url):
+            raise ValueError(
+                f"Embeddings endpoint was provided an invalid URL (set to: '{base_url}'). Make sure embedding_endpoint is set correctly in your Letta config."
+            )
+        self.model_name = model
+        self._user = user
+        self._base_url = base_url
+        self._timeout = timeout
+
+    def _call_api(self, text: str) -> List[float]:
+        if not is_valid_url(self._base_url):
+            raise ValueError(
+                f"Embeddings endpoint does not have a valid URL (set to: '{self._base_url}'). Make sure embedding_endpoint is set correctly in your Letta config."
+            )
+        import httpx
+
+        headers = {"Content-Type": "application/json"}
+        json_data = {"input": text, "model": self.model_name, "user": self._user}
+
+        with httpx.Client() as client:
+            response = client.post(
+                f"{self._base_url}/embeddings",
+                headers=headers,
+                json=json_data,
+                timeout=self._timeout,
+            )
+
+        response_json = response.json()
+
+        if isinstance(response_json, list):
+            # embedding directly in response
+            embedding = response_json
+        elif isinstance(response_json, dict):
+            # TEI embedding packaged inside openai-style response
+            try:
+                embedding = response_json["data"][0]["embedding"]
+            except (KeyError, IndexError):
+                raise TypeError(f"Got back an unexpected payload from text embedding function, response=\n{response_json}")
+        else:
+            # unknown response, can't parse
+            raise TypeError(f"Got back an unexpected payload from text embedding function, response=\n{response_json}")
+
+        return embedding
+
+    def get_text_embedding(self, text: str) -> List[float]:
+        return self._call_api(text)
+
+
+def default_embedding_model():
+    # default to hugging face model running local
+    # warning: this is a terrible model
+    from llama_index.embeddings.huggingface import HuggingFaceEmbedding
+
+    os.environ["TOKENIZERS_PARALLELISM"] = "False"
+    model = "BAAI/bge-small-en-v1.5"
+    return HuggingFaceEmbedding(model_name=model)
+
+
+def query_embedding(embedding_model, query_text: str):
+    """Generate padded embedding for querying database"""
+    query_vec = embedding_model.get_text_embedding(query_text)
+    query_vec = np.array(query_vec)
+    query_vec = np.pad(query_vec, (0, MAX_EMBEDDING_DIM - query_vec.shape[0]), mode="constant").tolist()
+    return query_vec
+
+
+def embedding_model(config: EmbeddingConfig, user_id: Optional[uuid.UUID] = None):
+    """Return LlamaIndex embedding model to use for embeddings"""
+
+    endpoint_type = config.embedding_endpoint_type
+
+    # TODO refactor to pass credentials through args
+    credentials = LettaCredentials.load()
+
+    if endpoint_type == "openai":
+        from llama_index.embeddings.openai import OpenAIEmbedding
+
+        additional_kwargs = {"user_id": user_id} if user_id else {}
+        model = OpenAIEmbedding(
+            api_base=config.embedding_endpoint,
+            api_key=credentials.openai_key,
+            additional_kwargs=additional_kwargs,
+        )
+        return model
+
+    elif endpoint_type == "azure":
+        assert all(
+            [
+                credentials.azure_key is not None,
+                credentials.azure_embedding_endpoint is not None,
+                credentials.azure_version is not None,
+            ]
+        )
+        from llama_index.embeddings.azure_openai import AzureOpenAIEmbedding
+
+        # https://learn.microsoft.com/en-us/azure/ai-services/openai/reference#embeddings
+        model = "text-embedding-ada-002"
+        deployment = credentials.azure_embedding_deployment if credentials.azure_embedding_deployment is not None else model
+        return AzureOpenAIEmbedding(
+            model=model,
+            deployment_name=deployment,
+            api_key=credentials.azure_key,
+            azure_endpoint=credentials.azure_endpoint,
+            api_version=credentials.azure_version,
+        )
+
+    elif endpoint_type == "hugging-face":
+        return EmbeddingEndpoint(
+            model=config.embedding_model,
+            base_url=config.embedding_endpoint,
+            user=user_id,
+        )
+    elif endpoint_type == "ollama":
+
+        from llama_index.embeddings.ollama import OllamaEmbedding
+
+        ollama_additional_kwargs = {}
+        callback_manager = None
+
+        model = OllamaEmbedding(
+            model_name=config.embedding_model,
+            base_url=config.embedding_endpoint,
+            ollama_additional_kwargs=ollama_additional_kwargs or {},
+            callback_manager=callback_manager or None,
+        )
+        return model
+
+    else:
+        return default_embedding_model()

letta/errors.py

@@ -0,0 +1,26 @@
+class LLMError(Exception):
+    """Base class for all LLM-related errors."""
+
+
+class LLMJSONParsingError(LLMError):
+    """Exception raised for errors in the JSON parsing process."""
+
+    def __init__(self, message="Error parsing JSON generated by LLM"):
+        self.message = message
+        super().__init__(self.message)
+
+
+class LocalLLMError(LLMError):
+    """Generic catch-all error for local LLM problems"""
+
+    def __init__(self, message="Encountered an error while running local LLM"):
+        self.message = message
+        super().__init__(self.message)
+
+
+class LocalLLMConnectionError(LLMError):
+    """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)

letta/functions/function_sets/base.py

@@ -0,0 +1,174 @@
+from typing import Optional
+
+from letta.agent import Agent
+from letta.constants import MAX_PAUSE_HEARTBEATS
+
+# import math
+# from letta.utils import json_dumps
+
+### Functions / tools the agent can use
+# All functions should return a response string (or None)
+# If the function fails, throw an exception
+
+
+def send_message(self: Agent, message: str) -> Optional[str]:
+    """
+    Sends a message to the human user.
+
+    Args:
+        message (str): Message contents. All unicode (including emojis) are supported.
+
+    Returns:
+        Optional[str]: None is always returned as this function does not produce a response.
+    """
+    # FIXME passing of msg_obj here is a hack, unclear if guaranteed to be the correct reference
+    self.interface.assistant_message(message)  # , msg_obj=self._messages[-1])
+    return None
+
+
+# Construct the docstring dynamically (since it should use the external constants)
+pause_heartbeats_docstring = f"""
+Temporarily ignore timed heartbeats. You may still receive messages from manual heartbeats and other events.
+
+Args:
+    minutes (int): Number of minutes to ignore heartbeats for. Max value of {MAX_PAUSE_HEARTBEATS} minutes ({MAX_PAUSE_HEARTBEATS // 60} hours).
+
+Returns:
+    str: Function status response
+"""
+
+
+def pause_heartbeats(self: Agent, minutes: int) -> Optional[str]:
+    import datetime
+
+    from letta.constants import MAX_PAUSE_HEARTBEATS
+
+    minutes = min(MAX_PAUSE_HEARTBEATS, minutes)
+
+    # Record the current time
+    self.pause_heartbeats_start = datetime.datetime.now(datetime.timezone.utc)
+    # And record how long the pause should go for
+    self.pause_heartbeats_minutes = int(minutes)
+
+    return f"Pausing timed heartbeats for {minutes} min"
+
+
+pause_heartbeats.__doc__ = pause_heartbeats_docstring
+
+
+def conversation_search(self: Agent, query: str, page: Optional[int] = 0) -> Optional[str]:
+    """
+    Search prior conversation history using case-insensitive string matching.
+
+    Args:
+        query (str): String to search for.
+        page (int): Allows you to page through results. Only use on a follow-up query. Defaults to 0 (first page).
+
+    Returns:
+        str: Query result string
+    """
+
+    import math
+
+    from letta.constants import RETRIEVAL_QUERY_DEFAULT_PAGE_SIZE
+    from letta.utils import json_dumps
+
+    if page is None or (isinstance(page, str) and page.lower().strip() == "none"):
+        page = 0
+    try:
+        page = int(page)
+    except:
+        raise ValueError(f"'page' argument must be an integer")
+    count = RETRIEVAL_QUERY_DEFAULT_PAGE_SIZE
+    results, total = self.persistence_manager.recall_memory.text_search(query, count=count, start=page * count)
+    num_pages = math.ceil(total / count) - 1  # 0 index
+    if len(results) == 0:
+        results_str = f"No results found."
+    else:
+        results_pref = f"Showing {len(results)} of {total} results (page {page}/{num_pages}):"
+        results_formatted = [f"timestamp: {d['timestamp']}, {d['message']['role']} - {d['message']['content']}" for d in results]
+        results_str = f"{results_pref} {json_dumps(results_formatted)}"
+    return results_str
+
+
+def conversation_search_date(self: Agent, start_date: str, end_date: str, page: Optional[int] = 0) -> Optional[str]:
+    """
+    Search prior conversation history using a date range.
+
+    Args:
+        start_date (str): The start of the date range to search, in the format 'YYYY-MM-DD'.
+        end_date (str): The end of the date range to search, in the format 'YYYY-MM-DD'.
+        page (int): Allows you to page through results. Only use on a follow-up query. Defaults to 0 (first page).
+
+    Returns:
+        str: Query result string
+    """
+    import math
+
+    from letta.constants import RETRIEVAL_QUERY_DEFAULT_PAGE_SIZE
+    from letta.utils import json_dumps
+
+    if page is None or (isinstance(page, str) and page.lower().strip() == "none"):
+        page = 0
+    try:
+        page = int(page)
+    except:
+        raise ValueError(f"'page' argument must be an integer")
+    count = RETRIEVAL_QUERY_DEFAULT_PAGE_SIZE
+    results, total = self.persistence_manager.recall_memory.date_search(start_date, end_date, count=count, start=page * count)
+    num_pages = math.ceil(total / count) - 1  # 0 index
+    if len(results) == 0:
+        results_str = f"No results found."
+    else:
+        results_pref = f"Showing {len(results)} of {total} results (page {page}/{num_pages}):"
+        results_formatted = [f"timestamp: {d['timestamp']}, {d['message']['role']} - {d['message']['content']}" for d in results]
+        results_str = f"{results_pref} {json_dumps(results_formatted)}"
+    return results_str
+
+
+def archival_memory_insert(self: Agent, content: str) -> Optional[str]:
+    """
+    Add to archival memory. Make sure to phrase the memory contents such that it can be easily queried later.
+
+    Args:
+        content (str): Content to write to the memory. All unicode (including emojis) are supported.
+
+    Returns:
+        Optional[str]: None is always returned as this function does not produce a response.
+    """
+    self.persistence_manager.archival_memory.insert(content)
+    return None
+
+
+def archival_memory_search(self: Agent, query: str, page: Optional[int] = 0) -> Optional[str]:
+    """
+    Search archival memory using semantic (embedding-based) search.
+
+    Args:
+        query (str): String to search for.
+        page (Optional[int]): Allows you to page through results. Only use on a follow-up query. Defaults to 0 (first page).
+
+    Returns:
+        str: Query result string
+    """
+    import math
+
+    from letta.constants import RETRIEVAL_QUERY_DEFAULT_PAGE_SIZE
+    from letta.utils import json_dumps
+
+    if page is None or (isinstance(page, str) and page.lower().strip() == "none"):
+        page = 0
+    try:
+        page = int(page)
+    except:
+        raise ValueError(f"'page' argument must be an integer")
+    count = RETRIEVAL_QUERY_DEFAULT_PAGE_SIZE
+    results, total = self.persistence_manager.archival_memory.search(query, count=count, start=page * count)
+    num_pages = math.ceil(total / count) - 1  # 0 index
+    if len(results) == 0:
+        results_str = f"No results found."
+    else:
+        results_pref = f"Showing {len(results)} of {total} results (page {page}/{num_pages}):"
+        results_formatted = [f"timestamp: {d['timestamp']}, memory: {d['content']}" for d in results]
+        results_str = f"{results_pref} {json_dumps(results_formatted)}"
+    return results_str

letta/functions/function_sets/extras.py

@@ -0,0 +1,132 @@
+import os
+import uuid
+from typing import Optional
+
+import requests
+
+from letta.constants import (
+    MESSAGE_CHATGPT_FUNCTION_MODEL,
+    MESSAGE_CHATGPT_FUNCTION_SYSTEM_MESSAGE,
+)
+from letta.llm_api.llm_api_tools import create
+from letta.schemas.message import Message
+from letta.utils import json_dumps, json_loads
+
+
+def message_chatgpt(self, message: str):
+    """
+    Send a message to a more basic AI, ChatGPT. A useful resource for asking questions. ChatGPT does not retain memory of previous interactions.
+
+    Args:
+        message (str): Message to send ChatGPT. Phrase your message as a full English sentence.
+
+    Returns:
+        str: Reply message from ChatGPT
+    """
+    dummy_user_id = uuid.uuid4()
+    dummy_agent_id = uuid.uuid4()
+    message_sequence = [
+        Message(user_id=dummy_user_id, agent_id=dummy_agent_id, role="system", text=MESSAGE_CHATGPT_FUNCTION_SYSTEM_MESSAGE),
+        Message(user_id=dummy_user_id, agent_id=dummy_agent_id, role="user", text=str(message)),
+    ]
+    # TODO: this will error without an LLMConfig
+    response = create(
+        model=MESSAGE_CHATGPT_FUNCTION_MODEL,
+        messages=message_sequence,
+    )
+
+    reply = response.choices[0].message.content
+    return reply
+
+
+def read_from_text_file(self, filename: str, line_start: int, num_lines: Optional[int] = 1):
+    """
+    Read lines from a text file.
+
+    Args:
+        filename (str): The name of the file to read.
+        line_start (int): Line to start reading from.
+        num_lines (Optional[int]): How many lines to read (defaults to 1).
+
+    Returns:
+        str: Text read from the file
+    """
+    max_chars = 500
+    trunc_message = True
+    if not os.path.exists(filename):
+        raise FileNotFoundError(f"The file '{filename}' does not exist.")
+
+    if line_start < 1 or num_lines < 1:
+        raise ValueError("Both line_start and num_lines must be positive integers.")
+
+    lines = []
+    chars_read = 0
+    with open(filename, "r", encoding="utf-8") as file:
+        for current_line_number, line in enumerate(file, start=1):
+            if line_start <= current_line_number < line_start + num_lines:
+                chars_to_add = len(line)
+                if max_chars is not None and chars_read + chars_to_add > max_chars:
+                    # If adding this line exceeds MAX_CHARS, truncate the line if needed and stop reading further.
+                    excess_chars = (chars_read + chars_to_add) - max_chars
+                    lines.append(line[:-excess_chars].rstrip("\n"))
+                    if trunc_message:
+                        lines.append(f"[SYSTEM ALERT - max chars ({max_chars}) reached during file read]")
+                    break
+                else:
+                    lines.append(line.rstrip("\n"))
+                    chars_read += chars_to_add
+            if current_line_number >= line_start + num_lines - 1:
+                break
+
+    return "\n".join(lines)
+
+
+def append_to_text_file(self, filename: str, content: str):
+    """
+    Append to a text file.
+
+    Args:
+        filename (str): The name of the file to append to.
+        content (str): Content to append to the file.
+
+    Returns:
+        Optional[str]: None is always returned as this function does not produce a response.
+    """
+    if not os.path.exists(filename):
+        raise FileNotFoundError(f"The file '{filename}' does not exist.")
+
+    with open(filename, "a", encoding="utf-8") as file:
+        file.write(content + "\n")
+
+
+def http_request(self, method: str, url: str, payload_json: Optional[str] = None):
+    """
+    Generates an HTTP request and returns the response.
+
+    Args:
+        method (str): The HTTP method (e.g., 'GET', 'POST').
+        url (str): The URL for the request.
+        payload_json (Optional[str]): A JSON string representing the request payload.
+
+    Returns:
+        dict: The response from the HTTP request.
+    """
+    try:
+        headers = {"Content-Type": "application/json"}
+
+        # For GET requests, ignore the payload
+        if method.upper() == "GET":
+            print(f"[HTTP] launching GET request to {url}")
+            response = requests.get(url, headers=headers)
+        else:
+            # Validate and convert the payload for other types of requests
+            if payload_json:
+                payload = json_loads(payload_json)
+            else:
+                payload = {}
+            print(f"[HTTP] launching {method} request to {url}, payload=\n{json_dumps(payload, indent=2)}")
+            response = requests.request(method, url, json=payload, headers=headers)
+
+        return {"status_code": response.status_code, "headers": dict(response.headers), "body": response.text}
+    except Exception as e:
+        return {"error": str(e)}

letta/functions/functions.py

@@ -0,0 +1,105 @@
+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.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"""
+    source_code = dedent(inspect.getsource(func))
+    return source_code
+
+
+def load_function_set(module: ModuleType) -> dict:
+    """Load the functions and generate schema for them, given a module object"""
+    function_dict = {}
+
+    for attr_name in dir(module):
+        # Get the attribute
+        attr = getattr(module, attr_name)
+
+        # Check if it's a callable function and not a built-in or special method
+        if inspect.isfunction(attr) and attr.__module__ == module.__name__:
+            if attr_name in function_dict:
+                raise ValueError(f"Found a duplicate of function name '{attr_name}'")
+
+            generated_schema = generate_schema(attr)
+            function_dict[attr_name] = {
+                "module": inspect.getsource(module),
+                "python_function": attr,
+                "json_schema": generated_schema,
+            }
+
+    if len(function_dict) == 0:
+        raise ValueError(f"No functions found in module {module}")
+    return function_dict
+
+
+def validate_function(module_name, module_full_path):
+    try:
+        file = os.path.basename(module_full_path)
+        spec = importlib.util.spec_from_file_location(module_name, module_full_path)
+        module = importlib.util.module_from_spec(spec)
+        spec.loader.exec_module(module)
+    except ModuleNotFoundError as e:
+        # Handle missing module imports
+        missing_package = str(e).split("'")[1]  # Extract the name of the missing package
+        print(f"{CLI_WARNING_PREFIX}skipped loading python file '{module_full_path}'!")
+        return (
+            False,
+            f"'{file}' imports '{missing_package}', but '{missing_package}' is not installed locally - install python package '{missing_package}' to link functions from '{file}' to Letta.",
+        )
+    except SyntaxError as e:
+        # Handle syntax errors in the module
+        return False, f"{CLI_WARNING_PREFIX}skipped loading python file '{file}' due to a syntax error: {e}"
+    except Exception as e:
+        # Handle other general exceptions
+        return False, f"{CLI_WARNING_PREFIX}skipped loading python file '{file}': {e}"
+
+    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
+    try:
+        spec = importlib.util.spec_from_file_location(module_name, filepath)
+        module = importlib.util.module_from_spec(spec)
+        spec.loader.exec_module(module)
+    except ModuleNotFoundError as e:
+        # Handle missing module imports
+        missing_package = str(e).split("'")[1]  # Extract the name of the missing package
+        print(f"{CLI_WARNING_PREFIX}skipped loading python file '{filepath}'!")
+        print(
+            f"'{file}' imports '{missing_package}', but '{missing_package}' is not installed locally - install python package '{missing_package}' to link functions from '{file}' to Letta."
+        )
+    # load all functions in the module
+    function_dict = load_function_set(module)
+    return function_dict