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

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)

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

@@ -10,7 +10,7 @@ import typer
 from rich.console import Console
 
 from evalvault.adapters.outbound.filesystem.difficulty_profile_writer import DifficultyProfileWriter
-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.difficulty_profile_reporter import DifficultyProfileReporter
 from evalvault.domain.services.difficulty_profiling_service import (
@@ -58,7 +58,7 @@ def register_profile_difficulty_commands(
         concurrency: int | None = typer.Option(
             None, "--concurrency", help="Max concurrency when parallel is enabled.", min=1
         ),
-        db_path: Path | None = db_option(help_text="SQLite DB path."),
+        db_path: Path | None = db_option(help_text="DB path."),
     ) -> None:
         if not dataset_name and not run_id:
             print_cli_error(
@@ -75,15 +75,6 @@ def register_profile_difficulty_commands(
             )
             raise typer.Exit(1)
 
-        resolved_db_path = db_path or Settings().evalvault_db_path
-        if resolved_db_path is None:
-            print_cli_error(
-                console,
-                "DB 경로가 필요합니다.",
-                fixes=["--db 옵션으로 SQLite DB 경로를 지정하세요."],
-            )
-            raise typer.Exit(1)
-
         metric_list = parse_csv_option(metrics)
         if metric_list:
             validate_choices(metric_list, available_metrics, console, value_label="metric")
@@ -94,7 +85,7 @@ def register_profile_difficulty_commands(
         resolved_output = output_path or Path("reports") / "difficulty" / f"{prefix}.json"
         resolved_artifacts_dir = artifacts_dir or resolved_output.parent / "artifacts" / prefix
 
-        storage = SQLiteStorageAdapter(db_path=resolved_db_path)
+        storage = build_storage_adapter(settings=Settings(), db_path=db_path)
         writer = DifficultyProfileWriter()
         reporter = DifficultyProfileReporter(writer)
         service = DifficultyProfilingService(storage=storage, reporter=reporter)

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

@@ -13,7 +13,7 @@ from rich.table import Table
 
 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.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.entities import Dataset, EvaluationRun, PromptSetBundle, TestCase
 from evalvault.domain.services.evaluator import RagasEvaluator
@@ -42,17 +42,6 @@ def _bundle_to_role_map(bundle: PromptSetBundle) -> dict[str, dict[str, str]]:
     return roles
 
 
-def _require_db_path(console: Console, db_path: Path | None) -> Path:
-    if db_path is None:
-        print_cli_error(
-            console,
-            "DB 경로가 필요합니다.",
-            fixes=["--db 옵션으로 SQLite DB 경로를 지정하세요."],
-        )
-        raise typer.Exit(1)
-    return db_path
-
-
 def _default_role(bundle: PromptSetBundle) -> str | None:
     for item in bundle.items:
         if item.role == "system":
@@ -229,8 +218,7 @@ def create_prompts_app(console: Console) -> typer.Typer:
         db_path: Path | None = db_option(help_text="Path to database file."),
     ) -> None:
         """Show prompt snapshots attached to a run."""
-        resolved_db = _require_db_path(console, db_path)
-        storage = SQLiteStorageAdapter(db_path=resolved_db)
+        storage = build_storage_adapter(settings=Settings(), db_path=db_path)
         bundle = storage.get_prompt_set_for_run(run_id)
         if not bundle:
             console.print("[yellow]No prompt set found for this run.[/yellow]")
@@ -273,8 +261,7 @@ def create_prompts_app(console: Console) -> typer.Typer:
         ),
     ) -> None:
         """Compare prompt snapshots between two runs."""
-        resolved_db = _require_db_path(console, db_path)
-        storage = SQLiteStorageAdapter(db_path=resolved_db)
+        storage = build_storage_adapter(settings=Settings(), db_path=db_path)
         bundle_a = storage.get_prompt_set_for_run(run_id_a)
         bundle_b = storage.get_prompt_set_for_run(run_id_b)
 
@@ -462,8 +449,7 @@ def create_prompts_app(console: Console) -> typer.Typer:
     ) -> None:
         """Suggest prompt improvements by scoring candidate prompts."""
 
-        resolved_db = _require_db_path(console, db_path)
-        storage = SQLiteStorageAdapter(db_path=resolved_db)
+        storage = build_storage_adapter(settings=Settings(), db_path=db_path)
 
         try:
             run = storage.get_run(run_id)

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

@@ -20,7 +20,8 @@ from evalvault.adapters.outbound.report.ci_report_formatter import (
 from evalvault.adapters.outbound.report.pr_comment_formatter import (
     format_ci_gate_pr_comment,
 )
-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.regression_gate_service import (
     RegressionGateReport,
     RegressionGateService,
@@ -133,7 +134,7 @@ def register_regress_commands(app: typer.Typer, console: Console) -> None:
         validate_choice(test, ["t-test", "mann-whitney"], console, value_label="test")
         metric_list = parse_csv_option(metrics)
 
-        storage = SQLiteStorageAdapter(db_path=db_path)
+        storage = build_storage_adapter(settings=Settings(), db_path=db_path)
         analysis_adapter = StatisticalAnalysisAdapter()
         service = RegressionGateService(storage=storage, analysis_adapter=analysis_adapter)
 
@@ -243,7 +244,7 @@ def register_regress_commands(app: typer.Typer, console: Console) -> None:
             value_label="format",
         )
 
-        storage = SQLiteStorageAdapter(db_path=db_path)
+        storage = build_storage_adapter(settings=Settings(), db_path=db_path)
         analysis_adapter = StatisticalAnalysisAdapter()
         service = RegressionGateService(storage=storage, analysis_adapter=analysis_adapter)
 
@@ -414,7 +415,7 @@ def register_regress_commands(app: typer.Typer, console: Console) -> None:
             console.print("[red]Error:[/red] Database path is not configured.")
             raise typer.Exit(1)
 
-        storage = SQLiteStorageAdapter(db_path=db_path)
+        storage = build_storage_adapter(settings=Settings(), db_path=db_path)
 
         if action == "set":
             if not run_id: