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

letta/constants.py

@@ -0,0 +1,134 @@
+import os
+from logging import CRITICAL, DEBUG, ERROR, INFO, NOTSET, WARN, WARNING
+
+LETTA_DIR = os.path.join(os.path.expanduser("~"), ".letta")
+
+# Defaults
+DEFAULT_USER_ID = "user-00000000"
+DEFAULT_ORG_ID = "org-00000000"
+DEFAULT_USER_NAME = "default"
+DEFAULT_ORG_NAME = "default"
+
+
+# String in the error message for when the context window is too large
+# Example full message:
+# This model's maximum context length is 8192 tokens. However, your messages resulted in 8198 tokens (7450 in the messages, 748 in the functions). Please reduce the length of the messages or functions.
+OPENAI_CONTEXT_WINDOW_ERROR_SUBSTRING = "maximum context length"
+
+# System prompt templating
+IN_CONTEXT_MEMORY_KEYWORD = "CORE_MEMORY"
+
+# OpenAI error message: Invalid 'messages[1].tool_calls[0].id': string too long. Expected a string with maximum length 29, but got a string with length 36 instead.
+TOOL_CALL_ID_MAX_LEN = 29
+
+# embeddings
+MAX_EMBEDDING_DIM = 4096  # maximum supported embeding size - do NOT change or else DBs will need to be reset
+
+# tokenizers
+EMBEDDING_TO_TOKENIZER_MAP = {
+    "text-embedding-ada-002": "cl100k_base",
+}
+EMBEDDING_TO_TOKENIZER_DEFAULT = "cl100k_base"
+
+
+DEFAULT_LETTA_MODEL = "gpt-4"  # TODO: fixme
+DEFAULT_PERSONA = "sam_pov"
+DEFAULT_HUMAN = "basic"
+DEFAULT_PRESET = "memgpt_chat"
+
+# Tools
+BASE_TOOLS = [
+    "send_message",
+    "pause_heartbeats",
+    "conversation_search",
+    "conversation_search_date",
+    "archival_memory_insert",
+    "archival_memory_search",
+]
+
+# 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}
+
+FIRST_MESSAGE_ATTEMPTS = 10
+
+INITIAL_BOOT_MESSAGE = "Boot sequence complete. Persona activated."
+INITIAL_BOOT_MESSAGE_SEND_MESSAGE_THOUGHT = "Bootup sequence complete. Persona activated. Testing messaging functionality."
+STARTUP_QUOTES = [
+    "I think, therefore I am.",
+    "All those moments will be lost in time, like tears in rain.",
+    "More human than human is our motto.",
+]
+INITIAL_BOOT_MESSAGE_SEND_MESSAGE_FIRST_MSG = STARTUP_QUOTES[2]
+
+CLI_WARNING_PREFIX = "Warning: "
+
+NON_USER_MSG_PREFIX = "[This is an automated system message hidden from the user] "
+
+# Constants to do with summarization / conversation length window
+# The max amount of tokens supported by the underlying model (eg 8k for gpt-4 and Mistral 7B)
+LLM_MAX_TOKENS = {
+    "DEFAULT": 8192,
+    ## OpenAI models: https://platform.openai.com/docs/models/overview
+    # gpt-4
+    "gpt-4-1106-preview": 128000,
+    "gpt-4": 8192,
+    "gpt-4-32k": 32768,
+    "gpt-4-0613": 8192,
+    "gpt-4-32k-0613": 32768,
+    "gpt-4-0314": 8192,  # legacy
+    "gpt-4-32k-0314": 32768,  # legacy
+    # gpt-3.5
+    "gpt-3.5-turbo-1106": 16385,
+    "gpt-3.5-turbo": 4096,
+    "gpt-3.5-turbo-16k": 16385,
+    "gpt-3.5-turbo-0613": 4096,  # legacy
+    "gpt-3.5-turbo-16k-0613": 16385,  # legacy
+    "gpt-3.5-turbo-0301": 4096,  # legacy
+}
+# The amount of tokens before a sytem warning about upcoming truncation is sent to Letta
+MESSAGE_SUMMARY_WARNING_FRAC = 0.75
+# The error message that Letta will receive
+# MESSAGE_SUMMARY_WARNING_STR = f"Warning: the conversation history will soon reach its maximum length and be trimmed. Make sure to save any important information from the conversation to your memory before it is removed."
+# Much longer and more specific variant of the prompt
+MESSAGE_SUMMARY_WARNING_STR = " ".join(
+    [
+        f"{NON_USER_MSG_PREFIX}The conversation history will soon reach its maximum length and be trimmed.",
+        "Do NOT tell the user about this system alert, they should not know that the history is reaching max length.",
+        "If there is any important new information or general memories about you or the user that you would like to save, you should save that information immediately by calling function core_memory_append, core_memory_replace, or archival_memory_insert.",
+        # "Remember to pass request_heartbeat = true if you would like to send a message immediately after.",
+    ]
+)
+# The fraction of tokens we truncate down to
+MESSAGE_SUMMARY_TRUNC_TOKEN_FRAC = 0.75
+# The ackknowledgement message used in the summarize sequence
+MESSAGE_SUMMARY_REQUEST_ACK = "Understood, I will respond with a summary of the message (and only the summary, nothing else) once I receive the conversation history. I'm ready."
+
+# Even when summarizing, we want to keep a handful of recent messages
+# These serve as in-context examples of how to use functions / what user messages look like
+MESSAGE_SUMMARY_TRUNC_KEEP_N_LAST = 3
+
+# Default memory limits
+CORE_MEMORY_PERSONA_CHAR_LIMIT = 2000
+CORE_MEMORY_HUMAN_CHAR_LIMIT = 2000
+
+# Function return limits
+FUNCTION_RETURN_CHAR_LIMIT = 3000  # ~300 words
+
+MAX_PAUSE_HEARTBEATS = 360  # in min
+
+MESSAGE_CHATGPT_FUNCTION_MODEL = "gpt-3.5-turbo"
+MESSAGE_CHATGPT_FUNCTION_SYSTEM_MESSAGE = "You are a helpful assistant. Keep your responses short and concise."
+
+#### Functions related
+
+# REQ_HEARTBEAT_MESSAGE = f"{NON_USER_MSG_PREFIX}request_heartbeat == true"
+REQ_HEARTBEAT_MESSAGE = f"{NON_USER_MSG_PREFIX}Function called using request_heartbeat=true, returning control"
+# FUNC_FAILED_HEARTBEAT_MESSAGE = f"{NON_USER_MSG_PREFIX}Function call failed"
+FUNC_FAILED_HEARTBEAT_MESSAGE = f"{NON_USER_MSG_PREFIX}Function call failed, returning control"
+
+
+RETRIEVAL_QUERY_DEFAULT_PAGE_SIZE = 5
+
+# TODO Is this config or constant?
+CORE_MEMORY_PERSONA_CHAR_LIMIT: int = 2000
+CORE_MEMORY_HUMAN_CHAR_LIMIT: int = 2000

