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

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/config.py

@@ -71,7 +71,9 @@ class ConfigUpdateRequest(BaseModel):
     phoenix_endpoint: str | None = None
     phoenix_enabled: bool | None = None
     phoenix_sample_rate: float | None = None
-    tracker_provider: Literal["langfuse", "mlflow", "phoenix", "none"] | None = None
+    phoenix_project_name: str | None = None
+    phoenix_annotations_enabled: bool | None = None
+    tracker_provider: str | None = None
     postgres_host: str | None = None
     postgres_port: int | None = None
     postgres_database: str | None = None

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
     ]

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

@@ -26,7 +26,8 @@ from evalvault.adapters.outbound.analysis.pipeline_helpers import to_serializabl
 from evalvault.adapters.outbound.cache import MemoryCacheAdapter
 from evalvault.adapters.outbound.llm import get_llm_adapter
 from evalvault.adapters.outbound.report import DashboardGenerator, MarkdownReportAdapter
-from evalvault.adapters.outbound.storage.sqlite_adapter import SQLiteStorageAdapter
+from evalvault.adapters.outbound.storage.factory import build_storage_adapter
+from evalvault.adapters.outbound.storage.postgres_adapter import PostgreSQLStorageAdapter
 from evalvault.config.phoenix_support import get_phoenix_trace_url
 from evalvault.config.settings import Settings, apply_profile
 from evalvault.domain.entities import EvaluationRun
@@ -115,11 +116,7 @@ def register_analyze_commands(app: typer.Typer, console: Console) -> None:
     ) -> None:
         """평가 실행 결과를 분석하고 통계 인사이트를 표시합니다."""
 
-        resolved_db_path = db_path or Settings().evalvault_db_path
-        if resolved_db_path is None:
-            _console.print("[red]오류: DB 경로가 설정되지 않았습니다.[/red]")
-            raise typer.Exit(1)
-        storage = SQLiteStorageAdapter(db_path=resolved_db_path)
+        storage = build_storage_adapter(settings=Settings(), db_path=db_path)
 
         try:
             run = storage.get_run(run_id)
@@ -217,7 +214,12 @@ def register_analyze_commands(app: typer.Typer, console: Console) -> None:
                 _save_analysis_payload(bundle.causal, "causal")
             if improvement_report is not None:
                 _save_analysis_payload(improvement_report, "playbook")
-            _console.print(f"\n[green]분석 결과 DB 저장: {resolved_db_path}[/green]")
+            storage_label = (
+                "PostgreSQL"
+                if isinstance(storage, PostgreSQLStorageAdapter)
+                else f"SQLite ({db_path})"
+            )
+            _console.print(f"\n[green]분석 결과 DB 저장: {storage_label}[/green]")
 
         if dashboard:
             dashboard_gen = DashboardGenerator()
@@ -359,11 +361,7 @@ def register_analyze_commands(app: typer.Typer, console: Console) -> None:
     ) -> None:
         """두 실행을 통계적으로 비교합니다."""
 
-        resolved_db_path = db_path or Settings().evalvault_db_path
-        if resolved_db_path is None:
-            _console.print("[red]오류: DB 경로가 설정되지 않았습니다.[/red]")
-            raise typer.Exit(1)
-        storage = SQLiteStorageAdapter(db_path=resolved_db_path)
+        storage = build_storage_adapter(settings=Settings(), db_path=db_path)
 
         try:
             run_a = storage.get_run(run_id1)

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

