letta-nightly 0.6.27.dev20250220104103__py3-none-any.whl → 0.6.29.dev20250221033538__py3-none-any.whl

letta/server/server.py

@@ -18,6 +18,7 @@ import letta.server.utils as server_utils
 import letta.system as system
 from letta.agent import Agent, save_agent
 from letta.chat_only_agent import ChatOnlyAgent
+from letta.config import LettaConfig
 from letta.data_sources.connectors import DataConnector, load_data
 from letta.helpers.datetime_helpers import get_utc_time
 from letta.helpers.json_helpers import json_dumps, json_loads
@@ -27,7 +28,6 @@ from letta.interface import AgentInterface  # abstract
 from letta.interface import CLIInterface  # for printing to terminal
 from letta.log import get_logger
 from letta.offline_memory_agent import OfflineMemoryAgent
-from letta.orm import Base
 from letta.orm.errors import NoResultFound
 from letta.schemas.agent import AgentState, AgentType, CreateAgent
 from letta.schemas.block import BlockUpdate
@@ -48,6 +48,7 @@ from letta.schemas.providers import (
     AnthropicBedrockProvider,
     AnthropicProvider,
     AzureProvider,
+    DeepSeekProvider,
     GoogleAIProvider,
     GoogleVertexProvider,
     GroqProvider,
@@ -70,6 +71,7 @@ from letta.server.rest_api.interface import StreamingServerInterface
 from letta.server.rest_api.utils import sse_async_generator
 from letta.services.agent_manager import AgentManager
 from letta.services.block_manager import BlockManager
+from letta.services.identity_manager import IdentityManager
 from letta.services.job_manager import JobManager
 from letta.services.message_manager import MessageManager
 from letta.services.organization_manager import OrganizationManager
@@ -82,8 +84,11 @@ from letta.services.step_manager import StepManager
 from letta.services.tool_execution_sandbox import ToolExecutionSandbox
 from letta.services.tool_manager import ToolManager
 from letta.services.user_manager import UserManager
+from letta.settings import model_settings, settings, tool_settings
+from letta.tracing import trace_method
 from letta.utils import get_friendly_error_msg
 
+config = LettaConfig.load()
 logger = get_logger(__name__)
 
 
@@ -145,118 +150,6 @@ class Server(object):
         raise NotImplementedError
 
 
-from contextlib import contextmanager
-
-from rich.console import Console
-from rich.panel import Panel
-from rich.text import Text
-from sqlalchemy import create_engine
-from sqlalchemy.orm import sessionmaker
-
-from letta.config import LettaConfig
-
-# NOTE: hack to see if single session management works
-from letta.settings import model_settings, settings, tool_settings
-
-config = LettaConfig.load()
-
-
-def print_sqlite_schema_error():
-    """Print a formatted error message for SQLite schema issues"""
-    console = Console()
-    error_text = Text()
-    error_text.append("Existing SQLite DB schema is invalid, and schema migrations are not supported for SQLite. ", style="bold red")
-    error_text.append("To have migrations supported between Letta versions, please run Letta with Docker (", style="white")
-    error_text.append("https://docs.letta.com/server/docker", style="blue underline")
-    error_text.append(") or use Postgres by setting ", style="white")
-    error_text.append("LETTA_PG_URI", style="yellow")
-    error_text.append(".\n\n", style="white")
-    error_text.append("If you wish to keep using SQLite, you can reset your database by removing the DB file with ", style="white")
-    error_text.append("rm ~/.letta/sqlite.db", style="yellow")
-    error_text.append(" or downgrade to your previous version of Letta.", style="white")
-
-    console.print(Panel(error_text, border_style="red"))
-
-
-@contextmanager
-def db_error_handler():
-    """Context manager for handling database errors"""
-    try:
-        yield
-    except Exception as e:
-        # Handle other SQLAlchemy errors
-        print(e)
-        print_sqlite_schema_error()
-        # raise ValueError(f"SQLite DB error: {str(e)}")
-        exit(1)
-
-
-if settings.letta_pg_uri_no_default:
-    print("Creating postgres engine")
-    config.recall_storage_type = "postgres"
-    config.recall_storage_uri = settings.letta_pg_uri_no_default
-    config.archival_storage_type = "postgres"
-    config.archival_storage_uri = settings.letta_pg_uri_no_default
-
-    # create engine
-    engine = create_engine(
-        settings.letta_pg_uri,
-        pool_size=settings.pg_pool_size,
-        max_overflow=settings.pg_max_overflow,
-        pool_timeout=settings.pg_pool_timeout,
-        pool_recycle=settings.pg_pool_recycle,
-        echo=settings.pg_echo,
-    )
-else:
-    # TODO: don't rely on config storage
-    engine_path = "sqlite:///" + os.path.join(config.recall_storage_path, "sqlite.db")
-    logger.info("Creating sqlite engine " + engine_path)
-
-    engine = create_engine(engine_path)
-
-    # Store the original connect method
-    original_connect = engine.connect
-
-    def wrapped_connect(*args, **kwargs):
-        with db_error_handler():
-            # Get the connection
-            connection = original_connect(*args, **kwargs)
-
-            # Store the original execution method
-            original_execute = connection.execute
-
-            # Wrap the execute method of the connection
-            def wrapped_execute(*args, **kwargs):
-                with db_error_handler():
-                    return original_execute(*args, **kwargs)
-
-            # Replace the connection's execute method
-            connection.execute = wrapped_execute
-
-            return connection
-
-    # Replace the engine's connect method
-    engine.connect = wrapped_connect
-
-    Base.metadata.create_all(bind=engine)
-
-SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
-
-
-# Dependency
-def get_db():
-    db = SessionLocal()
-    try:
-        yield db
-    finally:
-        db.close()
-
-
-from contextlib import contextmanager
-
-db_context = contextmanager(get_db)
-
-
 class SyncServer(Server):
     """Simple single-threaded / blocking server process"""
 
@@ -304,6 +197,7 @@ class SyncServer(Server):
         self.agent_manager = AgentManager()
         self.provider_manager = ProviderManager()
         self.step_manager = StepManager()
+        self.identity_manager = IdentityManager()
 
         # Managers that interface with parallelism
         self.per_agent_lock_manager = PerAgentLockManager()
@@ -415,6 +309,8 @@ class SyncServer(Server):
                 else model_settings.lmstudio_base_url + "/v1"
             )
             self._enabled_providers.append(LMStudioOpenAIProvider(base_url=lmstudio_url))
