evalvault 1.73.2__py3-none-any.whl → 1.75.0__py3-none-any.whl

evalvault/adapters/inbound/api/routers/domain.py

@@ -5,17 +5,22 @@ from __future__ import annotations
 from fastapi import APIRouter, HTTPException
 from pydantic import BaseModel
 
-from evalvault.adapters.outbound.domain_memory.sqlite_adapter import SQLiteDomainMemoryAdapter
+from evalvault.adapters.outbound.domain_memory import build_domain_memory_adapter
 from evalvault.config.settings import get_settings
+from evalvault.ports.outbound.domain_memory_port import DomainMemoryPort
 
 router = APIRouter()
-DEFAULT_MEMORY_DB_PATH = get_settings().evalvault_memory_db_path
+_settings = get_settings()
+DEFAULT_MEMORY_DB_PATH = (
+    _settings.evalvault_memory_db_path if _settings.db_backend == "sqlite" else None
+)
 
 
-# --- Dependencies ---
-def get_memory_adapter(db_path: str = DEFAULT_MEMORY_DB_PATH) -> SQLiteDomainMemoryAdapter:
+def get_memory_adapter(db_path: str | None = DEFAULT_MEMORY_DB_PATH) -> DomainMemoryPort:
     """Get memory adapter instance."""
-    return SQLiteDomainMemoryAdapter(db_path)
+    from pathlib import Path
+
+    return build_domain_memory_adapter(db_path=Path(db_path) if db_path else None)
 
 
 # --- Pydantic Models ---

evalvault/adapters/inbound/api/routers/pipeline.py

@@ -8,7 +8,7 @@ from fastapi.encoders import jsonable_encoder
 from pydantic import BaseModel
 
 from evalvault.adapters.outbound.llm import get_llm_adapter
-from evalvault.adapters.outbound.storage.sqlite_adapter import SQLiteStorageAdapter
+from evalvault.adapters.outbound.storage.factory import build_storage_adapter
 from evalvault.config.settings import get_settings
 from evalvault.domain.entities.analysis_pipeline import AnalysisIntent
 from evalvault.domain.metrics.analysis_registry import list_analysis_metric_specs
@@ -264,9 +264,9 @@ def _intent_label(intent_value: str) -> str:
     return meta["label"] if meta else intent.value
 
 
-def _build_pipeline_service() -> tuple[AnalysisPipelineService, SQLiteStorageAdapter]:
+def _build_pipeline_service() -> tuple[AnalysisPipelineService, Any]:
     settings = get_settings()
-    storage = SQLiteStorageAdapter(db_path=settings.evalvault_db_path)
+    storage = build_storage_adapter(settings=settings)
     llm_adapter = None
     try:
         llm_adapter = get_llm_adapter(settings)

evalvault/adapters/inbound/api/routers/runs.py

@@ -21,7 +21,7 @@ from evalvault.adapters.outbound.dataset.templates import (
     render_dataset_template_xlsx,
 )
 from evalvault.adapters.outbound.debug.report_renderer import render_markdown