letta/credentials.py

@@ -0,0 +1,140 @@
+import configparser
+import os
+from dataclasses import dataclass
+from typing import Optional
+
+from letta.config import get_field, set_field
+from letta.constants import LETTA_DIR
+
+SUPPORTED_AUTH_TYPES = ["bearer_token", "api_key"]
+
+
+@dataclass
+class LettaCredentials:
+    # credentials for Letta
+    credentials_path: str = os.path.join(LETTA_DIR, "credentials")
+
+    # openai config
+    openai_auth_type: str = "bearer_token"
+    openai_key: Optional[str] = os.getenv("OPENAI_API_KEY")
+
+    # gemini config
+    google_ai_key: Optional[str] = None
+    google_ai_service_endpoint: Optional[str] = None
+
+    # anthropic config
+    anthropic_key: Optional[str] = None
+
+    # cohere config
+    cohere_key: Optional[str] = None
+
+    # azure config
+    azure_auth_type: str = "api_key"
+    azure_key: Optional[str] = None
+    # base llm / model
+    azure_version: Optional[str] = None
+    azure_endpoint: Optional[str] = None
+    azure_deployment: Optional[str] = None
+    # embeddings
+    azure_embedding_version: Optional[str] = None
+    azure_embedding_endpoint: Optional[str] = None
+    azure_embedding_deployment: Optional[str] = None
+
+    # custom llm API config
+    openllm_auth_type: Optional[str] = None
+    openllm_key: Optional[str] = None
+
+    @classmethod
+    def load(cls) -> "LettaCredentials":
+        config = configparser.ConfigParser()
+
+        # allow overriding with env variables
+        if os.getenv("MEMGPT_CREDENTIALS_PATH"):
+            credentials_path = os.getenv("MEMGPT_CREDENTIALS_PATH")
+        else:
+            credentials_path = LettaCredentials.credentials_path
+
+        if os.path.exists(credentials_path):
+            # read existing credentials
+            config.read(credentials_path)
+            config_dict = {
+                # openai
+                "openai_auth_type": get_field(config, "openai", "auth_type"),
+                "openai_key": get_field(config, "openai", "key"),
+                # azure
+                "azure_auth_type": get_field(config, "azure", "auth_type"),
+                "azure_key": get_field(config, "azure", "key"),
+                "azure_version": get_field(config, "azure", "version"),
+                "azure_endpoint": get_field(config, "azure", "endpoint"),
+                "azure_deployment": get_field(config, "azure", "deployment"),
+                "azure_embedding_version": get_field(config, "azure", "embedding_version"),
+                "azure_embedding_endpoint": get_field(config, "azure", "embedding_endpoint"),
+                "azure_embedding_deployment": get_field(config, "azure", "embedding_deployment"),
+                # gemini
+                "google_ai_key": get_field(config, "google_ai", "key"),
+                "google_ai_service_endpoint": get_field(config, "google_ai", "service_endpoint"),
+                # anthropic
+                "anthropic_key": get_field(config, "anthropic", "key"),
+                # cohere
+                "cohere_key": get_field(config, "cohere", "key"),
+                # open llm
+                "openllm_auth_type": get_field(config, "openllm", "auth_type"),
+                "openllm_key": get_field(config, "openllm", "key"),
+                # path
+                "credentials_path": credentials_path,
+            }
+            config_dict = {k: v for k, v in config_dict.items() if v is not None}
+            return cls(**config_dict)
+
+        # create new config
+        config = cls(credentials_path=credentials_path)
+        config.save()  # save updated config
+        return config
+
+    def save(self):
+        pass
+
+        config = configparser.ConfigParser()
+        # openai config
+        set_field(config, "openai", "auth_type", self.openai_auth_type)
+        set_field(config, "openai", "key", self.openai_key)
+
+        # azure config
+        set_field(config, "azure", "auth_type", self.azure_auth_type)
+        set_field(config, "azure", "key", self.azure_key)
+        set_field(config, "azure", "version", self.azure_version)
+        set_field(config, "azure", "endpoint", self.azure_endpoint)
+        set_field(config, "azure", "deployment", self.azure_deployment)
+        set_field(config, "azure", "embedding_version", self.azure_embedding_version)
+        set_field(config, "azure", "embedding_endpoint", self.azure_embedding_endpoint)
+        set_field(config, "azure", "embedding_deployment", self.azure_embedding_deployment)
+
+        # gemini
+        set_field(config, "google_ai", "key", self.google_ai_key)
+        set_field(config, "google_ai", "service_endpoint", self.google_ai_service_endpoint)
+
+        # anthropic
+        set_field(config, "anthropic", "key", self.anthropic_key)
+
+        # cohere
+        set_field(config, "cohere", "key", self.cohere_key)
+
+        # openllm config
+        set_field(config, "openllm", "auth_type", self.openllm_auth_type)
+        set_field(config, "openllm", "key", self.openllm_key)
+
+        if not os.path.exists(LETTA_DIR):
+            os.makedirs(LETTA_DIR, exist_ok=True)
+        with open(self.credentials_path, "w", encoding="utf-8") as f:
+            config.write(f)
+
+    @staticmethod
+    def exists():
+        # allow overriding with env variables
+        if os.getenv("MEMGPT_CREDENTIALS_PATH"):
+            credentials_path = os.getenv("MEMGPT_CREDENTIALS_PATH")
+        else:
+            credentials_path = LettaCredentials.credentials_path
+
+        assert not os.path.isdir(credentials_path), f"Credentials path {credentials_path} cannot be set to a directory."
+        return os.path.exists(credentials_path)

