evalvault 1.58.0__py3-none-any.whl → 1.59.0__py3-none-any.whl

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

@@ -71,6 +71,54 @@ INTENT_CATALOG = {
         "description": "시간에 따른 추세를 분석합니다.",
         "sample_query": "메트릭 추세를 분석해줘",
     },
+    AnalysisIntent.ANALYZE_STATISTICAL: {
+        "label": "기술 통계량",
+        "category": "analysis",
+        "description": "메트릭별 기초 통계량을 계산합니다.",
+        "sample_query": "기초 통계 분석해줘",
+    },
+    AnalysisIntent.ANALYZE_NLP: {
+        "label": "NLP 분석",
+        "category": "analysis",
+        "description": "질문/답변 텍스트를 분석합니다.",
+        "sample_query": "텍스트 분석해줘",
+    },
+    AnalysisIntent.ANALYZE_CAUSAL: {
+        "label": "인과 관계 분석",
+        "category": "analysis",
+        "description": "요인별 영향도와 인과 관계를 분석합니다.",
+        "sample_query": "인과 관계 분석해줘",
+    },
+    AnalysisIntent.ANALYZE_NETWORK: {
+        "label": "네트워크 분석",
+        "category": "analysis",
+        "description": "메트릭 간 상관관계 네트워크를 분석합니다.",
+        "sample_query": "메트릭 네트워크 분석해줘",
+    },
+    AnalysisIntent.ANALYZE_PLAYBOOK: {
+        "label": "플레이북 분석",
+        "category": "analysis",
+        "description": "개선 플레이북 기반 진단을 수행합니다.",
+        "sample_query": "플레이북으로 분석해줘",
+    },
+    AnalysisIntent.DETECT_ANOMALIES: {
+        "label": "이상 탐지",
+        "category": "timeseries",
+        "description": "시계열 이상 패턴을 탐지합니다.",
+        "sample_query": "이상 탐지해줘",
+    },
+    AnalysisIntent.FORECAST_PERFORMANCE: {
+        "label": "성능 예측",
+        "category": "timeseries",
+        "description": "미래 성능을 예측합니다.",
+        "sample_query": "성능 예측해줘",
+    },
+    AnalysisIntent.GENERATE_HYPOTHESES: {
+        "label": "가설 생성",
+        "category": "generation",
+        "description": "성능 저하 원인에 대한 가설을 생성합니다.",
+        "sample_query": "가설 생성해줘",
+    },
     AnalysisIntent.BENCHMARK_RETRIEVAL: {
         "label": "검색 벤치마크",
         "category": "benchmark",

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

@@ -12,15 +12,18 @@ from rich.table import Table
 
 from evalvault.adapters.outbound.analysis import (
     CausalAnalysisAdapter,
+    HypothesisGeneratorModule,
+    NetworkAnalyzerModule,
     NLPAnalysisAdapter,
     StatisticalAnalysisAdapter,
+    TimeSeriesAdvancedModule,
 )
 from evalvault.adapters.outbound.analysis.pipeline_factory import (
     build_analysis_pipeline_service,
 )
 from evalvault.adapters.outbound.cache import MemoryCacheAdapter
 from evalvault.adapters.outbound.llm import get_llm_adapter
-from evalvault.adapters.outbound.report import MarkdownReportAdapter
+from evalvault.adapters.outbound.report import DashboardGenerator, MarkdownReportAdapter
 from evalvault.adapters.outbound.storage.sqlite_adapter import SQLiteStorageAdapter
 from evalvault.config.phoenix_support import get_phoenix_trace_url
 from evalvault.config.settings import Settings, apply_profile
@@ -64,6 +67,37 @@ def register_analyze_commands(app: typer.Typer, console: Console) -> None:
             "-L",
             help="플레이북 분석에서 LLM 인사이트 생성",
         ),
