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

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

@@ -6,7 +6,7 @@ import json
 from collections.abc import Callable, Sequence
 from dataclasses import asdict, dataclass
 from pathlib import Path
-from typing import Any, Literal
+from typing import Any
 
 import click
 import typer
@@ -18,13 +18,14 @@ 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,
     set_span_attributes,
 )
-from evalvault.config.settings import Settings
+from evalvault.config.settings import Settings, resolve_tracker_providers
 from evalvault.domain.entities import (
     Dataset,
     EvaluationRun,
@@ -57,7 +58,7 @@ from evalvault.ports.outbound.tracker_port import TrackerPort
 from ..utils.console import print_cli_error, print_cli_warning
 from ..utils.formatters import format_score, format_status
 
-TrackerType = Literal["langfuse", "mlflow", "phoenix", "none"]
+TrackerType = str
 apply_retriever_to_dataset = retriever_context.apply_retriever_to_dataset
 
 
@@ -318,15 +319,22 @@ def _display_memory_insights(insights: dict[str, Any], console: Console) -> None
     console.print(Panel(panel_body, title="Domain Memory Insights", border_style="magenta"))
 
 
-def _get_tracker(settings: Settings, tracker_type: str, console: Console) -> TrackerPort | None:
+def _get_tracker(
+    settings: Settings,
+    tracker_type: str,
+    console: Console,
+    *,
+    required: bool = False,
+) -> TrackerPort | None:
     """Get the appropriate tracker adapter based on type."""
     if tracker_type == "langfuse":
         if not settings.langfuse_public_key or not settings.langfuse_secret_key:
-            print_cli_warning(
-                console,
-                "Langfuse 자격 증명이 설정되지 않아 로깅을 건너뜁니다.",
-                tips=["LANGFUSE_PUBLIC_KEY / LANGFUSE_SECRET_KEY를 .env에 추가하세요."],
-            )
+            message = "Langfuse 자격 증명이 설정되지 않았습니다."
+            tips = ["LANGFUSE_PUBLIC_KEY / LANGFUSE_SECRET_KEY를 .env에 추가하세요."]
+            if required:
+                print_cli_error(console, message, fixes=tips)
+                raise typer.Exit(2)
+            print_cli_warning(console, message + " 로깅을 건너뜁니다.", tips=tips)
             return None
         from evalvault.adapters.outbound.tracker.langfuse_adapter import LangfuseAdapter
 
@@ -338,11 +346,12 @@ def _get_tracker(settings: Settings, tracker_type: str, console: Console) -> Tra
 
     elif tracker_type == "mlflow":
         if not settings.mlflow_tracking_uri:
-            print_cli_warning(
-                console,
-                "MLflow tracking URI가 설정되지 않아 로깅을 건너뜁니다.",
-                tips=["MLFLOW_TRACKING_URI 환경 변수를 설정하세요."],
-            )
+            message = "MLflow tracking URI가 설정되지 않았습니다."
+            tips = ["MLFLOW_TRACKING_URI 환경 변수를 설정하세요."]
+            if required:
+                print_cli_error(console, message, fixes=tips)
+                raise typer.Exit(2)
+            print_cli_warning(console, message + " 로깅을 건너뜁니다.", tips=tips)
             return None
         try:
             from evalvault.adapters.outbound.tracker.mlflow_adapter import MLflowAdapter
@@ -352,11 +361,12 @@ def _get_tracker(settings: Settings, tracker_type: str, console: Console) -> Tra
                 experiment_name=settings.mlflow_experiment_name,
             )
         except ImportError:
-            print_cli_warning(
-                console,
-                "MLflow extra가 설치되지 않았습니다.",
-                tips=["uv sync --extra mlflow 명령으로 구성요소를 설치하세요."],
-            )
+            message = "MLflow extra가 설치되지 않았습니다."
+            tips = ["uv sync --extra mlflow 명령으로 구성요소를 설치하세요."]
+            if required:
+                print_cli_error(console, message, fixes=tips)
+                raise typer.Exit(2)
+            print_cli_warning(console, message, tips=tips)
             return None
 
     elif tracker_type == "phoenix":