+        if model_settings.deepseek_api_key:
+            self._enabled_providers.append(DeepSeekProvider(api_key=model_settings.deepseek_api_key))
 
     def load_agent(self, agent_id: str, actor: User, interface: Union[AgentInterface, None] = None) -> Agent:
         """Updated method to load agents from persisted storage"""
@@ -440,6 +336,7 @@ class SyncServer(Server):
         agent_id: str,
         input_messages: Union[Message, List[Message]],
         interface: Union[AgentInterface, None] = None,  # needed to getting responses
+        put_inner_thoughts_first: bool = True,
         # timestamp: Optional[datetime],
     ) -> LettaUsageStatistics:
         """Send the input message through the agent"""
@@ -472,6 +369,7 @@ class SyncServer(Server):
                 stream=token_streaming,
                 skip_verify=True,
                 metadata=metadata,
+                put_inner_thoughts_first=put_inner_thoughts_first,
             )
 
         except Exception as e:
@@ -729,6 +627,7 @@ class SyncServer(Server):
         wrap_system_message: bool = True,
         interface: Union[AgentInterface, ChatCompletionsStreamingInterface, None] = None,  # needed to getting responses
         metadata: Optional[dict] = None,  # Pass through metadata to interface
+        put_inner_thoughts_first: bool = True,
     ) -> LettaUsageStatistics:
         """Send a list of messages to the agent
 
@@ -779,7 +678,13 @@ class SyncServer(Server):
             interface.metadata = metadata
 
         # Run the agent state forward
-        return self._step(actor=actor, agent_id=agent_id, input_messages=message_objects, interface=interface)
+        return self._step(
+            actor=actor,
+            agent_id=agent_id,
+            input_messages=message_objects,
+            interface=interface,
+            put_inner_thoughts_first=put_inner_thoughts_first,
+        )
 
     # @LockingServer.agent_lock_decorator
     def run_command(self, user_id: str, agent_id: str, command: str) -> LettaUsageStatistics:
@@ -1256,6 +1161,7 @@ class SyncServer(Server):
         actions = self.get_composio_client(api_key=api_key).actions.get(apps=[composio_app_name])
         return actions
 
+    @trace_method("Send Message")
     async def send_message_to_agent(
         self,
         agent_id: str,
@@ -1273,7 +1179,6 @@ class SyncServer(Server):
         metadata: Optional[dict] = None,
     ) -> Union[StreamingResponse, LettaResponse]:
         """Split off into a separate function so that it can be imported in the /chat/completion proxy."""
-
         # TODO: @charles is this the correct way to handle?
         include_final_message = True
 
@@ -1292,11 +1197,12 @@ class SyncServer(Server):
             # Disable token streaming if not OpenAI or Anthropic
             # TODO: cleanup this logic
             llm_config = letta_agent.agent_state.llm_config
+            supports_token_streaming = ["openai", "anthropic", "deepseek"]
             if stream_tokens and (
-                llm_config.model_endpoint_type not in ["openai", "anthropic"] or "inference.memgpt.ai" in llm_config.model_endpoint
+                llm_config.model_endpoint_type not in supports_token_streaming or "inference.memgpt.ai" in llm_config.model_endpoint
             ):
                 warnings.warn(
-                    f"Token streaming is only supported for models with type 'openai' or 'anthropic' in the model_endpoint: agent has endpoint type {llm_config.model_endpoint_type} and {llm_config.model_endpoint}. Setting stream_tokens to False."
+                    f"Token streaming is only supported for models with type {' or '.join(supports_token_streaming)} in the model_endpoint: agent has endpoint type {llm_config.model_endpoint_type} and {llm_config.model_endpoint}. Setting stream_tokens to False."
                 )
                 stream_tokens = False
 

letta/services/agent_manager.py

@@ -11,6 +11,7 @@ from letta.log import get_logger
 from letta.orm import Agent as AgentModel
 from letta.orm import AgentPassage, AgentsTags
 from letta.orm import Block as BlockModel
+from letta.orm import Identity as IdentityModel
 from letta.orm import Source as SourceModel
 from letta.orm import SourcePassage, SourcesAgents
 from letta.orm import Tool as ToolModel
@@ -27,8 +28,11 @@ from letta.schemas.message import MessageCreate
 from letta.schemas.passage import Passage as PydanticPassage
 from letta.schemas.source import Source as PydanticSource
 from letta.schemas.tool import Tool as PydanticTool
+from letta.schemas.tool_rule import ContinueToolRule as PydanticContinueToolRule
+from letta.schemas.tool_rule import TerminalToolRule as PydanticTerminalToolRule
 from letta.schemas.tool_rule import ToolRule as PydanticToolRule
 from letta.schemas.user import User as PydanticUser
+from letta.serialize_schemas import SerializedAgentSchema
 from letta.services.block_manager import BlockManager
 from letta.services.helpers.agent_manager_helper import (
     _process_relationship,
@@ -39,6 +43,7 @@ from letta.services.helpers.agent_manager_helper import (
     initialize_message_sequence,
     package_initial_message_sequence,
 )
+from letta.services.identity_manager import IdentityManager
 from letta.services.message_manager import MessageManager
 from letta.services.source_manager import SourceManager
 from letta.services.tool_manager import ToolManager
@@ -53,13 +58,14 @@ class AgentManager:
     """Manager class to handle business logic related to Agents."""
 
     def __init__(self):
-        from letta.server.server import db_context
+        from letta.server.db import db_context
 
         self.session_maker = db_context
         self.block_manager = BlockManager()
         self.tool_manager = ToolManager()
         self.source_manager = SourceManager()
         self.message_manager = MessageManager()
+        self.identity_manager = IdentityManager()
 
     # ======================================================================================================================
     # Basic CRUD operations
@@ -75,10 +81,6 @@ class AgentManager:
         if not agent_create.llm_config or not agent_create.embedding_config:
             raise ValueError("llm_config and embedding_config are required")
 
-        # Check tool rules are valid
-        if agent_create.tool_rules:
-            check_supports_structured_output(model=agent_create.llm_config.model, tool_rules=agent_create.tool_rules)
-
         # create blocks (note: cannot be linked into the agent_id is created)
         block_ids = list(agent_create.block_ids or [])  # Create a local copy to avoid modifying the original
         if agent_create.memory_blocks:
@@ -98,6 +100,25 @@ class AgentManager:
         # Remove duplicates
         tool_names = list(set(tool_names))
 
+        # add default tool rules
+        if agent_create.include_base_tool_rules:
+            if not agent_create.tool_rules:
+                tool_rules = []
+            else:
+                tool_rules = agent_create.tool_rules
+
+            # apply default tool rules
+            for tool_name in tool_names:
+                if tool_name == "send_message" or tool_name == "send_message_to_agent_async":
+                    tool_rules.append(PydanticTerminalToolRule(tool_name=tool_name))
+                elif tool_name in BASE_TOOLS:
+                    tool_rules.append(PydanticContinueToolRule(tool_name=tool_name))
+        else:
+            tool_rules = agent_create.tool_rules
+        # Check tool rules are valid
+        if agent_create.tool_rules:
+            check_supports_structured_output(model=agent_create.llm_config.model, tool_rules=agent_create.tool_rules)
+
         tool_ids = agent_create.tool_ids or []
         for tool_name in tool_names:
             tool = self.tool_manager.get_tool_by_name(tool_name=tool_name, actor=actor)
@@ -117,9 +138,10 @@ class AgentManager:
             tool_ids=tool_ids,
             source_ids=agent_create.source_ids or [],
             tags=agent_create.tags or [],
+            identity_ids=agent_create.identity_ids or [],
             description=agent_create.description,
             metadata=agent_create.metadata,
-            tool_rules=agent_create.tool_rules,
+            tool_rules=tool_rules,
             actor=actor,
             project_id=agent_create.project_id,
             template_id=agent_create.template_id,
@@ -181,6 +203,7 @@ class AgentManager:
         tool_ids: List[str],
         source_ids: List[str],
         tags: List[str],
+        identity_ids: List[str],
         description: Optional[str] = None,
         metadata: Optional[Dict] = None,
         tool_rules: Optional[List[PydanticToolRule]] = None,
@@ -214,6 +237,8 @@ class AgentManager:
             _process_relationship(session, new_agent, "sources", SourceModel, source_ids, replace=True)
             _process_relationship(session, new_agent, "core_memory", BlockModel, block_ids, replace=True)
             _process_tags(new_agent, tags, replace=True)
+            _process_relationship(session, new_agent, "identities", IdentityModel, identity_ids, replace=True)
+
             new_agent.create(session, actor=actor)
 
             # Convert to PydanticAgentState and return
@@ -286,6 +311,8 @@ class AgentManager:
                 _process_relationship(session, agent, "core_memory", BlockModel, agent_update.block_ids, replace=True)
             if agent_update.tags is not None:
                 _process_tags(agent, agent_update.tags, replace=True)
+            if agent_update.identity_ids is not None:
+                _process_relationship(session, agent, "identities", IdentityModel, agent_update.identity_ids, replace=True)
 
             # Commit and refresh the agent
             agent.update(session, actor=actor)
@@ -303,6 +330,7 @@ class AgentManager:
         tags: Optional[List[str]] = None,
         match_all_tags: bool = False,
         query_text: Optional[str] = None,
+        identifier_keys: Optional[List[str]] = None,
         **kwargs,
     ) -> List[PydanticAgentState]:
         """
