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

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:

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

@@ -21,7 +21,7 @@ from evalvault.adapters.outbound.dataset import get_loader, load_multiturn_datas
 from evalvault.adapters.outbound.documents.versioned_loader import (
     load_versioned_chunks_from_pdf_dir,
 )
-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.llm import SettingsLLMFactory, get_llm_adapter
 from evalvault.adapters.outbound.nlp.korean.toolkit_factory import try_create_korean_toolkit
 from evalvault.adapters.outbound.phoenix.sync_service import (
@@ -30,7 +30,7 @@ from evalvault.adapters.outbound.phoenix.sync_service import (
     PhoenixSyncService,
     build_experiment_metadata,
 )
-from evalvault.adapters.outbound.storage.sqlite_adapter import SQLiteStorageAdapter
+from evalvault.adapters.outbound.storage.factory import build_storage_adapter
 from evalvault.adapters.outbound.tracer.phoenix_tracer_adapter import PhoenixTracerAdapter
 from evalvault.config.phoenix_support import ensure_phoenix_instrumentation
 from evalvault.config.settings import Settings, apply_profile
@@ -57,6 +57,7 @@ from evalvault.domain.services.ragas_prompt_overrides import (
 )
 from evalvault.domain.services.retriever_context import apply_versioned_retriever_to_dataset
 from evalvault.domain.services.stage_event_builder import StageEventBuilder
+from evalvault.ports.outbound.domain_memory_port import DomainMemoryPort
 from evalvault.ports.outbound.korean_nlp_port import RetrieverPort
 
 from ..utils.analysis_io import (
@@ -111,7 +112,7 @@ def _build_dense_retriever(
     settings: Settings,
     profile_name: str | None,
 ) -> Any:
-    """Build and index a dense retriever, preferring Ollama embeddings when available."""
+    """Build and index a dense retriever, preferring OpenAI-compatible embeddings when available."""
 
     from evalvault.adapters.outbound.nlp.korean.dense_retriever import KoreanDenseRetriever
 
@@ -135,6 +136,17 @@ def _build_dense_retriever(
             dense_retriever.index(documents)
             return dense_retriever
 
+    if settings.llm_provider == "vllm":
+        from evalvault.adapters.outbound.llm.vllm_adapter import VLLMAdapter
+
+        adapter = VLLMAdapter(settings)
+        dense_retriever = KoreanDenseRetriever(
+            model_name=settings.vllm_embedding_model,
+            ollama_adapter=adapter,
+        )
+        dense_retriever.index(documents)
+        return dense_retriever
+
     try:
         dense_retriever = KoreanDenseRetriever()
         dense_retriever.index(documents)
@@ -142,7 +154,8 @@ def _build_dense_retriever(
     except Exception as exc:
         raise RuntimeError(
             "Dense retriever initialization failed. "
-            "Use --profile dev/prod (Ollama embedding), or install/prepare a local embedding model."
+            "Use --profile dev/prod (Ollama embedding), --profile vllm (vLLM embedding), "
+            "or install/prepare a local embedding model."
         ) from exc
 
 
@@ -1729,7 +1742,7 @@ def register_run_commands(
 
         assert llm_adapter is not None
 
-        memory_adapter: SQLiteDomainMemoryAdapter | None = None
+        memory_adapter: DomainMemoryPort | None = None
         memory_evaluator: MemoryAwareEvaluator | None = None
         memory_domain_name = memory_domain or ds.metadata.get("domain") or "default"
         memory_required = domain_memory_requested
@@ -1751,8 +1764,15 @@ def register_run_commands(
                 f"Domain Memory 초기화 시작 (domain={memory_domain_name}, lang={memory_language})",
             )
             try:
-                memory_db_path = memory_db or settings.evalvault_memory_db_path
-                memory_adapter = SQLiteDomainMemoryAdapter(memory_db_path)
+                if memory_db:
+                    memory_db_path = memory_db
+                elif settings.db_backend == "sqlite":
+                    memory_db_path = settings.evalvault_memory_db_path
+                else:
+                    memory_db_path = None
+                memory_adapter = build_domain_memory_adapter(
+                    settings=settings, db_path=Path(memory_db_path) if memory_db_path else None
+                )
                 memory_evaluator = MemoryAwareEvaluator(
                     evaluator=evaluator,
                     memory_port=memory_adapter,
@@ -2161,16 +2181,9 @@ def register_run_commands(
                 stored = _write_stage_events_jsonl(stage_events, stage_event_payload)
                 console.print(f"[green]Saved {stored} stage event(s).[/green]")
             if stage_store:
-                if db_path:
-                    storage = SQLiteStorageAdapter(db_path=db_path)
-                    stored = storage.save_stage_events(stage_event_payload)
-                    console.print(f"[green]Stored {stored} stage event(s).[/green]")
-                else:
-                    print_cli_warning(
-                        console,
-                        "Stage 이벤트를 저장하려면 --db 경로가 필요합니다.",
-                        tips=["--db <sqlite_path> 옵션을 함께 지정하세요."],
-                    )
+                storage = build_storage_adapter(settings=settings, db_path=db_path)
+                stored = storage.save_stage_events(stage_event_payload)
+                console.print(f"[green]Stored {stored} stage event(s).[/green]")
 
         if effective_tracker != "none":
             phoenix_opts = None
@@ -2194,23 +2207,21 @@ def register_run_commands(
                 log_phoenix_traces_fn=log_phoenix_traces,
             )
             _log_duration(console, verbose, "Tracker 로깅 완료", tracker_started_at)
-        if db_path:
-            db_started_at = datetime.now()
-            _log_timestamp(console, verbose, f"DB 저장 시작 ({db_path})")
-            _save_to_db(
-                db_path,
-                result,
-                console,
-                storage_cls=SQLiteStorageAdapter,
-                prompt_bundle=prompt_bundle,
-                export_excel=excel_output is None,
-            )
-            _log_duration(console, verbose, "DB 저장 완료", db_started_at)
+        db_started_at = datetime.now()
+        _log_timestamp(console, verbose, "DB 저장 시작")
+        _save_to_db(
+            db_path,
+            result,
+            console,
+            prompt_bundle=prompt_bundle,
+            export_excel=excel_output is None,
+        )
+        _log_duration(console, verbose, "DB 저장 완료", db_started_at)
         if excel_output:
             excel_started_at = datetime.now()
             _log_timestamp(console, verbose, f"엑셀 저장 시작 ({excel_output})")
             try:
-                storage = SQLiteStorageAdapter(db_path=db_path)
+                storage = build_storage_adapter(settings=settings, db_path=db_path)
                 storage.export_run_to_excel(result.run_id, excel_output)
                 console.print(f"[green]Excel export saved: {excel_output}[/green]")
             except Exception as exc:
@@ -2242,7 +2253,7 @@ def register_run_commands(
                     prefix=analysis_prefix,
                 )
                 console.print("\n[bold]자동 분석 실행[/bold]")
-                storage = SQLiteStorageAdapter(db_path=db_path) if db_path else None
+                storage = build_storage_adapter(settings=settings, db_path=db_path)
                 pipeline_service = build_analysis_pipeline_service(
                     storage=storage,
                     llm_adapter=llm_adapter,

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

@@ -18,7 +18,8 @@ from rich.table import Table
 from evalvault.adapters.outbound.dataset import StreamingConfig, StreamingDatasetLoader
 from evalvault.adapters.outbound.dataset.thresholds import extract_thresholds_from_rows
 from evalvault.adapters.outbound.kg.networkx_adapter import NetworkXKnowledgeGraph
-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,
     instrumentation_span,
@@ -454,18 +455,21 @@ def _log_to_tracker(
 
 
 def _save_to_db(
-    db_path: Path,
+    db_path: Path | None,
     result,
     console: Console,
     *,
-    storage_cls: type[SQLiteStorageAdapter] = SQLiteStorageAdapter,
     prompt_bundle: PromptSetBundle | None = None,
     export_excel: bool = True,
 ) -> None:
-    """Persist evaluation run (and optional prompt set) to SQLite database."""
-    with console.status(f"[bold green]Saving to database {db_path}..."):
+    """Persist evaluation run (and optional prompt set) to database."""
+    storage = build_storage_adapter(settings=Settings(), db_path=db_path)
+    storage_label = (
+        "PostgreSQL" if isinstance(storage, PostgreSQLStorageAdapter) else f"SQLite ({db_path})"
+    )
+    export_base = db_path.parent if db_path else Path("data/exports")
+    with console.status(f"[bold green]Saving to database {storage_label}..."):
         try:
-            storage = storage_cls(db_path=db_path)
             if prompt_bundle:
                 storage.save_prompt_set(prompt_bundle)
             storage.save_run(result)
@@ -475,7 +479,8 @@ def _save_to_db(
                     prompt_bundle.prompt_set.prompt_set_id,
                 )
             if export_excel:
-                excel_path = db_path.parent / f"evalvault_run_{result.run_id}.xlsx"
+                export_base.mkdir(parents=True, exist_ok=True)
+                excel_path = export_base / f"evalvault_run_{result.run_id}.xlsx"
                 try:
                     storage.export_run_to_excel(result.run_id, excel_path)
                     console.print(f"[green]Excel export saved: {excel_path}[/green]")
@@ -485,7 +490,7 @@ def _save_to_db(
                         "엑셀 내보내기에 실패했습니다.",
                         tips=[str(exc)],
                     )
-            console.print(f"[green]Results saved to database: {db_path}[/green]")
+            console.print(f"[green]Results saved to database: {storage_label}[/green]")
             console.print(f"[dim]Run ID: {result.run_id}[/dim]")
             if prompt_bundle:
                 console.print(
@@ -502,21 +507,24 @@ def _save_to_db(
 
 
 def _save_multiturn_to_db(
-    db_path: Path,
+    db_path: Path | None,
     run_record: MultiTurnRunRecord,
     conversations: list[MultiTurnConversationRecord],
     turn_results: list[MultiTurnTurnResult],
     console: Console,
     *,
-    storage_cls: type[SQLiteStorageAdapter] = SQLiteStorageAdapter,
     export_excel: bool = True,
     excel_output_path: Path | None = None,
     metric_thresholds: dict[str, float] | None = None,
 ) -> None:
-    """Persist multiturn evaluation run to SQLite database."""
-    with console.status(f"[bold green]Saving multiturn run to {db_path}..."):
+    """Persist multiturn evaluation run to database."""
+    storage = build_storage_adapter(settings=Settings(), db_path=db_path)
+    storage_label = (
+        "PostgreSQL" if isinstance(storage, PostgreSQLStorageAdapter) else f"SQLite ({db_path})"
+    )
+    export_base = db_path.parent if db_path else Path("data/exports")
+    with console.status(f"[bold green]Saving multiturn run to {storage_label}..."):
         try:
-            storage = storage_cls(db_path=db_path)
             storage.save_multiturn_run(
                 run_record,
                 conversations,
@@ -524,8 +532,9 @@ def _save_multiturn_to_db(
                 metric_thresholds=metric_thresholds,
             )
             if export_excel:
+                export_base.mkdir(parents=True, exist_ok=True)
                 excel_path = excel_output_path or (
-                    db_path.parent / f"evalvault_multiturn_{run_record.run_id}.xlsx"
+                    export_base / f"evalvault_multiturn_{run_record.run_id}.xlsx"
                 )
                 try:
                     storage.export_multiturn_run_to_excel(run_record.run_id, excel_path)
@@ -536,7 +545,7 @@ def _save_multiturn_to_db(
                         "멀티턴 엑셀 내보내기에 실패했습니다.",
                         tips=[str(exc)],
                     )
-            console.print(f"[green]Multiturn results saved to database: {db_path}[/green]")
+            console.print(f"[green]Multiturn results saved to database: {storage_label}[/green]")
             console.print(f"[dim]Run ID: {run_record.run_id}[/dim]")
         except Exception as exc:  # pragma: no cover - persistence errors
             print_cli_error(

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

@@ -16,7 +16,7 @@ from rich.table import Table
 from evalvault.adapters.outbound.improvement.stage_metric_playbook_loader import (
     StageMetricPlaybookLoader,
 )
-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.entities.stage import REQUIRED_STAGE_TYPES, StageEvent, StageMetric
 from evalvault.domain.services.stage_metric_guide_service import StageMetricGuideService
@@ -28,13 +28,6 @@ from ..utils.options import db_option
 logger = logging.getLogger(__name__)
 
 
-def _resolve_db_path(db_path: Path | None) -> Path:
-    resolved = db_path or Settings().evalvault_db_path
-    if resolved is None:
-        raise typer.BadParameter("Database path is not configured.")
-    return resolved
-
-
 @dataclass
 class ValidationStats:
     """Tracks StageEvent validation failures by error type."""
@@ -122,8 +115,7 @@ def create_stage_app(console: Console) -> typer.Typer:
             console.print("[yellow]No valid stage events found in the input file.[/yellow]")
             raise typer.Exit(1)
 
-        resolved_db_path = _resolve_db_path(db_path)
-        storage = SQLiteStorageAdapter(db_path=resolved_db_path)
+        storage = build_storage_adapter(settings=Settings(), db_path=db_path)
         stored = storage.save_stage_events(events)
 
         console.print(f"[green]Stored {stored} stage event(s).[/green]")
@@ -147,8 +139,7 @@ def create_stage_app(console: Console) -> typer.Typer:
         db_path: Path | None = db_option(help_text="Path to database file."),
     ) -> None:
         """List stage events for a run."""
-        resolved_db_path = _resolve_db_path(db_path)
-        storage = SQLiteStorageAdapter(db_path=resolved_db_path)
+        storage = build_storage_adapter(settings=Settings(), db_path=db_path)
         events = storage.list_stage_events(run_id, stage_type=stage_type)
 
         if not events:
@@ -184,8 +175,7 @@ def create_stage_app(console: Console) -> typer.Typer:
         db_path: Path | None = db_option(help_text="Path to database file."),
     ) -> None:
         """Show summary stats for stage events."""
-        resolved_db_path = _resolve_db_path(db_path)
-        storage = SQLiteStorageAdapter(db_path=resolved_db_path)
+        storage = build_storage_adapter(settings=Settings(), db_path=db_path)
         events = storage.list_stage_events(run_id)
         if not events:
             console.print("[yellow]No stage events found.[/yellow]")
@@ -218,8 +208,7 @@ def create_stage_app(console: Console) -> typer.Typer:
         db_path: Path | None = db_option(help_text="Path to database file."),
     ) -> None:
         """Compute stage metrics from stored events."""
-        resolved_db_path = _resolve_db_path(db_path)
-        storage = SQLiteStorageAdapter(db_path=resolved_db_path)
+        storage = build_storage_adapter(settings=Settings(), db_path=db_path)
         events = storage.list_stage_events(run_id)
         if not events:
             console.print("[yellow]No stage events found.[/yellow]")
@@ -276,8 +265,7 @@ def create_stage_app(console: Console) -> typer.Typer:
         db_path: Path | None = db_option(help_text="Path to database file."),
     ) -> None:
         """Report stage summary, metrics, and improvement guides."""
-        resolved_db_path = _resolve_db_path(db_path)
-        storage = SQLiteStorageAdapter(db_path=resolved_db_path)
+        storage = build_storage_adapter(settings=Settings(), db_path=db_path)
         events = storage.list_stage_events(run_id)
         if not events:
             console.print("[yellow]No stage events found.[/yellow]")
@@ -547,13 +535,6 @@ def _load_default_profile() -> str | None:
         return None
 
 
-def _resolve_db_path(db_path: Path | None) -> Path:
-    resolved = db_path or Settings().evalvault_db_path
-    if resolved is None:
-        raise typer.BadParameter("Database path is not configured.")
-    return resolved
-
-
 def _print_stage_summary(console: Console, summary_data) -> None:
     table = Table(show_header=True, header_style="bold cyan")
     table.add_column("Stage Type")

evalvault/adapters/inbound/cli/utils/options.py

@@ -31,11 +31,11 @@ def profile_option(
 def db_option(
     *,
     default: str | Path | None = _UNSET,
-    help_text: str = "Path to SQLite database file.",
+    help_text: str = "SQLite DB path (PostgreSQL is default when omitted).",
 ) -> Path | None:
     """Shared --db / -D option definition."""
 
-    resolved_default = Settings().evalvault_db_path if default is _UNSET else default
+    resolved_default = None if default is _UNSET else default
     normalized_default = _normalize_path(resolved_default)
     return typer.Option(
         normalized_default,
@@ -49,11 +49,17 @@ def db_option(
 def memory_db_option(
     *,
     default: str | Path | None = _UNSET,
-    help_text: str = "Path to Domain Memory SQLite database.",
+    help_text: str = "Domain Memory SQLite path (Postgres is default when omitted).",
 ) -> Path | None:
     """Shared option factory for the domain memory database path."""
 
-    resolved_default = Settings().evalvault_memory_db_path if default is _UNSET else default
+    if default is _UNSET:
+        settings = Settings()
+        resolved_default = (
+            settings.evalvault_memory_db_path if settings.db_backend == "sqlite" else None
+        )
+    else:
+        resolved_default = default
     normalized_default = _normalize_path(resolved_default)
     return typer.Option(
         normalized_default,

evalvault/adapters/inbound/mcp/tools.py

@@ -20,12 +20,13 @@ from evalvault.adapters.outbound.analysis.pipeline_factory import build_analysis
 from evalvault.adapters.outbound.analysis.statistical_adapter import StatisticalAnalysisAdapter
 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.analysis_pipeline import AnalysisIntent
 from evalvault.domain.services.analysis_service import AnalysisService
 from evalvault.domain.services.evaluator import RagasEvaluator
 from evalvault.ports.inbound.web_port import EvalRequest, RunFilters, RunSummary
+from evalvault.ports.outbound.storage_port import StoragePort
 
 from .schemas import (
     AnalyzeCompareRequest,
@@ -82,7 +83,7 @@ def list_runs(payload: dict[str, Any] | ListRunsRequest) -> ListRunsResponse:
             errors=[_error("EVAL_DB_UNSAFE_PATH", str(exc), stage=ErrorStage.storage)]
         )
 
-    storage = SQLiteStorageAdapter(db_path=db_path)
+    storage = build_storage_adapter(settings=Settings(), db_path=db_path)
     adapter = WebUIAdapter(storage=storage, settings=Settings())
 
     filters = RunFilters(
@@ -123,7 +124,7 @@ def get_run_summary(payload: dict[str, Any] | GetRunSummaryRequest) -> GetRunSum
             errors=[_error("EVAL_DB_UNSAFE_PATH", str(exc), stage=ErrorStage.storage)]
         )
 
-    storage = SQLiteStorageAdapter(db_path=db_path)
+    storage = build_storage_adapter(settings=Settings(), db_path=db_path)
     try:
         run = storage.get_run(request.run_id)
     except KeyError as exc:
@@ -175,7 +176,7 @@ def run_evaluation(payload: dict[str, Any] | RunEvaluationRequest) -> RunEvaluat
             errors=[_error("EVAL_LLM_INIT_FAILED", str(exc), stage=ErrorStage.evaluate)],
         )
 
-    storage = SQLiteStorageAdapter(db_path=db_path)
+    storage = build_storage_adapter(settings=Settings(), db_path=db_path)
     llm_factory = SettingsLLMFactory(settings)
     korean_toolkit = try_create_korean_toolkit()
     evaluator = RagasEvaluator(korean_toolkit=korean_toolkit, llm_factory=llm_factory)
@@ -266,7 +267,7 @@ def analyze_compare(payload: dict[str, Any] | AnalyzeCompareRequest) -> AnalyzeC
             errors=[_error("EVAL_DB_UNSAFE_PATH", str(exc), stage=ErrorStage.storage)],
         )
 
-    storage = SQLiteStorageAdapter(db_path=db_path)
+    storage = build_storage_adapter(settings=Settings(), db_path=db_path)
     try:
         run_a = storage.get_run(request.run_id_a)
         run_b = storage.get_run(request.run_id_b)
@@ -503,9 +504,11 @@ def _serialize_run_summary(summary: RunSummary) -> RunSummaryPayload:
     return RunSummaryPayload.model_validate(payload)
 
 
-def _resolve_db_path(db_path: Path | None) -> Path:
+def _resolve_db_path(db_path: Path | None) -> Path | None:
+    settings = Settings()
     if db_path is None:
-        settings = Settings()
+        if getattr(settings, "db_backend", "postgres") != "sqlite":
+            return None
         db_path = Path(settings.evalvault_db_path)
     resolved = db_path.expanduser().resolve()
     _ensure_allowed_path(resolved)
@@ -547,7 +550,7 @@ def _run_auto_analysis(
     *,
     run_id: str,
     run: Any,
-    storage: SQLiteStorageAdapter,
+    storage: StoragePort,
     llm_adapter: Any,
     analysis_output: Path | None,
     analysis_report: Path | None,

evalvault/adapters/outbound/analysis/embedding_analyzer_module.py

@@ -152,6 +152,20 @@ class EmbeddingAnalyzerModule(BaseAnalysisModule):
                 errors.append(str(exc))
                 retriever = None
 
+        if retriever is None and (backend_hint == "vllm" or embedding_profile == "vllm"):
+            try:
+                from evalvault.adapters.outbound.llm.vllm_adapter import VLLMAdapter
+
+                adapter = VLLMAdapter(settings)
+                retriever = KoreanDenseRetriever(
+                    model_name=model_name or settings.vllm_embedding_model,
+                    ollama_adapter=adapter,
+                    profile=embedding_profile,
+                )
+            except Exception as exc:
+                errors.append(str(exc))
+                retriever = None
+
         if retriever is None and backend_hint != "ollama":
             try:
                 retriever = KoreanDenseRetriever(model_name=model_name)
@@ -166,7 +180,9 @@ class EmbeddingAnalyzerModule(BaseAnalysisModule):
                     batch_size=batch_size if isinstance(batch_size, int) else None,
                 )
                 meta = {
-                    "backend": "ollama"
+                    "backend": "vllm"
+                    if backend_hint == "vllm" or embedding_profile == "vllm"
+                    else "ollama"
                     if retriever.model_name.startswith("qwen3")
                     else "sentence-transformers",
                     "model": retriever.model_name,

evalvault/adapters/outbound/analysis/embedding_searcher_module.py

@@ -77,6 +77,20 @@ class EmbeddingSearcherModule(BaseAnalysisModule):
                 errors.append(str(exc))
                 retriever = None
 
+        if retriever is None and embedding_profile == "vllm":
+            try:
+                from evalvault.adapters.outbound.llm.vllm_adapter import VLLMAdapter
+
+                adapter = VLLMAdapter(settings)
+                retriever = KoreanDenseRetriever(
+                    model_name=settings.vllm_embedding_model,
+                    ollama_adapter=adapter,
+                    profile=embedding_profile,
+                )
+            except Exception as exc:
+                errors.append(str(exc))
+                retriever = None
+
         if retriever is None:
             try:
                 retriever = KoreanDenseRetriever(model_name=model_name)

evalvault/adapters/outbound/domain_memory/__init__.py

@@ -1,7 +1,11 @@
 """Domain Memory adapters for factual, experiential, and working memory layers."""
 
-from evalvault.adapters.outbound.domain_memory.sqlite_adapter import (
-    SQLiteDomainMemoryAdapter,
-)
+from evalvault.adapters.outbound.domain_memory.factory import build_domain_memory_adapter
+from evalvault.adapters.outbound.domain_memory.postgres_adapter import PostgresDomainMemoryAdapter
+from evalvault.adapters.outbound.domain_memory.sqlite_adapter import SQLiteDomainMemoryAdapter
 
-__all__ = ["SQLiteDomainMemoryAdapter"]
+__all__ = [
+    "SQLiteDomainMemoryAdapter",
+    "PostgresDomainMemoryAdapter",
+    "build_domain_memory_adapter",
+]