QuickLab-MCP 0.1.0__py3-none-any.whl

ml_mcp/infrastructure/postgres/repositories/__init__.py

@@ -0,0 +1,21 @@
+"""PostgreSQL Repositories package."""
+
+from ml_mcp.infrastructure.postgres.repositories.artifacts import ArtifactRepository
+from ml_mcp.infrastructure.postgres.repositories.audit import AuditRepository
+from ml_mcp.infrastructure.postgres.repositories.datasets import DatasetRepository
+from ml_mcp.infrastructure.postgres.repositories.experiments import ExperimentRepository
+from ml_mcp.infrastructure.postgres.repositories.metrics import MetricRepository
+from ml_mcp.infrastructure.postgres.repositories.models import ModelRepository
+from ml_mcp.infrastructure.postgres.repositories.outbox import OutboxRepository
+from ml_mcp.infrastructure.postgres.repositories.projects import ProjectRepository
+
+__all__ = [
+    "ModelRepository",
+    "DatasetRepository",
+    "ExperimentRepository",
+    "MetricRepository",
+    "ArtifactRepository",
+    "OutboxRepository",
+    "AuditRepository",
+    "ProjectRepository",
+]

ml_mcp/infrastructure/postgres/repositories/artifacts.py

@@ -0,0 +1,34 @@
+"""Repository for experiment artifact metadata."""
+
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from ml_mcp.infrastructure.postgres.models import ArtifactOrm
+
+
+class ArtifactRepository:
+    """Tenant-scoped data access for persisted analytical and model artifacts."""
+
+    def __init__(self, session: AsyncSession) -> None:
+        self.session = session
+
+    async def record_artifact(self, artifact: ArtifactOrm) -> ArtifactOrm:
+        self.session.add(artifact)
+        await self.session.flush()
+        return artifact
+
+    async def list_artifacts(self, tenant_id: str, experiment_id: str) -> list[ArtifactOrm]:
+        stmt = (
+            select(ArtifactOrm)
+            .where(ArtifactOrm.tenant_id == tenant_id, ArtifactOrm.experiment_id == experiment_id)
+            .order_by(ArtifactOrm.created_at.desc())
+        )
+        result = await self.session.execute(stmt)
+        return list(result.scalars().all())
+
+    async def get_artifact(self, tenant_id: str, artifact_id: str) -> ArtifactOrm | None:
+        stmt = select(ArtifactOrm).where(
+            ArtifactOrm.tenant_id == tenant_id, ArtifactOrm.id == artifact_id
+        )
+        result = await self.session.execute(stmt)
+        return result.scalar_one_or_none()

ml_mcp/infrastructure/postgres/repositories/audit.py

@@ -0,0 +1,34 @@
+"""Repository for immutable audit log records."""
+
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from ml_mcp.infrastructure.postgres.models import AuditEventOrm
+
+
+class AuditRepository:
+    """Append-only audit trail repository."""
+
+    def __init__(self, session: AsyncSession) -> None:
+        self.session = session
+
+    async def record_event(self, event: AuditEventOrm) -> AuditEventOrm:
+        self.session.add(event)
+        await self.session.flush()
+        return event
+
+    async def list_events(
+        self,
+        tenant_id: str,
+        limit: int = 100,
+        offset: int = 0,
+    ) -> list[AuditEventOrm]:
+        stmt = (
+            select(AuditEventOrm)
+            .where(AuditEventOrm.tenant_id == tenant_id)
+            .order_by(AuditEventOrm.timestamp.desc())
+            .limit(limit)
+            .offset(offset)
+        )
+        result = await self.session.execute(stmt)
+        return list(result.scalars().all())

ml_mcp/infrastructure/postgres/repositories/datasets.py