@@ -385,7 +385,7 @@ def create_benchmark_app(console: Console) -> typer.Typer:
         """
         try:
             from evalvault.adapters.outbound.benchmark import LMEvalAdapter
-            from evalvault.adapters.outbound.storage import SQLiteStorageAdapter
+            from evalvault.adapters.outbound.storage.factory import build_storage_adapter
             from evalvault.config.settings import get_settings
             from evalvault.domain.services.benchmark_service import BenchmarkService
             from evalvault.ports.outbound.benchmark_port import BenchmarkBackend
@@ -426,7 +426,7 @@ def create_benchmark_app(console: Console) -> typer.Typer:
             ensure_phoenix_instrumentation(settings, console=console, force=True)
 
         benchmark_adapter = LMEvalAdapter(settings=settings)
-        storage_adapter = SQLiteStorageAdapter(db_path=db)
+        storage_adapter = build_storage_adapter(settings=settings, db_path=db)
         tracer_adapter = _create_tracer_adapter(phoenix)
         service = BenchmarkService(
             benchmark_adapter=benchmark_adapter,
@@ -556,9 +556,11 @@ def create_benchmark_app(console: Console) -> typer.Typer:
         ),
     ) -> None:
         """View past benchmark runs."""
-        from evalvault.adapters.outbound.storage import SQLiteStorageAdapter
+        from evalvault.adapters.outbound.storage.factory import build_storage_adapter
+        from evalvault.config.settings import get_settings
 
-        storage = SQLiteStorageAdapter(db_path=db)
+        settings = get_settings()
+        storage = build_storage_adapter(settings=settings, db_path=db)
         runs = storage.list_benchmark_runs(
             benchmark_type=benchmark_type,
             model_name=model_name,
@@ -629,7 +631,7 @@ def create_benchmark_app(console: Console) -> typer.Typer:
           evalvault benchmark report abc123
           evalvault benchmark report abc123 -o report.md -p dev
         """
-        from evalvault.adapters.outbound.storage import SQLiteStorageAdapter
+        from evalvault.adapters.outbound.storage.factory import build_storage_adapter
         from evalvault.config.settings import get_settings
         from evalvault.domain.services.benchmark_report_service import (
             BenchmarkReportService,
@@ -639,7 +641,7 @@ def create_benchmark_app(console: Console) -> typer.Typer:
         if profile:
             settings.profile = profile
 
-        storage = SQLiteStorageAdapter(db_path=db)
+        storage = build_storage_adapter(settings=settings, db_path=db)
         benchmark_run = storage.get_benchmark_run(run_id)
 
         if not benchmark_run:
@@ -717,7 +719,7 @@ def create_benchmark_app(console: Console) -> typer.Typer:
           evalvault benchmark compare abc123 def456
           evalvault benchmark compare abc123 def456 -o comparison.md
         """
-        from evalvault.adapters.outbound.storage import SQLiteStorageAdapter
+        from evalvault.adapters.outbound.storage.factory import build_storage_adapter
         from evalvault.config.settings import get_settings
         from evalvault.domain.services.benchmark_report_service import (
             BenchmarkReportService,
@@ -727,7 +729,7 @@ def create_benchmark_app(console: Console) -> typer.Typer:
         if profile:
             settings.profile = profile
 
-        storage = SQLiteStorageAdapter(db_path=db)
+        storage = build_storage_adapter(settings=settings, db_path=db)
         baseline = storage.get_benchmark_run(baseline_id)
         target = storage.get_benchmark_run(target_id)
 

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

@@ -7,7 +7,7 @@ import typer
 from rich.console import Console
 from rich.table import Table
 
-from evalvault.adapters.outbound.storage.sqlite_adapter import SQLiteStorageAdapter
+from evalvault.adapters.outbound.storage.factory import build_storage_adapter
 from evalvault.config.settings import Settings
 from evalvault.domain.services.satisfaction_calibration_service import (
     SatisfactionCalibrationService,
@@ -36,12 +36,7 @@ def register_calibrate_commands(app: typer.Typer, console: Console) -> None:
         ),
         db_path: Path | None = db_option(help_text="DB 경로"),
     ) -> None:
-        resolved_db_path = db_path or Settings().evalvault_db_path
-        if resolved_db_path is None:
-            _console.print("[red]오류: DB 경로가 설정되지 않았습니다.[/red]")
-            raise typer.Exit(1)
-
-        storage = SQLiteStorageAdapter(db_path=resolved_db_path)
+        storage = build_storage_adapter(settings=Settings(), db_path=db_path)
         try:
             run = storage.get_run(run_id)
         except KeyError: