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

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

evalvault/adapters/outbound/domain_memory/factory.py

@@ -0,0 +1,68 @@
+from __future__ import annotations
+
+import logging
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from evalvault.adapters.outbound.domain_memory.postgres_adapter import PostgresDomainMemoryAdapter
+from evalvault.adapters.outbound.domain_memory.sqlite_adapter import SQLiteDomainMemoryAdapter
+
+if TYPE_CHECKING:
+    from evalvault.config.settings import Settings
+    from evalvault.ports.outbound.domain_memory_port import DomainMemoryPort
+
+logger = logging.getLogger(__name__)
+
+
+def build_domain_memory_adapter(
+    *,
+    settings: Settings | None = None,
+    db_path: Path | None = None,
+    fallback_to_sqlite: bool = True,
+) -> DomainMemoryPort:
+    """Build domain memory adapter based on settings and parameters.
+
+    Args:
+        settings: Application settings (uses default if None)
+        db_path: Explicit SQLite database path (forces SQLite if provided)
+        fallback_to_sqlite: Fall back to SQLite if Postgres fails
+
+    Returns:
+        DomainMemoryPort implementation (Postgres by default, SQLite if specified)
+    """
+    from evalvault.config.settings import Settings
+
+    resolved_settings = settings or Settings()
+
+    if db_path is not None:
+        return SQLiteDomainMemoryAdapter(db_path=db_path)
+
+    backend = getattr(resolved_settings, "db_backend", "postgres")
+    if backend == "sqlite":
+        resolved_db_path = resolved_settings.evalvault_memory_db_path
+        if resolved_db_path is None:
+            raise RuntimeError("SQLite backend selected but evalvault_memory_db_path is not set.")
+        return SQLiteDomainMemoryAdapter(db_path=resolved_db_path)
+
+    conn_string = resolved_settings.postgres_connection_string
+    if not conn_string:
+        host = resolved_settings.postgres_host or "localhost"
+        port = resolved_settings.postgres_port
+        database = resolved_settings.postgres_database
+        user = resolved_settings.postgres_user or "postgres"
+        password = resolved_settings.postgres_password or ""
+        conn_string = f"host={host} port={port} dbname={database} user={user} password={password}"
+
+    try:
+        return PostgresDomainMemoryAdapter(connection_string=conn_string)
+    except Exception as exc:
+        if not fallback_to_sqlite:
+            raise
+        logger.warning("PostgreSQL domain memory adapter failed (%s). Falling back to SQLite.", exc)
+        resolved_db_path = resolved_settings.evalvault_memory_db_path
+        if resolved_db_path is None:
+            raise
+        return SQLiteDomainMemoryAdapter(db_path=resolved_db_path)
+
+
+__all__ = ["build_domain_memory_adapter"]