@@ -0,0 +1,85 @@
+"""Repository for dataset and dataset version persistence."""
+
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.orm import selectinload
+
+from ml_mcp.infrastructure.postgres.models import DatasetOrm, DatasetVersionOrm
+
+
+class DatasetRepository:
+    """Tenant-scoped data access for registered datasets and versions."""
+
+    def __init__(self, session: AsyncSession) -> None:
+        self.session = session
+
+    async def create_dataset(self, dataset: DatasetOrm) -> DatasetOrm:
+        self.session.add(dataset)
+        await self.session.flush()
+        return dataset
+
+    async def get_dataset(self, tenant_id: str, dataset_id: str) -> DatasetOrm | None:
+        stmt = (
+            select(DatasetOrm)
+            .where(DatasetOrm.tenant_id == tenant_id, DatasetOrm.id == dataset_id)
+            .options(selectinload(DatasetOrm.versions))
+        )
+        result = await self.session.execute(stmt)
+        return result.scalar_one_or_none()
+
+    async def list_datasets(
+        self, tenant_id: str, project_id: str | None = None
+    ) -> list[DatasetOrm]:
+        stmt = select(DatasetOrm).where(DatasetOrm.tenant_id == tenant_id)
+        if project_id:
+            stmt = stmt.where(DatasetOrm.project_id == project_id)
+        stmt = stmt.options(selectinload(DatasetOrm.versions)).order_by(
+            DatasetOrm.created_at.desc()
+        )
+        result = await self.session.execute(stmt)
+        return list(result.scalars().all())
+
+    async def create_version(self, version: DatasetVersionOrm) -> DatasetVersionOrm:
+        self.session.add(version)
+        await self.session.flush()
+        return version
+
+    async def get_version(
+        self, tenant_id: str, dataset_id: str, version: str
+    ) -> DatasetVersionOrm | None:
+        stmt = (
+            select(DatasetVersionOrm)
+            .join(DatasetOrm, DatasetVersionOrm.dataset_id == DatasetOrm.id)
+            .where(
+                DatasetOrm.tenant_id == tenant_id,
+                DatasetVersionOrm.dataset_id == dataset_id,
+                DatasetVersionOrm.version == version,
+            )
+        )
+        result = await self.session.execute(stmt)
+        return result.scalar_one_or_none()
+
+    async def get_version_by_id(self, tenant_id: str, version_id: str) -> DatasetVersionOrm | None:
+        stmt = (
+            select(DatasetVersionOrm)
+            .join(DatasetOrm, DatasetVersionOrm.dataset_id == DatasetOrm.id)
+            .where(
+                DatasetOrm.tenant_id == tenant_id,
+                DatasetVersionOrm.id == version_id,
+            )
+        )
+        result = await self.session.execute(stmt)
+        return result.scalar_one_or_none()
+
+    async def list_versions(self, tenant_id: str, dataset_id: str) -> list[DatasetVersionOrm]:
+        stmt = (
+            select(DatasetVersionOrm)
+            .join(DatasetOrm, DatasetVersionOrm.dataset_id == DatasetOrm.id)
+            .where(
+                DatasetOrm.tenant_id == tenant_id,
+                DatasetVersionOrm.dataset_id == dataset_id,
+            )
+            .order_by(DatasetVersionOrm.created_at.desc())
+        )
+        result = await self.session.execute(stmt)
+        return list(result.scalars().all())

ml_mcp/infrastructure/postgres/repositories/experiments.py

@@ -0,0 +1,134 @@
+"""Repository for experiments, runs, and transactional outbox emission."""
+
+from typing import Any
+
+from sqlalchemy import select, update
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.orm import selectinload
+
+from ml_mcp.infrastructure.postgres.base import utc_now
+from ml_mcp.infrastructure.postgres.models import (
+    ExperimentOrm,
+    ExperimentRunOrm,
+    ModelVersionOrm,
+    OutboxEventOrm,
+)
+
+
+class ExperimentRepository:
+    """Tenant-scoped data access for experiments and execution runs."""
+
+    def __init__(self, session: AsyncSession) -> None:
+        self.session = session
+
+    async def create_experiment(
+        self,
+        experiment: ExperimentOrm,
+        initial_outbox_event: OutboxEventOrm | None = None,
+    ) -> ExperimentOrm:
+        """Create experiment and optional transactional outbox event atomically."""
+        self.session.add(experiment)
+        if initial_outbox_event:
+            self.session.add(initial_outbox_event)
+        await self.session.flush()
+        return experiment
+
+    async def get_by_idempotency_key(
+        self,
+        tenant_id: str,
+        project_id: str,
+        idempotency_key: str,
+    ) -> ExperimentOrm | None:
+        stmt = (
+            select(ExperimentOrm)
+            .where(
+                ExperimentOrm.tenant_id == tenant_id,
+                ExperimentOrm.project_id == project_id,
+                ExperimentOrm.idempotency_key == idempotency_key,
+            )
+            .options(selectinload(ExperimentOrm.runs))
+        )
+        result = await self.session.execute(stmt)
+        return result.scalar_one_or_none()
+
+    async def get_experiment(self, tenant_id: str, experiment_id: str) -> ExperimentOrm | None:
+        stmt = (
+            select(ExperimentOrm)
+            .where(ExperimentOrm.tenant_id == tenant_id, ExperimentOrm.id == experiment_id)
+            .options(
+                selectinload(ExperimentOrm.runs),
+                selectinload(ExperimentOrm.metrics),
+                selectinload(ExperimentOrm.artifacts),
+                selectinload(ExperimentOrm.analysis),
+                selectinload(ExperimentOrm.model_version).selectinload(ModelVersionOrm.model),
+                selectinload(ExperimentOrm.dataset_version),
+            )
+        )
+        result = await self.session.execute(stmt)
+        return result.scalar_one_or_none()
+
+    async def list_experiments(
+        self,
+        tenant_id: str,
+        project_id: str | None = None,
+        status: str | None = None,
+        limit: int = 50,
+        offset: int = 0,
+    ) -> list[ExperimentOrm]:
+        stmt = select(ExperimentOrm).where(ExperimentOrm.tenant_id == tenant_id)
+        if project_id:
+            stmt = stmt.where(ExperimentOrm.project_id == project_id)
+        if status:
+            stmt = stmt.where(ExperimentOrm.status == status)
+        stmt = (
+            stmt.options(selectinload(ExperimentOrm.runs))
+            .order_by(ExperimentOrm.created_at.desc())
+            .limit(limit)
+            .offset(offset)
+        )
+        result = await self.session.execute(stmt)
+        return list(result.scalars().all())
+
+    async def update_status(self, tenant_id: str, experiment_id: str, new_status: str) -> bool:
+        stmt = (
+            update(ExperimentOrm)
+            .where(ExperimentOrm.tenant_id == tenant_id, ExperimentOrm.id == experiment_id)
+            .values(status=new_status, updated_at=utc_now())
+        )
+        result = await self.session.execute(stmt)
+        return result.rowcount > 0
+
+    async def create_run(self, run: ExperimentRunOrm) -> ExperimentRunOrm:
+        self.session.add(run)
+        await self.session.flush()
+        return run
+
+    async def update_run(
+        self,
+        run_id: str,
+        status: str,
+        duration_seconds: float | None = None,
+        failure_reason: str | None = None,
+        end_time: bool = False,
+    ) -> bool:
+        values: dict[str, Any] = {"status": status}
+        if duration_seconds is not None:
+            values["duration_seconds"] = duration_seconds
+        if failure_reason is not None:
+            values["failure_reason"] = failure_reason
+        if end_time:
+            values["end_time"] = utc_now()
+
+        stmt = update(ExperimentRunOrm).where(ExperimentRunOrm.id == run_id).values(**values)
+        result = await self.session.execute(stmt)
+        return result.rowcount > 0
+
+    async def get_latest_run(self, experiment_id: str) -> ExperimentRunOrm | None:
+        stmt = (
+            select(ExperimentRunOrm)
+            .where(ExperimentRunOrm.experiment_id == experiment_id)
+            .order_by(ExperimentRunOrm.run_number.desc())
+            .limit(1)
+        )
+        result = await self.session.execute(stmt)
+        return result.scalar_one_or_none()

ml_mcp/infrastructure/postgres/repositories/metrics.py