@@ -366,13 +376,16 @@ def _get_tracker(settings: Settings, tracker_type: str, console: Console) -> Tra
             return PhoenixAdapter(
                 endpoint=settings.phoenix_endpoint,
                 service_name="evalvault",
+                project_name=getattr(settings, "phoenix_project_name", None),
+                annotations_enabled=getattr(settings, "phoenix_annotations_enabled", True),
             )
         except ImportError:
-            print_cli_warning(
-                console,
-                "Phoenix extra가 설치되지 않았습니다.",
-                tips=["uv sync --extra phoenix 명령으로 의존성을 추가하세요."],
-            )
+            message = "Phoenix extra가 설치되지 않았습니다."
+            tips = ["uv sync --extra phoenix 명령으로 의존성을 추가하세요."]
+            if required:
+                print_cli_error(console, message, fixes=tips)
+                raise typer.Exit(2)
+            print_cli_warning(console, message, tips=tips)
             return None
 
     else:
@@ -384,6 +397,22 @@ def _get_tracker(settings: Settings, tracker_type: str, console: Console) -> Tra
         return None
 
 
+def _resolve_tracker_list(tracker_type: str) -> list[str]:
+    providers = resolve_tracker_providers(tracker_type)
+    if not providers:
+        return []
+    if providers == ["none"]:
+        return ["none"]
+    supported = {"langfuse", "mlflow", "phoenix"}
+    unknown = [entry for entry in providers if entry not in supported]
+    if unknown:
+        raise ValueError(f"Unknown tracker provider(s): {', '.join(unknown)}")
+    required = {"mlflow", "phoenix"}
+    if not required.issubset(set(providers)):
+        raise ValueError("tracker must include both 'mlflow' and 'phoenix'")
+    return providers
+
+
 def _build_phoenix_trace_url(endpoint: str, trace_id: str) -> str:
     """Build a Phoenix UI URL for the given trace ID."""
 
@@ -394,7 +423,7 @@ def _build_phoenix_trace_url(endpoint: str, trace_id: str) -> str:
     return f"{base.rstrip('/')}/#/traces/{trace_id}"
 
 