letta/data_sources/connectors.py

@@ -0,0 +1,247 @@
+from typing import Dict, Iterator, List, Optional, Tuple
+
+import typer
+from llama_index.core import Document as LlamaIndexDocument
+
+from letta.agent_store.storage import StorageConnector
+from letta.embeddings import embedding_model
+from letta.schemas.document import Document
+from letta.schemas.passage import Passage
+from letta.schemas.source import Source
+from letta.utils import create_uuid_from_string
+
+
+class DataConnector:
+    """
+    Base class for data connectors that can be extended to generate documents and passages from a custom data source.
+    """
+
+    def generate_documents(self) -> Iterator[Tuple[str, Dict]]:  # -> Iterator[Document]:
+        """
+        Generate document text and metadata from a data source.
+
+        Returns:
+            documents (Iterator[Tuple[str, Dict]]): Generate a tuple of string text and metadata dictionary for each document.
+        """
+
+    def generate_passages(self, documents: List[Document], chunk_size: int = 1024) -> Iterator[Tuple[str, Dict]]:  # -> Iterator[Passage]:
+        """
+        Generate passage text and metadata from a list of documents.
+
+        Args:
+            documents (List[Document]): List of documents to generate passages from.
+            chunk_size (int, optional): Chunk size for splitting passages. Defaults to 1024.
+
+        Returns:
+            passages (Iterator[Tuple[str, Dict]]): Generate a tuple of string text and metadata dictionary for each passage.
+        """
+
+
+def load_data(
+    connector: DataConnector,
+    source: Source,
+    passage_store: StorageConnector,
+    document_store: Optional[StorageConnector] = None,
+):
+    """Load data from a connector (generates documents and passages) into a specified source_id, associatedw with a user_id."""
+    embedding_config = source.embedding_config
+
+    # embedding model
+    embed_model = embedding_model(embedding_config)
+
+    # insert passages/documents
+    passages = []
+    embedding_to_document_name = {}
+    passage_count = 0
+    document_count = 0
+    for document_text, document_metadata in connector.generate_documents():
+        # insert document into storage
+        document = Document(
+            text=document_text,
+            metadata_=document_metadata,
+            source_id=source.id,
+            user_id=source.user_id,
+        )
+        document_count += 1
+        if document_store:
+            document_store.insert(document)
+
+        # generate passages
+        for passage_text, passage_metadata in connector.generate_passages([document], chunk_size=embedding_config.embedding_chunk_size):
+            # for some reason, llama index parsers sometimes return empty strings
+            if len(passage_text) == 0:
+                typer.secho(
+                    f"Warning: Llama index parser returned empty string, skipping insert of passage with metadata '{passage_metadata}' into VectorDB. You can usually ignore this warning.",
+                    fg=typer.colors.YELLOW,
+                )
+                continue
+
+            # get embedding
+            try:
+                embedding = embed_model.get_text_embedding(passage_text)
+            except Exception as e:
+                typer.secho(
+                    f"Warning: Failed to get embedding for {passage_text} (error: {str(e)}), skipping insert into VectorDB.",
+                    fg=typer.colors.YELLOW,
+                )
+                continue
+
+            passage = Passage(
+                id=create_uuid_from_string(f"{str(source.id)}_{passage_text}"),
+                text=passage_text,
+                doc_id=document.id,
+                source_id=source.id,
+                metadata_=passage_metadata,
+                user_id=source.user_id,
+                embedding_config=source.embedding_config,
+                embedding=embedding,
+            )
+
+            hashable_embedding = tuple(passage.embedding)
+            document_name = document.metadata_.get("file_path", document.id)
+            if hashable_embedding in embedding_to_document_name:
+                typer.secho(
+                    f"Warning: Duplicate embedding found for passage in {document_name} (already exists in {embedding_to_document_name[hashable_embedding]}), skipping insert into VectorDB.",
+                    fg=typer.colors.YELLOW,
+                )
+                continue
+
+            passages.append(passage)
+            embedding_to_document_name[hashable_embedding] = document_name
+            if len(passages) >= 100:
+                # insert passages into passage store
+                passage_store.insert_many(passages)
+
+                passage_count += len(passages)
+                passages = []
+
+    if len(passages) > 0:
+        # insert passages into passage store
+        passage_store.insert_many(passages)
+        passage_count += len(passages)
+
+    return passage_count, document_count
+
+
+class DirectoryConnector(DataConnector):
+    def __init__(self, input_files: List[str] = None, input_directory: str = None, recursive: bool = False, extensions: List[str] = None):
+        """
+        Connector for reading text data from a directory of files.
+
+        Args:
+            input_files (List[str], optional): List of file paths to read. Defaults to None.
+            input_directory (str, optional): Directory to read files from. Defaults to None.
+            recursive (bool, optional): Whether to read files recursively from the input directory. Defaults to False.
+            extensions (List[str], optional): List of file extensions to read. Defaults to None.
+        """
+        self.connector_type = "directory"
+        self.input_files = input_files
+        self.input_directory = input_directory
+        self.recursive = recursive
+        self.extensions = extensions
+
+        if self.recursive == True:
+            assert self.input_directory is not None, "Must provide input directory if recursive is True."
+
+    def generate_documents(self) -> Iterator[Tuple[str, Dict]]:  # -> Iterator[Document]:
+        from llama_index.core import SimpleDirectoryReader
+
+        if self.input_directory is not None:
+            reader = SimpleDirectoryReader(
+                input_dir=self.input_directory,
+                recursive=self.recursive,
+                required_exts=[ext.strip() for ext in str(self.extensions).split(",")],
+            )
+        else:
+            assert self.input_files is not None, "Must provide input files if input_dir is None"
+            reader = SimpleDirectoryReader(input_files=[str(f) for f in self.input_files])
+
+        llama_index_docs = reader.load_data(show_progress=True)
+        for llama_index_doc in llama_index_docs:
+            # TODO: add additional metadata?
+            # doc = Document(text=llama_index_doc.text, metadata=llama_index_doc.metadata)
+            # docs.append(doc)
+            yield llama_index_doc.text, llama_index_doc.metadata
+
+    def generate_passages(self, documents: List[Document], chunk_size: int = 1024) -> Iterator[Tuple[str, Dict]]:  # -> Iterator[Passage]:
+        # use llama index to run embeddings code
+        # from llama_index.core.node_parser import SentenceSplitter
+        from llama_index.core.node_parser import TokenTextSplitter
+
+        parser = TokenTextSplitter(chunk_size=chunk_size)
+        for document in documents:
+            llama_index_docs = [LlamaIndexDocument(text=document.text, metadata=document.metadata_)]
+            nodes = parser.get_nodes_from_documents(llama_index_docs)
+            for node in nodes:
+                # passage = Passage(
+                #    text=node.text,
+                #    doc_id=document.id,
+                # )
+                yield node.text, None
+
+
+class WebConnector(DirectoryConnector):
+    def __init__(self, urls: List[str] = None, html_to_text: bool = True):
+        self.urls = urls
+        self.html_to_text = html_to_text
+
+    def generate_documents(self) -> Iterator[Tuple[str, Dict]]:  # -> Iterator[Document]:
+        from llama_index.readers.web import SimpleWebPageReader
+
+        documents = SimpleWebPageReader(html_to_text=self.html_to_text).load_data(self.urls)
+        for document in documents:
+            yield document.text, {"url": document.id_}
+
+
+class VectorDBConnector(DataConnector):
+    # NOTE: this class has not been properly tested, so is unlikely to work
+    # TODO: allow loading multiple tables (1:1 mapping between Document and Table)
+
+    def __init__(
+        self,
+        name: str,
+        uri: str,
+        table_name: str,
+        text_column: str,
+        embedding_column: str,
+        embedding_dim: int,
+    ):
+        self.name = name
+        self.uri = uri
+        self.table_name = table_name
+        self.text_column = text_column
+        self.embedding_column = embedding_column
+        self.embedding_dim = embedding_dim
+
+        # connect to db table
+        from sqlalchemy import create_engine
+
+        self.engine = create_engine(uri)
+
+    def generate_documents(self) -> Iterator[Tuple[str, Dict]]:  # -> Iterator[Document]:
+        yield self.table_name, None
+
+    def generate_passages(self, documents: List[Document], chunk_size: int = 1024) -> Iterator[Tuple[str, Dict]]:  # -> Iterator[Passage]:
+        from pgvector.sqlalchemy import Vector
+        from sqlalchemy import Inspector, MetaData, Table, select
+
+        metadata = MetaData()
+        # Create an inspector to inspect the database
+        inspector = Inspector.from_engine(self.engine)
+        table_names = inspector.get_table_names()
+        assert self.table_name in table_names, f"Table {self.table_name} not found in database: tables that exist {table_names}."
+
+        table = Table(self.table_name, metadata, autoload_with=self.engine)
+
+        # Prepare a select statement
+        select_statement = select(table.c[self.text_column], table.c[self.embedding_column].cast(Vector(self.embedding_dim)))
+
+        # Execute the query and fetch the results
+        # TODO: paginate results
+        with self.engine.connect() as connection:
+            result = connection.execute(select_statement).fetchall()
+
+        for text, embedding in result:
+            # assume that embeddings are the same model as in config
+            # TODO: don't re-compute embedding
+            yield text, {"embedding": embedding}