@@ -0,0 +1,61 @@
+"""Repository for evaluation metrics recording and cross-experiment comparison."""
+
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from ml_mcp.infrastructure.postgres.models import ExperimentOrm, MetricOrm
+
+
+class MetricRepository:
+    """Tenant-scoped data access for experiment evaluation metrics."""
+
+    def __init__(self, session: AsyncSession) -> None:
+        self.session = session
+
+    async def record_metrics(self, metrics: list[MetricOrm]) -> list[MetricOrm]:
+        self.session.add_all(metrics)
+        await self.session.flush()
+        return metrics
+
+    async def get_metrics(
+        self,
+        tenant_id: str,
+        experiment_id: str,
+        split: str | None = None,
+    ) -> list[MetricOrm]:
+        stmt = (
+            select(MetricOrm)
+            .join(ExperimentOrm, MetricOrm.experiment_id == ExperimentOrm.id)
+            .where(ExperimentOrm.tenant_id == tenant_id, MetricOrm.experiment_id == experiment_id)
+        )
+        if split:
+            stmt = stmt.where(MetricOrm.split == split)
+        stmt = stmt.order_by(MetricOrm.metric_name)
+        result = await self.session.execute(stmt)
+        return list(result.scalars().all())
+
+    async def compare_metrics(
+        self,
+        tenant_id: str,
+        experiment_ids: list[str],
+    ) -> dict[str, dict[str, float]]:
+        """Return {experiment_id: {metric_name: metric_value}} across authorized experiments."""
+        if not experiment_ids:
+            return {}
+
+        stmt = (
+            select(MetricOrm)
+            .join(ExperimentOrm, MetricOrm.experiment_id == ExperimentOrm.id)
+            .where(
+                ExperimentOrm.tenant_id == tenant_id,
+                MetricOrm.experiment_id.in_(experiment_ids),
+                MetricOrm.split == "validation",
+            )
+        )
+        result = await self.session.execute(stmt)
+        rows = result.scalars().all()
+
+        comparison: dict[str, dict[str, float]] = {eid: {} for eid in experiment_ids}
+        for row in rows:
+            comparison[row.experiment_id][row.metric_name] = row.metric_value
+        return comparison

ml_mcp/infrastructure/postgres/repositories/models.py

@@ -0,0 +1,61 @@
+"""Repository for registered models and model versions."""
+
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.orm import selectinload
+
+from ml_mcp.infrastructure.postgres.models import ModelOrm, ModelVersionOrm
+
+
+class ModelRepository:
+    """Data access operations for the approved model catalog."""
+
+    def __init__(self, session: AsyncSession) -> None:
+        self.session = session
+
+    async def get_by_id(self, model_id: str) -> ModelOrm | None:
+        stmt = (
+            select(ModelOrm).where(ModelOrm.id == model_id).options(selectinload(ModelOrm.versions))
+        )
+        result = await self.session.execute(stmt)
+        return result.scalar_one_or_none()
+
+    async def list_models(self) -> list[ModelOrm]:
+        stmt = select(ModelOrm).options(selectinload(ModelOrm.versions)).order_by(ModelOrm.id)
+        result = await self.session.execute(stmt)
+        return list(result.scalars().all())
+
+    async def get_version(self, model_id: str, version: str) -> ModelVersionOrm | None:
+        stmt = select(ModelVersionOrm).where(
+            ModelVersionOrm.model_id == model_id, ModelVersionOrm.version == version
+        )
+        result = await self.session.execute(stmt)
+        return result.scalar_one_or_none()
+
+    async def get_version_by_id(self, version_id: str) -> ModelVersionOrm | None:
+        stmt = (
+            select(ModelVersionOrm)
+            .where(ModelVersionOrm.id == version_id)
+            .options(selectinload(ModelVersionOrm.model))
+        )
+        result = await self.session.execute(stmt)
+        return result.scalar_one_or_none()
+
+    async def list_versions(self, model_id: str) -> list[ModelVersionOrm]:
+        stmt = (
+            select(ModelVersionOrm)
+            .where(ModelVersionOrm.model_id == model_id)
+            .order_by(ModelVersionOrm.created_at.desc())
+        )
+        result = await self.session.execute(stmt)
+        return list(result.scalars().all())
+
+    async def create_model(self, model: ModelOrm) -> ModelOrm:
+        self.session.add(model)
+        await self.session.flush()
+        return model
+
+    async def create_version(self, version: ModelVersionOrm) -> ModelVersionOrm:
+        self.session.add(version)
+        await self.session.flush()
+        return version

ml_mcp/infrastructure/postgres/repositories/outbox.py

@@ -0,0 +1,47 @@
+"""Repository for Outbox event lifecycle management."""
+
+from sqlalchemy import select, update
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from ml_mcp.infrastructure.postgres.base import utc_now
+from ml_mcp.infrastructure.postgres.models import OutboxEventOrm
+
+
+class OutboxRepository:
+    """Operations for polling and updating transactional outbox events."""
+
+    def __init__(self, session: AsyncSession) -> None:
+        self.session = session
+
+    async def fetch_pending(self, limit: int = 50) -> list[OutboxEventOrm]:
+        """Fetch pending outbox events scheduled for delivery."""
+        stmt = (
+            select(OutboxEventOrm)
+            .where(
+                OutboxEventOrm.status == "PENDING",
+                OutboxEventOrm.scheduled_at <= utc_now(),
+            )
+            .order_by(OutboxEventOrm.scheduled_at.asc())
+            .limit(limit)
+        )
+        result = await self.session.execute(stmt)
+        return list(result.scalars().all())
+
+    async def mark_delivered(self, event_id: str) -> bool:
+        stmt = (
+            update(OutboxEventOrm)
+            .where(OutboxEventOrm.id == event_id)
+            .values(status="DELIVERED", processed_at=utc_now())
+        )
+        result = await self.session.execute(stmt)
+        return result.rowcount > 0
+
+    async def mark_failed(self, event_id: str, retry_count: int, max_retries: int = 5) -> bool:
+        new_status = "FAILED" if retry_count >= max_retries else "PENDING"
+        stmt = (
+            update(OutboxEventOrm)
+            .where(OutboxEventOrm.id == event_id)
+            .values(status=new_status, retry_count=retry_count)
+        )
+        result = await self.session.execute(stmt)
+        return result.rowcount > 0

ml_mcp/infrastructure/postgres/repositories/projects.py

@@ -0,0 +1,83 @@
+"""Repository for project control plane persistence."""
+
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from ml_mcp.infrastructure.postgres.models import ProjectOrm, TenantOrm
+
+
+class ProjectRepository:
+    """Tenant-scoped data access for projects."""
+
+    def __init__(self, session: AsyncSession) -> None:
+        self.session = session
+
+    async def create_project(self, project: ProjectOrm) -> ProjectOrm:
+        self.session.add(project)
+        await self.session.flush()
+        return project
+
+    async def get_project(self, tenant_id: str, project_id: str) -> ProjectOrm | None:
+        stmt = select(ProjectOrm).where(
+            ProjectOrm.tenant_id == tenant_id,
+            ProjectOrm.id == project_id,
+        )
+        result = await self.session.execute(stmt)
+        return result.scalar_one_or_none()
+
+    async def get_project_by_name(self, tenant_id: str, name: str) -> ProjectOrm | None:
+        stmt = select(ProjectOrm).where(
+            ProjectOrm.tenant_id == tenant_id,
+            ProjectOrm.name == name,
+        )
+        result = await self.session.execute(stmt)
+        return result.scalar_one_or_none()
+
+    async def list_projects(
+        self, tenant_id: str, limit: int = 50, offset: int = 0
+    ) -> list[ProjectOrm]:
+        stmt = (
+            select(ProjectOrm)
+            .where(ProjectOrm.tenant_id == tenant_id)
+            .order_by(ProjectOrm.created_at.desc())
+            .limit(limit)
+            .offset(offset)
+        )
+        result = await self.session.execute(stmt)
+        return list(result.scalars().all())
+
+    async def get_or_create_default_project(
+        self, tenant_id: str = "default-tenant"
+    ) -> ProjectOrm:
+        """Ensure tenant and default project exist, returning the project."""
+        # 1. Ensure tenant exists
+        tenant_stmt = select(TenantOrm).where(TenantOrm.id == tenant_id)
+        tenant_res = await self.session.execute(tenant_stmt)
+        tenant = tenant_res.scalar_one_or_none()
+        if not tenant:
+            tenant = TenantOrm(
+                id=tenant_id,
+                name="Default Tenant" if tenant_id == "default-tenant" else tenant_id,
+            )
+            self.session.add(tenant)
+            await self.session.flush()
+
+        # 2. Ensure default-project exists
+        proj_id = "default-project" if tenant_id == "default-tenant" else f"{tenant_id}-default-project"
+        proj_stmt = select(ProjectOrm).where(
+            ProjectOrm.tenant_id == tenant_id,
+            (ProjectOrm.id == proj_id) | (ProjectOrm.name == "Default Project"),
+        )
+        proj_res = await self.session.execute(proj_stmt)
+        project = proj_res.scalar_one_or_none()
+        if not project:
+            project = ProjectOrm(
+                id=proj_id,
+                tenant_id=tenant_id,
+                name="Default Project",
+                description="Default ModelLab experimentation project",
+            )
+            self.session.add(project)
+            await self.session.flush()
+
+        return project