+        dashboard: bool = typer.Option(False, "--dashboard", help="시각화 대시보드 생성"),
+        dashboard_format: str = typer.Option(
+            "png", "--dashboard-format", help="대시보드 출력 형식 (png, svg, pdf)"
+        ),
+        anomaly_detect: bool = typer.Option(
+            False, "--anomaly-detect", "-A", help="이상치 탐지 실행 (Phase 2)"
+        ),
+        window_size: int = typer.Option(
+            200, "--window-size", "-w", help="이상치 탐지 윈도 크기", min=50, max=500
+        ),
+        forecast: bool = typer.Option(False, "--forecast", "-F", help="성능 예측 실행 (Phase 2)"),
+        forecast_horizon: int = typer.Option(
+            3, "--forecast-horizon", help="예측 범위(런 개수)", min=1, max=10
+        ),
+        network: bool = typer.Option(
+            False, "--network", help="메트릭 상관관계 네트워크 생성 (Phase 3)"
+        ),
+        min_correlation: float = typer.Option(
+            0.5, "--min-correlation", help="네트워크 최소 상관계수", min=0, max=1
+        ),
+        generate_hypothesis: bool = typer.Option(
+            False, "--generate-hypothesis", "-H", help="가설 자동 생성 (Phase 4)"
+        ),
+        hypothesis_method: str = typer.Option(
+            "heuristic",
+            "--hypothesis-method",
+            help="가설 생성 방식 (heuristic, hyporefine, union)",
+        ),
+        num_hypotheses: int = typer.Option(
+            5, "--num-hypotheses", help="생성할 가설 수", min=1, max=20
+        ),
         output: Path | None = typer.Option(None, "--output", "-o", help="JSON 출력 파일"),
         report: Path | None = typer.Option(
             None, "--report", "-r", help="리포트 출력 파일 (*.md 또는 *.html)"
@@ -77,6 +111,9 @@ def register_analyze_commands(app: typer.Typer, console: Console) -> 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)
 
         try:
@@ -161,6 +198,97 @@ def register_analyze_commands(app: typer.Typer, console: Console) -> None:
             storage.save_analysis(analysis)
             _console.print(f"\n[green]분석 결과 DB 저장: {resolved_db_path}[/green]")
 
+        if dashboard:
+            dashboard_gen = DashboardGenerator()
+            _console.print("\n[bold cyan]Generating visualization dashboard...[/bold cyan]")
+
+            fig = dashboard_gen.generate_evaluation_dashboard(run_id)
+
+            output_dir = Path("reports/dashboard")
+            output_dir.mkdir(parents=True, exist_ok=True)
+
+            output_path = output_dir / f"dashboard_{run_id[:8]}.{dashboard_format}"
+            fig.savefig(output_path, dpi=300, bbox_inches="tight")
+            _console.print(f"\n[green]Dashboard saved to: {output_path}[/green]")
+
+        if anomaly_detect or forecast:
+            ts_analyzer = TimeSeriesAdvancedModule(window_size=window_size)
+            run_history = storage.list_runs(limit=50)
+
+            if not run_history or len(run_history) < 5:
+                _console.print("[yellow]Need at least 5 runs for time series analysis.[/yellow]")
+            else:
+                if anomaly_detect:
+                    _console.print("\n[bold cyan]Running anomaly detection...[/bold cyan]")
+                    history_data = [
+                        {
+                            "run_id": r.run_id,
+                            "pass_rate": r.pass_rate,
+                            "timestamp": r.started_at,
+                        }
+                        for r in run_history
+                    ]
+                    anomaly_result = ts_analyzer.detect_anomalies(history_data)
+                    _display_anomaly_detection(anomaly_result)
+
+                if forecast:
+                    _console.print("\n[bold cyan]Running performance forecasting...[/bold cyan]")
+                    history_data = [
+                        {"run_id": r.run_id, "pass_rate": r.pass_rate} for r in run_history
+                    ]
+                    forecast_result = ts_analyzer.forecast_performance(
+                        history_data, horizon=forecast_horizon
+                    )
+                    _display_forecast_result(forecast_result)
+
+        if network:
+            _console.print("\n[bold cyan]Building metric correlation network...[/bold cyan]")
+            net_analyzer = NetworkAnalyzerModule()
+
+            if not bundle.statistical or not bundle.statistical.significant_correlations:
+                _console.print("[yellow]No significant correlations for network analysis.[/yellow]")
+            else:
+                correlations_data = [
+                    {
+                        "variable1": corr.variable1,
+                        "variable2": corr.variable2,
+                        "correlation": corr.correlation,
+                        "p_value": corr.p_value,
+                        "is_significant": corr.is_significant,
+                    }
+                    for corr in bundle.statistical.significant_correlations
+                ]
+                graph = net_analyzer.build_correlation_network(
+                    correlations_data, min_correlation=min_correlation
+                )
+                net_result = net_analyzer.analyze_metric_network(graph)
+                _display_network_analysis(net_result)
+
+        if generate_hypothesis:
+            _console.print(
+                f"\n[bold cyan]Generating hypotheses ({hypothesis_method})...[/bold cyan]"
+            )
+            hyp_gen = HypothesisGeneratorModule(
+                method=hypothesis_method, num_hypotheses=num_hypotheses
+            )
+
+            metric_scores = {}
+            for metric_name, stats in analysis.metrics_summary.items():
+                metric_scores[metric_name] = stats.mean
+
+            low_performers_data = [
+                {
+                    "question": lp.test_case_id,
+                    "metric_name": lp.metric_name,
+                }
+                for lp in (analysis.low_performers or [])
+            ]
+
+            hypotheses = hyp_gen.generate_simple_hypotheses(
+                run_id, metric_scores, low_performers_data
+            )
+            _display_hypothesis_generation(hypotheses, hypothesis_method)
+
         if output:
             _export_analysis_json(analysis, output, bundle.nlp if nlp else None, improvement_report)
             _console.print(f"\n[green]분석 결과 내보냄: {output}[/green]")