-from evalvault.adapters.outbound.domain_memory.sqlite_adapter import SQLiteDomainMemoryAdapter
+from evalvault.adapters.outbound.domain_memory import build_domain_memory_adapter
 from evalvault.adapters.outbound.report import DashboardGenerator
 from evalvault.config.settings import get_settings
 from evalvault.domain.entities import (
@@ -64,6 +64,7 @@ class RunSummaryResponse(BaseModel):
     phoenix_precision: float | None = None
     phoenix_drift: float | None = None
     phoenix_experiment_url: str | None = None
+    feedback_count: int | None = None
 
     model_config = {"from_attributes": True}
 
@@ -908,11 +909,20 @@ async def start_evaluation_endpoint(
                 )
 
                 try:
+                    from pathlib import Path
+
                     settings = get_settings()
-                    memory_db = memory_config.get("db_path") or settings.evalvault_memory_db_path
+                    if memory_config.get("db_path"):
+                        memory_db = memory_config.get("db_path")
+                    elif settings.db_backend == "sqlite":
+                        memory_db = settings.evalvault_memory_db_path
+                    else:
+                        memory_db = None
                     domain = memory_config.get("domain") or "default"
                     language = memory_config.get("language") or "ko"
-                    memory_adapter = SQLiteDomainMemoryAdapter(memory_db)
+                    memory_adapter = build_domain_memory_adapter(
+                        settings=settings, db_path=Path(memory_db) if memory_db else None
+                    )
                     hook = DomainLearningHook(memory_adapter)
                     await hook.on_evaluation_complete(
                         evaluation_run=result,
@@ -944,14 +954,22 @@ async def start_evaluation_endpoint(
 def list_runs(
     adapter: AdapterDep,
     limit: int = 50,
+    offset: int = Query(0, ge=0, description="Pagination offset"),
     dataset_name: str | None = Query(None, description="Filter by dataset name"),
     model_name: str | None = Query(None, description="Filter by model name"),
+    include_feedback: bool = Query(False, description="Include feedback count"),
 ) -> list[Any]:
     """List evaluation runs."""
     from evalvault.ports.inbound.web_port import RunFilters
 
     filters = RunFilters(dataset_name=dataset_name, model_name=model_name)
-    summaries = adapter.list_runs(limit=limit, filters=filters)
+    summaries = adapter.list_runs(limit=limit, offset=offset, filters=filters)
+    feedback_counts: dict[str, int] = {}
+    if include_feedback:
+        feedback_counts = {
+            summary.run_id: adapter.get_feedback_summary(summary.run_id).total_feedback
+            for summary in summaries
+        }
 
     # Convert RunSummary dataclass to dict/Pydantic compatible format
     # The adapter returns RunSummary objects which matches our response model mostly
@@ -975,6 +993,7 @@ def list_runs(
             "phoenix_precision": s.phoenix_precision,
             "phoenix_drift": s.phoenix_drift,
             "phoenix_experiment_url": s.phoenix_experiment_url,
+            "feedback_count": feedback_counts.get(s.run_id) if include_feedback else None,
         }
         for s in summaries
     ]

evalvault/adapters/inbound/cli/commands/analyze.py

@@ -26,7 +26,8 @@ from evalvault.adapters.outbound.analysis.pipeline_helpers import to_serializabl
 from evalvault.adapters.outbound.cache import MemoryCacheAdapter
 from evalvault.adapters.outbound.llm import get_llm_adapter
 from evalvault.adapters.outbound.report import DashboardGenerator, MarkdownReportAdapter
-from evalvault.adapters.outbound.storage.sqlite_adapter import SQLiteStorageAdapter
+from evalvault.adapters.outbound.storage.factory import build_storage_adapter
+from evalvault.adapters.outbound.storage.postgres_adapter import PostgreSQLStorageAdapter
 from evalvault.config.phoenix_support import get_phoenix_trace_url
 from evalvault.config.settings import Settings, apply_profile
 from evalvault.domain.entities import EvaluationRun
@@ -115,11 +116,7 @@ def register_analyze_commands(app: typer.Typer, console: Console) -> None:
     ) -> None:
         """평가 실행 결과를 분석하고 통계 인사이트를 표시합니다."""
 
-        resolved_db_path = db_path or Settings().evalvault_db_path
-        if resolved_db_path is None:
-            _console.print("[red]오류: DB 경로가 설정되지 않았습니다.[/red]")
-            raise typer.Exit(1)
-        storage = SQLiteStorageAdapter(db_path=resolved_db_path)
+        storage = build_storage_adapter(settings=Settings(), db_path=db_path)
 
         try:
             run = storage.get_run(run_id)
@@ -217,7 +214,12 @@ def register_analyze_commands(app: typer.Typer, console: Console) -> None:
                 _save_analysis_payload(bundle.causal, "causal")
             if improvement_report is not None:
                 _save_analysis_payload(improvement_report, "playbook")
-            _console.print(f"\n[green]분석 결과 DB 저장: {resolved_db_path}[/green]")
+            storage_label = (
+                "PostgreSQL"
+                if isinstance(storage, PostgreSQLStorageAdapter)
+                else f"SQLite ({db_path})"
+            )
+            _console.print(f"\n[green]분석 결과 DB 저장: {storage_label}[/green]")
 
         if dashboard:
             dashboard_gen = DashboardGenerator()
@@ -359,11 +361,7 @@ def register_analyze_commands(app: typer.Typer, console: Console) -> None:
     ) -> None:
         """두 실행을 통계적으로 비교합니다."""
 