ml_mcp/infrastructure/postgres/session.py

@@ -0,0 +1,117 @@
+"""Async database engine, session factory, and lifecycle management."""
+
+import logging
+from collections.abc import AsyncGenerator
+from contextlib import asynccontextmanager
+from typing import Any
+
+from sqlalchemy import text
+from sqlalchemy.ext.asyncio import (
+    AsyncEngine,
+    AsyncSession,
+    async_sessionmaker,
+    create_async_engine,
+)
+
+from ml_mcp.config import Settings, get_settings
+
+logger = logging.getLogger(__name__)
+
+
+class DatabaseManager:
+    """Manages async PostgreSQL connection pool and session factories."""
+
+    def __init__(self, settings: Settings | None = None) -> None:
+        self.settings = settings or get_settings()
+        self._engine: AsyncEngine | None = None
+        self._sessionmaker: async_sessionmaker[AsyncSession] | None = None
+
+    def initialize(self, custom_url: str | None = None) -> None:
+        """Initialize the async engine and sessionmaker."""
+        db_url = custom_url or self.settings.database.url
+
+        engine_kwargs: dict[str, Any] = {
+            "echo": self.settings.database.echo,
+            "pool_pre_ping": True,
+        }
+
+        # SQLite requires StaticPool for in-memory and does not support pool_size or max_overflow
+        if db_url.startswith("sqlite"):
+            from sqlalchemy.pool import StaticPool
+
+            engine_kwargs["poolclass"] = StaticPool
+            engine_kwargs["connect_args"] = {"check_same_thread": False}
+        else:
+            engine_kwargs.update(
+                {
+                    "pool_size": self.settings.database.pool_size,
+                    "max_overflow": self.settings.database.max_overflow,
+                    "pool_timeout": self.settings.database.pool_timeout,
+                    "pool_recycle": self.settings.database.pool_recycle,
+                }
+            )
+
+        self._engine = create_async_engine(db_url, **engine_kwargs)
+        self._sessionmaker = async_sessionmaker(
+            bind=self._engine,
+            class_=AsyncSession,
+            expire_on_commit=False,
+            autoflush=False,
+        )
+        logger.info(
+            "Database engine initialized for %s", db_url.split("@")[-1] if "@" in db_url else db_url
+        )
+
+    @property
+    def engine(self) -> AsyncEngine:
+        if self._engine is None:
+            self.initialize()
+        assert self._engine is not None
+        return self._engine
+
+    @property
+    def sessionmaker(self) -> async_sessionmaker[AsyncSession]:
+        if self._sessionmaker is None:
+            self.initialize()
+        assert self._sessionmaker is not None
+        return self._sessionmaker
+
+    @asynccontextmanager
+    async def session(self) -> AsyncGenerator[AsyncSession]:
+        """Provide a transactional async session scope."""
+        async with self.sessionmaker() as sess:
+            try:
+                yield sess
+                await sess.commit()
+            except Exception:
+                await sess.rollback()
+                raise
+
+    async def check_health(self) -> bool:
+        """Perform a quick healthcheck query (SELECT 1)."""
+        try:
+            async with self.session() as sess:
+                result = await sess.execute(text("SELECT 1"))
+                return result.scalar() == 1
+        except Exception as exc:
+            logger.error("Database healthcheck failed: %s", exc)
+            return False
+
+    async def close(self) -> None:
+        """Dispose the underlying connection pool."""
+        if self._engine is not None:
+            await self._engine.dispose()
+            self._engine = None
+            self._sessionmaker = None
+            logger.info("Database connection pool disposed")
+
+
+_db_manager: DatabaseManager | None = None
+
+
+def get_db_manager() -> DatabaseManager:
+    """Return singleton DatabaseManager instance."""
+    global _db_manager
+    if _db_manager is None:
+        _db_manager = DatabaseManager()
+    return _db_manager

ml_mcp/infrastructure/queue/__init__.py

@@ -0,0 +1,6 @@
+"""Queue infrastructure package."""
+
+from ml_mcp.infrastructure.queue.outbox_processor import OutboxProcessor
+from ml_mcp.infrastructure.queue.task_queue import RedisTaskQueue, TaskMessage
+
+__all__ = ["TaskMessage", "RedisTaskQueue", "OutboxProcessor"]