basic-memory 0.16.1__py3-none-any.whl → 0.17.4__py3-none-any.whl

basic_memory/db.py

@@ -1,11 +1,12 @@
 import asyncio
 import os
+import sys
 from contextlib import asynccontextmanager
 from enum import Enum, auto
 from pathlib import Path
 from typing import AsyncGenerator, Optional
 
-from basic_memory.config import BasicMemoryConfig, ConfigManager
+from basic_memory.config import BasicMemoryConfig, ConfigManager, DatabaseBackend
 from alembic import command
 from alembic.config import Config
 
@@ -20,12 +21,27 @@ from sqlalchemy.ext.asyncio import (
 )
 from sqlalchemy.pool import NullPool
 
-from basic_memory.repository.search_repository import SearchRepository
+from basic_memory.repository.postgres_search_repository import PostgresSearchRepository
+from basic_memory.repository.sqlite_search_repository import SQLiteSearchRepository
+
+# -----------------------------------------------------------------------------
+# Windows event loop policy
+# -----------------------------------------------------------------------------
+# On Windows, the default ProactorEventLoop has known rough edges with aiosqlite
+# during shutdown/teardown (threads posting results to a loop that's closing),
+# which can manifest as:
+# - "RuntimeError: Event loop is closed"
+# - "IndexError: pop from an empty deque"
+#
+# The SelectorEventLoop doesn't support subprocess operations, so code that uses
+# asyncio.create_subprocess_shell() (like sync_service._quick_count_files) must
+# detect Windows and use fallback implementations.
+if sys.platform == "win32":  # pragma: no cover
+    asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
 
 # Module level state
 _engine: Optional[AsyncEngine] = None
 _session_maker: Optional[async_sessionmaker[AsyncSession]] = None
-_migrations_completed: bool = False
 
 
 class DatabaseType(Enum):
@@ -33,10 +49,41 @@ class DatabaseType(Enum):
 
     MEMORY = auto()
     FILESYSTEM = auto()
+    POSTGRES = auto()
 
     @classmethod
-    def get_db_url(cls, db_path: Path, db_type: "DatabaseType") -> str:
-        """Get SQLAlchemy URL for database path."""
+    def get_db_url(
+        cls, db_path: Path, db_type: "DatabaseType", config: Optional[BasicMemoryConfig] = None
+    ) -> str:
+        """Get SQLAlchemy URL for database path.
+
+        Args:
+            db_path: Path to SQLite database file (ignored for Postgres)
+            db_type: Type of database (MEMORY, FILESYSTEM, or POSTGRES)
+            config: Optional config to check for database backend and URL
+
+        Returns:
+            SQLAlchemy connection URL
+        """
+        # Load config if not provided
+        if config is None:
+            config = ConfigManager().config
+
+        # Handle explicit Postgres type
+        if db_type == cls.POSTGRES:
+            if not config.database_url:
+                raise ValueError("DATABASE_URL must be set when using Postgres backend")
+            logger.info(f"Using Postgres database: {config.database_url}")
+            return config.database_url
+
+        # Check if Postgres backend is configured (for backward compatibility)
+        if config.database_backend == DatabaseBackend.POSTGRES:
+            if not config.database_url:
+                raise ValueError("DATABASE_URL must be set when using Postgres backend")
+            logger.info(f"Using Postgres database: {config.database_url}")
+            return config.database_url
+
+        # SQLite databases
         if db_type == cls.MEMORY:
             logger.info("Using in-memory SQLite database")
             return "sqlite+aiosqlite://"
@@ -64,7 +111,14 @@ async def scoped_session(
     factory = get_scoped_session_factory(session_maker)
     session = factory()
     try:
-        await session.execute(text("PRAGMA foreign_keys=ON"))
+        # Only enable foreign keys for SQLite (Postgres has them enabled by default)
+        # Detect database type from session's bind (engine) dialect
+        engine = session.get_bind()
+        dialect_name = engine.dialect.name
+
+        if dialect_name == "sqlite":
+            await session.execute(text("PRAGMA foreign_keys=ON"))
+
         yield session
         await session.commit()
     except Exception:
@@ -103,13 +157,16 @@ def _configure_sqlite_connection(dbapi_conn, enable_wal: bool = True) -> None:
         cursor.close()
 
 
-def _create_engine_and_session(
-    db_path: Path, db_type: DatabaseType = DatabaseType.FILESYSTEM
-) -> tuple[AsyncEngine, async_sessionmaker[AsyncSession]]:
-    """Internal helper to create engine and session maker."""
-    db_url = DatabaseType.get_db_url(db_path, db_type)
-    logger.debug(f"Creating engine for db_url: {db_url}")
+def _create_sqlite_engine(db_url: str, db_type: DatabaseType) -> AsyncEngine:
+    """Create SQLite async engine with appropriate configuration.
 
+    Args:
+        db_url: SQLite connection URL
+        db_type: Database type (MEMORY or FILESYSTEM)
+
+    Returns:
+        Configured async engine for SQLite
+    """
     # Configure connection args with Windows-specific settings
     connect_args: dict[str, bool | float | None] = {"check_same_thread": False}
 
@@ -146,6 +203,73 @@ def _create_engine_and_session(
         """Enable WAL mode on each connection."""
         _configure_sqlite_connection(dbapi_conn, enable_wal=enable_wal)
 
+    return engine
+
+
+def _create_postgres_engine(db_url: str, config: BasicMemoryConfig) -> AsyncEngine:
+    """Create Postgres async engine with appropriate configuration.
+
+    Args:
+        db_url: Postgres connection URL (postgresql+asyncpg://...)
+        config: BasicMemoryConfig with pool settings
+
+    Returns:
+        Configured async engine for Postgres
+    """
+    # Use NullPool connection issues.
+    # Assume connection pooler like PgBouncer handles connection pooling.
+    engine = create_async_engine(
+        db_url,
+        echo=False,
+        poolclass=NullPool,  # No pooling - fresh connection per request
+        connect_args={
+            # Disable statement cache to avoid issues with prepared statements on reconnect
+            "statement_cache_size": 0,
+            # Allow 30s for commands (Neon cold start can take 2-5s, sometimes longer)
+            "command_timeout": 30,
+            # Allow 30s for initial connection (Neon wake-up time)
+            "timeout": 30,
+            "server_settings": {
+                "application_name": "basic-memory",
+                # Statement timeout for queries (30s to allow for cold start)
+                "statement_timeout": "30s",
+            },
+        },
+    )
+    logger.debug("Created Postgres engine with NullPool (no connection pooling)")
+
+    return engine
+
+
+def _create_engine_and_session(
+    db_path: Path,
+    db_type: DatabaseType = DatabaseType.FILESYSTEM,
+    config: Optional[BasicMemoryConfig] = None,
+) -> tuple[AsyncEngine, async_sessionmaker[AsyncSession]]:
+    """Internal helper to create engine and session maker.
+
+    Args:
+        db_path: Path to database file (used for SQLite, ignored for Postgres)
+        db_type: Type of database (MEMORY, FILESYSTEM, or POSTGRES)
+        config: Optional explicit config. If not provided, reads from ConfigManager.
+            Prefer passing explicitly from composition roots.
+
+    Returns:
+        Tuple of (engine, session_maker)
+    """
+    # Prefer explicit parameter; fall back to ConfigManager for backwards compatibility
+    if config is None:
+        config = ConfigManager().config
+    db_url = DatabaseType.get_db_url(db_path, db_type, config)
+    logger.debug(f"Creating engine for db_url: {db_url}")
+
+    # Delegate to backend-specific engine creation
+    # Check explicit POSTGRES type first, then config setting
+    if db_type == DatabaseType.POSTGRES or config.database_backend == DatabaseBackend.POSTGRES:
+        engine = _create_postgres_engine(db_url, config)
+    else:
+        engine = _create_sqlite_engine(db_url, db_type)
+
     session_maker = async_sessionmaker(engine, expire_on_commit=False)
     return engine, session_maker
 
@@ -154,17 +278,29 @@ async def get_or_create_db(
     db_path: Path,
     db_type: DatabaseType = DatabaseType.FILESYSTEM,
     ensure_migrations: bool = True,
+    config: Optional[BasicMemoryConfig] = None,
 ) -> tuple[AsyncEngine, async_sessionmaker[AsyncSession]]:  # pragma: no cover
-    """Get or create database engine and session maker."""
+    """Get or create database engine and session maker.
+
+    Args:
+        db_path: Path to database file
+        db_type: Type of database
+        ensure_migrations: Whether to run migrations
+        config: Optional explicit config. If not provided, reads from ConfigManager.
+            Prefer passing explicitly from composition roots.
+    """
     global _engine, _session_maker
 
+    # Prefer explicit parameter; fall back to ConfigManager for backwards compatibility
+    if config is None:
+        config = ConfigManager().config
+
     if _engine is None:
-        _engine, _session_maker = _create_engine_and_session(db_path, db_type)
+        _engine, _session_maker = _create_engine_and_session(db_path, db_type, config)
 
         # Run migrations automatically unless explicitly disabled
         if ensure_migrations:
-            app_config = ConfigManager().config
-            await run_migrations(app_config, db_type)
+            await run_migrations(config, db_type)
 
     # These checks should never fail since we just created the engine and session maker
     # if they were None, but we'll check anyway for the type checker
@@ -181,70 +317,37 @@ async def get_or_create_db(
 
 async def shutdown_db() -> None:  # pragma: no cover
     """Clean up database connections."""
-    global _engine, _session_maker, _migrations_completed
+    global _engine, _session_maker
 
     if _engine:
         await _engine.dispose()
         _engine = None
         _session_maker = None
-        _migrations_completed = False
 
 
 @asynccontextmanager
 async def engine_session_factory(
     db_path: Path,
     db_type: DatabaseType = DatabaseType.MEMORY,
+    config: Optional[BasicMemoryConfig] = None,
 ) -> AsyncGenerator[tuple[AsyncEngine, async_sessionmaker[AsyncSession]], None]:
     """Create engine and session factory.
 
     Note: This is primarily used for testing where we want a fresh database
     for each test. For production use, use get_or_create_db() instead.
-    """
-
-    global _engine, _session_maker, _migrations_completed
 
-    db_url = DatabaseType.get_db_url(db_path, db_type)
-    logger.debug(f"Creating engine for db_url: {db_url}")
-
-    # Configure connection args with Windows-specific settings
-    connect_args: dict[str, bool | float | None] = {"check_same_thread": False}
-
-    # Add Windows-specific parameters to improve reliability
-    if os.name == "nt":  # Windows
-        connect_args.update(
-            {
-                "timeout": 30.0,  # Increase timeout to 30 seconds for Windows
-                "isolation_level": None,  # Use autocommit mode
-            }
-        )
-        # Use NullPool for Windows filesystem databases to avoid connection pooling issues
-        # Important: Do NOT use NullPool for in-memory databases as it will destroy the database
-        # between connections
-        if db_type == DatabaseType.FILESYSTEM:
-            _engine = create_async_engine(
-                db_url,
-                connect_args=connect_args,
-                poolclass=NullPool,  # Disable connection pooling on Windows
-                echo=False,
-            )
-        else:
-            # In-memory databases need connection pooling to maintain state
-            _engine = create_async_engine(db_url, connect_args=connect_args)
-    else:
-        _engine = create_async_engine(db_url, connect_args=connect_args)
+    Args:
+        db_path: Path to database file
+        db_type: Type of database
+        config: Optional explicit config. If not provided, reads from ConfigManager.
+    """
 
-    # Enable WAL mode for better concurrency and reliability
-    # Note: WAL mode is not supported for in-memory databases
-    enable_wal = db_type != DatabaseType.MEMORY
+    global _engine, _session_maker
 
-    @event.listens_for(_engine.sync_engine, "connect")
-    def enable_wal_mode(dbapi_conn, connection_record):
-        """Enable WAL mode on each connection."""
-        _configure_sqlite_connection(dbapi_conn, enable_wal=enable_wal)
+    # Use the same helper function as production code
+    _engine, _session_maker = _create_engine_and_session(db_path, db_type, config)
 
     try:
-        _session_maker = async_sessionmaker(_engine, expire_on_commit=False)
-
         # Verify that engine and session maker are initialized
         if _engine is None:  # pragma: no cover
             logger.error("Database engine is None in engine_session_factory")
@@ -260,20 +363,16 @@ async def engine_session_factory(
             await _engine.dispose()
             _engine = None
             _session_maker = None
-            _migrations_completed = False
 
 
 async def run_migrations(
-    app_config: BasicMemoryConfig, database_type=DatabaseType.FILESYSTEM, force: bool = False
+    app_config: BasicMemoryConfig, database_type=DatabaseType.FILESYSTEM
 ):  # pragma: no cover
-    """Run any pending alembic migrations."""
-    global _migrations_completed
-
-    # Skip if migrations already completed unless forced
-    if _migrations_completed and not force:
-        logger.debug("Migrations already completed in this session, skipping")
-        return
+    """Run any pending alembic migrations.
 
+    Note: Alembic tracks which migrations have been applied via the alembic_version table,
+    so it's safe to call this multiple times - it will only run pending migrations.
+    """
     logger.info("Running database migrations...")
     try:
         # Get the absolute path to the alembic directory relative to this file
@@ -288,9 +387,11 @@ async def run_migrations(
         )
         config.set_main_option("timezone", "UTC")
         config.set_main_option("revision_environment", "false")
-        config.set_main_option(
-            "sqlalchemy.url", DatabaseType.get_db_url(app_config.database_path, database_type)
-        )
+
+        # Get the correct database URL based on backend configuration
+        # No URL conversion needed - env.py now handles both async and sync engines
+        db_url = DatabaseType.get_db_url(app_config.database_path, database_type, app_config)
+        config.set_main_option("sqlalchemy.url", db_url)
 
         command.upgrade(config, "head")
         logger.info("Migrations completed successfully")
@@ -301,12 +402,17 @@ async def run_migrations(
         else:
             session_maker = _session_maker
 
-        # initialize the search Index schema
-        # the project_id is not used for init_search_index, so we pass a dummy value
-        await SearchRepository(session_maker, 1).init_search_index()
-
-        # Mark migrations as completed
-        _migrations_completed = True
+        # Initialize the search index schema
+        # For SQLite: Create FTS5 virtual table
+        # For Postgres: No-op (tsvector column added by migrations)
+        # The project_id is not used for init_search_index, so we pass a dummy value
+        if (
+            database_type == DatabaseType.POSTGRES
+            or app_config.database_backend == DatabaseBackend.POSTGRES
+        ):
+            await PostgresSearchRepository(session_maker, 1).init_search_index()
+        else:
+            await SQLiteSearchRepository(session_maker, 1).init_search_index()
     except Exception as e:  # pragma: no cover
         logger.error(f"Error running migrations: {e}")
         raise

basic_memory/deps/__init__.py

@@ -0,0 +1,293 @@
+"""Dependency injection for basic-memory.
+
+This package provides FastAPI dependencies organized by feature:
+- config: Application configuration
+- db: Database/session management
+- projects: Project resolution and config
+- repositories: Data access layer
+- services: Business logic layer
+- importers: Import functionality
+
+For backwards compatibility, all dependencies are re-exported from this module.
+New code should import from specific submodules to reduce coupling.
+"""
+
+# Re-export everything for backwards compatibility
+# Eventually, callers should import from specific submodules
+
+from basic_memory.deps.config import (
+    get_app_config,
+    AppConfigDep,
+)
+
+from basic_memory.deps.db import (
+    get_engine_factory,
+    EngineFactoryDep,
+    get_session_maker,
+    SessionMakerDep,
+)
+
+from basic_memory.deps.projects import (
+    get_project_repository,
+    ProjectRepositoryDep,
+    ProjectPathDep,
+    get_project_id,
+    ProjectIdDep,
+    get_project_config,
+    ProjectConfigDep,
+    validate_project_id,
+    ProjectIdPathDep,
+    get_project_config_v2,
+    ProjectConfigV2Dep,
+    validate_project_external_id,
+    ProjectExternalIdPathDep,
+    get_project_config_v2_external,
+    ProjectConfigV2ExternalDep,
+)
+
+from basic_memory.deps.repositories import (
+    get_entity_repository,
+    EntityRepositoryDep,
+    get_entity_repository_v2,
+    EntityRepositoryV2Dep,
+    get_entity_repository_v2_external,
+    EntityRepositoryV2ExternalDep,
+    get_observation_repository,
+    ObservationRepositoryDep,
+    get_observation_repository_v2,
+    ObservationRepositoryV2Dep,
+    get_observation_repository_v2_external,
+    ObservationRepositoryV2ExternalDep,
+    get_relation_repository,
+    RelationRepositoryDep,
+    get_relation_repository_v2,
+    RelationRepositoryV2Dep,
+    get_relation_repository_v2_external,
+    RelationRepositoryV2ExternalDep,
+    get_search_repository,
+    SearchRepositoryDep,
+    get_search_repository_v2,
+    SearchRepositoryV2Dep,
+    get_search_repository_v2_external,
+    SearchRepositoryV2ExternalDep,
+)
+
+from basic_memory.deps.services import (
+    get_entity_parser,
+    EntityParserDep,
+    get_entity_parser_v2,
+    EntityParserV2Dep,
+    get_entity_parser_v2_external,
+    EntityParserV2ExternalDep,
+    get_markdown_processor,
+    MarkdownProcessorDep,
+    get_markdown_processor_v2,
+    MarkdownProcessorV2Dep,
+    get_markdown_processor_v2_external,
+    MarkdownProcessorV2ExternalDep,
+    get_file_service,
+    FileServiceDep,
+    get_file_service_v2,
+    FileServiceV2Dep,
+    get_file_service_v2_external,
+    FileServiceV2ExternalDep,
+    get_search_service,
+    SearchServiceDep,
+    get_search_service_v2,
+    SearchServiceV2Dep,
+    get_search_service_v2_external,
+    SearchServiceV2ExternalDep,
+    get_link_resolver,
+    LinkResolverDep,
+    get_link_resolver_v2,
+    LinkResolverV2Dep,
+    get_link_resolver_v2_external,
+    LinkResolverV2ExternalDep,
+    get_entity_service,
+    EntityServiceDep,
+    get_entity_service_v2,
+    EntityServiceV2Dep,
+    get_entity_service_v2_external,
+    EntityServiceV2ExternalDep,
+    get_context_service,
+    ContextServiceDep,
+    get_context_service_v2,
+    ContextServiceV2Dep,
+    get_context_service_v2_external,
+    ContextServiceV2ExternalDep,
+    get_sync_service,
+    SyncServiceDep,
+    get_sync_service_v2,
+    SyncServiceV2Dep,
+    get_sync_service_v2_external,
+    SyncServiceV2ExternalDep,
+    get_project_service,
+    ProjectServiceDep,
+    get_directory_service,
+    DirectoryServiceDep,
+    get_directory_service_v2,
+    DirectoryServiceV2Dep,
+    get_directory_service_v2_external,
+    DirectoryServiceV2ExternalDep,
+)
+
+from basic_memory.deps.importers import (
+    get_chatgpt_importer,
+    ChatGPTImporterDep,
+    get_chatgpt_importer_v2,
+    ChatGPTImporterV2Dep,
+    get_chatgpt_importer_v2_external,
+    ChatGPTImporterV2ExternalDep,
+    get_claude_conversations_importer,
+    ClaudeConversationsImporterDep,
+    get_claude_conversations_importer_v2,
+    ClaudeConversationsImporterV2Dep,
+    get_claude_conversations_importer_v2_external,
+    ClaudeConversationsImporterV2ExternalDep,
+    get_claude_projects_importer,
+    ClaudeProjectsImporterDep,
+    get_claude_projects_importer_v2,
+    ClaudeProjectsImporterV2Dep,
+    get_claude_projects_importer_v2_external,
+    ClaudeProjectsImporterV2ExternalDep,
+    get_memory_json_importer,
+    MemoryJsonImporterDep,
+    get_memory_json_importer_v2,
+    MemoryJsonImporterV2Dep,
+    get_memory_json_importer_v2_external,
+    MemoryJsonImporterV2ExternalDep,
+)
+
+__all__ = [
+    # Config
+    "get_app_config",
+    "AppConfigDep",
+    # Database
+    "get_engine_factory",
+    "EngineFactoryDep",
+    "get_session_maker",
+    "SessionMakerDep",
+    # Projects
+    "get_project_repository",
+    "ProjectRepositoryDep",
+    "ProjectPathDep",
+    "get_project_id",
+    "ProjectIdDep",
+    "get_project_config",
+    "ProjectConfigDep",
+    "validate_project_id",
+    "ProjectIdPathDep",
+    "get_project_config_v2",
+    "ProjectConfigV2Dep",
+    "validate_project_external_id",
+    "ProjectExternalIdPathDep",
+    "get_project_config_v2_external",
+    "ProjectConfigV2ExternalDep",
+    # Repositories
+    "get_entity_repository",
+    "EntityRepositoryDep",
+    "get_entity_repository_v2",
+    "EntityRepositoryV2Dep",
+    "get_entity_repository_v2_external",
+    "EntityRepositoryV2ExternalDep",
+    "get_observation_repository",
+    "ObservationRepositoryDep",
+    "get_observation_repository_v2",
+    "ObservationRepositoryV2Dep",
+    "get_observation_repository_v2_external",
+    "ObservationRepositoryV2ExternalDep",
+    "get_relation_repository",
+    "RelationRepositoryDep",
+    "get_relation_repository_v2",
+    "RelationRepositoryV2Dep",
+    "get_relation_repository_v2_external",
+    "RelationRepositoryV2ExternalDep",
+    "get_search_repository",
+    "SearchRepositoryDep",
+    "get_search_repository_v2",
+    "SearchRepositoryV2Dep",
+    "get_search_repository_v2_external",
+    "SearchRepositoryV2ExternalDep",
+    # Services
+    "get_entity_parser",
+    "EntityParserDep",
+    "get_entity_parser_v2",
+    "EntityParserV2Dep",
+    "get_entity_parser_v2_external",
+    "EntityParserV2ExternalDep",
+    "get_markdown_processor",
+    "MarkdownProcessorDep",
+    "get_markdown_processor_v2",
+    "MarkdownProcessorV2Dep",
+    "get_markdown_processor_v2_external",
+    "MarkdownProcessorV2ExternalDep",
+    "get_file_service",
+    "FileServiceDep",
+    "get_file_service_v2",
+    "FileServiceV2Dep",
+    "get_file_service_v2_external",
+    "FileServiceV2ExternalDep",
+    "get_search_service",
+    "SearchServiceDep",
+    "get_search_service_v2",
+    "SearchServiceV2Dep",
+    "get_search_service_v2_external",
+    "SearchServiceV2ExternalDep",
+    "get_link_resolver",
+    "LinkResolverDep",
+    "get_link_resolver_v2",
+    "LinkResolverV2Dep",
+    "get_link_resolver_v2_external",
+    "LinkResolverV2ExternalDep",
+    "get_entity_service",
+    "EntityServiceDep",
+    "get_entity_service_v2",
+    "EntityServiceV2Dep",
+    "get_entity_service_v2_external",
+    "EntityServiceV2ExternalDep",
+    "get_context_service",
+    "ContextServiceDep",
+    "get_context_service_v2",
+    "ContextServiceV2Dep",
+    "get_context_service_v2_external",
+    "ContextServiceV2ExternalDep",
+    "get_sync_service",
+    "SyncServiceDep",
+    "get_sync_service_v2",
+    "SyncServiceV2Dep",
+    "get_sync_service_v2_external",
+    "SyncServiceV2ExternalDep",
+    "get_project_service",
+    "ProjectServiceDep",
+    "get_directory_service",
+    "DirectoryServiceDep",
+    "get_directory_service_v2",
+    "DirectoryServiceV2Dep",
+    "get_directory_service_v2_external",
+    "DirectoryServiceV2ExternalDep",
+    # Importers
+    "get_chatgpt_importer",
+    "ChatGPTImporterDep",
+    "get_chatgpt_importer_v2",
+    "ChatGPTImporterV2Dep",
+    "get_chatgpt_importer_v2_external",
+    "ChatGPTImporterV2ExternalDep",
+    "get_claude_conversations_importer",
+    "ClaudeConversationsImporterDep",
+    "get_claude_conversations_importer_v2",
+    "ClaudeConversationsImporterV2Dep",
+    "get_claude_conversations_importer_v2_external",
+    "ClaudeConversationsImporterV2ExternalDep",
+    "get_claude_projects_importer",
+    "ClaudeProjectsImporterDep",
+    "get_claude_projects_importer_v2",
+    "ClaudeProjectsImporterV2Dep",
+    "get_claude_projects_importer_v2_external",
+    "ClaudeProjectsImporterV2ExternalDep",
+    "get_memory_json_importer",
+    "MemoryJsonImporterDep",
+    "get_memory_json_importer_v2",
+    "MemoryJsonImporterV2Dep",
+    "get_memory_json_importer_v2_external",
+    "MemoryJsonImporterV2ExternalDep",
+]

basic_memory/deps/config.py

@@ -0,0 +1,26 @@
+"""Configuration dependency injection for basic-memory.
+
+This module provides configuration-related dependencies.
+Note: Long-term goal is to minimize direct ConfigManager access
+and inject config from composition roots instead.
+"""
+
+from typing import Annotated
+
+from fastapi import Depends
+
+from basic_memory.config import BasicMemoryConfig, ConfigManager
+
+
+def get_app_config() -> BasicMemoryConfig:  # pragma: no cover
+    """Get the application configuration.
+
+    Note: This is a transitional dependency. The goal is for composition roots
+    to read ConfigManager and inject config explicitly. During migration,
+    this provides the same behavior as before.
+    """
+    app_config = ConfigManager().config
+    return app_config
+
+
+AppConfigDep = Annotated[BasicMemoryConfig, Depends(get_app_config)]