-def _log_to_tracker(
+def _log_to_trackers(
     settings: Settings,
     result,
     console: Console,
@@ -403,18 +432,39 @@ def _log_to_tracker(
     phoenix_options: dict[str, Any] | None = None,
     log_phoenix_traces_fn: Callable[..., int] | None = None,
 ) -> None:
-    """Log evaluation results to the specified tracker."""
-    tracker = _get_tracker(settings, tracker_type, console)
-    if tracker is None:
+    """Log evaluation results to the specified tracker(s)."""
+    try:
+        tracker_types = _resolve_tracker_list(tracker_type)
+    except ValueError as exc:
+        print_cli_error(console, "Tracker 설정이 올바르지 않습니다.", details=str(exc))
+        raise typer.Exit(2) from exc
+    if not tracker_types or tracker_types == ["none"]:
         return
 
-    tracker_name = tracker_type.capitalize()
-    trace_id: str | None = None
-    with console.status(f"[bold green]Logging to {tracker_name}..."):
-        try:
-            trace_id = tracker.log_evaluation_run(result)
-            console.print(f"[green]Logged to {tracker_name}[/green] (trace_id: {trace_id})")
-            if trace_id and tracker_type == "phoenix":
+    result.tracker_metadata.setdefault("tracker_providers", tracker_types)
+    for provider in tracker_types:
+        tracker = _get_tracker(settings, provider, console, required=True)
+        if tracker is None:
+            raise typer.Exit(2)
+        tracker_name = provider.capitalize()
+        trace_id: str | None = None
+        with console.status(f"[bold green]Logging to {tracker_name}..."):
+            try:
+                trace_id = tracker.log_evaluation_run(result)
+                console.print(f"[green]Logged to {tracker_name}[/green] (trace_id: {trace_id})")
+            except Exception as exc:
+                print_cli_error(
+                    console,
+                    f"{tracker_name} 로깅에 실패했습니다.",
+                    details=str(exc),
+                )
+                raise typer.Exit(2) from exc
+
+        if trace_id:
+            provider_meta = result.tracker_metadata.setdefault(provider, {})
+            if isinstance(provider_meta, dict):
+                provider_meta.setdefault("trace_id", trace_id)
+            if provider == "phoenix":
                 endpoint = getattr(settings, "phoenix_endpoint", "http://localhost:6006/v1/traces")
                 if not isinstance(endpoint, str) or not endpoint:
                     endpoint = "http://localhost:6006/v1/traces"
@@ -430,42 +480,96 @@ def _log_to_tracker(
                 trace_url = get_phoenix_trace_url(result.tracker_metadata)
                 if trace_url:
                     console.print(f"[dim]Phoenix Trace: {trace_url}[/dim]")
-        except Exception as exc:  # pragma: no cover - telemetry best-effort
-            print_cli_warning(
-                console,
-                f"{tracker_name} 로깅에 실패했습니다.",
-                tips=[str(exc)],
+
+                options = phoenix_options or {}
+                log_traces = log_phoenix_traces_fn or log_phoenix_traces
+                extra = log_traces(
+                    tracker,
+                    result,
+                    max_traces=options.get("max_traces"),
+                    metadata=options.get("metadata"),
+                )
+                if extra:
+                    console.print(
+                        f"[dim]Recorded {extra} Phoenix RAG trace(s) for detailed observability.[/dim]"
+                    )
+
+
+def _log_analysis_artifacts(
+    settings: Settings,
+    result: EvaluationRun,
+    console: Console,
+    tracker_type: str,
+    *,
+    analysis_payload: dict[str, Any],
+    artifact_index: dict[str, Any],
+    report_text: str,
+    output_path: Path,
+    report_path: Path,
+) -> None:
+    """Log analysis artifacts to tracker(s) as a separate trace/run."""
+    try:
+        tracker_types = _resolve_tracker_list(tracker_type)
+    except ValueError as exc:
+        print_cli_error(console, "Tracker 설정이 올바르지 않습니다.", details=str(exc))
+        raise typer.Exit(2) from exc
+    if not tracker_types or tracker_types == ["none"]:
+        return
+
+    metadata = {
+        "run_id": result.run_id,
+        "dataset_name": result.dataset_name,
+        "dataset_version": result.dataset_version,
+        "analysis_output": str(output_path),
+        "analysis_report": str(report_path),
+        "analysis_artifacts_dir": artifact_index.get("dir"),
+        "event_type": "analysis",
+    }
+
+    for provider in tracker_types:
+        tracker = _get_tracker(settings, provider, console, required=True)
+        if tracker is None:
+            raise typer.Exit(2)
+        trace_name = f"analysis-{result.run_id[:8]}"
+        try:
+            trace_id = tracker.start_trace(trace_name, metadata=metadata)
+            tracker.save_artifact(
+                trace_id, "analysis_payload", analysis_payload, artifact_type="json"
             )
-            return
-
-    if tracker_type == "phoenix":
-        options = phoenix_options or {}
-        log_traces = log_phoenix_traces_fn or log_phoenix_traces
-        extra = log_traces(
-            tracker,
-            result,
-            max_traces=options.get("max_traces"),
-            metadata=options.get("metadata"),
-        )
-        if extra:
+            tracker.save_artifact(
+                trace_id, "analysis_artifacts", artifact_index, artifact_type="json"
+            )
+            tracker.save_artifact(trace_id, "analysis_report", report_text, artifact_type="text")
+            tracker.end_trace(trace_id)
             console.print(
-                f"[dim]Recorded {extra} Phoenix RAG trace(s) for detailed observability.[/dim]"
+                f"[green]Logged analysis artifacts to {provider.capitalize()}[/green] "
+                f"(trace_id: {trace_id})"
             )
+        except Exception as exc:
+            print_cli_error(
+                console,
+                f"{provider.capitalize()} 분석 로깅에 실패했습니다.",
+                details=str(exc),
+            )
+            raise typer.Exit(2) from exc
 
 
 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 +579,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 +590,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 +607,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 +632,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 +645,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(
@@ -1164,8 +1273,10 @@ def _collect_prompt_metadata(
             prompt_path=target,
             content=content,
         )
-        summary.content_preview = _build_content_preview(content)
-        summaries.append(asdict(summary))
+        summary_dict = asdict(summary)
+        summary_dict["content_preview"] = _build_content_preview(content)
+        summary_dict["content"] = content
+        summaries.append(summary_dict)
 
     return summaries
 

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",
+]