@@ -318,6 +346,7 @@ class AgentManager:
                 match_all_tags=match_all_tags,
                 organization_id=actor.organization_id if actor else None,
                 query_text=query_text,
+                identifier_keys=identifier_keys,
                 **kwargs,
             )
 
@@ -355,6 +384,24 @@ class AgentManager:
             agent = AgentModel.read(db_session=session, identifier=agent_id, actor=actor)
             agent.hard_delete(session)
 
+    @enforce_types
+    def serialize(self, agent_id: str, actor: PydanticUser) -> dict:
+        with self.session_maker() as session:
+            # Retrieve the agent
+            agent = AgentModel.read(db_session=session, identifier=agent_id, actor=actor)
+            schema = SerializedAgentSchema(session=session)
+            return schema.dump(agent)
+
+    @enforce_types
+    def deserialize(self, serialized_agent: dict, actor: PydanticUser) -> PydanticAgentState:
+        # TODO: Use actor to override fields
+        with self.session_maker() as session:
+            schema = SerializedAgentSchema(session=session)
+            agent = schema.load(serialized_agent, session=session)
+            agent.organization_id = actor.organization_id
+            agent = agent.create(session, actor=actor)
+            return agent.to_pydantic()
+
     # ======================================================================================================================
     # Per Agent Environment Variable Management
     # ======================================================================================================================

letta/services/block_manager.py

@@ -16,7 +16,7 @@ class BlockManager:
 
     def __init__(self):
         # Fetching the db_context similarly as in ToolManager
-        from letta.server.server import db_context
+        from letta.server.db import db_context
 
         self.session_maker = db_context
 

letta/services/identity_manager.py

@@ -0,0 +1,156 @@
+from typing import List, Optional
+
+from fastapi import HTTPException
+from sqlalchemy.exc import NoResultFound
+from sqlalchemy.orm import Session
+
+from letta.orm.agent import Agent as AgentModel
+from letta.orm.identity import Identity as IdentityModel
+from letta.schemas.identity import Identity as PydanticIdentity
+from letta.schemas.identity import IdentityCreate, IdentityType, IdentityUpdate
+from letta.schemas.user import User as PydanticUser
+from letta.utils import enforce_types
+
+
+class IdentityManager:
+
+    def __init__(self):
+        from letta.server.db import db_context
+
+        self.session_maker = db_context
+
+    @enforce_types
+    def list_identities(
+        self,
+        name: Optional[str] = None,
+        project_id: Optional[str] = None,
+        identifier_key: Optional[str] = None,
+        identity_type: Optional[IdentityType] = None,
+        before: Optional[str] = None,
+        after: Optional[str] = None,
+        limit: Optional[int] = 50,
+        actor: PydanticUser = None,
+    ) -> list[PydanticIdentity]:
+        with self.session_maker() as session:
+            filters = {"organization_id": actor.organization_id}
+            if project_id:
+                filters["project_id"] = project_id
+            if identifier_key:
+                filters["identifier_key"] = identifier_key
+            if identity_type:
+                filters["identity_type"] = identity_type
+            identities = IdentityModel.list(
+                db_session=session,
+                query_text=name,
+                before=before,
+                after=after,
+                limit=limit,
+                **filters,
+            )
+            return [identity.to_pydantic() for identity in identities]
+
+    @enforce_types
+    def get_identity(self, identity_id: str, actor: PydanticUser) -> PydanticIdentity:
+        with self.session_maker() as session:
+            identity = IdentityModel.read(db_session=session, identifier=identity_id, actor=actor)
+            return identity.to_pydantic()
+
+    @enforce_types
+    def create_identity(self, identity: IdentityCreate, actor: PydanticUser) -> PydanticIdentity:
+        with self.session_maker() as session:
+            new_identity = IdentityModel(**identity.model_dump(exclude={"agent_ids"}, exclude_unset=True))
+            new_identity.organization_id = actor.organization_id
+            self._process_agent_relationship(session=session, identity=new_identity, agent_ids=identity.agent_ids, allow_partial=False)
+            new_identity.create(session, actor=actor)
+            return new_identity.to_pydantic()
+
+    @enforce_types
+    def upsert_identity(self, identity: IdentityCreate, actor: PydanticUser) -> PydanticIdentity:
+        with self.session_maker() as session:
+            existing_identity = IdentityModel.read(
+                db_session=session,
+                identifier_key=identity.identifier_key,
+                project_id=identity.project_id,
+                organization_id=actor.organization_id,
+                actor=actor,
+            )
+
+        if existing_identity is None:
+            return self.create_identity(identity=identity, actor=actor)
+        else:
+            identity_update = IdentityUpdate(name=identity.name, identity_type=identity.identity_type, agent_ids=identity.agent_ids)
+            return self._update_identity(
+                session=session, existing_identity=existing_identity, identity=identity_update, actor=actor, replace=True
+            )
+
+    @enforce_types
+    def update_identity(self, identity_id: str, identity: IdentityUpdate, actor: PydanticUser, replace: bool = False) -> PydanticIdentity:
+        with self.session_maker() as session:
+            try:
+                existing_identity = IdentityModel.read(db_session=session, identifier=identity_id, actor=actor)
+            except NoResultFound:
+                raise HTTPException(status_code=404, detail="Identity not found")
+            if existing_identity.organization_id != actor.organization_id:
+                raise HTTPException(status_code=403, detail="Forbidden")
+
+            return self._update_identity(
+                session=session, existing_identity=existing_identity, identity=identity, actor=actor, replace=replace
+            )
+
+    def _update_identity(
+        self,
+        session: Session,
+        existing_identity: IdentityModel,
+        identity: IdentityUpdate,
+        actor: PydanticUser,
+        replace: bool = False,
+    ) -> PydanticIdentity:
+        if identity.identifier_key is not None:
+            existing_identity.identifier_key = identity.identifier_key
+        if identity.name is not None:
+            existing_identity.name = identity.name
+        if identity.identity_type is not None:
+            existing_identity.identity_type = identity.identity_type
+
+        self._process_agent_relationship(
+            session=session, identity=existing_identity, agent_ids=identity.agent_ids, allow_partial=False, replace=replace
+        )
+        existing_identity.update(session, actor=actor)
+        return existing_identity.to_pydantic()
+
+    @enforce_types
+    def delete_identity(self, identity_id: str, actor: PydanticUser) -> None:
+        with self.session_maker() as session:
+            identity = IdentityModel.read(db_session=session, identifier=identity_id)
+            if identity is None:
+                raise HTTPException(status_code=404, detail="Identity not found")
+            if identity.organization_id != actor.organization_id:
+                raise HTTPException(status_code=403, detail="Forbidden")
+            session.delete(identity)
+            session.commit()
+
+    def _process_agent_relationship(
+        self, session: Session, identity: IdentityModel, agent_ids: List[str], allow_partial=False, replace=True
+    ):
+        current_relationship = getattr(identity, "agents", [])
+        if not agent_ids:
+            if replace:
+                setattr(identity, "agents", [])
+            return
+
+        # Retrieve models for the provided IDs
+        found_items = session.query(AgentModel).filter(AgentModel.id.in_(agent_ids)).all()
+
+        # Validate all items are found if allow_partial is False
+        if not allow_partial and len(found_items) != len(agent_ids):
+            missing = set(agent_ids) - {item.id for item in found_items}
+            raise NoResultFound(f"Items not found in agents: {missing}")
+
+        if replace:
+            # Replace the relationship
+            setattr(identity, "agents", found_items)
+        else:
+            # Extend the relationship (only add new items)
+            current_ids = {item.id for item in current_relationship}
+            new_items = [item for item in found_items if item.id not in current_ids]
+            current_relationship.extend(new_items)

letta/services/job_manager.py

@@ -29,7 +29,7 @@ class JobManager:
 
     def __init__(self):
         # Fetching the db_context similarly as in OrganizationManager
-        from letta.server.server import db_context
+        from letta.server.db import db_context
 
         self.session_maker = db_context
 

letta/services/message_manager.py

@@ -16,7 +16,7 @@ class MessageManager:
     """Manager class to handle business logic related to Messages."""
 
     def __init__(self):
-        from letta.server.server import db_context
+        from letta.server.db import db_context
 
         self.session_maker = db_context
 

letta/services/organization_manager.py

@@ -16,7 +16,7 @@ class OrganizationManager:
         # TODO: Please refactor this out
         # I am currently working on a ORM refactor and would like to make a more minimal set of changes
         # - Matt
-        from letta.server.server import db_context
+        from letta.server.db import db_context
 
         self.session_maker = db_context
 

letta/services/passage_manager.py

@@ -16,7 +16,7 @@ class PassageManager:
     """Manager class to handle business logic related to Passages."""
 
     def __init__(self):
-        from letta.server.server import db_context
+        from letta.server.db import db_context
 
         self.session_maker = db_context
 

letta/services/provider_manager.py

@@ -10,7 +10,7 @@ from letta.utils import enforce_types
 class ProviderManager:
 
     def __init__(self):
