letta-nightly 0.6.3.dev20241211050151__py3-none-any.whl → 0.6.3.dev20241212015858__py3-none-any.whl

{letta_nightly-0.6.3.dev20241211050151.dist-info → letta_nightly-0.6.3.dev20241212015858.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
@@ -154,7 +150,7 @@ letta/schemas/letta_request.py,sha256=Hfb66FB1tXmrpEX4_yLQVfTrTSMbPYeEvZY-vqW9Tj
 letta/schemas/letta_response.py,sha256=vQV5uqe-kq9fc4wCo-sVB_PJt5yUk8DB2zOgHsrmN-k,6189
 letta/schemas/llm_config.py,sha256=RbgnCaqYd_yl-Xs7t-DEI1NhpKD8WiVWjxcwq5mZd5M,4467
 letta/schemas/memory.py,sha256=80Y7gqWQQndhNkJ-0j38d2m619gTlfes_qJNA6_ant8,10040
-letta/schemas/message.py,sha256=GFuHcfPU5kgRXgu70osF9H03Mv0JcO5nbURTYR3XXDg,34154
+letta/schemas/message.py,sha256=QF6OrCVfh5ETo-KJ2KZpleAuvisBIMMsIL3uH6h_kMM,34161
 letta/schemas/openai/chat_completion_request.py,sha256=AOIwgbN3CZKVqkuXeMHeSa53u4h0wVq69t3T_LJ0vIE,3389
 letta/schemas/openai/chat_completion_response.py,sha256=ub-oVSyLpuJd-5_yzCSIRR8tD3GM83IeDO1c1uAATa4,3970
 letta/schemas/openai/chat_completions.py,sha256=V0ZPIIk-ds3O6MAkNHMz8zh1hqMFSPrTcYr88WDYzWE,3588
@@ -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.dev20241211050151.dist-info/LICENSE,sha256=mExtuZ_GYJgDEI38GWdiEYZizZS4KkVt2SF1g_GPNhI,10759
-letta_nightly-0.6.3.dev20241211050151.dist-info/METADATA,sha256=pzK7XMc5nR-XJOyIEFDuWEtTkaRERhb3oDgt2Cj1FQQ,19560
-letta_nightly-0.6.3.dev20241211050151.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
-letta_nightly-0.6.3.dev20241211050151.dist-info/entry_points.txt,sha256=2zdiyGNEZGV5oYBuS-y2nAAgjDgcC9yM_mHJBFSRt5U,40
-letta_nightly-0.6.3.dev20241211050151.dist-info/RECORD,,
+letta_nightly-0.6.3.dev20241212015858.dist-info/LICENSE,sha256=mExtuZ_GYJgDEI38GWdiEYZizZS4KkVt2SF1g_GPNhI,10759
+letta_nightly-0.6.3.dev20241212015858.dist-info/METADATA,sha256=6HeN_TZpUhDFRKUvNLPZpQ7wO2wKgD73b8SFJkqsnSo,21689
+letta_nightly-0.6.3.dev20241212015858.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
+letta_nightly-0.6.3.dev20241212015858.dist-info/entry_points.txt,sha256=2zdiyGNEZGV5oYBuS-y2nAAgjDgcC9yM_mHJBFSRt5U,40
+letta_nightly-0.6.3.dev20241212015858.dist-info/RECORD,,

letta/agent_store/db.py

@@ -1,467 +0,0 @@
-import base64
-import json
-import os
-from datetime import datetime
-from typing import Dict, List, Optional
-
-import numpy as np
-from sqlalchemy import (
-    BINARY,
-    Column,
-    DateTime,
-    Index,
-    String,
-    TypeDecorator,
-    and_,
-    asc,
-    desc,
-    or_,
-    select,
-    text,
-)
-from sqlalchemy.orm import mapped_column
-from sqlalchemy.orm.session import close_all_sessions
-from sqlalchemy.sql import func
-from sqlalchemy_json import MutableJson
-from tqdm import tqdm
-
-from letta.agent_store.storage import StorageConnector, TableType
-from letta.config import LettaConfig
-from letta.constants import MAX_EMBEDDING_DIM
-from letta.metadata import EmbeddingConfigColumn
-from letta.orm.base import Base
-from letta.orm.file import FileMetadata as FileMetadataModel
-
-# from letta.schemas.message import Message, Passage, Record, RecordType, ToolCall
-from letta.orm.passage import Passage as PassageModel
-from letta.settings import settings
-
-config = LettaConfig()
-
-
-class CommonVector(TypeDecorator):
-    """Common type for representing vectors in SQLite"""
-
-    impl = BINARY
-    cache_ok = True
-
-    def load_dialect_impl(self, dialect):
-        return dialect.type_descriptor(BINARY())
-
-    def process_bind_param(self, value, dialect):
-        if value is None:
-            return value
-        # Ensure value is a numpy array
-        if isinstance(value, list):
-            value = np.array(value, dtype=np.float32)
-        # Serialize numpy array to bytes, then encode to base64 for universal compatibility
-        return base64.b64encode(value.tobytes())
-
-    def process_result_value(self, value, dialect):
-        if not value:
-            return value
-        # Check database type and deserialize accordingly
-        if dialect.name == "sqlite":
-            # Decode from base64 and convert back to numpy array
-            value = base64.b64decode(value)
-        # For PostgreSQL, value is already in bytes
-        return np.frombuffer(value, dtype=np.float32)
-
-class SQLStorageConnector(StorageConnector):
-    def __init__(self, table_type: str, config: LettaConfig, user_id, agent_id=None):
-        super().__init__(table_type=table_type, config=config, user_id=user_id, agent_id=agent_id)
-        self.config = config
-
-    def get_filters(self, filters: Optional[Dict] = {}):
-        if filters is not None:
-            filter_conditions = {**self.filters, **filters}
-        else:
-            filter_conditions = self.filters
-        all_filters = [getattr(self.db_model, key) == value for key, value in filter_conditions.items()]
-        return all_filters
-
-    def get_all_paginated(self, filters: Optional[Dict] = {}, page_size: Optional[int] = 1000, offset=0):
-        filters = self.get_filters(filters)
-        while True:
-            # Retrieve a chunk of records with the given page_size
-            with self.session_maker() as session:
-                db_record_chunk = session.query(self.db_model).filter(*filters).offset(offset).limit(page_size).all()
-
-            # If the chunk is empty, we've retrieved all records
-            if not db_record_chunk:
-                break
-
-            # Yield a list of Record objects converted from the chunk
-            yield [record.to_record() for record in db_record_chunk]
-
-            # Increment the offset to get the next chunk in the next iteration
-            offset += page_size
-
-    def get_all_cursor(
-        self,
-        filters: Optional[Dict] = {},
-        after: str = None,
-        before: str = None,
-        limit: Optional[int] = 1000,
-        order_by: str = "created_at",
-        reverse: bool = False,
-    ):
-        """Get all that returns a cursor (record.id) and records"""
-        filters = self.get_filters(filters)
-
-        # generate query
-        with self.session_maker() as session:
-            query = session.query(self.db_model).filter(*filters)
-            # query = query.order_by(asc(self.db_model.id))
-
-            # records are sorted by the order_by field first, and then by the ID if two fields are the same
-            if reverse:
-                query = query.order_by(desc(getattr(self.db_model, order_by)), asc(self.db_model.id))
-            else:
-                query = query.order_by(asc(getattr(self.db_model, order_by)), asc(self.db_model.id))
-
-            # cursor logic: filter records based on before/after ID
-            if after:
-                after_value = getattr(self.get(id=after), order_by)
-                sort_exp = getattr(self.db_model, order_by) > after_value
-                query = query.filter(
-                    or_(sort_exp, and_(getattr(self.db_model, order_by) == after_value, self.db_model.id > after))  # tiebreaker case
-                )
-            if before:
-                before_value = getattr(self.get(id=before), order_by)
-                sort_exp = getattr(self.db_model, order_by) < before_value
-                query = query.filter(or_(sort_exp, and_(getattr(self.db_model, order_by) == before_value, self.db_model.id < before)))
-
-            # get records
-            db_record_chunk = query.limit(limit).all()
-        if not db_record_chunk:
-            return (None, [])
-        records = [record.to_record() for record in db_record_chunk]
-        next_cursor = db_record_chunk[-1].id
-        assert isinstance(next_cursor, str)
-
-        # return (cursor, list[records])
-        return (next_cursor, records)
-
-    def get_all(self, filters: Optional[Dict] = {}, limit=None):
-        filters = self.get_filters(filters)
-        with self.session_maker() as session:
-            if limit:
-                db_records = session.query(self.db_model).filter(*filters).limit(limit).all()
-            else:
-                db_records = session.query(self.db_model).filter(*filters).all()
-        return [record.to_record() for record in db_records]
-
-    def get(self, id: str):
-        with self.session_maker() as session:
-            db_record = session.get(self.db_model, id)
-        if db_record is None:
-            return None
-        return db_record.to_record()
-
-    def size(self, filters: Optional[Dict] = {}) -> int:
-        # return size of table
-        filters = self.get_filters(filters)
-        with self.session_maker() as session:
-            return session.query(self.db_model).filter(*filters).count()
-
-    def insert(self, record):
-        raise NotImplementedError
-
-    def insert_many(self, records, show_progress=False):
-        raise NotImplementedError
-
-    def query(self, query: str, query_vec: List[float], top_k: int = 10, filters: Optional[Dict] = {}):
-        raise NotImplementedError("Vector query not implemented for SQLStorageConnector")
-
-    def save(self):
-        return
-
-    def list_data_sources(self):
-        assert self.table_type == TableType.ARCHIVAL_MEMORY, f"list_data_sources only implemented for ARCHIVAL_MEMORY"
-        with self.session_maker() as session:
-            unique_data_sources = session.query(self.db_model.data_source).filter(*self.filters).distinct().all()
-        return unique_data_sources
-
-    def query_date(self, start_date, end_date, limit=None, offset=0):
-        filters = self.get_filters({})
-        with self.session_maker() as session:
-            query = (
-                session.query(self.db_model)
-                .filter(*filters)
-                .filter(self.db_model.created_at >= start_date)
-                .filter(self.db_model.created_at <= end_date)
-                .filter(self.db_model.role != "system")
-                .filter(self.db_model.role != "tool")
-                .offset(offset)
-            )
-            if limit:
-                query = query.limit(limit)
-            results = query.all()
-        return [result.to_record() for result in results]
-
-    def query_text(self, query, limit=None, offset=0):
-        # todo: make fuzz https://stackoverflow.com/questions/42388956/create-a-full-text-search-index-with-sqlalchemy-on-postgresql/42390204#42390204
-        filters = self.get_filters({})
-        with self.session_maker() as session:
-            query = (
-                session.query(self.db_model)
-                .filter(*filters)
-                .filter(func.lower(self.db_model.text).contains(func.lower(query)))
-                .filter(self.db_model.role != "system")
-                .filter(self.db_model.role != "tool")
-                .offset(offset)
-            )
-            if limit:
-                query = query.limit(limit)
-            results = query.all()
-        # return [self.type(**vars(result)) for result in results]
-        return [result.to_record() for result in results]
-
-    # Should be used only in tests!
-    def delete_table(self):
-        close_all_sessions()
-        with self.session_maker() as session:
-            self.db_model.__table__.drop(session.bind)
-            session.commit()
-
-    def delete(self, filters: Optional[Dict] = {}):
-        filters = self.get_filters(filters)
-        with self.session_maker() as session:
-            session.query(self.db_model).filter(*filters).delete()
-            session.commit()
-
-
-class PostgresStorageConnector(SQLStorageConnector):
-    """Storage via Postgres"""
-
-    # TODO: this should probably eventually be moved into a parent DB class
-
-    def __init__(self, table_type: str, config: LettaConfig, user_id, agent_id=None):
-        from pgvector.sqlalchemy import Vector
-
-        super().__init__(table_type=table_type, config=config, user_id=user_id, agent_id=agent_id)
-
-        # construct URI from enviornment variables
-        if settings.pg_uri:
-            self.uri = settings.pg_uri
-
-        # use config URI
-        # TODO: remove this eventually (config should NOT contain URI)
-        if table_type == TableType.ARCHIVAL_MEMORY or table_type == TableType.PASSAGES:
-            self.uri = self.config.archival_storage_uri
-            self.db_model = PassageModel
-            if self.config.archival_storage_uri is None:
-                raise ValueError(f"Must specify archival_storage_uri in config {self.config.config_path}")
-        elif table_type == TableType.FILES:
-            self.uri = self.config.metadata_storage_uri
-            self.db_model = FileMetadataModel
-            if self.config.metadata_storage_uri is None:
-                raise ValueError(f"Must specify metadata_storage_uri in config {self.config.config_path}")
-        else:
-            raise ValueError(f"Table type {table_type} not implemented")
-
-        if settings.pg_uri:
-            for c in self.db_model.__table__.columns:
-                if c.name == "embedding":
-                    assert isinstance(c.type, Vector), f"Embedding column must be of type Vector, got {c.type}"
-
-        from letta.server.server import db_context
-
-        self.session_maker = db_context
-
-        # TODO: move to DB init
-        if settings.pg_uri:
-            with self.session_maker() as session:
-                session.execute(text("CREATE EXTENSION IF NOT EXISTS vector"))  # Enables the vector extension
-
-    def query(self, query: str, query_vec: List[float], top_k: int = 10, filters: Optional[Dict] = {}):
-        filters = self.get_filters(filters)
-        with self.session_maker() as session:
-            results = session.scalars(
-                select(self.db_model).filter(*filters).order_by(self.db_model.embedding.l2_distance(query_vec)).limit(top_k)
-            ).all()
-
-        # Convert the results into Passage objects
-        records = [result.to_record() for result in results]
-        return records
-
-    def insert_many(self, records, exists_ok=True, show_progress=False):
-        # TODO: this is terrible, should eventually be done the same way for all types (migrate to SQLModel)
-        if len(records) == 0:
-            return
-
-        added_ids = []  # avoid adding duplicates
-        # NOTE: this has not great performance due to the excessive commits
-        with self.session_maker() as session:
-            iterable = tqdm(records) if show_progress else records
-            for record in iterable:
-                # db_record = self.db_model(**vars(record))
-
-                if record.id in added_ids:
-                    continue
-
-                existing_record = session.query(self.db_model).filter_by(id=record.id).first()
-                if existing_record:
-                    if exists_ok:
-                        fields = record.model_dump()
-                        fields.pop("id")
-                        session.query(self.db_model).filter(self.db_model.id == record.id).update(fields)
-                        print(f"Updated record with id {record.id}")
-                        session.commit()
-                    else:
-                        raise ValueError(f"Record with id {record.id} already exists.")
-
-                else:
-                    db_record = self.db_model(**record.dict())
-                    session.add(db_record)
-                    # print(f"Added record with id {record.id}")
-                    session.commit()
-
-                added_ids.append(record.id)
-
-    def insert(self, record, exists_ok=True):
-        self.insert_many([record], exists_ok=exists_ok)
-
-    def update(self, record):
-        """
-        Updates a record in the database based on the provided Record object.
-        """
-        with self.session_maker() as session:
-            # Find the record by its ID
-            db_record = session.query(self.db_model).filter_by(id=record.id).first()
-            if not db_record:
-                raise ValueError(f"Record with id {record.id} does not exist.")
-
-            # Update the record with new values from the provided Record object
-            for attr, value in vars(record).items():
-                setattr(db_record, attr, value)
-
-            # Commit the changes to the database
-            session.commit()
-
-    def str_to_datetime(self, str_date: str) -> datetime:
-        val = str_date.split("-")
-        _datetime = datetime(int(val[0]), int(val[1]), int(val[2]))
-        return _datetime
-
-    def query_date(self, start_date, end_date, limit=None, offset=0):
-        filters = self.get_filters({})
-        _start_date = self.str_to_datetime(start_date) if isinstance(start_date, str) else start_date
-        _end_date = self.str_to_datetime(end_date) if isinstance(end_date, str) else end_date
-        with self.session_maker() as session:
-            query = (
-                session.query(self.db_model)
-                .filter(*filters)
-                .filter(self.db_model.created_at >= _start_date)
-                .filter(self.db_model.created_at <= _end_date)
-                .filter(self.db_model.role != "system")
-                .filter(self.db_model.role != "tool")
-                .offset(offset)
-            )
-            if limit:
-                query = query.limit(limit)
-            results = query.all()
-        return [result.to_record() for result in results]
-
-
-class SQLLiteStorageConnector(SQLStorageConnector):
-    def __init__(self, table_type: str, config: LettaConfig, user_id, agent_id=None):
-        super().__init__(table_type=table_type, config=config, user_id=user_id, agent_id=agent_id)
-
-        # get storage URI
-        if table_type == TableType.ARCHIVAL_MEMORY or table_type == TableType.PASSAGES:
-            self.db_model = PassageModel
-            if settings.letta_pg_uri_no_default:
-                self.uri = settings.letta_pg_uri_no_default
-            else:
-                # For SQLite, use the archival storage path
-                self.path = config.archival_storage_path
-                self.uri = f"sqlite:///{os.path.join(config.archival_storage_path, 'letta.db')}"
-        elif table_type == TableType.FILES:
-            self.path = self.config.metadata_storage_path
-            if self.path is None:
-                raise ValueError(f"Must specify metadata_storage_path in config.")
-            self.db_model = FileMetadataModel
-
-        else:
-            raise ValueError(f"Table type {table_type} not implemented")
-
-        self.path = os.path.join(self.path, f"sqlite.db")
-
-        from letta.server.server import db_context
-
-        self.session_maker = db_context
-
-        # Need this in order to allow UUIDs to be stored successfully in the sqlite database
-        # import sqlite3
-        # import uuid
-        #
-        # sqlite3.register_adapter(uuid.UUID, lambda u: u.bytes_le)
-        # sqlite3.register_converter("UUID", lambda b: uuid.UUID(bytes_le=b))
-
-    def insert_many(self, records, exists_ok=True, show_progress=False):
-        # TODO: this is terrible, should eventually be done the same way for all types (migrate to SQLModel)
-        if len(records) == 0:
-            return
-
-        added_ids = []  # avoid adding duplicates
-        # NOTE: this has not great performance due to the excessive commits
-        with self.session_maker() as session:
-            iterable = tqdm(records) if show_progress else records
-            for record in iterable:
-                # db_record = self.db_model(**vars(record))
-
-                if record.id in added_ids:
-                    continue
-
-                existing_record = session.query(self.db_model).filter_by(id=record.id).first()
-                if existing_record:
-                    if exists_ok:
-                        fields = record.model_dump()
-                        fields.pop("id")
-                        session.query(self.db_model).filter(self.db_model.id == record.id).update(fields)
-                        session.commit()
-                    else:
-                        raise ValueError(f"Record with id {record.id} already exists.")
-
-                else:
-                    db_record = self.db_model(**record.dict())
-                    session.add(db_record)
-                    session.commit()
-
-                added_ids.append(record.id)
-
-    def insert(self, record, exists_ok=True):
-        self.insert_many([record], exists_ok=exists_ok)
-
-    def update(self, record):
-        """
-        Updates an existing record in the database with values from the provided record object.
-        """
-        if not record.id:
-            raise ValueError("Record must have an id.")
-
-        with self.session_maker() as session:
-            # Fetch the existing record from the database
-            db_record = session.query(self.db_model).filter_by(id=record.id).first()
-            if not db_record:
-                raise ValueError(f"Record with id {record.id} does not exist.")
-
-            # Update the database record with values from the provided record object
-            for column in self.db_model.__table__.columns:
-                column_name = column.name
-                if hasattr(record, column_name):
-                    new_value = getattr(record, column_name)
-                    setattr(db_record, column_name, new_value)
-
-            # Commit the changes to the database
-            session.commit()
-
-
-def attach_base():
-    # This should be invoked in server.py to make sure Base gets initialized properly
-    # DO NOT REMOVE
-    from letta.utils import printd
-
-    printd("Initializing database...")