-        resolved_db_path = db_path or Settings().evalvault_db_path
-        if resolved_db_path is None:
-            _console.print("[red]오류: DB 경로가 설정되지 않았습니다.[/red]")
-            raise typer.Exit(1)
-        storage = SQLiteStorageAdapter(db_path=resolved_db_path)
+        storage = build_storage_adapter(settings=Settings(), db_path=db_path)
 
         try:
             run_a = storage.get_run(run_id1)

evalvault/adapters/inbound/cli/commands/benchmark.py

@@ -385,7 +385,7 @@ def create_benchmark_app(console: Console) -> typer.Typer:
         """
         try:
             from evalvault.adapters.outbound.benchmark import LMEvalAdapter
-            from evalvault.adapters.outbound.storage import SQLiteStorageAdapter
+            from evalvault.adapters.outbound.storage.factory import build_storage_adapter
             from evalvault.config.settings import get_settings
             from evalvault.domain.services.benchmark_service import BenchmarkService
             from evalvault.ports.outbound.benchmark_port import BenchmarkBackend
@@ -426,7 +426,7 @@ def create_benchmark_app(console: Console) -> typer.Typer:
             ensure_phoenix_instrumentation(settings, console=console, force=True)
 
         benchmark_adapter = LMEvalAdapter(settings=settings)
-        storage_adapter = SQLiteStorageAdapter(db_path=db)
+        storage_adapter = build_storage_adapter(settings=settings, db_path=db)
         tracer_adapter = _create_tracer_adapter(phoenix)
         service = BenchmarkService(
             benchmark_adapter=benchmark_adapter,
@@ -556,9 +556,11 @@ def create_benchmark_app(console: Console) -> typer.Typer:
         ),
     ) -> None:
         """View past benchmark runs."""
-        from evalvault.adapters.outbound.storage import SQLiteStorageAdapter
+        from evalvault.adapters.outbound.storage.factory import build_storage_adapter
+        from evalvault.config.settings import get_settings
 
-        storage = SQLiteStorageAdapter(db_path=db)
+        settings = get_settings()
+        storage = build_storage_adapter(settings=settings, db_path=db)
         runs = storage.list_benchmark_runs(
             benchmark_type=benchmark_type,
             model_name=model_name,
@@ -629,7 +631,7 @@ def create_benchmark_app(console: Console) -> typer.Typer:
           evalvault benchmark report abc123
           evalvault benchmark report abc123 -o report.md -p dev
         """
-        from evalvault.adapters.outbound.storage import SQLiteStorageAdapter
+        from evalvault.adapters.outbound.storage.factory import build_storage_adapter
         from evalvault.config.settings import get_settings
         from evalvault.domain.services.benchmark_report_service import (
             BenchmarkReportService,
@@ -639,7 +641,7 @@ def create_benchmark_app(console: Console) -> typer.Typer:
         if profile:
             settings.profile = profile
 
-        storage = SQLiteStorageAdapter(db_path=db)
+        storage = build_storage_adapter(settings=settings, db_path=db)
         benchmark_run = storage.get_benchmark_run(run_id)
 
         if not benchmark_run:
@@ -717,7 +719,7 @@ def create_benchmark_app(console: Console) -> typer.Typer:
           evalvault benchmark compare abc123 def456
           evalvault benchmark compare abc123 def456 -o comparison.md
         """
-        from evalvault.adapters.outbound.storage import SQLiteStorageAdapter
+        from evalvault.adapters.outbound.storage.factory import build_storage_adapter
         from evalvault.config.settings import get_settings
         from evalvault.domain.services.benchmark_report_service import (
             BenchmarkReportService,
@@ -727,7 +729,7 @@ def create_benchmark_app(console: Console) -> typer.Typer:
         if profile:
             settings.profile = profile
 
-        storage = SQLiteStorageAdapter(db_path=db)
+        storage = build_storage_adapter(settings=settings, db_path=db)
         baseline = storage.get_benchmark_run(baseline_id)
         target = storage.get_benchmark_run(target_id)
 

evalvault/adapters/inbound/cli/commands/calibrate.py

@@ -7,7 +7,7 @@ import typer
 from rich.console import Console
 from rich.table import Table
 
-from evalvault.adapters.outbound.storage.sqlite_adapter import SQLiteStorageAdapter
+from evalvault.adapters.outbound.storage.factory import build_storage_adapter
 from evalvault.config.settings import Settings
 from evalvault.domain.services.satisfaction_calibration_service import (
     SatisfactionCalibrationService,
@@ -36,12 +36,7 @@ def register_calibrate_commands(app: typer.Typer, console: Console) -> None:
         ),
         db_path: Path | None = db_option(help_text="DB 경로"),
     ) -> None:
-        resolved_db_path = db_path or Settings().evalvault_db_path
-        if resolved_db_path is None:
-            _console.print("[red]오류: DB 경로가 설정되지 않았습니다.[/red]")
-            raise typer.Exit(1)
-
-        storage = SQLiteStorageAdapter(db_path=resolved_db_path)
+        storage = build_storage_adapter(settings=Settings(), db_path=db_path)
         try:
             run = storage.get_run(run_id)
         except KeyError:

evalvault/adapters/inbound/cli/commands/calibrate_judge.py

@@ -12,7 +12,7 @@ from evalvault.adapters.inbound.cli.utils.console import print_cli_error, progre
 from evalvault.adapters.inbound.cli.utils.options import db_option
 from evalvault.adapters.inbound.cli.utils.validators import parse_csv_option, validate_choice
 from evalvault.adapters.outbound.judge_calibration_reporter import JudgeCalibrationReporter
-from evalvault.adapters.outbound.storage.sqlite_adapter import SQLiteStorageAdapter
+from evalvault.adapters.outbound.storage.factory import build_storage_adapter
 from evalvault.config.settings import Settings
 from evalvault.domain.services.judge_calibration_service import JudgeCalibrationService
 
@@ -75,11 +75,6 @@ def register_calibrate_judge_commands(app: typer.Typer, console: Console) -> Non
         concurrency: int = typer.Option(8, "--concurrency", help="동시성 수준"),
         db_path: Path | None = db_option(help_text="DB 경로"),
     ) -> None:
-        resolved_db_path = db_path or Settings().evalvault_db_path
-        if resolved_db_path is None:
-            print_cli_error(_console, "DB 경로가 설정되지 않았습니다.")
-            raise typer.Exit(1)
-
         labels_source = labels_source.strip().lower()
         method = method.strip().lower()
         validate_choice(labels_source, _ALLOWED_LABELS, _console, value_label="labels-source")
@@ -96,7 +91,7 @@ def register_calibrate_judge_commands(app: typer.Typer, console: Console) -> Non
             print_cli_error(_console, "--concurrency 값은 1 이상이어야 합니다.")
             raise typer.Exit(1)
 
-        storage = SQLiteStorageAdapter(db_path=resolved_db_path)
+        storage = build_storage_adapter(settings=Settings(), db_path=db_path)
         try:
             run = storage.get_run(run_id)
         except KeyError:

evalvault/adapters/inbound/cli/commands/compare.py

@@ -12,7 +12,7 @@ from evalvault.adapters.outbound.analysis.comparison_pipeline_adapter import (
 )
 from evalvault.adapters.outbound.analysis.pipeline_factory import build_analysis_pipeline_service
 from evalvault.adapters.outbound.analysis.statistical_adapter import StatisticalAnalysisAdapter
-from evalvault.adapters.outbound.storage.sqlite_adapter import SQLiteStorageAdapter
+from evalvault.adapters.outbound.storage.factory import build_storage_adapter
 from evalvault.config.settings import Settings, apply_profile
 from evalvault.domain.services.run_comparison_service import (
     RunComparisonError,
@@ -91,15 +91,10 @@ def register_compare_commands(app: typer.Typer, console: Console) -> None:
         validate_choice(test, ["t-test", "mann-whitney"], console, value_label="test")
         validate_choice(output_format, ["table", "json"], console, value_label="format")
 
-        resolved_db_path = db_path or Settings().evalvault_db_path
-        if resolved_db_path is None:
-            print_cli_error(console, "DB 경로가 설정되지 않았습니다.")
-            raise typer.Exit(1)
-
         metric_list = parse_csv_option(metrics)
         metric_list = metric_list or None
 
-        storage = SQLiteStorageAdapter(db_path=resolved_db_path)
+        storage = build_storage_adapter(settings=Settings(), db_path=db_path)
         analysis_adapter = StatisticalAnalysisAdapter()
 
         settings = Settings()

evalvault/adapters/inbound/cli/commands/debug.py

@@ -9,7 +9,8 @@ from rich.console import Console
 from rich.markdown import Markdown
 
 from evalvault.adapters.outbound.debug.report_renderer import render_json, render_markdown
-from evalvault.adapters.outbound.storage.sqlite_adapter import SQLiteStorageAdapter
+from evalvault.adapters.outbound.storage.factory import build_storage_adapter
+from evalvault.config.settings import Settings
 from evalvault.domain.services.debug_report_service import DebugReportService
 
 from ..utils.options import db_option
@@ -42,7 +43,7 @@ def create_debug_app(console: Console) -> typer.Typer:
 
         validate_choice(format, ["markdown", "json"], console, value_label="format")
 
-        storage = SQLiteStorageAdapter(db_path=db_path)
+        storage = build_storage_adapter(settings=Settings(), db_path=db_path)
         service = DebugReportService()
 
         try:

evalvault/adapters/inbound/cli/commands/domain.py

@@ -11,9 +11,7 @@ import typer
 from rich.console import Console
 from rich.table import Table
 
-from evalvault.adapters.outbound.domain_memory.sqlite_adapter import (
-    SQLiteDomainMemoryAdapter,
-)
+from evalvault.adapters.outbound.domain_memory import build_domain_memory_adapter
 from evalvault.config.domain_config import (
     generate_domain_template,
     list_domains,
@@ -23,6 +21,7 @@ from evalvault.config.domain_config import (
 from evalvault.domain.entities.memory import FactType
 from evalvault.domain.services.domain_learning_hook import DomainLearningHook
 from evalvault.domain.services.embedding_overlay import build_cluster_facts
+from evalvault.ports.outbound.domain_memory_port import DomainMemoryPort
 
 from ..utils.options import memory_db_option
 from ..utils.validators import parse_csv_option, validate_choices
@@ -117,8 +116,8 @@ def create_domain_app(console: Console) -> typer.Typer:
     memory_app = typer.Typer(name="memory", help="Domain memory utilities.")
     domain_app.add_typer(memory_app, name="memory")
 
-    def _load_memory_adapter(db_path: Path) -> SQLiteDomainMemoryAdapter:
-        return SQLiteDomainMemoryAdapter(db_path)
+    def _load_memory_adapter(db_path: Path | None) -> DomainMemoryPort:
+        return build_domain_memory_adapter(db_path=db_path)
 
     def _truncate(text: str, max_length: int = 40) -> str:
         if len(text) <= max_length:
@@ -160,7 +159,7 @@ def create_domain_app(console: Console) -> typer.Typer:
             "-d",
             help="Filter by domain (leave empty for global stats).",
         ),
-        memory_db: Path = memory_db_option(),
+        memory_db: Path | None = memory_db_option(),
     ) -> None:
         """Show aggregated domain memory statistics."""
 
@@ -175,8 +174,9 @@ def create_domain_app(console: Console) -> typer.Typer:
         table.add_row("Behaviors", str(stats.get("behaviors", 0)))
         table.add_row("Contexts", str(stats.get("contexts", 0)))
         console.print(table)
+        database_label = "postgres (default)" if memory_db is None else str(memory_db)
         console.print(
-            f"[dim]Database:[/dim] {memory_db}  |  [dim]Domain:[/dim] {domain or 'all'}\n"
+            f"[dim]Database:[/dim] {database_label}  |  [dim]Domain:[/dim] {domain or 'all'}\n"
         )
 
     @memory_app.command("ingest-embeddings")
@@ -212,7 +212,7 @@ def create_domain_app(console: Console) -> typer.Typer:
         dry_run: bool = typer.Option(
             False, "--dry-run", help="Print summary without writing to the database."
         ),
-        memory_db: Path = memory_db_option(),
+        memory_db: Path | None = memory_db_option(),
     ) -> None:
         """Convert Phoenix embedding exports into Domain Memory facts."""
 
@@ -292,7 +292,7 @@ def create_domain_app(console: Console) -> typer.Typer:
             "--min-score",
             help="최소 검증 점수 필터 (0.0~1.0).",
         ),
-        memory_db: Path = memory_db_option(),
+        memory_db: Path | None = memory_db_option(),
     ) -> None:
         """Search factual facts stored in domain memory."""
 
@@ -350,7 +350,7 @@ def create_domain_app(console: Console) -> typer.Typer:
             "--min-success",
             help="최소 성공률 필터 (0.0~1.0).",
         ),
-        memory_db: Path = memory_db_option(),
+        memory_db: Path | None = memory_db_option(),
     ) -> None:
         """List reusable behaviors from domain memory."""
 
@@ -401,7 +401,7 @@ def create_domain_app(console: Console) -> typer.Typer:
         domain: str = typer.Option("insurance", "--domain", "-d", help="도메인 이름."),
         language: str = typer.Option("ko", "--language", "-l", help="언어 코드."),
         limit: int = typer.Option(5, "--limit", "-n", help="최대 결과 수."),
-        memory_db: Path = memory_db_option(),
+        memory_db: Path | None = memory_db_option(),
     ) -> None:
         """Display experiential learning entries stored in memory."""
 
@@ -444,7 +444,7 @@ def create_domain_app(console: Console) -> typer.Typer:
             "-y",
             help="확인 프롬프트를 건너뜁니다.",
         ),
-        memory_db: Path = memory_db_option(),
+        memory_db: Path | None = memory_db_option(),
     ) -> None:
         """Run consolidation/cleanup on stored memories."""
 

evalvault/adapters/inbound/cli/commands/experiment.py

@@ -8,7 +8,8 @@ import typer
 from rich.console import Console
 from rich.table import Table
 
-from evalvault.adapters.outbound.storage.sqlite_adapter import SQLiteStorageAdapter
+from evalvault.adapters.outbound.storage.factory import build_storage_adapter
+from evalvault.config.settings import Settings
 from evalvault.domain.services.experiment_manager import ExperimentManager
 
 from ..utils.options import db_option
@@ -48,7 +49,7 @@ def register_experiment_commands(app: typer.Typer, console: Console) -> None:
                 validate_choice(retriever_name, ["bm25", "dense", "hybrid", "graphrag"], console)
 
         console.print("\n[bold]Creating Experiment[/bold]\n")
-        storage = SQLiteStorageAdapter(db_path=db_path)
+        storage = build_storage_adapter(settings=Settings(), db_path=db_path)
         manager = ExperimentManager(storage)
         metric_list = parse_csv_option(metrics)
         metric_list = metric_list or None
@@ -88,7 +89,7 @@ def register_experiment_commands(app: typer.Typer, console: Console) -> None:
     ) -> None:
         """Add a group to an experiment."""
 
-        storage = SQLiteStorageAdapter(db_path=db_path)
+        storage = build_storage_adapter(settings=Settings(), db_path=db_path)
         manager = ExperimentManager(storage)
         try:
             manager.add_group_to_experiment(experiment_id, group_name, description)
@@ -108,7 +109,7 @@ def register_experiment_commands(app: typer.Typer, console: Console) -> None:
     ) -> None:
         """Add an evaluation run to an experiment group."""
 
-        storage = SQLiteStorageAdapter(db_path=db_path)
+        storage = build_storage_adapter(settings=Settings(), db_path=db_path)
         manager = ExperimentManager(storage)
         try:
             manager.add_run_to_experiment_group(experiment_id, group_name, run_id)
@@ -132,7 +133,7 @@ def register_experiment_commands(app: typer.Typer, console: Console) -> None:
         """List experiments."""
 
         console.print("\n[bold]Experiments[/bold]\n")
-        storage = SQLiteStorageAdapter(db_path=db_path)
+        storage = build_storage_adapter(settings=Settings(), db_path=db_path)
         manager = ExperimentManager(storage)
         experiments = manager.list_experiments(status=status)
         if not experiments:
@@ -172,7 +173,7 @@ def register_experiment_commands(app: typer.Typer, console: Console) -> None:
         """Compare groups inside an experiment."""
 
         console.print("\n[bold]Experiment Comparison[/bold]\n")
-        storage = SQLiteStorageAdapter(db_path=db_path)
+        storage = build_storage_adapter(settings=Settings(), db_path=db_path)
         manager = ExperimentManager(storage)
         try:
             experiment = manager.get_experiment(experiment_id)
@@ -222,7 +223,7 @@ def register_experiment_commands(app: typer.Typer, console: Console) -> None:
     ) -> None:
         """Conclude an experiment and record findings."""
 
-        storage = SQLiteStorageAdapter(db_path=db_path)
+        storage = build_storage_adapter(settings=Settings(), db_path=db_path)
         manager = ExperimentManager(storage)
         try:
             manager.conclude_experiment(experiment_id, conclusion)
@@ -239,7 +240,7 @@ def register_experiment_commands(app: typer.Typer, console: Console) -> None:
     ) -> None:
         """Show experiment summary."""
 
-        storage = SQLiteStorageAdapter(db_path=db_path)
+        storage = build_storage_adapter(settings=Settings(), db_path=db_path)
         manager = ExperimentManager(storage)
         try:
             summary = manager.get_summary(experiment_id)

evalvault/adapters/inbound/cli/commands/gate.py

@@ -9,8 +9,9 @@ import typer
 from rich.console import Console
 from rich.table import Table
 
-from evalvault.adapters.outbound.storage.sqlite_adapter import SQLiteStorageAdapter
+from evalvault.adapters.outbound.storage.factory import build_storage_adapter
 from evalvault.config.phoenix_support import get_phoenix_trace_url
+from evalvault.config.settings import Settings
 
 from ..utils.formatters import format_diff, format_score, format_status
 from ..utils.options import db_option
@@ -50,7 +51,7 @@ def register_gate_commands(app: typer.Typer, console: Console) -> None:
     ) -> None:
         """Quality gate check for CI/CD pipelines."""
 
-        storage = SQLiteStorageAdapter(db_path=db_path)
+        storage = build_storage_adapter(settings=Settings(), db_path=db_path)
 
         try:
             run = storage.get_run(run_id)

evalvault/adapters/inbound/cli/commands/graph_rag.py

@@ -17,7 +17,7 @@ from evalvault.adapters.outbound.dataset import get_loader
 from evalvault.adapters.outbound.llm import SettingsLLMFactory, get_llm_adapter
 from evalvault.adapters.outbound.nlp.korean.toolkit_factory import try_create_korean_toolkit
 from evalvault.adapters.outbound.retriever.graph_rag_adapter import GraphRAGAdapter
-from evalvault.adapters.outbound.storage.sqlite_adapter import SQLiteStorageAdapter
+from evalvault.adapters.outbound.storage.factory import build_storage_adapter
 from evalvault.config.settings import Settings, apply_profile
 from evalvault.domain.services.analysis_service import AnalysisService
 from evalvault.domain.services.evaluator import RagasEvaluator
@@ -185,7 +185,7 @@ def create_graph_rag_app(console: Console) -> typer.Typer:
         console.print(f"[green]Saved GraphRAG artifacts:[/green] {artifacts_path}")
 
         if db_path is not None:
-            storage = SQLiteStorageAdapter(db_path=db_path)
+            storage = build_storage_adapter(settings=Settings(), db_path=db_path)
             storage.save_run(result.baseline_run)
             storage.save_run(result.graph_run)
             console.print(f"[green]Saved baseline run:[/green] {result.baseline_run.run_id}")

evalvault/adapters/inbound/cli/commands/history.py

@@ -4,13 +4,12 @@ from __future__ import annotations
 
 import json
 from pathlib import Path
-from typing import cast
 
 import typer
 from rich.console import Console
 from rich.table import Table
 
-from evalvault.adapters.outbound.storage.sqlite_adapter import SQLiteStorageAdapter
+from evalvault.adapters.outbound.storage.factory import build_storage_adapter
 from evalvault.config.phoenix_support import PhoenixExperimentResolver
 from evalvault.config.settings import Settings
 
@@ -88,11 +87,7 @@ def register_history_commands(app: typer.Typer, console: Console) -> None:
                     "[red]Error:[/red] --mode must be one of: " + ", ".join(RUN_MODE_CHOICES)
                 )
                 raise typer.Exit(2)
-        resolved_db_path = db_path or Settings().evalvault_db_path
-        if resolved_db_path is None:
-            console.print("[red]Error:[/red] Database path is not configured.")
-            raise typer.Exit(1)
-        storage = SQLiteStorageAdapter(db_path=cast(Path, resolved_db_path))
+        storage = build_storage_adapter(settings=Settings(), db_path=db_path)
         runs = storage.list_runs(limit=limit, dataset_name=dataset, model_name=model)
         if normalized_mode:
             runs = [
@@ -199,11 +194,7 @@ def register_history_commands(app: typer.Typer, console: Console) -> None:
         """
         console.print(f"\n[bold]Exporting Run {run_id}[/bold]\n")
 
-        resolved_db_path = db_path or Settings().evalvault_db_path
-        if resolved_db_path is None:
-            console.print("[red]Error:[/red] Database path is not configured.")
-            raise typer.Exit(1)
-        storage = SQLiteStorageAdapter(db_path=cast(Path, resolved_db_path))
+        storage = build_storage_adapter(settings=Settings(), db_path=db_path)
 
         try:
             run = storage.get_run(run_id)

evalvault/adapters/inbound/cli/commands/method.py

@@ -424,8 +424,7 @@ def create_method_app(console: Console) -> typer.Typer:
         if eval_output:
             _save_results(eval_output, result, console)
 
-        if db_path is not None:
-            _save_to_db(db_path, result, console)
+        _save_to_db(db_path, result, console)
 
     return method_app
 

evalvault/adapters/inbound/cli/commands/ops.py

@@ -7,7 +7,7 @@ import typer
 from rich.console import Console
 
 from evalvault.adapters.outbound.filesystem.ops_snapshot_writer import OpsSnapshotWriter
-from evalvault.adapters.outbound.storage.sqlite_adapter import SQLiteStorageAdapter
+from evalvault.adapters.outbound.storage.factory import build_storage_adapter
 from evalvault.config.settings import Settings, apply_profile
 from evalvault.domain.services.ops_snapshot_service import (
     OpsSnapshotRequest,
@@ -57,7 +57,7 @@ def create_ops_app(console: Console) -> typer.Typer:
             settings = apply_profile(settings, resolved_profile)
 
         resolved_db_path = _resolve_storage_path(db_path)
-        storage = SQLiteStorageAdapter(db_path=resolved_db_path)
+        storage = build_storage_adapter(settings=Settings(), db_path=db_path)
         writer = OpsSnapshotWriter()
         service = OpsSnapshotService(
             storage=storage,

evalvault/adapters/inbound/cli/commands/pipeline.py

@@ -11,7 +11,7 @@ import typer
 from rich.panel import Panel
 from rich.table import Table
 
-from evalvault.adapters.outbound.storage.sqlite_adapter import SQLiteStorageAdapter
+from evalvault.adapters.outbound.storage.factory import build_storage_adapter
 from evalvault.config.phoenix_support import ensure_phoenix_instrumentation
 from evalvault.config.settings import Settings
 
@@ -64,7 +64,7 @@ def register_pipeline_commands(app: typer.Typer, console) -> None:
             console.print("[red]Error: Database path is not configured.[/red]")
             raise typer.Exit(1)
 
-        storage = SQLiteStorageAdapter(db_path=db_path)
+        storage = build_storage_adapter(settings=Settings(), db_path=db_path)
         llm_adapter = None
         try:
             llm_adapter = get_llm_adapter(settings)