@@ -192,6 +320,9 @@ def register_analyze_commands(app: typer.Typer, console: Console) -> 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)
 
         try:
@@ -220,7 +351,15 @@ def register_analyze_commands(app: typer.Typer, console: Console) -> None:
             _console.print(f"    Phoenix 트레이스: {trace_b}")
         _console.print(f"  검정: {test}\n")
 
-        comparisons = service.compare_runs(run_a, run_b, metrics=metric_list, test_type=test)
+        if test == "t-test":
+            test_type = "t-test"
+        elif test == "mann-whitney":
+            test_type = "mann-whitney"
+        else:
+            _console.print(f"[red]Error: Unsupported test type: {test}[/red]")
+            raise typer.Exit(1)
+
+        comparisons = service.compare_runs(run_a, run_b, metrics=metric_list, test_type=test_type)
 
         if not comparisons:
             _console.print("[yellow]비교할 공통 메트릭이 없습니다.[/yellow]")
@@ -942,6 +1081,123 @@ def _generate_report(
         file.write(content)
 
 
+def _display_anomaly_detection(anomaly_result) -> None:
+    _console.print("\n[bold]Anomaly Detection Results[/bold]")
+    _console.print(f"Detection method: {anomaly_result.detection_method}")
+    _console.print(f"Threshold: {anomaly_result.threshold:.2f}")
+    _console.print(f"Total runs: {anomaly_result.total_runs}")
+
+    if anomaly_result.anomalies:
+        detected = [a for a in anomaly_result.anomalies if a.is_anomaly]
+        if detected:
+            _console.print(f"\n[red]Detected {len(detected)} anomalies:[/red]")
+            table = Table(show_header=True, header_style="bold cyan")
+            table.add_column("Run ID")
+            table.add_column("Score", justify="right")
+            table.add_column("Pass Rate", justify="right")
+            table.add_column("Severity")
+
+            for anomaly in detected[:10]:
+                severity_color = (
+                    "red"
+                    if anomaly.severity == "high"
+                    else "yellow"
+                    if anomaly.severity == "medium"
+                    else "green"
+                )
+                table.add_row(
+                    anomaly.run_id[:12] + "...",
+                    f"{anomaly.anomaly_score:.2f}",
+                    f"{anomaly.pass_rate:.1%}",
+                    f"[{severity_color}]{anomaly.severity}[/{severity_color}]",
+                )
+            _console.print(table)
+        else:
+            _console.print("[green]No anomalies detected.[/green]")
+
+    if anomaly_result.insights:
+        _console.print("\n[bold]Insights:[/bold]")
+        for insight in anomaly_result.insights:
+            _console.print(f"  • {insight}")
+
+
+def _display_forecast_result(forecast_result) -> None:
+    _console.print("\n[bold]Forecast Results[/bold]")
+    _console.print(f"Method: {forecast_result.method}")
+    _console.print(f"Horizon: {forecast_result.horizon} runs")
+
+    if forecast_result.predicted_values:
+        _console.print("\n[bold]Predicted Pass Rates:[/bold]")
+        table = Table(show_header=True, header_style="bold cyan")
+        table.add_column("Run")
+        table.add_column("Predicted", justify="right")
+
+        for i, value in enumerate(forecast_result.predicted_values, 1):
+            table.add_row(f"+{i}", f"{value:.1%}")
+        _console.print(table)
+
+        avg_forecast = sum(forecast_result.predicted_values) / len(forecast_result.predicted_values)
+        _console.print(f"\nAverage forecast: {avg_forecast:.1%}")
+
+
+def _display_network_analysis(net_result) -> None:
+    _console.print("\n[bold]Network Analysis Results[/bold]")
+    _console.print(f"Nodes (metrics): {net_result.node_count}")
+    _console.print(f"Edges (correlations): {net_result.edge_count}")
+    _console.print(f"Density: {net_result.density:.3f}")
+    _console.print(f"Avg clustering: {net_result.avg_clustering:.3f}")
+
+    if net_result.communities:
+        _console.print(f"\n[bold]Communities ({len(net_result.communities)}):[/bold]")
+        for i, community in enumerate(net_result.communities):
+            if len(community) > 1:
+                _console.print(f"  Community {i + 1}: {', '.join(community)}")
+
+    if net_result.hub_metrics:
+        _console.print("\n[bold]Hub Metrics:[/bold]")
+        for metric in net_result.hub_metrics:
+            _console.print(f"  • {metric}")
+
+    if net_result.insights:
+        _console.print("\n[bold]Insights:[/bold]")
+        for insight in net_result.insights:
+            _console.print(f"  • {insight}")
+
+
+def _display_hypothesis_generation(hypotheses, method: str) -> None:
+    _console.print("\n[bold]Hypothesis Generation Results[/bold]")
+    _console.print(f"Method: {method}")
+    _console.print(f"Total hypotheses: {len(hypotheses)}")
+
+    if hypotheses:
+        _console.print("\n[bold]Generated Hypotheses:[/bold]")
+        table = Table(show_header=True, header_style="bold cyan")
+        table.add_column("#")
+        table.add_column("Hypothesis")
+        table.add_column("Metric")
+        table.add_column("Confidence", justify="right")
+        table.add_column("Evidence")
+
+        for i, hyp in enumerate(hypotheses[:10], 1):
+            confidence_color = (
+                "green" if hyp.confidence >= 0.8 else "yellow" if hyp.confidence >= 0.6 else "red"
+            )
+            table.add_row(
+                str(i),
+                hyp.text[:60] + "..." if len(hyp.text) > 60 else hyp.text,
+                hyp.metric_name or "-",
+                f"[{confidence_color}]{hyp.confidence:.2f}[/{confidence_color}]",
+                hyp.evidence[:30] + "..." if len(hyp.evidence) > 30 else hyp.evidence,
+            )
+        _console.print(table)
+
+        high_conf = [h for h in hypotheses if h.confidence >= 0.8]
+        if high_conf:
+            _console.print(
+                f"\n[green]High confidence hypotheses: {len(high_conf)}/{len(hypotheses)}[/green]"
+            )
+
+
 __all__ = [
     "register_analyze_commands",
     "_perform_playbook_analysis",

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

@@ -36,7 +36,7 @@ def register_pipeline_commands(app: typer.Typer, console) -> None:
             "-o",
             help="Output file for results (JSON format).",
         ),
-        db_path: Path = db_option(help_text="Path to database file."),
+        db_path: Path | None = db_option(help_text="Path to database file."),
     ) -> None:
         """Analyze evaluation results using natural language query."""
         from evalvault.adapters.outbound.analysis.pipeline_factory import (
@@ -52,6 +52,10 @@ def register_pipeline_commands(app: typer.Typer, console) -> None:
         if settings.phoenix_enabled:
             ensure_phoenix_instrumentation(settings, console=console)
 
+        if db_path is None:
+            console.print("[red]Error: Database path is not configured.[/red]")
+            raise typer.Exit(1)
+
         storage = SQLiteStorageAdapter(db_path=db_path)
         llm_adapter = None
         try:

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

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import asyncio
+import os
 from collections.abc import Callable, Sequence
 from datetime import date, datetime
 from pathlib import Path
@@ -794,6 +795,12 @@ def register_run_commands(
             )
             raise typer.Exit(1)
 
+        ollama_env_url = os.environ.get("OLLAMA_BASE_URL")
+        if ollama_env_url:
+            normalized_url = ollama_env_url.strip()
+            if normalized_url and "://" not in normalized_url:
+                os.environ["OLLAMA_BASE_URL"] = f"http://{normalized_url}"
+
         settings = Settings()
 
         # Apply profile (CLI > .env > default)
@@ -915,6 +922,15 @@ def register_run_commands(
                 raise typer.Exit(1) from exc
 
         if settings.llm_provider == "ollama":
+            base_url = getattr(settings, "ollama_base_url", "")
+            if not isinstance(base_url, str):
+                base_url = ""
+            base_url = base_url.strip()
+            if not base_url:
+                base_url = "http://localhost:11434"
+            elif "://" not in base_url:
+                base_url = f"http://{base_url}"
+            settings.ollama_base_url = base_url
             display_model = f"ollama/{settings.ollama_model}"
         elif settings.llm_provider == "vllm":
             display_model = f"vllm/{settings.vllm_model}"
@@ -1421,37 +1437,55 @@ def register_run_commands(
             ensure_phoenix_instrumentation(settings, console=console, force=True)
 
         evaluator = RagasEvaluator()
+        llm_adapter = None
         try:
             llm_adapter = get_llm_adapter(settings)
         except Exception as exc:
             provider = str(getattr(settings, "llm_provider", "")).strip().lower()
-            fixes: list[str] = []
-            if provider == "ollama":
-                fixes = [
-                    "Ollama 서버가 실행 중인지 확인하세요 (기본: http://localhost:11434).",
-                    "필요 모델을 받아두세요: `ollama pull gemma3:1b` 및 `ollama pull qwen3-embedding:0.6b`.",
-                    "URL을 바꿨다면 .env의 `OLLAMA_BASE_URL`을 확인하세요.",
-                ]
-            elif provider == "openai":
-                fixes = [
-                    "`.env`에 `OPENAI_API_KEY`를 설정하세요.",
-                    "프록시/네트워크가 필요한 환경이면 연결 가능 여부를 확인하세요.",
-                ]
-            elif provider == "vllm":
-                fixes = [
-                    "`.env`의 `VLLM_BASE_URL`/`VLLM_MODEL` 설정을 확인하세요.",
-                    "vLLM 서버가 OpenAI 호환 API로 실행 중인지 확인하세요.",
-                ]
-            else:
-                fixes = ["--profile 또는 환경변수 설정을 확인하세요."]
+            recovered = False
+            if provider == "ollama" and "http://" in str(exc):
+                base_url = getattr(settings, "ollama_base_url", "")
+                if not isinstance(base_url, str) or not base_url.strip():
+                    base_url = "http://localhost:11434"
+                elif "://" not in base_url:
+                    base_url = f"http://{base_url.strip()}"
+                settings.ollama_base_url = base_url
+                try:
+                    llm_adapter = get_llm_adapter(settings)
+                    recovered = True
+                except Exception as retry_exc:
+                    exc = retry_exc
+
+            if not recovered:
+                fixes: list[str] = []
+                if provider == "ollama":
+                    fixes = [
+                        "Ollama 서버가 실행 중인지 확인하세요 (기본: http://localhost:11434).",
+                        "필요 모델을 받아두세요: `ollama pull gemma3:1b` 및 `ollama pull qwen3-embedding:0.6b`.",
+                        "URL을 바꿨다면 .env의 `OLLAMA_BASE_URL`을 확인하세요.",
+                    ]
+                elif provider == "openai":
+                    fixes = [
+                        "`.env`에 `OPENAI_API_KEY`를 설정하세요.",
+                        "프록시/네트워크가 필요한 환경이면 연결 가능 여부를 확인하세요.",
+                    ]
+                elif provider == "vllm":
+                    fixes = [
+                        "`.env`의 `VLLM_BASE_URL`/`VLLM_MODEL` 설정을 확인하세요.",
+                        "vLLM 서버가 OpenAI 호환 API로 실행 중인지 확인하세요.",
+                    ]
+                else:
+                    fixes = ["--profile 또는 환경변수 설정을 확인하세요."]
 
-            print_cli_error(
-                console,
-                "LLM/임베딩 어댑터를 초기화하지 못했습니다.",
-                details=str(exc),
-                fixes=fixes,
-            )
-            raise typer.Exit(1) from exc
+                print_cli_error(
+                    console,
+                    "LLM/임베딩 어댑터를 초기화하지 못했습니다.",
+                    details=str(exc),
+                    fixes=fixes,
+                )
+                raise typer.Exit(1) from exc
+
+        assert llm_adapter is not None
 
         memory_adapter: SQLiteDomainMemoryAdapter | None = None
         memory_evaluator: MemoryAwareEvaluator | None = None

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

@@ -187,9 +187,9 @@ def build_metric_scorecard(
         threshold = _resolve_threshold(run, metric)
         pass_rate = pass_rates.get(metric) if isinstance(pass_rates, dict) else None
         status = "unknown"
-        if isinstance(mean, (int, float)):
+        if isinstance(mean, int | float):
             status = "pass" if float(mean) >= threshold else "risk"
-        elif isinstance(pass_rate, (int, float)):
+        elif isinstance(pass_rate, int | float):
             status = "pass" if float(pass_rate) >= 0.7 else "risk"
         scorecard.append(
             {

evalvault/adapters/outbound/analysis/__init__.py

@@ -42,6 +42,9 @@ from evalvault.adapters.outbound.analysis.hybrid_rrf_module import HybridRRFModu
 from evalvault.adapters.outbound.analysis.hybrid_weighted_module import (
     HybridWeightedModule,
 )
+from evalvault.adapters.outbound.analysis.hypothesis_generator_module import (
+    HypothesisGeneratorModule,
+)
 from evalvault.adapters.outbound.analysis.llm_report_module import LLMReportModule
 from evalvault.adapters.outbound.analysis.low_performer_extractor_module import (
     LowPerformerExtractorModule,
@@ -53,6 +56,9 @@ from evalvault.adapters.outbound.analysis.morpheme_analyzer_module import (
 from evalvault.adapters.outbound.analysis.morpheme_quality_checker_module import (
     MorphemeQualityCheckerModule,
 )
+from evalvault.adapters.outbound.analysis.network_analyzer_module import (
+    NetworkAnalyzerModule,
+)
 from evalvault.adapters.outbound.analysis.nlp_adapter import NLPAnalysisAdapter
 from evalvault.adapters.outbound.analysis.nlp_analyzer_module import NLPAnalyzerModule
 from evalvault.adapters.outbound.analysis.pattern_detector_module import (
@@ -103,6 +109,9 @@ from evalvault.adapters.outbound.analysis.summary_report_module import (
 from evalvault.adapters.outbound.analysis.time_series_analyzer_module import (
     TimeSeriesAnalyzerModule,
 )
+from evalvault.adapters.outbound.analysis.timeseries_advanced_module import (
+    TimeSeriesAdvancedModule,
+)
 from evalvault.adapters.outbound.analysis.trend_detector_module import (
     TrendDetectorModule,
 )
@@ -111,16 +120,16 @@ from evalvault.adapters.outbound.analysis.verification_report_module import (
 )
 
 __all__ = [
-    # Phase 2-3
-    "CausalAnalysisAdapter",
+    "TimeSeriesAdvancedModule",
+    "NetworkAnalyzerModule",
     "NLPAnalysisAdapter",
     "StatisticalAnalysisAdapter",
     "BaseAnalysisAdapter",
     "AnalysisDataProcessor",
-    # Phase 14
     "BaseAnalysisModule",
     "AnalysisReportModule",
     "BM25SearcherModule",
+    "CausalAnalysisAdapter",
     "CausalAnalyzerModule",
     "ComparisonReportModule",
     "DataLoaderModule",
@@ -131,6 +140,7 @@ __all__ = [
     "EmbeddingSearcherModule",
     "HybridRRFModule",
     "HybridWeightedModule",
+    "HypothesisGeneratorModule",
     "LowPerformerExtractorModule",
     "LLMReportModule",
     "ModelAnalyzerModule",

evalvault/adapters/outbound/analysis/embedding_analyzer_module.py

@@ -8,7 +8,6 @@ import numpy as np
 
 from evalvault.adapters.outbound.analysis.base_module import BaseAnalysisModule
 from evalvault.adapters.outbound.analysis.pipeline_helpers import get_upstream_output
-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
 from evalvault.domain.entities import EvaluationRun
@@ -140,6 +139,8 @@ class EmbeddingAnalyzerModule(BaseAnalysisModule):
 
         if backend_hint == "ollama" or embedding_profile in {"dev", "prod"}:
             try:
+                from evalvault.adapters.outbound.llm.ollama_adapter import OllamaAdapter
+
                 adapter = OllamaAdapter(settings)
                 retriever = KoreanDenseRetriever(
                     model_name=model_name or settings.ollama_embedding_model,

evalvault/adapters/outbound/analysis/embedding_searcher_module.py

@@ -12,7 +12,6 @@ from evalvault.adapters.outbound.analysis.pipeline_helpers import (
     recall_at_k,
     safe_mean,
 )
-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
 from evalvault.domain.entities import EvaluationRun
@@ -66,6 +65,8 @@ class EmbeddingSearcherModule(BaseAnalysisModule):
 
         if embedding_profile in {"dev", "prod"}:
             try:
+                from evalvault.adapters.outbound.llm.ollama_adapter import OllamaAdapter
+
                 adapter = OllamaAdapter(settings)
                 retriever = KoreanDenseRetriever(
                     model_name=settings.ollama_embedding_model,