-        from letta.server.server import db_context
+        from letta.server.db import db_context
 
         self.session_maker = db_context
 

letta/services/sandbox_config_manager.py

@@ -20,7 +20,7 @@ class SandboxConfigManager:
     """Manager class to handle business logic related to SandboxConfig and SandboxEnvironmentVariable."""
 
     def __init__(self):
-        from letta.server.server import db_context
+        from letta.server.db import db_context
 
         self.session_maker = db_context
 

letta/services/source_manager.py

@@ -15,7 +15,7 @@ class SourceManager:
     """Manager class to handle business logic related to Sources."""
 
     def __init__(self):
-        from letta.server.server import db_context
+        from letta.server.db import db_context
 
         self.session_maker = db_context
 

letta/services/step_manager.py

@@ -17,7 +17,7 @@ from letta.utils import enforce_types
 class StepManager:
 
     def __init__(self):
-        from letta.server.server import db_context
+        from letta.server.db import db_context
 
         self.session_maker = db_context
 

letta/services/tool_manager.py

@@ -31,7 +31,7 @@ class ToolManager:
 
     def __init__(self):
         # Fetching the db_context similarly as in OrganizationManager
-        from letta.server.server import db_context
+        from letta.server.db import db_context
 
         self.session_maker = db_context
 

letta/services/user_manager.py

@@ -17,7 +17,7 @@ class UserManager:
 
     def __init__(self):
         # Fetching the db_context similarly as in OrganizationManager
-        from letta.server.server import db_context
+        from letta.server.db import db_context
 
         self.session_maker = db_context
 

letta/settings.py

@@ -60,6 +60,9 @@ class ModelSettings(BaseSettings):
     openai_api_key: Optional[str] = None
     openai_api_base: str = "https://api.openai.com/v1"
 
+    # deepseek
+    deepseek_api_key: Optional[str] = None
+
     # groq
     groq_api_key: Optional[str] = None