evalvault 1.68.1__py3-none-any.whl → 1.70.0__py3-none-any.whl

evalvault/adapters/outbound/analysis/multiturn_analyzer_module.py

@@ -0,0 +1,212 @@
+"""
+멀티턴 평가 요약 모듈입니다.
+"""
+
+from __future__ import annotations
+
+from collections import defaultdict
+from typing import Any
+
+from evalvault.adapters.outbound.analysis.base_module import BaseAnalysisModule
+from evalvault.adapters.outbound.analysis.pipeline_helpers import get_upstream_output, safe_mean
+from evalvault.domain.entities import EvaluationRun
+
+
+class MultiTurnAnalyzerModule(BaseAnalysisModule):
+    """멀티턴(대화) 단위로 결과를 집계합니다."""
+
+    module_id = "multiturn_analyzer"
+    name = "멀티턴 분석"
+    description = "대화/턴 메타데이터를 기준으로 멀티턴 성능을 요약합니다."
+    input_types = ["run"]
+    output_types = ["multiturn_summary", "multiturn_conversations", "multiturn_turns"]
+    requires = ["data_loader"]
+    tags = ["analysis", "multiturn"]
+
+    def execute(
+        self,
+        inputs: dict[str, Any],
+        params: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        loader_output = get_upstream_output(inputs, "load_data", "data_loader") or {}
+        run = loader_output.get("run")
+        if not isinstance(run, EvaluationRun):
+            return {
+                "available": False,
+                "summary": {},
+                "conversations": [],
+                "turns": [],
+                "coverage": {},
+            }
+
+        retrieval_meta = run.retrieval_metadata or {}
+        cases = run.results
+        total_cases = len(cases)
+
+        coverage = {
+            "total_cases": total_cases,
+            "has_conversation_id": 0,
+            "has_turn_index": 0,
+        }
+
+        grouped: dict[str, list[dict[str, Any]]] = defaultdict(list)
+        turns: list[dict[str, Any]] = []
+
+        for result in cases:
+            case_meta = _resolve_case_metadata(retrieval_meta, result.test_case_id)
+            conversation_id = _coerce_text(case_meta.get("conversation_id"))
+            turn_index = _coerce_turn_index(case_meta.get("turn_index"))
+            turn_id = _coerce_text(case_meta.get("turn_id"))
+
+            if conversation_id:
+                coverage["has_conversation_id"] += 1
+            if turn_index is not None:
+                coverage["has_turn_index"] += 1
+
+            metrics = {
+                metric.name: metric.score for metric in result.metrics if metric.score is not None
+            }
+            avg_score = safe_mean(metrics.values()) if metrics else 0.0
+            failed_metrics = [metric.name for metric in result.metrics if not metric.passed]
+            entry = {
+                "test_case_id": result.test_case_id,
+                "conversation_id": conversation_id,
+                "turn_index": turn_index,
+                "turn_id": turn_id,
+                "avg_score": round(avg_score, 4),
+                "metrics": metrics,
+                "failed_metrics": failed_metrics,
+                "passed_all": result.all_passed,
+            }
+            turns.append(entry)
+            if conversation_id:
+                grouped[conversation_id].append(entry)
+
+        conversations: list[dict[str, Any]] = []
+        first_failure_hist: dict[str, int] = defaultdict(int)
+
+        for conversation_id, entries in grouped.items():
+            entries_sorted = _sort_turns(entries)
+            avg_scores = [item["avg_score"] for item in entries_sorted]
+            metric_scores: dict[str, list[float]] = defaultdict(list)
+            for item in entries_sorted:
+                for name, score in (item.get("metrics") or {}).items():
+                    metric_scores[name].append(float(score))
+
+            metric_means = {
+                name: round(safe_mean(values), 4) for name, values in metric_scores.items()
+            }
+            passed_all = all(item.get("passed_all") for item in entries_sorted)
+            failure_turn = _first_failure_turn(entries_sorted)
+            if failure_turn is not None:
+                first_failure_hist[str(failure_turn)] += 1
+
+            worst_turn = _select_worst_turn(entries_sorted)
+
+            conversations.append(
+                {
+                    "conversation_id": conversation_id,
+                    "turn_count": len(entries_sorted),
+                    "avg_score": round(safe_mean(avg_scores), 4),
+                    "passed_all_turns": passed_all,
+                    "first_failure_turn_index": failure_turn,
+                    "worst_turn": worst_turn,
+                    "metric_means": metric_means,
+                }
+            )
+
+        conversation_count = len(grouped)
+        turn_count = sum(len(items) for items in grouped.values())
+        summary = {
+            "conversation_count": conversation_count,
+            "turn_count": turn_count,
+            "avg_turns_per_conversation": round(
+                (turn_count / conversation_count) if conversation_count else 0.0, 3
+            ),
+            "conversation_pass_rate": round(
+                (
+                    sum(1 for item in conversations if item.get("passed_all_turns"))
+                    / conversation_count
+                )
+                if conversation_count
+                else 0.0,
+                4,
+            ),
+            "first_failure_turn_histogram": dict(first_failure_hist),
+        }
+
+        if total_cases:
+            coverage["has_conversation_id"] = round(
+                coverage["has_conversation_id"] / total_cases, 4
+            )
+            coverage["has_turn_index"] = round(coverage["has_turn_index"] / total_cases, 4)
+
+        return {
+            "available": True,
+            "summary": summary,
+            "conversations": conversations,
+            "turns": turns,
+            "coverage": coverage,
+        }
+
+
+def _resolve_case_metadata(
+    retrieval_metadata: dict[str, dict[str, Any]],
+    test_case_id: str,
+) -> dict[str, Any]:
+    meta = retrieval_metadata.get(test_case_id)
+    if isinstance(meta, dict):
+        nested = meta.get("test_case_metadata")
+        if isinstance(nested, dict):
+            merged = dict(nested)
+            merged.update({k: v for k, v in meta.items() if k != "test_case_metadata"})
+            return merged
+        return dict(meta)
+    return {}
+
+
+def _coerce_text(value: Any) -> str | None:
+    if value is None:
+        return None
+    if isinstance(value, str):
+        trimmed = value.strip()
+        return trimmed or None
+    return str(value)
+
+
+def _coerce_turn_index(value: Any) -> int | None:
+    if value is None:
+        return None
+    if isinstance(value, int):
+        return value
+    if isinstance(value, float) and value.is_integer():
+        return int(value)
+    if isinstance(value, str) and value.strip().isdigit():
+        return int(value.strip())
+    return None
+
+
+def _sort_turns(entries: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    if all(item.get("turn_index") is None for item in entries):
+        return list(entries)
+    return sorted(
+        entries, key=lambda item: (item.get("turn_index") is None, item.get("turn_index") or 0)
+    )
+
+
+def _first_failure_turn(entries: list[dict[str, Any]]) -> int | None:
+    for item in entries:
+        if not item.get("passed_all"):
+            return item.get("turn_index")
+    return None
+
+
+def _select_worst_turn(entries: list[dict[str, Any]]) -> dict[str, Any] | None:
+    if not entries:
+        return None
+    worst = min(entries, key=lambda item: item.get("avg_score", 0.0))
+    return {
+        "test_case_id": worst.get("test_case_id"),
+        "avg_score": worst.get("avg_score"),
+        "failed_metrics": worst.get("failed_metrics", []),
+    }

evalvault/adapters/outbound/analysis/pipeline_factory.py

@@ -58,6 +58,7 @@ def build_analysis_pipeline_service(
     service.register_module(analysis_modules.DiagnosticPlaybookModule())
     service.register_module(analysis_modules.RootCauseAnalyzerModule())
     service.register_module(analysis_modules.PatternDetectorModule())
+    service.register_module(analysis_modules.MultiTurnAnalyzerModule())
     service.register_module(analysis_modules.TimeSeriesAnalyzerModule())
     service.register_module(analysis_modules.TimeSeriesAdvancedModule())
     service.register_module(analysis_modules.TrendDetectorModule())

evalvault/adapters/outbound/analysis/retrieval_analyzer_module.py

@@ -37,6 +37,8 @@ class RetrievalAnalyzerModule(BaseAnalysisModule):
 
         params = params or {}
         max_cases = int(params.get("max_cases", 150))
+        max_examples = int(params.get("max_examples", 5))
+        max_graphrag_docs = int(params.get("max_graphrag_docs", 5))
 
         context_counts: list[int] = []
         context_token_counts: list[int] = []
@@ -96,6 +98,11 @@ class RetrievalAnalyzerModule(BaseAnalysisModule):
         retrieval_meta = run.retrieval_metadata or {}
         retrieval_times: list[float] = []
         retrieval_scores: list[float] = []
+        graph_nodes: list[int] = []
+        graph_edges: list[int] = []
+        subgraph_sizes: list[int] = []
+        graphrag_cases = 0
+        graphrag_examples: list[dict[str, Any]] = []
         for item in retrieval_meta.values():
             if isinstance(item, dict):
                 if "retrieval_time_ms" in item:
@@ -103,6 +110,20 @@ class RetrievalAnalyzerModule(BaseAnalysisModule):
                 scores = item.get("scores")
                 if isinstance(scores, list) and scores:
                     retrieval_scores.append(safe_mean([float(s) for s in scores]))
+                if "graph_nodes" in item:
+                    graph_nodes.append(int(item["graph_nodes"]))
+                if "graph_edges" in item:
+                    graph_edges.append(int(item["graph_edges"]))
+                if "subgraph_size" in item:
+                    subgraph_sizes.append(int(item["subgraph_size"]))
+                if item.get("retriever") == "graphrag":
+                    graphrag_cases += 1
+                    if len(graphrag_examples) < max_examples:
+                        graphrag_details = item.get("graphrag")
+                        if isinstance(graphrag_details, dict):
+                            graphrag_examples.append(
+                                _trim_graphrag_example(graphrag_details, max_docs=max_graphrag_docs)
+                            )
 
         summary = {
             "total_cases": total_cases,
@@ -122,6 +143,15 @@ class RetrievalAnalyzerModule(BaseAnalysisModule):
             summary["avg_retrieval_time_ms"] = round(safe_mean(retrieval_times), 2)
         if retrieval_scores:
             summary["avg_retrieval_score"] = round(safe_mean(retrieval_scores), 4)
+        if graph_nodes:
+            summary["avg_graph_nodes"] = round(safe_mean(graph_nodes), 2)
+        if graph_edges:
+            summary["avg_graph_edges"] = round(safe_mean(graph_edges), 2)
+        if subgraph_sizes:
+            summary["avg_subgraph_size"] = round(safe_mean(subgraph_sizes), 2)
+        if total_cases:
+            summary["graphrag_case_rate"] = round(graphrag_cases / total_cases, 4)
+        summary["graphrag_case_count"] = graphrag_cases
 
         insights = []
         if summary["avg_contexts"] < 1:
@@ -138,6 +168,38 @@ class RetrievalAnalyzerModule(BaseAnalysisModule):
                 "context_token_counts": context_token_counts[:100],
                 "keyword_overlap_scores": keyword_overlap_scores[:100],
                 "faithfulness_scores": faithfulness_scores[:100],
+                "graph_nodes": graph_nodes[:100],
+                "graph_edges": graph_edges[:100],
+                "subgraph_sizes": subgraph_sizes[:100],
+                "graphrag_examples": graphrag_examples,
             },
             "insights": insights,
         }
+
+
+def _trim_graphrag_example(payload: dict[str, Any], *, max_docs: int) -> dict[str, Any]:
+    docs = payload.get("docs")
+    if isinstance(docs, list):
+        trimmed_docs = []
+        for entry in docs[:max_docs]:
+            if not isinstance(entry, dict):
+                continue
+            trimmed_docs.append(_trim_graphrag_doc(entry))
+        docs = trimmed_docs
+    else:
+        docs = []
+    return {
+        "docs": docs,
+        "max_docs": max_docs,
+    }
+
+
+def _trim_graphrag_doc(entry: dict[str, Any]) -> dict[str, Any]:
+    output: dict[str, Any] = {}
+    for key in ("doc_id", "rank", "score"):
+        if key in entry:
+            output[key] = entry[key]
+    sources = entry.get("sources")
+    if isinstance(sources, dict):
+        output["sources"] = sources
+    return output

evalvault/domain/services/pipeline_template_registry.py

@@ -658,6 +658,12 @@ class PipelineTemplateRegistry:
                 module="statistical_analyzer",
                 depends_on=["load_data"],
             ),
+            AnalysisNode(
+                id="retrieval_analysis",
+                name="검색 분석",
+                module="retrieval_analyzer",
+                depends_on=["load_data"],
+            ),
             AnalysisNode(
                 id="priority_summary",
                 name="우선순위 요약",
@@ -669,7 +675,7 @@ class PipelineTemplateRegistry:
                 name="LLM 요약 보고서",
                 module="llm_report",
                 params={"report_type": "summary"},
-                depends_on=["load_data", "statistics"],
+                depends_on=["load_data", "statistics", "retrieval_analysis"],
             ),
         ]
         return AnalysisPipeline(
@@ -698,6 +704,12 @@ class PipelineTemplateRegistry:
                 module="ragas_evaluator",
                 depends_on=["load_data"],
             ),
+            AnalysisNode(
+                id="retrieval_analysis",
+                name="검색 분석",
+                module="retrieval_analyzer",
+                depends_on=["load_data"],
+            ),
             AnalysisNode(
                 id="low_samples",
                 name="낮은 성능 케이스 추출",
@@ -710,6 +722,12 @@ class PipelineTemplateRegistry:
                 module="diagnostic_playbook",
                 depends_on=["load_data", "ragas_eval"],
             ),
+            AnalysisNode(
+                id="multiturn",
+                name="멀티턴 분석",
+                module="multiturn_analyzer",
+                depends_on=["load_data", "ragas_eval"],
+            ),
             AnalysisNode(
                 id="nlp_analysis",
                 name="NLP 분석",
@@ -767,11 +785,13 @@ class PipelineTemplateRegistry:
                     "load_data",
                     "statistics",
                     "ragas_eval",
+                    "retrieval_analysis",
                     "nlp_analysis",
                     "pattern_detection",
                     "causal_analysis",
                     "root_cause",
                     "priority_summary",
+                    "multiturn",
                     "trend_detection",
                 ],
             ),

evalvault/domain/services/retriever_context.py

@@ -48,6 +48,14 @@ def apply_retriever_to_dataset(
         if scores:
             metadata["scores"] = scores
         metadata.update(_extract_graph_attributes(results))
+        graphrag_details = _build_graphrag_details(
+            results,
+            doc_ids=resolved_doc_ids,
+            max_docs=top_k,
+        )
+        if graphrag_details:
+            metadata["retriever"] = "graphrag"
+            metadata["graphrag"] = graphrag_details
         retrieval_metadata[test_case.id] = metadata
 
     return retrieval_metadata
@@ -164,6 +172,114 @@ def _compact_values(values: set[str]) -> str | list[str]:
     return sorted(values)
 
 
+def _build_graphrag_details(
+    results: Sequence[RetrieverResultProtocol],
+    *,
+    doc_ids: Sequence[str],
+    max_docs: int,
+    max_entities: int = 20,
+    max_relations: int = 20,
+) -> dict[str, Any] | None:
+    details: list[dict[str, Any]] = []
+    for rank, result in enumerate(results, start=1):
+        metadata = getattr(result, "metadata", None)
+        if not isinstance(metadata, dict):
+            continue
+
+        kg_meta = metadata.get("kg") if isinstance(metadata.get("kg"), dict) else None
+        bm25_meta = metadata.get("bm25") if isinstance(metadata.get("bm25"), dict) else None
+        dense_meta = metadata.get("dense") if isinstance(metadata.get("dense"), dict) else None
+        community_id = metadata.get("community_id")
+
+        if not (kg_meta or bm25_meta or dense_meta or community_id is not None):
+            continue
+
+        doc_id = _resolve_doc_id(result, doc_ids, rank)
+        entry: dict[str, Any] = {
+            "doc_id": doc_id,
+            "rank": rank,
+        }
+        score = _extract_score(result)
+        if score is not None:
+            entry["score"] = score
+
+        sources: dict[str, Any] = {}
+        if kg_meta:
+            sources["kg"] = {
+                "entity_score": _coerce_float_or_none(kg_meta.get("entity_score")),
+                "relation_score": _coerce_float_or_none(kg_meta.get("relation_score")),
+                "entities": _limit_strings(kg_meta.get("entities"), max_entities),
+                "relations": _limit_strings(kg_meta.get("relations"), max_relations),
+                "community_id": _coerce_text_or_list(kg_meta.get("community_id")),
+            }
+        if bm25_meta:
+            sources["bm25"] = _build_rank_score(bm25_meta)
+        if dense_meta:
+            sources["dense"] = _build_rank_score(dense_meta)
+        if community_id is not None:
+            sources["community_id"] = _coerce_text_or_list(community_id)
+        if sources:
+            entry["sources"] = sources
+
+        details.append(entry)
+        if len(details) >= max_docs:
+            break
+
+    if not details:
+        return None
+
+    return {
+        "docs": details,
+        "max_docs": max_docs,
+        "max_entities": max_entities,
+        "max_relations": max_relations,
+    }
+
+
+def _build_rank_score(payload: dict[str, Any]) -> dict[str, Any]:
+    out: dict[str, Any] = {}
+    rank = _coerce_int_optional(payload.get("rank"))
+    if rank is not None:
+        out["rank"] = rank
+    score = _coerce_float_or_none(payload.get("score"))
+    if score is not None:
+        out["score"] = score
+    return out
+
+
+def _coerce_float_or_none(value: Any) -> float | None:
+    try:
+        if value is None:
+            return None
+        return float(value)
+    except (TypeError, ValueError):
+        return None
+
+
+def _coerce_int_optional(value: Any) -> int | None:
+    try:
+        if value is None:
+            return None
+        return int(value)
+    except (TypeError, ValueError):
+        return None
+
+
+def _coerce_text_or_list(value: Any) -> str | list[str] | None:
+    if value is None:
+        return None
+    if isinstance(value, (list, tuple, set)):
+        return [str(item) for item in value]
+    return str(value)
+
+
+def _limit_strings(value: Any, limit: int) -> list[str]:
+    if not value:
+        return []
+    items = list(value) if isinstance(value, (list, tuple, set)) else [value]
+    return [str(item) for item in items[:limit]]
+
+
 def apply_versioned_retriever_to_dataset(
     *,
     dataset: Dataset,

{evalvault-1.68.1.dist-info → evalvault-1.70.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: evalvault
-Version: 1.68.1
+Version: 1.70.0
 Summary: RAG evaluation system using Ragas with Phoenix/Langfuse tracing
 Project-URL: Homepage, https://github.com/ntts9990/EvalVault
 Project-URL: Documentation, https://github.com/ntts9990/EvalVault#readme

{evalvault-1.68.1.dist-info → evalvault-1.70.0.dist-info}/RECORD

@@ -86,15 +86,16 @@ evalvault/adapters/outbound/analysis/low_performer_extractor_module.py,sha256=Pt
 evalvault/adapters/outbound/analysis/model_analyzer_module.py,sha256=28rHdXBXYIFpLHixbbZcv6-j2QVgl3yaGN0vU1Q0gFc,2682
 evalvault/adapters/outbound/analysis/morpheme_analyzer_module.py,sha256=Hrh4mluMsOhQHPrliD2w0FVKokJpfikXOFKT6sNwk74,4158
 evalvault/adapters/outbound/analysis/morpheme_quality_checker_module.py,sha256=_uRKDXdwGbfYduf_3XT77vF8X3-_zW3stHYc3HKYQTE,2216
+evalvault/adapters/outbound/analysis/multiturn_analyzer_module.py,sha256=6R_lcbJyQr5CEEI_zpDJDdw6G4n3ZnkUI0ovfUPGrtU,7557
 evalvault/adapters/outbound/analysis/network_analyzer_module.py,sha256=ITUVnt_CI5pHy5SAESBSi004yMtiAhGFsbhC61VTezk,8475
 evalvault/adapters/outbound/analysis/nlp_adapter.py,sha256=aLtF_fns-7IEtitwON2EYS_lweq_IdldFsRm47alN0Q,29561
 evalvault/adapters/outbound/analysis/nlp_analyzer_module.py,sha256=kVuG9pVMQO6OYY5zxj_w9nNQZ1-qIO0y6XcXo6lG-n0,8221
 evalvault/adapters/outbound/analysis/pattern_detector_module.py,sha256=SyCDO_VS-r-tjGh8WrW-t1GCSC9ouxirdVk4NizFPXo,1882
-evalvault/adapters/outbound/analysis/pipeline_factory.py,sha256=XvcCbKCN_otv1pGUzk0oE76RV19yFga8r6RngBvgEFo,3691
+evalvault/adapters/outbound/analysis/pipeline_factory.py,sha256=Yk-VPagdAZXbbD08pCSOleg-URuVAzJks4oGl61mKAs,3763
 evalvault/adapters/outbound/analysis/pipeline_helpers.py,sha256=8E8IrYI5JvRrpnjxe0DS7srbPzB0XAxxXhLLYgfwsgU,5756
 evalvault/adapters/outbound/analysis/priority_summary_module.py,sha256=o8Y0rfHjYYE9WNTwKtpJulwfvLA3MNMhYjdSg15Vacc,10802
 evalvault/adapters/outbound/analysis/ragas_evaluator_module.py,sha256=Cd-spGn56zMcqOdoTLUHTYVOFqHqR17tPFyJs7rmnbw,7659
-evalvault/adapters/outbound/analysis/retrieval_analyzer_module.py,sha256=D24GTaKabHacSBI-UqCd_jy61hnne8-QG1p4rqW1Bzk,5748
+evalvault/adapters/outbound/analysis/retrieval_analyzer_module.py,sha256=STRHWapVAEz0YbSxR3NzT6zV7wfwlPxjKZunuWpfTmE,8340
 evalvault/adapters/outbound/analysis/retrieval_benchmark_module.py,sha256=_duIBlYhAsFygEpC7DuwoAqfTbVG2xgp70JjW1LJAGE,9312
 evalvault/adapters/outbound/analysis/retrieval_quality_checker_module.py,sha256=K1IJn4bvvz-BfqQmhd5Ik9oATjq_-G7V1AZSW8zKtSE,3121
 evalvault/adapters/outbound/analysis/root_cause_analyzer_module.py,sha256=UagHWb2d1vD7aCH0vLl3tSJx86gkkxNarrF-rwtEBhU,2811
@@ -280,7 +281,7 @@ evalvault/domain/services/memory_based_analysis.py,sha256=oh2irCy3le7fWiTtL31SME
 evalvault/domain/services/method_runner.py,sha256=pABqKZeaALpWZYDfzAbd-VOZt2djQggRNIPuuPQeUSw,3571
 evalvault/domain/services/ops_snapshot_service.py,sha256=1CqJN2p3tM6SgzLCZKcVEM213fd1cDGexTRPG_3e59w,5138
 evalvault/domain/services/pipeline_orchestrator.py,sha256=yriVlEVZYDtt0Vwt4Ae6xyW1H6Dj4Hxdn8XQSvQNSoQ,19436
-evalvault/domain/services/pipeline_template_registry.py,sha256=aWqXLQ24grpSZo9M4tZLRo1ysD10c6hUpW3JupZH9e0,28083
+evalvault/domain/services/pipeline_template_registry.py,sha256=k5Ce1BC3NgcYqCLiUZpXsl_6WwDHOXONoYDH7KzX2L4,28809
 evalvault/domain/services/prompt_candidate_service.py,sha256=Ibyb5EaWK28Ju2HnTqHHGOoiA9Q-VwY3hjxVODALwGY,3997
 evalvault/domain/services/prompt_manifest.py,sha256=5s5Kd6-_Dn-xrjjlU99CVo6njsPhvE50H5m_85U-H6U,5612
 evalvault/domain/services/prompt_registry.py,sha256=QyL4yIcKT93uv6L0-Q_iaNXno8QnsC19YcGekuSRMtE,5247
@@ -290,7 +291,7 @@ evalvault/domain/services/prompt_suggestion_reporter.py,sha256=Fc6sCPebUMk8SZVpj
 evalvault/domain/services/ragas_prompt_overrides.py,sha256=4BecYE2KrreUBbIM3ssP9WzHcK_wRc8jW7CE_k58QOU,1412
 evalvault/domain/services/regression_gate_service.py,sha256=qBMODgpizmEzqEL8_JX-FYSVyARiroMW7MFVzlz7gjc,6579
 evalvault/domain/services/retrieval_metrics.py,sha256=dtrQPLMrXSyWLcgF8EGcLNFwzwA59WDzEh41JRToHAY,2980
-evalvault/domain/services/retriever_context.py,sha256=ySQ-GuadiggS0LVAib4AxA_0JpasYz4S9hbjau0eyIA,6482
+evalvault/domain/services/retriever_context.py,sha256=TeJ9UgT4l3lXxOXcYMz_7PdVMlV7JsW2ewTXdv9dI2M,10185
 evalvault/domain/services/run_comparison_service.py,sha256=_NScltCRcY3zrvdyYDiPmssTxCDv1GyjCLdP3uAxJts,5631
 evalvault/domain/services/satisfaction_calibration_service.py,sha256=H7Z8opOyPHRO5qVIw-XDsNhIwdCteAS9_a3BTlfIqHg,11906
 evalvault/domain/services/stage_event_builder.py,sha256=FAT34Wmylvd2Yz5rDlhaTh1lqSCDhGApCXMi7Hjkib0,9748
@@ -339,8 +340,8 @@ evalvault/reports/__init__.py,sha256=Bb1X4871msAN8I6PM6nKGED3psPwZt88hXZBAOdH06Y
 evalvault/reports/release_notes.py,sha256=pZj0PBFT-4F_Ty-Kv5P69BuoOnmTCn4kznDcORFJd0w,4011
 evalvault/scripts/__init__.py,sha256=NwEeIFQbkX4ml2R_PhtIoNtArDSX_suuoymgG_7Kwso,89
 evalvault/scripts/regression_runner.py,sha256=SxZori5BZ8jVQ057Mf5V5FPgIVDccrV5oRONmnhuk8w,8438
-evalvault-1.68.1.dist-info/METADATA,sha256=BRG7UFXRx1fT_JDFqSsdOuB_nk_LVnaNSNYzVyYWyyU,26159
-evalvault-1.68.1.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-evalvault-1.68.1.dist-info/entry_points.txt,sha256=Oj9Xc5gYcyUYYNmQfWI8NYGw7nN-3M-h2ipHIMlVn6o,65
-evalvault-1.68.1.dist-info/licenses/LICENSE.md,sha256=3RNWY4jjtrQ_yYa-D-7I3XO12Ti7YzxsLV_dpykujvo,11358
-evalvault-1.68.1.dist-info/RECORD,,
+evalvault-1.70.0.dist-info/METADATA,sha256=Bm7z86HYTWoMfyTK9VpmxjNk-mhp2LHsIJ9Gt8s-onw,26159
+evalvault-1.70.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+evalvault-1.70.0.dist-info/entry_points.txt,sha256=Oj9Xc5gYcyUYYNmQfWI8NYGw7nN-3M-h2ipHIMlVn6o,65
+evalvault-1.70.0.dist-info/licenses/LICENSE.md,sha256=3RNWY4jjtrQ_yYa-D-7I3XO12Ti7YzxsLV_dpykujvo,11358
+evalvault-1.70.0.dist-info/RECORD,,