letta-nightly 0.6.3.dev20241211104238__py3-none-any.whl → 0.6.3.dev20241212104231__py3-none-any.whl

letta/agent.py

@@ -8,7 +8,6 @@ from typing import List, Literal, Optional, Tuple, Union
 
 from tqdm import tqdm
 
-from letta.agent_store.storage import StorageConnector
 from letta.constants import (
     BASE_TOOLS,
     CLI_WARNING_PREFIX,

letta/data_sources/connectors.py

@@ -2,7 +2,6 @@ from typing import Dict, Iterator, List, Tuple, Optional
 
 import typer
 
-from letta.agent_store.storage import StorageConnector
 from letta.data_sources.connectors_helper import (
     assert_all_files_exist_locally,
     extract_metadata_from_files,
@@ -12,6 +11,7 @@ from letta.embeddings import embedding_model
 from letta.schemas.file import FileMetadata
 from letta.schemas.passage import Passage
 from letta.schemas.source import Source
+from letta.services.passage_manager import PassageManager
 from letta.services.source_manager import SourceManager
 from letta.utils import create_uuid_from_string
 
@@ -42,7 +42,7 @@ class DataConnector:
         """
 
 
-def load_data(connector: DataConnector, source: Source, passage_store: StorageConnector, source_manager: SourceManager, actor: "User", agent_id: Optional[str] = None):
+def load_data(connector: DataConnector, source: Source, passage_manager: PassageManager, source_manager: SourceManager, actor: "User", agent_id: Optional[str] = None):
     """Load data from a connector (generates file and passages) into a specified source_id, associated with a user_id."""
     embedding_config = source.embedding_config
 
@@ -103,14 +103,14 @@ def load_data(connector: DataConnector, source: Source, passage_store: StorageCo
             embedding_to_document_name[hashable_embedding] = file_name
             if len(passages) >= 100:
                 # insert passages into passage store
-                passage_store.insert_many(passages)
+                passage_manager.create_many_passages(passages, actor)
 
                 passage_count += len(passages)
                 passages = []
 
     if len(passages) > 0:
         # insert passages into passage store
-        passage_store.insert_many(passages)
+        passage_manager.create_many_passages(passages, actor)
         passage_count += len(passages)
 
     return passage_count, file_count
@@ -170,74 +170,3 @@ class DirectoryConnector(DataConnector):
         nodes = parser.get_nodes_from_documents(documents)
         for node in nodes:
             yield node.text, None
-
-
-"""
-The below isn't used anywhere, it isn't tested, and pretty much should be deleted.
-- Matt
-"""
-# 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_files(self) -> Iterator[Tuple[str, Dict]]:  # -> Iterator[Document]:
-#         from llama_index.readers.web import SimpleWebPageReader
-#
-#         files = SimpleWebPageReader(html_to_text=self.html_to_text).load_data(self.urls)
-#         for document in files:
-#             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 FileMetadata 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_files(self) -> Iterator[Tuple[str, Dict]]:  # -> Iterator[Document]:
-#         yield self.table_name, None
-#
-#     def generate_passages(self, file_text: str, file: FileMetadata, 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}

letta/memory.py

@@ -87,280 +87,3 @@ def summarize_messages(
     printd(f"summarize_messages gpt reply: {response.choices[0]}")
     reply = response.choices[0].message.content
     return reply
-
-
-class ArchivalMemory(ABC):
-    @abstractmethod
-    def insert(self, memory_string: str):
-        """Insert new archival memory
-
-        :param memory_string: Memory string to insert
-        :type memory_string: str
-        """
-
-    @abstractmethod
-    def search(self, query_string, count=None, start=None) -> Tuple[List[str], int]:
-        """Search archival memory
-
-        :param query_string: Query string
-        :type query_string: str
-        :param count: Number of results to return (None for all)
-        :type count: Optional[int]
-        :param start: Offset to start returning results from (None if 0)
-        :type start: Optional[int]
-
-        :return: Tuple of (list of results, total number of results)
-        """
-
-    @abstractmethod
-    def compile(self) -> str:
-        """Convert archival memory into a string representation for a prompt"""
-
-    @abstractmethod
-    def count(self) -> int:
-        """Count the number of memories in the archival memory"""
-
-
-class RecallMemory(ABC):
-    @abstractmethod
-    def text_search(self, query_string, count=None, start=None):
-        """Search messages that match query_string in recall memory"""
-
-    @abstractmethod
-    def date_search(self, start_date, end_date, count=None, start=None):
-        """Search messages between start_date and end_date in recall memory"""
-
-    @abstractmethod
-    def compile(self) -> str:
-        """Convert recall memory into a string representation for a prompt"""
-
-    @abstractmethod
-    def count(self) -> int:
-        """Count the number of memories in the recall memory"""
-
-    @abstractmethod
-    def insert(self, message: Message):
-        """Insert message into recall memory"""
-
-
-class DummyRecallMemory(RecallMemory):
-    """Dummy in-memory version of a recall memory database (eg run on MongoDB)
-
-    Recall memory here is basically just a full conversation history with the user.
-    Queryable via string matching, or date matching.
-
-    Recall Memory: The AI's capability to search through past interactions,
-    effectively allowing it to 'remember' prior engagements with a user.
-    """
-
-    def __init__(self, message_database=None, restrict_search_to_summaries=False):
-        self._message_logs = [] if message_database is None else message_database  # consists of full message dicts
-
-        # If true, the pool of messages that can be queried are the automated summaries only
-        # (generated when the conversation window needs to be shortened)
-        self.restrict_search_to_summaries = restrict_search_to_summaries
-
-    def __len__(self):
-        return len(self._message_logs)
-
-    def count(self) -> int:
-        return len(self)
-
-    def compile(self) -> str:
-        # don't dump all the conversations, just statistics
-        system_count = user_count = assistant_count = function_count = other_count = 0
-        for msg in self._message_logs:
-            role = msg["message"]["role"]
-            if role == "system":
-                system_count += 1
-            elif role == "user":
-                user_count += 1
-            elif role == "assistant":
-                assistant_count += 1
-            elif role == "function":
-                function_count += 1
-            else:
-                other_count += 1
-        memory_str = (
-            f"Statistics:"
-            + f"\n{len(self._message_logs)} total messages"
-            + f"\n{system_count} system"
-            + f"\n{user_count} user"
-            + f"\n{assistant_count} assistant"
-            + f"\n{function_count} function"
-            + f"\n{other_count} other"
-        )
-        return f"\n### RECALL MEMORY ###" + f"\n{memory_str}"
-
-    def insert(self, message):
-        raise NotImplementedError("This should be handled by the PersistenceManager, recall memory is just a search layer on top")
-
-    def text_search(self, query_string, count=None, start=None):
-        # in the dummy version, run an (inefficient) case-insensitive match search
-        message_pool = [d for d in self._message_logs if d["message"]["role"] not in ["system", "function"]]
-        start = 0 if start is None else int(start)
-        count = 0 if count is None else int(count)
-
-        printd(
-            f"recall_memory.text_search: searching for {query_string} (c={count}, s={start}) in {len(self._message_logs)} total messages"
-        )
-        matches = [
-            d for d in message_pool if d["message"]["content"] is not None and query_string.lower() in d["message"]["content"].lower()
-        ]
-        printd(f"recall_memory - matches:\n{matches[start:start+count]}")
-
-        # start/count support paging through results
-        if start is not None and count is not None:
-            return matches[start : start + count], len(matches)
-        elif start is None and count is not None:
-            return matches[:count], len(matches)
-        elif start is not None and count is None:
-            return matches[start:], len(matches)
-        else:
-            return matches, len(matches)
-
-    def date_search(self, start_date, end_date, count=None, start=None):
-        message_pool = [d for d in self._message_logs if d["message"]["role"] not in ["system", "function"]]
-
-        # First, validate the start_date and end_date format
-        if not validate_date_format(start_date) or not validate_date_format(end_date):
-            raise ValueError("Invalid date format. Expected format: YYYY-MM-DD")
-
-        # Convert dates to datetime objects for comparison
-        start_date_dt = datetime.datetime.strptime(start_date, "%Y-%m-%d")
-        end_date_dt = datetime.datetime.strptime(end_date, "%Y-%m-%d")
-
-        # Next, match items inside self._message_logs
-        matches = [
-            d
-            for d in message_pool
-            if start_date_dt <= datetime.datetime.strptime(extract_date_from_timestamp(d["timestamp"]), "%Y-%m-%d") <= end_date_dt
-        ]
-
-        # start/count support paging through results
-        start = 0 if start is None else int(start)
-        count = 0 if count is None else int(count)
-        if start is not None and count is not None:
-            return matches[start : start + count], len(matches)
-        elif start is None and count is not None:
-            return matches[:count], len(matches)
-        elif start is not None and count is None:
-            return matches[start:], len(matches)
-        else:
-            return matches, len(matches)
-
-
-class EmbeddingArchivalMemory(ArchivalMemory):
-    """Archival memory with embedding based search"""
-
-    def __init__(self, agent_state: AgentState, top_k: int = 100):
-        """Init function for archival memory
-
-        :param archival_memory_database: name of dataset to pre-fill archival with
-        :type archival_memory_database: str
-        """
-        from letta.agent_store.storage import StorageConnector
-
-        self.top_k = top_k
-        self.agent_state = agent_state
-
-        # create embedding model
-        self.embed_model = embedding_model(agent_state.embedding_config)
-        if agent_state.embedding_config.embedding_chunk_size is None:
-            raise ValueError(f"Must set {agent_state.embedding_config.embedding_chunk_size}")
-        else:
-            self.embedding_chunk_size = agent_state.embedding_config.embedding_chunk_size
-
-        # create storage backend
-        self.storage = StorageConnector.get_archival_storage_connector(user_id=agent_state.user_id, agent_id=agent_state.id)
-        # TODO: have some mechanism for cleanup otherwise will lead to OOM
-        self.cache = {}
-
-    def create_passage(self, text, embedding):
-        return Passage(
-            user_id=self.agent_state.user_id,
-            agent_id=self.agent_state.id,
-            text=text,
-            embedding=embedding,
-            embedding_config=self.agent_state.embedding_config,
-        )
-
-    def save(self):
-        """Save the index to disk"""
-        self.storage.save()
-
-    def insert(self, memory_string, return_ids=False) -> Union[bool, List[str]]:
-        """Embed and save memory string"""
-
-        if not isinstance(memory_string, str):
-            raise TypeError("memory must be a string")
-
-        try:
-            passages = []
-
-            # breakup string into passages
-            for text in parse_and_chunk_text(memory_string, self.embedding_chunk_size):
-                embedding = self.embed_model.get_text_embedding(text)
-                # fixing weird bug where type returned isn't a list, but instead is an object
-                # eg: embedding={'object': 'list', 'data': [{'object': 'embedding', 'embedding': [-0.0071973633, -0.07893023,
-                if isinstance(embedding, dict):
-                    try:
-                        embedding = embedding["data"][0]["embedding"]
-                    except (KeyError, IndexError):
-                        # TODO as a fallback, see if we can find any lists in the payload
-                        raise TypeError(
-                            f"Got back an unexpected payload from text embedding function, type={type(embedding)}, value={embedding}"
-                        )
-                passages.append(self.create_passage(text, embedding))
-
-            # grab the return IDs before the list gets modified
-            ids = [str(p.id) for p in passages]
-
-            # insert passages
-            self.storage.insert_many(passages)
-
-            if return_ids:
-                return ids
-            else:
-                return True
-
-        except Exception as e:
-            print("Archival insert error", e)
-            raise e
-
-    def search(self, query_string, count=None, start=None):
-        """Search query string"""
-        start = 0 if start is None else int(start)
-        count = self.top_k if count is None else int(count)
-
-        if not isinstance(query_string, str):
-            return TypeError("query must be a string")
-
-        try:
-            if query_string not in self.cache:
-                # self.cache[query_string] = self.retriever.retrieve(query_string)
-                query_vec = query_embedding(self.embed_model, query_string)
-                self.cache[query_string] = self.storage.query(query_string, query_vec, top_k=self.top_k)
-
-            end = min(count + start, len(self.cache[query_string]))
-
-            results = self.cache[query_string][start:end]
-            results = [{"timestamp": get_local_time(), "content": node.text} for node in results]
-            return results, len(results)
-        except Exception as e:
-            print("Archival search error", e)
-            raise e
-
-    def compile(self) -> str:
-        limit = 10
-        passages = []
-        for passage in list(self.storage.get_all(limit=limit)):  # TODO: only get first 10
-            passages.append(str(passage.text))
-        memory_str = "\n".join(passages)
-        return f"\n### ARCHIVAL MEMORY ###" + f"\n{memory_str}" + f"\nSize: {self.storage.size()}"
-
-    def __len__(self):
-        return self.storage.size()
-
-    def count(self) -> int:
-        return len(self)

letta/server/server.py

@@ -16,7 +16,6 @@ import letta.constants as constants
 import letta.server.utils as server_utils
 import letta.system as system
 from letta.agent import Agent, save_agent
-from letta.agent_store.storage import StorageConnector, TableType
 from letta.chat_only_agent import ChatOnlyAgent
 from letta.credentials import LettaCredentials
 from letta.data_sources.connectors import DataConnector, load_data
@@ -558,7 +557,6 @@ class SyncServer(Server):
                 raise ValueError(command)
 
             # attach data to agent from source
-            source_connector = StorageConnector.get_storage_connector(TableType.PASSAGES, self.config, user_id=user_id)
             letta_agent.attach_source(
                 user=self.user_manager.get_user_by_id(user_id=user_id),
                 source_id=data_source,
@@ -1571,8 +1569,7 @@ class SyncServer(Server):
         self.source_manager.delete_source(source_id=source_id, actor=actor)
 
         # delete data from passage store
-        passage_store = StorageConnector.get_storage_connector(TableType.PASSAGES, self.config, user_id=actor.id)
-        passage_store.delete({"source_id": source_id})
+        self.passage_manager.delete_passages(actor=actor, limit=None, source_id=source_id)
 
         # TODO: delete data from agent passage stores (?)
 
@@ -1614,11 +1611,10 @@ class SyncServer(Server):
         if source is None:
             raise ValueError(f"Data source {source_name} does not exist for user {user_id}")
 
-        # get the data connectors
-        passage_store = StorageConnector.get_storage_connector(TableType.PASSAGES, self.config, user_id=user_id)
-
         # load data into the document store
-        passage_count, document_count = load_data(connector, source, passage_store, self.source_manager, actor=user, agent_id=agent_id)
+        passage_count, document_count = load_data(
+            connector, source, self.passage_manager, self.source_manager, actor=user, agent_id=agent_id
+        )
         return passage_count, document_count
 
     def attach_source_to_agent(
@@ -1694,8 +1690,7 @@ class SyncServer(Server):
         for source in sources:
 
             # count number of passages
-            passage_conn = StorageConnector.get_storage_connector(TableType.PASSAGES, self.config, user_id=actor.id)
-            num_passages = passage_conn.size({"source_id": source.id})
+            num_passages = self.passage_manager.size(actor=actor, source_id=source.id)
 
             # TODO: add when files table implemented
             ## count number of files
@@ -1806,14 +1801,20 @@ class SyncServer(Server):
 
         llm_models = []
         for provider in self._enabled_providers:
-            llm_models.extend(provider.list_llm_models())
+            try:
+                llm_models.extend(provider.list_llm_models())
+            except Exception as e:
+                warnings.warn(f"An error occurred while listing LLM models for provider {provider}: {e}")
         return llm_models
 
     def list_embedding_models(self) -> List[EmbeddingConfig]:
         """List available embedding models"""
         embedding_models = []
         for provider in self._enabled_providers:
-            embedding_models.extend(provider.list_embedding_models())
+            try:
+                embedding_models.extend(provider.list_embedding_models())
+            except Exception as e:
+                warnings.warn(f"An error occurred while listing embedding models for provider {provider}: {e}")
         return embedding_models
 
     def add_llm_model(self, request: LLMConfig) -> LLMConfig:

letta/settings.py

@@ -17,7 +17,7 @@ class ToolSettings(BaseSettings):
 
 class ModelSettings(BaseSettings):
 
-    model_config = SettingsConfigDict(env_file='.env')
+    model_config = SettingsConfigDict(env_file='.env', extra='ignore')
 
     # env_prefix='my_prefix_'
 
@@ -64,7 +64,7 @@ cors_origins = ["http://letta.localhost", "http://localhost:8283", "http://local
 
 
 class Settings(BaseSettings):
-    model_config = SettingsConfigDict(env_prefix="letta_")
+    model_config = SettingsConfigDict(env_prefix="letta_", extra='ignore')
 
     letta_dir: Optional[Path] = Field(Path.home() / ".letta", env="LETTA_DIR")
     debug: Optional[bool] = False
@@ -103,7 +103,7 @@ class Settings(BaseSettings):
 
 
 class TestSettings(Settings):
-    model_config = SettingsConfigDict(env_prefix="letta_test_")
+    model_config = SettingsConfigDict(env_prefix="letta_test_", extra='ignore')
 
     letta_dir: Optional[Path] = Field(Path.home() / ".letta/test", env="LETTA_TEST_DIR")
 

{letta_nightly-0.6.3.dev20241211104238.dist-info → letta_nightly-0.6.3.dev20241212104231.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: letta-nightly
-Version: 0.6.3.dev20241211104238
+Version: 0.6.3.dev20241212104231
 Summary: Create LLM agents with long-term memory and custom tools
 License: Apache License
 Author: Letta Team
@@ -82,9 +82,9 @@ Description-Content-Type: text/markdown
 
 <p align="center">
   <picture>
-    <source media="(prefers-color-scheme: dark)" srcset="assets/Letta-logo-RGB_GreyonTransparent_cropped_small.png">
-    <source media="(prefers-color-scheme: light)" srcset="assets/Letta-logo-RGB_OffBlackonTransparent_cropped_small.png">
-    <img alt="Letta logo" src="assets/Letta-logo-RGB_GreyonOffBlack_cropped_small.png" width="500">
+    <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/letta-ai/letta/refs/heads/main/assets/Letta-logo-RGB_GreyonTransparent_cropped_small.png">
+    <source media="(prefers-color-scheme: light)" srcset="https://raw.githubusercontent.com/letta-ai/letta/refs/heads/main/assets/Letta-logo-RGB_OffBlackonTransparent_cropped_small.png">
+    <img alt="Letta logo" src="https://raw.githubusercontent.com/letta-ai/letta/refs/heads/main/assets/Letta-logo-RGB_GreyonOffBlack_cropped_small.png" width="500">
   </picture>
 </p>
 
@@ -95,9 +95,9 @@ Description-Content-Type: text/markdown
 
 <p align="center">
   <picture>
-    <source media="(prefers-color-scheme: dark)" srcset="assets/example_ade_screenshot.png">
-    <source media="(prefers-color-scheme: light)" srcset="assets/example_ade_screenshot_light.png">
-    <img alt="Letta logo" src="assets/example_ade_screenshot.png" width="800">
+    <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/letta-ai/letta/refs/heads/main/assets/example_ade_screenshot.png">
+    <source media="(prefers-color-scheme: light)" srcset="https://raw.githubusercontent.com/letta-ai/letta/refs/heads/main/assets/example_ade_screenshot_light.png">
+    <img alt="Letta logo" src="https://raw.githubusercontent.com/letta-ai/letta/refs/heads/main/assets/example_ade_screenshot.png" width="800">
   </picture>
 </p>
 
@@ -133,7 +133,7 @@ Description-Content-Type: text/markdown
 
 ## ⚡ Quickstart
 
-_The recommended way to use Letta is to run use Docker. To install Docker, see [Docker's installation guide](https://docs.docker.com/get-docker/). For issues with installing Docker, see [Docker's troubleshooting guide](https://docs.docker.com/desktop/troubleshoot-and-support/troubleshoot/). You can also install Letta using `pip` (see guide [below](#-quickstart-pip))._
+_The recommended way to use Letta is to run use Docker. To install Docker, see [Docker's installation guide](https://docs.docker.com/get-docker/). For issues with installing Docker, see [Docker's troubleshooting guide](https://docs.docker.com/desktop/troubleshoot-and-support/troubleshoot/). You can also install Letta using `pip` (see instructions [below](#-quickstart-pip))._
 
 ### 🌖 Run the Letta server
 
@@ -171,9 +171,9 @@ Once the Letta server is running, you can access it via port `8283` (e.g. sendin
 
 <p align="center">
   <picture>
-    <source media="(prefers-color-scheme: dark)" srcset="assets/example_ade_screenshot.png">
-    <source media="(prefers-color-scheme: light)" srcset="assets/example_ade_screenshot_light.png">
-    <img alt="Letta logo" src="assets/example_ade_screenshot.png" width="800">
+    <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/letta-ai/letta/refs/heads/main/assets/example_ade_screenshot.png">
+    <source media="(prefers-color-scheme: light)" srcset="https://raw.githubusercontent.com/letta-ai/letta/refs/heads/main/assets/example_ade_screenshot_light.png">
+    <img alt="ADE screenshot" src="https://raw.githubusercontent.com/letta-ai/letta/refs/heads/main/assets/example_ade_screenshot.png" width="800">
   </picture>
 </p>
 
@@ -186,9 +186,9 @@ To connect the ADE with your local Letta server, simply:
 
 <p align="center">
   <picture>
-    <source media="(prefers-color-scheme: dark)" srcset="assets/example_ade_screenshot_agents.png">
-    <source media="(prefers-color-scheme: light)" srcset="assets/example_ade_screenshot_agents_light.png">
-    <img alt="Letta logo" src="assets/example_ade_screenshot_agents.png" width="800">
+    <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/letta-ai/letta/refs/heads/main/assets/example_ade_screenshot_agents.png">
+    <source media="(prefers-color-scheme: light)" srcset="https://raw.githubusercontent.com/letta-ai/letta/refs/heads/main/assets/example_ade_screenshot_agents_light.png">
+    <img alt="Letta logo" src="https://raw.githubusercontent.com/letta-ai/letta/refs/heads/main/assets/example_ade_screenshot_agents.png" width="800">
   </picture>
 </p>
 
@@ -217,6 +217,18 @@ If your Letta server isn't running on `localhost` (for example, you deployed it
 
 No, you can install Letta using `pip` (via `pip install -U letta`), as well as from source (via `poetry install`). See instructions below.
 
+> _"What's the difference between installing with `pip` vs `Docker`?"_
+
+Letta gives your agents persistence (they live indefinitely) by storing all your agent data in a database. Letta is designed to be used with a [PostgreSQL](https://en.wikipedia.org/wiki/PostgreSQL) (the world's most popular database), however, it is not possible to install PostgreSQL via `pip`, so the `pip` install of Letta defaults to using [SQLite](https://www.sqlite.org/). If you have a PostgreSQL instance running on your own computer, you can still connect Letta (installed via `pip`) to PostgreSQL by setting the environment variable `LETTA_PG_URI`.
+
+**Database migrations are not officially supported for Letta when using SQLite**, so you would like to ensure that if you're able to upgrade to the latest Letta version and migrate your Letta agents data, make sure that you're using PostgreSQL as your Letta database backend. Full compatability table below:
+
+| Installation method | Start server command | Database backend | Data migrations supported? |
+|---|---|---|---|
+| `pip install letta` | `letta server` | SQLite | ❌ |
+| `pip install letta` | `export LETTA_PG_URI=...` + `letta server` | PostgreSQL | ✅ |
+| *[Install Docker](https://www.docker.com/get-started/)*  |`docker run ...` ([full command](#-run-the-letta-server)) | PostgreSQL | ✅ |
+
 > _"How do I use the ADE locally?"_
 
 To connect the ADE to your local Letta server, simply run your Letta server (make sure you can access `localhost:8283`) and go to [https://app.letta.com](https://app.letta.com). If you would like to use the old version of the ADE (that runs on `localhost`), downgrade to Letta version `<=0.5.0`.

{letta_nightly-0.6.3.dev20241211104238.dist-info → letta_nightly-0.6.3.dev20241212104231.dist-info}/RECORD

@@ -1,10 +1,6 @@
 letta/__init__.py,sha256=XzSCdK-rlcvOAsPJarW8Ri5qelGVdpX237ds-yjHniY,1035
 letta/__main__.py,sha256=6Hs2PV7EYc5Tid4g4OtcLXhqVHiNYTGzSBdoOnW2HXA,29
-letta/agent.py,sha256=D4staw-NnTzsG31kV7cvb7fvLIpkeZii1rXsQIRPC0s,78058
-letta/agent_store/db.py,sha256=Rzgodcr-eT6DXnFr5bt4psiVpeH0Gy1BS16Ethf2CHw,19016
-letta/agent_store/milvus.py,sha256=xUu-D9a6N10MuGJ-R-QWR2IHX77ueqAp88tV4gg9B4M,8470
-letta/agent_store/qdrant.py,sha256=6_33V-FEDpT9LG5zmr6-3y9slw1YFLswxpahiyMkvHA,7880
-letta/agent_store/storage.py,sha256=F0kpHr8ALaph630ItxZ1ijYOMNq7P7sRrkP-2LkywVU,6547
+letta/agent.py,sha256=3jXQZ2Yjg_szr7-1zMzaPq1R5qpoAg5BalpUqaX_uig,78003
 letta/benchmark/benchmark.py,sha256=ebvnwfp3yezaXOQyGXkYCDYpsmre-b9hvNtnyx4xkG0,3701
 letta/benchmark/constants.py,sha256=aXc5gdpMGJT327VuxsT5FngbCK2J41PQYeICBO7g_RE,536
 letta/chat_only_agent.py,sha256=606FQybmeN9s04rIFQlDkWOHirrT0p48_3pMKY8d5Ts,4740
@@ -18,7 +14,7 @@ letta/client/utils.py,sha256=OJlAKWrldc4I6M1WpcTWNtPJ4wfxlzlZqWLfCozkFtI,2872
 letta/config.py,sha256=06F-kPu9r6AMOvz5uX6WKVrgE8h6QqSxWni3TT16ZdY,18923
 letta/constants.py,sha256=l2IyZpVG-d_raFFX5bN6mCbprnnc1IA-z-oCKPoyPSM,6902
 letta/credentials.py,sha256=D9mlcPsdDWlIIXQQD8wSPE9M_QvsRrb0p3LB5i9OF5Q,5806
-letta/data_sources/connectors.py,sha256=o6XhyeONu4FB7CM7l9K705M9zV8jE2ExddYy_ZjgYgs,10010
+letta/data_sources/connectors.py,sha256=zMN6EGZ-BRQdF8l6ZUqhONdn6H4lBNH7h5zKKclxyMg,7245
 letta/data_sources/connectors_helper.py,sha256=2TQjCt74fCgT5sw1AP8PalDEk06jPBbhrPG4HVr-WLs,3371
 letta/embeddings.py,sha256=XyecUdJaG3ENi5v3wAexVcgpG2g7_oTEEYLgUpm-Zvs,9080
 letta/errors.py,sha256=Voy_BP0W_M816-vWudKLBlgydRufPPA-Q2PNd-SvZYc,3897
@@ -83,7 +79,7 @@ letta/local_llm/webui/legacy_settings.py,sha256=BLmd3TSx5StnY3ibjwaxYATPt_Lvq-o1
 letta/local_llm/webui/settings.py,sha256=gmLHfiOl1u4JmlAZU2d2O8YKF9lafdakyjwR_ftVPh8,552
 letta/log.py,sha256=FxkAk2f8Bl-u9dfImSj1DYnjAsmV6PL3tjTSnEiNP48,2218
 letta/main.py,sha256=3rvn5rHMpChmgDsYKAH8GX7lLVsIzxLmkPhDJt6nFKA,19067
-letta/memory.py,sha256=R4Z_MYD5ve04FBe2yohux1pzp8MTjOSI1AZ5oLCdGRA,14568
+letta/memory.py,sha256=DO7aevi0HQBSX94wB5NVTe-rPgsXiYC1in9mJxTUnUo,3579
 letta/metadata.py,sha256=iU2KZewl_oqyB6mjKeSGH33BsvRUPeWb1K_qRgme5jo,15507
 letta/o1_agent.py,sha256=Jbc4Id15tMQ_1ek74hxRUJdfTegmsaIHQyRNc31g6dA,3092
 letta/offline_memory_agent.py,sha256=Pa4HmKMFYhmkzl6SyHHtHpdYIZkrJqbG0-fwPAU6Muo,7912
@@ -199,7 +195,7 @@ letta/server/rest_api/routers/v1/tools.py,sha256=ajYUo_cgUBDfm4Ja_EufxSdhBWoAb5N
 letta/server/rest_api/routers/v1/users.py,sha256=M1wEr2IyHzuRwINYxLXTkrbAH3osLe_cWjzrWrzR1aw,3729
 letta/server/rest_api/static_files.py,sha256=NG8sN4Z5EJ8JVQdj19tkFa9iQ1kBPTab9f_CUxd_u4Q,3143
 letta/server/rest_api/utils.py,sha256=6Z0T0kHIwDAgTIFh38Q1JQ_nhANgdqXcSlsuY41pL6M,3158
-letta/server/server.py,sha256=H6TxXsh7Bahgn-8Jf9iLnkbeL3G8Y8U0tetc4D_1lIQ,85587
+letta/server/server.py,sha256=Y6Oft1vCoLzTxqdP8ZU8JBtTBURZFwa4NWM_LIvR7O4,85433
 letta/server/startup.sh,sha256=722uKJWB2C4q3vjn39De2zzPacaZNw_1fN1SpLGjKIo,1569
 letta/server/static_files/assets/index-048c9598.js,sha256=mR16XppvselwKCcNgONs4L7kZEVa4OEERm4lNZYtLSk,146819
 letta/server/static_files/assets/index-0e31b727.css,sha256=DjG3J3RSFLcinzoisOYYLiyTAIe5Uaxge3HE-DmQIsU,7688
@@ -228,13 +224,13 @@ letta/services/tool_manager.py,sha256=lfrfWyxiFUWcEf-nATHs7r76XWutMYbOPyePs543ZO
 letta/services/tool_sandbox_env/.gitkeep,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/services/tools_agents_manager.py,sha256=kF6yIsUO154_Q3l-cEeSU56QW-VUr_M6B-9csqhHBkg,4847
 letta/services/user_manager.py,sha256=cfXgnVlnfqPCk7c-wYRsU3RegHs-4stksk186RW89Do,4403
-letta/settings.py,sha256=IBODJU3ZxFQAgzpB-nZtBbYuak6ad9rwhjLWv9oCgBo,3664
+letta/settings.py,sha256=o3eydtE_NrNz5GJ37VPQPXZri-qlz671PxFIJIzveRU,3712
 letta/streaming_interface.py,sha256=_FPUWy58j50evHcpXyd7zB1wWqeCc71NCFeWh_TBvnw,15736
 letta/streaming_utils.py,sha256=329fsvj1ZN0r0LpQtmMPZ2vSxkDBIUUwvGHZFkjm2I8,11745
 letta/system.py,sha256=buKYPqG5n2x41hVmWpu6JUpyd7vTWED9Km2_M7dLrvk,6960
 letta/utils.py,sha256=L8c6S77gyMYFgVP6ncGRaNbGjWtg6BOU_whI1vjt9Ts,32915
-letta_nightly-0.6.3.dev20241211104238.dist-info/LICENSE,sha256=mExtuZ_GYJgDEI38GWdiEYZizZS4KkVt2SF1g_GPNhI,10759
-letta_nightly-0.6.3.dev20241211104238.dist-info/METADATA,sha256=OzyQk10br4NZoCh6A9oPl4_JKTjAt0P_Ws3-o56VDo0,19560
-letta_nightly-0.6.3.dev20241211104238.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
-letta_nightly-0.6.3.dev20241211104238.dist-info/entry_points.txt,sha256=2zdiyGNEZGV5oYBuS-y2nAAgjDgcC9yM_mHJBFSRt5U,40
-letta_nightly-0.6.3.dev20241211104238.dist-info/RECORD,,
+letta_nightly-0.6.3.dev20241212104231.dist-info/LICENSE,sha256=mExtuZ_GYJgDEI38GWdiEYZizZS4KkVt2SF1g_GPNhI,10759
+letta_nightly-0.6.3.dev20241212104231.dist-info/METADATA,sha256=wbMkitQ5FROZGwS8bfy2ZlJpScQ4kaY88YGZKn1UfrQ,21689
+letta_nightly-0.6.3.dev20241212104231.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
+letta_nightly-0.6.3.dev20241212104231.dist-info/entry_points.txt,sha256=2zdiyGNEZGV5oYBuS-y2nAAgjDgcC9yM_mHJBFSRt5U,40
+letta_nightly-0.6.3.dev20241212104231.dist-info/RECORD,,