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

evalvault/adapters/inbound/api/adapter.py

@@ -127,14 +127,15 @@ class WebUIAdapter:
             llm_adapter: LLM 어댑터 (선택적)
             data_loader: 데이터 로더 (선택적)
         """
-        resolved_settings = settings
+        resolved_settings = settings or Settings()
         if storage is None:
-            resolved_settings = settings or Settings()
-            db_path = getattr(resolved_settings, "evalvault_db_path", None)
-            if db_path:
-                from evalvault.adapters.outbound.storage.sqlite_adapter import SQLiteStorageAdapter
+            from evalvault.adapters.outbound.storage.factory import build_storage_adapter
 
-                storage = SQLiteStorageAdapter(db_path=db_path)
+            try:
+                storage = build_storage_adapter(settings=resolved_settings)
+            except Exception as exc:
+                logger.warning("Storage initialization failed: %s", exc)
+                storage = None
 
         self._storage = storage
         self._evaluator = evaluator
@@ -450,7 +451,12 @@ class WebUIAdapter:
         memory_domain = memory_config.get("domain") or dataset.metadata.get("domain") or "default"
         memory_language = memory_config.get("language") or "ko"
         memory_augment = bool(memory_config.get("augment_context"))
-        memory_db_path = memory_config.get("db_path") or settings.evalvault_memory_db_path
+        if memory_config.get("db_path"):
+            memory_db_path = memory_config.get("db_path")
+        elif settings.db_backend == "sqlite":
+            memory_db_path = settings.evalvault_memory_db_path
+        else:
+            memory_db_path = None
         memory_evaluator = None
         requested_thresholds = request.thresholds or {}
         if request.threshold_profile or requested_thresholds:
@@ -472,16 +478,17 @@ class WebUIAdapter:
         memory_active = False
         if memory_enabled:
             try:
-                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.tracer.phoenix_tracer_adapter import (
                     PhoenixTracerAdapter,
                 )
                 from evalvault.domain.services.memory_aware_evaluator import MemoryAwareEvaluator
 
                 tracer = PhoenixTracerAdapter() if tracker_provider == "phoenix" else None
-                memory_adapter = SQLiteDomainMemoryAdapter(memory_db_path)
+                memory_adapter = build_domain_memory_adapter(
+                    settings=self._settings,
+                    db_path=Path(memory_db_path) if memory_db_path else None,
+                )
                 memory_evaluator = MemoryAwareEvaluator(
                     evaluator=self._evaluator,
                     memory_port=memory_adapter,
@@ -814,6 +821,7 @@ class WebUIAdapter:
     def list_runs(
         self,
         limit: int = 50,
+        offset: int = 0,
         filters: RunFilters | None = None,
     ) -> list[RunSummary]:
         """평가 목록 조회.
@@ -833,7 +841,7 @@ class WebUIAdapter:
 
         try:
             # 저장소에서 평가 목록 조회
-            runs = self._storage.list_runs(limit=limit)
+            runs = self._storage.list_runs(limit=limit, offset=offset)
 
             # RunSummary로 변환
             summaries = []
@@ -1029,7 +1037,11 @@ class WebUIAdapter:
         run = self.get_run_details(run_id)
         feedbacks = storage.list_feedback(run_id)
         if labels_source in {"feedback", "hybrid"} and not feedbacks:
-            raise ValueError("Feedback labels are required for this labels_source")
+            raise ValueError(
+                f"No feedback labels found for run '{run_id}'. "
+                f"Calibration with labels_source='{labels_source}' requires at least one feedback label. "
+                "Please add feedback labels via the UI or API, or use labels_source='gold' if gold labels are available."
+            )
         resolved_metrics = metrics or list(run.metrics_evaluated)
         if not resolved_metrics:
             raise ValueError("No metrics available for calibration")
@@ -2198,16 +2210,15 @@ def create_adapter() -> WebUIAdapter:
     """
     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 get_settings
     from evalvault.domain.services.evaluator import RagasEvaluator
 
     # 설정 로드
     settings = get_settings()
 
-    # Storage 생성 (기본 SQLite)
-    db_path = Path(settings.evalvault_db_path)
-    storage = SQLiteStorageAdapter(db_path=db_path)
+    # Storage 생성
+    storage = build_storage_adapter(settings=settings)
 
     # LLM adapter 생성 (API 키 없으면 None)
     llm_adapter = None

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

@@ -113,6 +113,15 @@ def run_judge_calibration(
     return JudgeCalibrationResponse.model_validate(payload)
 
 
+@router.get("/judge/history", response_model=list[JudgeCalibrationHistoryItem])
+def list_calibrations(
+    adapter: AdapterDep,
+    limit: int = Query(20, ge=1, le=200),
+) -> list[JudgeCalibrationHistoryItem]:
+    entries = adapter.list_judge_calibrations(limit=limit)
+    return [JudgeCalibrationHistoryItem.model_validate(entry) for entry in entries]
+
+
 @router.get("/judge/{calibration_id}", response_model=JudgeCalibrationResponse)
 def get_calibration_result(calibration_id: str, adapter: AdapterDep) -> JudgeCalibrationResponse:
     try:
@@ -122,12 +131,3 @@ def get_calibration_result(calibration_id: str, adapter: AdapterDep) -> JudgeCal
     except RuntimeError as exc:
         raise HTTPException(status_code=500, detail=str(exc)) from exc
     return JudgeCalibrationResponse.model_validate(payload)
-
-
-@router.get("/judge/history", response_model=list[JudgeCalibrationHistoryItem])
-def list_calibrations(
-    adapter: AdapterDep,
-    limit: int = Query(20, ge=1, le=200),
-) -> list[JudgeCalibrationHistoryItem]:
-    entries = adapter.list_judge_calibrations(limit=limit)
-    return [JudgeCalibrationHistoryItem.model_validate(entry) for entry in entries]

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

@@ -8,6 +8,7 @@ import os
 import re
 import time
 from collections.abc import AsyncGenerator
+from dataclasses import dataclass
 from datetime import UTC, datetime
 from pathlib import Path
 from typing import Any
@@ -34,6 +35,13 @@ _RAG_TEXTS: list[str] = []
 _RAG_INITIALIZED = False
 
 
+@dataclass(frozen=True)
+class _RagHit:
+    document: str
+    score: float
+    doc_id: int
+
+
 class ChatMessage(BaseModel):
     role: str
     content: str
@@ -315,14 +323,121 @@ async def _get_rag_retriever() -> tuple[Any | None, int]:
     if not _RAG_TEXTS:
         return None, 0
 
-    from evalvault.adapters.outbound.nlp.korean.bm25_retriever import KoreanBM25Retriever
-    from evalvault.adapters.outbound.nlp.korean.kiwi_tokenizer import KiwiTokenizer
+    from evalvault.adapters.outbound.nlp.korean.toolkit import KoreanNLPToolkit
+
+    use_hybrid = os.getenv("EVALVAULT_RAG_USE_HYBRID", "true").lower() == "true"
+    embedding_profile = os.getenv("EVALVAULT_RAG_EMBEDDING_PROFILE", "dev")
+    vector_store = os.getenv("EVALVAULT_RAG_VECTOR_STORE", "pgvector").lower()
+    pgvector_index = os.getenv("EVALVAULT_RAG_PGVECTOR_INDEX", "hnsw").lower()
+    pgvector_index_lists = int(os.getenv("EVALVAULT_RAG_PGVECTOR_INDEX_LISTS", "100"))
+    pgvector_hnsw_m = int(os.getenv("EVALVAULT_RAG_PGVECTOR_HNSW_M", "16"))
+    pgvector_hnsw_ef = int(os.getenv("EVALVAULT_RAG_PGVECTOR_HNSW_EF_CONSTRUCTION", "64"))
 
-    tokenizer = KiwiTokenizer()
-    retriever = KoreanBM25Retriever(tokenizer=tokenizer)
-    retriever.index(list(_RAG_TEXTS))
-    if tokens and len(tokens) == len(_RAG_TEXTS):
-        retriever._tokenized_docs = tokens
+    def _build_conn_string() -> str | None:
+        try:
+            from evalvault.config.settings import Settings
+
+            settings = Settings()
+            if settings.postgres_connection_string:
+                return settings.postgres_connection_string
+            if settings.postgres_host:
+                return "host={host} port={port} dbname={dbname} user={user} password={password}".format(
+                    host=settings.postgres_host,
+                    port=settings.postgres_port,
+                    dbname=settings.postgres_database,
+                    user=settings.postgres_user or "postgres",
+                    password=settings.postgres_password or "",
+                )
+        except Exception as exc:
+            logger.warning("Failed to build Postgres connection string: %s", exc)
+        return None
+
+    ollama_adapter = None
+    dense_retriever = None
+    embedding_func = None
+    if embedding_profile:
+        try:
+            from evalvault.adapters.outbound.llm.ollama_adapter import OllamaAdapter
+            from evalvault.adapters.outbound.nlp.korean.dense_retriever import KoreanDenseRetriever
+            from evalvault.config.settings import Settings
+
+            settings = Settings()
+            ollama_adapter = OllamaAdapter(settings)
+            dense_retriever = KoreanDenseRetriever(
+                profile=embedding_profile,
+                ollama_adapter=ollama_adapter,
+            )
+            embedding_func = dense_retriever.get_embedding_func()
+        except Exception as exc:  # pragma: no cover - runtime dependency
+            logger.warning("Failed to initialize dense retriever: %s", exc)
+
+    if vector_store == "pgvector" and embedding_func is not None:
+        conn_string = _build_conn_string()
+        if conn_string:
+            try:
+                from evalvault.adapters.outbound.nlp.korean.bm25_retriever import (
+                    KoreanBM25Retriever,
+                )
+                from evalvault.adapters.outbound.nlp.korean.kiwi_tokenizer import KiwiTokenizer
+                from evalvault.adapters.outbound.retriever.pgvector_store import PgvectorStore
+
+                store = PgvectorStore(
+                    conn_string,
+                    index_type=pgvector_index,
+                    index_lists=pgvector_index_lists,
+                    hnsw_m=pgvector_hnsw_m,
+                    hnsw_ef_construction=pgvector_hnsw_ef,
+                )
+                embedding_dim = (
+                    dense_retriever.dimension if dense_retriever else len(embedding_func(["x"])[0])
+                )
+                store.ensure_schema(dimension=embedding_dim)
+                source_hash = _hash_text(content)
+                existing_hash, existing_count = store.get_source_state(source="user_guide")
+                if existing_hash != source_hash or existing_count != len(_RAG_TEXTS):
+                    embeddings = embedding_func(list(_RAG_TEXTS))
+                    store.replace_documents(
+                        source="user_guide",
+                        source_hash=source_hash,
+                        documents=list(_RAG_TEXTS),
+                        embeddings=embeddings,
+                    )
+
+                tokenizer = KiwiTokenizer()
+                bm25_retriever = KoreanBM25Retriever(tokenizer=tokenizer)
+                bm25_retriever.index(list(_RAG_TEXTS))
+                if tokens and len(tokens) == len(_RAG_TEXTS):
+                    bm25_retriever._tokenized_docs = tokens
+
+                if use_hybrid:
+                    retriever = _PgvectorHybridRetriever(
+                        bm25_retriever=bm25_retriever,
+                        store=store,
+                        embedding_func=embedding_func,
+                        documents=list(_RAG_TEXTS),
+                    )
+                else:
+                    retriever = _PgvectorDenseRetriever(
+                        store=store,
+                        embedding_func=embedding_func,
+                        documents=list(_RAG_TEXTS),
+                    )
+
+                _RAG_RETRIEVER = retriever
+                return retriever, _RAG_DOCS_COUNT
+            except Exception as exc:
+                logger.warning("pgvector retriever setup failed: %s", exc)
+
+    toolkit = KoreanNLPToolkit()
+    retriever = toolkit.build_retriever(
+        list(_RAG_TEXTS),
+        use_hybrid=use_hybrid,
+        ollama_adapter=ollama_adapter,
+        embedding_profile=embedding_profile,
+        verbose=True,
+    )
+    if retriever is None:
+        return None, 0
 
     _RAG_RETRIEVER = retriever
     return retriever, _RAG_DOCS_COUNT
@@ -384,11 +499,153 @@ def _simple_retrieve(texts: list[str], query: str, top_k: int) -> list[str]:
     return [text for _, text in scored[:top_k]]
 
 
+def _rrf_fuse(
+    *,
+    bm25_results: list[Any],
+    dense_results: list[Any],
+    documents: list[str],
+    top_k: int,
+    bm25_weight: float = 0.4,
+    dense_weight: float = 0.6,
+    rrf_k: int = 60,
+) -> list[_RagHit]:
+    scores: dict[int, float] = {}
+
+    for rank, result in enumerate(bm25_results, 1):
+        doc_id = int(result.doc_id)
+        scores[doc_id] = scores.get(doc_id, 0.0) + (bm25_weight / (rrf_k + rank))
+
+    for rank, result in enumerate(dense_results, 1):
+        doc_id = int(result.doc_id)
+        scores[doc_id] = scores.get(doc_id, 0.0) + (dense_weight / (rrf_k + rank))
+
+    ranked = sorted(scores.items(), key=lambda item: item[1], reverse=True)
+    hits: list[_RagHit] = []
+    for doc_id, score in ranked[:top_k]:
+        if 0 <= doc_id < len(documents):
+            hits.append(_RagHit(document=documents[doc_id], score=score, doc_id=doc_id))
+    return hits
+
+
+class _PgvectorDenseRetriever:
+    def __init__(self, store: Any, embedding_func: Any, documents: list[str]) -> None:
+        self._store = store
+        self._embedding_func = embedding_func
+        self._documents = documents
+
+    def search(self, query: str, top_k: int = 5) -> list[_RagHit]:
+        query_embedding = self._embedding_func([query])[0]
+        results = self._store.search(
+            source="user_guide", query_embedding=query_embedding, top_k=top_k
+        )
+        hits: list[_RagHit] = []
+        for result in results:
+            if 0 <= result.doc_id < len(self._documents):
+                hits.append(
+                    _RagHit(
+                        document=self._documents[result.doc_id],
+                        score=float(result.score),
+                        doc_id=result.doc_id,
+                    )
+                )
+        return hits
+
+
+class _PgvectorHybridRetriever:
+    def __init__(
+        self,
+        *,
+        bm25_retriever: Any,
+        store: Any,
+        embedding_func: Any,
+        documents: list[str],
+    ) -> None:
+        self._bm25 = bm25_retriever
+        self._store = store
+        self._embedding_func = embedding_func
+        self._documents = documents
+
+    def search(self, query: str, top_k: int = 5) -> list[_RagHit]:
+        bm25_results = self._bm25.search(query, top_k=len(self._documents))
+        query_embedding = self._embedding_func([query])[0]
+        dense_results = self._store.search(
+            source="user_guide", query_embedding=query_embedding, top_k=len(self._documents)
+        )
+        dense_results = sorted(dense_results, key=lambda item: item.score)
+        return _rrf_fuse(
+            bm25_results=bm25_results,
+            dense_results=dense_results,
+            documents=self._documents,
+            top_k=top_k,
+        )
+
+
+def _read_text_limited(path: Path, limit: int = 4000) -> str | None:
+    try:
+        if not path.exists():
+            return None
+        content = path.read_text(encoding="utf-8", errors="ignore")
+    except Exception as exc:
+        logger.warning("Failed to read %s: %s", path, exc)
+        return None
+    content = content.strip()
+    if not content:
+        return None
+    if len(content) > limit:
+        return content[:limit] + "..."
+    return content
+
+
+async def _build_run_context(run_id: str) -> list[str]:
+    contexts: list[str] = []
+    try:
+        summary_result = await _call_mcp_tool("get_run_summary", {"run_id": run_id})
+        payload = _extract_json_content(summary_result)
+        if isinstance(payload, dict):
+            contexts.append("[RUN 요약]\n" + _summarize_run_summary(payload))
+    except Exception as exc:
+        logger.warning("Failed to fetch run summary: %s", exc)
+
+    try:
+        artifacts_result = await _call_mcp_tool(
+            "get_artifacts", {"run_id": run_id, "kind": "analysis"}
+        )
+        payload = _extract_json_content(artifacts_result)
+        if isinstance(payload, dict):
+            contexts.append("[RUN 아티팩트]\n" + _summarize_artifacts(payload))
+            artifacts = payload.get("artifacts") or {}
+            report_path = artifacts.get("report_path")
+            if isinstance(report_path, str) and report_path:
+                report_text = _read_text_limited(Path(report_path))
+                if report_text:
+                    contexts.append("[REPORT 발췌]\n" + report_text)
+    except Exception as exc:
+        logger.warning("Failed to fetch run artifacts: %s", exc)
+
+    return contexts
+
+
 async def _rag_answer(
     user_text: str, run_id: str | None = None, category: str | None = None
 ) -> str | None:
-    retriever, _ = await _get_rag_retriever()
     contexts: list[str] = []
+    rag_llm_enabled = os.getenv("EVALVAULT_RAG_LLM_ENABLED", "true").lower() == "true"
+    run_context_enabled = os.getenv("EVALVAULT_CHAT_RUN_CONTEXT_ENABLED", "true").lower() == "true"
+
+    if run_id and rag_llm_enabled and run_context_enabled:
+        contexts.extend(await _build_run_context(run_id))
+
+    if not rag_llm_enabled and contexts:
+        return "\n\n".join(contexts[:3])
+
+    if not rag_llm_enabled:
+        content = _load_user_guide_text()
+        if content:
+            chunks = [chunk.strip() for chunk in content.split("\n\n") if chunk.strip()]
+            contexts.extend(_simple_retrieve(chunks, user_text, top_k=5))
+        return "\n\n".join(contexts[:3]) if contexts else None
+
+    retriever, _ = await _get_rag_retriever()
 
     if retriever is not None:
         results = retriever.search(user_text, top_k=5)
@@ -403,7 +660,7 @@ async def _rag_answer(
     if not contexts:
         return None
 
-    if os.getenv("EVALVAULT_RAG_LLM_ENABLED", "true").lower() != "true":
+    if not rag_llm_enabled:
         return "\n\n".join(contexts[:3])
 
     prompt = (
@@ -431,15 +688,24 @@ async def _rag_answer(
     if options:
         payload["options"] = options
 
-    async with httpx.AsyncClient(timeout=60) as client:
-        response = await client.post(
-            f"{os.getenv('OLLAMA_BASE_URL', 'http://localhost:11434')}/api/chat",
-            json=payload,
-        )
-        response.raise_for_status()
-        data = response.json()
+    fallback = "\n\n".join(contexts[:3])
+    chat_timeout = int(os.getenv("OLLAMA_CHAT_TIMEOUT_SECONDS", "180"))
+    try:
+        async with httpx.AsyncClient(timeout=chat_timeout) as client:
+            response = await client.post(
+                f"{os.getenv('OLLAMA_BASE_URL', 'http://localhost:11434')}/api/chat",
+                json=payload,
+            )
+            response.raise_for_status()
+            data = response.json()
+    except httpx.ReadTimeout:
+        logger.warning("Ollama chat timed out; returning retrieved contexts")
+        return fallback or None
+    except httpx.HTTPError as exc:
+        logger.warning("Ollama chat failed: %s", exc)
+        return fallback or None
 
-    return data.get("message", {}).get("content", "").strip() or None
+    return data.get("message", {}).get("content", "").strip() or fallback or None
 
 
 async def _call_mcp_tool(tool_name: str, tool_args: dict[str, Any]) -> Any:
@@ -665,6 +931,17 @@ async def _chat_stream(
     user_text: str, run_id: str | None = None, category: str | None = None
 ) -> AsyncGenerator[str, None]:
     started_at = time.perf_counter()
+    simple_mode = os.getenv("EVALVAULT_CHAT_SIMPLE_MODE", "false").lower() == "true"
+    run_context_enabled = os.getenv("EVALVAULT_CHAT_RUN_CONTEXT_ENABLED", "true").lower() == "true"
+    if simple_mode:
+        yield _event({"type": "status", "message": "간단 채팅 처리 중..."})
+        answer = await _direct_chat_answer(user_text)
+        if answer:
+            async for item in _emit_answer(answer):
+                yield item
+        else:
+            yield _event({"type": "final", "content": "답변을 생성하지 못했습니다."})
+        return
     if category in {"result_interpretation", "improvement_direction"} and not run_id:
         yield _event(
             {
@@ -700,6 +977,7 @@ async def _chat_stream(
         _is_verb_only(user_text)
         and category in {"result_interpretation", "improvement_direction"}
         and run_id
+        and run_context_enabled
     ):
         yield _event({"type": "status", "message": "선택한 run 요약 중..."})
         try:
@@ -807,6 +1085,14 @@ async def _chat_stream(
     if tool_name == "get_artifacts" and not (tool_args.get("run_id") or run_id):
         yield _event({"type": "final", "content": "아티팩트 조회를 위해 run_id가 필요합니다."})
         return
+    if not run_context_enabled and tool_name in {"get_run_summary", "get_artifacts"}:
+        yield _event(
+            {
+                "type": "final",
+                "content": "run 요약/아티팩트 조회가 비활성화되어 있습니다.",
+            }
+        )
+        return
     if tool_name == "analyze_compare" and (
         not tool_args.get("run_id_a") or not tool_args.get("run_id_b")
     ):

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

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

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

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

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

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