diff --git a/.gitignore b/.gitignore
index bf49b53bf..f817be47d 100644
--- a/.gitignore
+++ b/.gitignore
@@ -202,3 +202,4 @@ text2sql_logs
 # MLflow artifacts
 mlartifacts
 mlflow.db
+plan
diff --git a/CLAUDE.md b/CLAUDE.md
index 41f0f2c50..8d913a88f 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -218,3 +218,4 @@ analytics_logger.addHandler(console_handler)
   - **Minimal setup**: `[project.optional-dependencies].dev-minimal` for fast development (79 packages)
   - **Full setup**: `[dependency-groups].dev` for comprehensive development (383 packages)
 - Use `make install-minimal` for most development tasks, `make install` for full ML stack work
+- if the user asks you to save a plan, save it into the plan/ directory with an appropriate file name.
diff --git a/Makefile b/Makefile
index 9150843db..3e4b4fb19 100644
--- a/Makefile
+++ b/Makefile
@@ -52,11 +52,11 @@ install: ## Install full dependencies with uv sync (backward compatible - modern
 format: ## Format and lint all code
 	@echo "Formatting and linting all code..."
 	@echo "(ruff format) Formatting ragas..."
-	$(Q)uv run --active ruff format src tests docs --config pyproject.toml
+	$(Q)uv run --active ruff format src tests docs --exclude src/ragas/_version.py --config pyproject.toml
 	@echo "(ruff) Auto-fixing ragas (includes import sorting and unused imports)..."
-	$(Q)uv run --active ruff check src tests docs --fix-only --config pyproject.toml
+	$(Q)uv run --active ruff check src tests docs --exclude src/ragas/_version.py --fix-only --config pyproject.toml
 	@echo "(ruff) Final linting check for ragas..."
-	$(Q)uv run --active ruff check src tests docs --config pyproject.toml
+	$(Q)uv run --active ruff check src tests docs --exclude src/ragas/_version.py --config pyproject.toml
 
 type: ## Type check all code
 	@echo "Type checking all code..."
@@ -93,8 +93,8 @@ benchmarks-test: ## Run benchmarks for ragas unit tests
 run-ci: ## Run complete CI pipeline (mirrors GitHub CI exactly)
 	@echo "Running complete CI pipeline..."
 	@echo "Format check..."
-	$(Q)uv run --active ruff format --check src tests docs --config pyproject.toml
-	$(Q)uv run --active ruff check src tests docs --config pyproject.toml
+	$(Q)uv run --active ruff format --check src tests docs --exclude src/ragas/_version.py --config pyproject.toml
+	$(Q)uv run --active ruff check src tests docs --exclude src/ragas/_version.py --config pyproject.toml
 	@echo "Type check..."
 	$(Q)$(MAKE) type
 	@echo "Unit tests..."
@@ -104,8 +104,8 @@ run-ci: ## Run complete CI pipeline (mirrors GitHub CI exactly)
 run-ci-format-check: ## Run format check in dry-run mode (like GitHub CI)
 	@echo "Running format check (dry-run, like GitHub CI)..."
 	@echo "Checking ragas formatting..."
-	$(Q)uv run --active ruff format --check src tests docs --config pyproject.toml
-	$(Q)uv run --active ruff check src docs tests --config pyproject.toml
+	$(Q)uv run --active ruff format --check src tests docs --exclude src/ragas/_version.py --config pyproject.toml
+	$(Q)uv run --active ruff check src docs tests --exclude src/ragas/_version.py --config pyproject.toml
 
 run-ci-type: ## Run type checking (matches GitHub CI)
 	@echo "Running type checking (matches GitHub CI)..."
@@ -118,8 +118,8 @@ run-ci-tests: ## Run all tests with CI options
 run-ci-fast: ## Fast CI check for quick local validation (2-3 minutes)
 	@echo "Running fast CI check for quick feedback..."
 	@echo "Format check..."
-	$(Q)uv run --active ruff format --check src tests docs --config pyproject.toml
-	$(Q)uv run --active ruff check src docs tests --config pyproject.toml
+	$(Q)uv run --active ruff format --check src tests docs --exclude src/ragas/_version.py --config pyproject.toml
+	$(Q)uv run --active ruff check src docs tests --exclude src/ragas/_version.py --config pyproject.toml
 	@echo "Core unit tests (no nbmake for speed)..."
 	$(Q)uv run --active pytest tests/unit --dist loadfile -n auto -x
 	@echo "Fast CI check completed!"
diff --git a/tests/e2e/metrics_migration/base_migration_test.py b/tests/e2e/metrics_migration/base_migration_test.py
new file mode 100644
index 000000000..d8f1fcb4d
--- /dev/null
+++ b/tests/e2e/metrics_migration/base_migration_test.py
@@ -0,0 +1,197 @@
+"""Base test class for metrics migration E2E tests."""
+
+from typing import Any, Callable, Dict, List, Optional
+
+import pytest
+
+from .test_utils import (
+    assert_score_types,
+    compare_scores_with_tolerance,
+    create_legacy_sample,
+    print_score_comparison,
+    print_test_header,
+    print_test_success,
+)
+
+
+class BaseMigrationTest:
+    """Base class for metrics migration E2E tests.
+
+    Provides common functionality for testing compatibility between legacy and v2 implementations.
+    Subclasses should implement metric-specific test data and configurations.
+    """
+
+    @pytest.mark.asyncio
+    async def run_e2e_compatibility_test(
+        self,
+        sample_data: List[Dict[str, Any]],
+        legacy_metric_factory: Callable,
+        v2_metric_factory: Callable,
+        v2_score_method_name: str = "ascore",
+        legacy_components: Optional[Dict[str, Any]] = None,
+        v2_components: Optional[Dict[str, Any]] = None,
+        tolerance: float = 0.3,
+        metric_name: str = "Metric",
+        additional_info_keys: Optional[List[str]] = None,
+    ) -> None:
+        """Run E2E compatibility test between legacy and v2 implementations.
+
+        Args:
+            sample_data: List of test cases, each as a dictionary
+            legacy_metric_factory: Function to create legacy metric instance
+            v2_metric_factory: Function to create v2 metric instance
+            v2_score_method_name: Name of the scoring method on v2 metric
+            legacy_components: Components for legacy metric (llm, embeddings, etc.)
+            v2_components: Components for v2 metric (llm, embeddings, etc.)
+            tolerance: Maximum allowed score difference
+            metric_name: Name of the metric for display
+            additional_info_keys: Keys from data dict to display in test output
+        """
+        # Check if required components are available
+        if legacy_components:
+            if any(component is None for component in legacy_components.values()):
+                pytest.skip("Required components not available for E2E testing")
+
+        if v2_components:
+            if any(component is None for component in v2_components.values()):
+                pytest.skip("Required components not available for E2E testing")
+
+        # Create metric instances
+        legacy_metric = (
+            legacy_metric_factory(**legacy_components)
+            if legacy_components
+            else legacy_metric_factory()
+        )
+        v2_metric = (
+            v2_metric_factory(**v2_components) if v2_components else v2_metric_factory()
+        )
+
+        # Run tests for each sample
+        for i, data in enumerate(sample_data):
+            description = data.get("description", "No description")
+
+            # Prepare additional info for display
+            additional_info = {}
+            if additional_info_keys:
+                for key in additional_info_keys:
+                    if key in data:
+                        additional_info[key.replace("_", " ").title()] = str(data[key])
+
+            print_test_header(metric_name, i + 1, description, additional_info)
+
+            # Score with legacy implementation
+            legacy_sample = create_legacy_sample(data)
+            legacy_score = await legacy_metric._single_turn_ascore(legacy_sample, None)
+
+            # Score with v2 implementation
+            # Extract parameters for v2 scoring (exclude metadata keys)
+            v2_params = {k: v for k, v in data.items() if k != "description"}
+            v2_score_method = getattr(v2_metric, v2_score_method_name)
+            v2_result = await v2_score_method(**v2_params)
+
+            # Compare scores
+            print_score_comparison(legacy_score, v2_result.value)
+
+            # Assert scores are within tolerance
+            compare_scores_with_tolerance(
+                legacy_score,
+                v2_result.value,
+                tolerance,
+                description,
+                i + 1,
+            )
+
+            # Assert types and ranges
+            assert_score_types(legacy_score, v2_result)
+
+            print_test_success()
+
+    @pytest.mark.asyncio
+    async def run_metric_specific_test(
+        self,
+        test_cases: List[Dict[str, Any]],
+        legacy_metric_factory: Callable,
+        v2_metric_factory: Callable,
+        legacy_components: Optional[Dict[str, Any]] = None,
+        v2_components: Optional[Dict[str, Any]] = None,
+        test_name: str = "Metric Specific Test",
+        assertion_fn: Optional[Callable] = None,
+    ) -> None:
+        """Run a metric-specific test with custom assertions.
+
+        Args:
+            test_cases: List of test cases
+            legacy_metric_factory: Function to create legacy metric instance
+            v2_metric_factory: Function to create v2 metric instance
+            legacy_components: Components for legacy metric
+            v2_components: Components for v2 metric
+            test_name: Name of the test for display
+            assertion_fn: Optional custom assertion function that takes (case, legacy_score, v2_result)
+        """
+        # Check if required components are available
+        if legacy_components:
+            if any(component is None for component in legacy_components.values()):
+                pytest.skip("Required components not available for testing")
+
+        if v2_components:
+            if any(component is None for component in v2_components.values()):
+                pytest.skip("Required components not available for testing")
+
+        # Create metric instances
+        legacy_metric = (
+            legacy_metric_factory(**legacy_components)
+            if legacy_components
+            else legacy_metric_factory()
+        )
+        v2_metric = (
+            v2_metric_factory(**v2_components) if v2_components else v2_metric_factory()
+        )
+
+        # Run tests for each case
+        for case in test_cases:
+            description = case.get("description", "No description")
+            print(f"\n🎯 Testing {test_name}: {description}")
+
+            # Score with legacy implementation
+            legacy_sample = create_legacy_sample(case)
+            legacy_score = await legacy_metric._single_turn_ascore(legacy_sample, None)
+
+            # Score with v2 implementation
+            v2_params = {
+                k: v
+                for k, v in case.items()
+                if k not in ["description", "expected_high", "expected_low"]
+            }
+            v2_result = await v2_metric.ascore(**v2_params)
+
+            # Print scores
+            print_score_comparison(legacy_score, v2_result.value)
+
+            # Run custom assertions if provided
+            if assertion_fn:
+                assertion_fn(case, legacy_score, v2_result)
+            else:
+                # Default: just verify types
+                assert_score_types(legacy_score, v2_result)
+
+    def create_requirements_documentation(
+        self,
+        metric_name: str,
+        requirements: Dict[str, str],
+        test_file_name: str,
+    ) -> None:
+        """Print documentation about E2E test requirements.
+
+        Args:
+            metric_name: Name of the metric
+            requirements: Dictionary of requirements
+            test_file_name: Name of the test file
+        """
+        print(f"\n📋 {metric_name} E2E Test Requirements:")
+        for key, value in requirements.items():
+            print(f"   {key.capitalize()}: {value}")
+
+        print("\n🚀 To enable full E2E testing:")
+        print("   1. Configure required providers (e.g., export OPENAI_API_KEY=...)")
+        print("   2. Remove @pytest.mark.skip decorators")
+        print(f"   3. Run: pytest tests/e2e/metrics_migration/{test_file_name} -v -s")
diff --git a/tests/e2e/metrics_migration/conftest.py b/tests/e2e/metrics_migration/conftest.py
new file mode 100644
index 000000000..22dd7ead1
--- /dev/null
+++ b/tests/e2e/metrics_migration/conftest.py
@@ -0,0 +1,69 @@
+"""Common fixtures for metrics migration E2E tests.
+
+This module provides pytest fixtures that wrap the shared utility functions
+from tests.utils.llm_setup for use in E2E migration tests.
+"""
+
+import pytest
+
+from tests.utils import (
+    create_legacy_embeddings,
+    create_legacy_llm,
+    create_modern_embeddings,
+    create_modern_llm,
+)
+
+
+@pytest.fixture
+def legacy_llm():
+    """Create a test LLM for legacy metric evaluation.
+
+    Uses legacy llm_factory for legacy implementation.
+    Skips if LLM factory is not available or API key is missing.
+    """
+    try:
+        return create_legacy_llm("gpt-3.5-turbo")
+    except Exception as e:
+        pytest.skip(str(e))
+
+
+@pytest.fixture
+def modern_llm():
+    """Create a modern instructor LLM for v2 implementation.
+
+    Uses instructor_llm_factory with OpenAI client.
+    Skips if instructor LLM factory is not available or API key is missing.
+    """
+    try:
+        return create_modern_llm("openai", model="gpt-3.5-turbo")
+    except Exception as e:
+        pytest.skip(str(e))
+
+
+@pytest.fixture
+def legacy_embeddings():
+    """Create legacy embeddings for legacy implementation.
+
+    Uses legacy embedding_factory interface.
+    Skips if embedding factory is not available or API key is missing.
+    """
+    try:
+        return create_legacy_embeddings("text-embedding-ada-002")
+    except Exception as e:
+        pytest.skip(str(e))
+
+
+@pytest.fixture
+def modern_embeddings():
+    """Create modern embeddings for v2 implementation.
+
+    Uses modern interface with explicit provider and client.
+    Skips if OpenAI or embedding factory is not available or API key is missing.
+    """
+    try:
+        return create_modern_embeddings(
+            provider="openai",
+            model="text-embedding-ada-002",
+        )
+    except Exception as e:
+        pytest.skip(str(e))
diff --git a/tests/e2e/metrics_migration/metric_score_diff.ipynb b/tests/e2e/metrics_migration/metric_score_diff.ipynb
new file mode 100644
index 000000000..8ec16c5c5
--- /dev/null
+++ b/tests/e2e/metrics_migration/metric_score_diff.ipynb
@@ -0,0 +1,1293 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Metrics Migration Testing Notebook (General Purpose)\n",
+    "\n",
+    "This notebook provides a **generalized, reusable approach** for comparing legacy and modern metric implementations.\n",
+    "\n",
+    "## Quick Start\n",
+    "1. **Edit the Configuration Cell** (cell 2) with your metric details\n",
+    "2. Run all cells - no other modifications needed!\n",
+    "3. Works for ANY metric type: LLM-based, embeddings-based, or deterministic\n",
+    "\n",
+    "## Purpose\n",
+    "- **PRIMARY**: Validate migration on real-world datasets (amnesty_qa, fiqa)\n",
+    "- **SECONDARY**: Test specific edge cases and behaviors\n",
+    "- **FLEXIBLE**: Works with any metric configuration\n",
+    "\n",
+    "## Structure\n",
+    "1. Configuration (specify your metrics and requirements)\n",
+    "2. Setup and component creation\n",
+    "3. Dataset-based comparison (Amnesty QA)\n",
+    "4. FIQA dataset testing (domain generalization)\n",
+    "5. Optional: Different LLMs, edge cases\n",
+    "\n",
+    "Based on: `tests/e2e/plan-for-metrics-migration.md`"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "\n",
+    "# Ragas imports"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "✓ Configuration loaded - Edit above for your metric\n"
+     ]
+    }
+   ],
+   "source": [
+    "## ⚠️ CONFIGURATION CELL - EDIT THIS FOR YOUR METRIC ⚠️\n",
+    "\n",
+    "# Metric Configuration - Update these values for any metric\n",
+    "METRIC_CONFIG = {\n",
+    "    # ===== METRIC IMPORTS =====\n",
+    "    \"legacy_import\": {\n",
+    "        \"module\": \"ragas.metrics._answer_relevance\",  # e.g., \"ragas.metrics._context_recall\"\n",
+    "        \"class_name\": \"AnswerRelevancy\",  # e.g., \"ContextRecall\"\n",
+    "    },\n",
+    "    \"modern_import\": {\n",
+    "        \"module\": \"ragas.metrics.collections\",\n",
+    "        \"class_name\": \"AnswerRelevancy\",\n",
+    "    },\n",
+    "    # ===== COMPONENT REQUIREMENTS =====\n",
+    "    # Set to False if your metric doesn't need this component\n",
+    "    \"needs_llm\": True,\n",
+    "    \"needs_embeddings\": True,\n",
+    "    # ===== DATASET FIELD MAPPING =====\n",
+    "    # Which fields does your metric require from the dataset?\n",
+    "    # Choose ONE based on your metric type:\n",
+    "    # OPTION 1: Answer-based metrics (AnswerRelevancy, AnswerSimilarity, etc.)\n",
+    "    \"dataset_fields\": [\"user_input\", \"response\"],\n",
+    "    # OPTION 2: Context-based metrics (ContextRecall, ContextPrecision, etc.)\n",
+    "    # \"dataset_fields\": [\"user_input\", \"retrieved_contexts\", \"reference\"],\n",
+    "    # OPTION 3: Deterministic metrics (NonLLMContextRecall, etc.)\n",
+    "    # \"dataset_fields\": [\"retrieved_contexts\", \"reference_contexts\"],\n",
+    "    # \"needs_llm\": False,\n",
+    "    # \"needs_embeddings\": False,\n",
+    "}\n",
+    "\n",
+    "# ===== QUICK REFERENCE =====\n",
+    "# AnswerRelevancy: dataset_fields = [\"user_input\", \"response\"], needs_llm = True, needs_embeddings = True\n",
+    "# ContextRecall: dataset_fields = [\"user_input\", \"retrieved_contexts\", \"reference\"], needs_llm = True, needs_embeddings = False\n",
+    "# NonLLMContextRecall: dataset_fields = [\"retrieved_contexts\", \"reference_contexts\"], needs_llm = False, needs_embeddings = False\n",
+    "# ContextPrecision: dataset_fields = [\"user_input\", \"retrieved_contexts\", \"reference\"], needs_llm = True, needs_embeddings = False\n",
+    "\n",
+    "print(\"✓ Configuration loaded - Edit above for your metric\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "METRIC_CONFIG = {\n",
+    "    # ===== METRIC IMPORTS =====\n",
+    "    \"legacy_import\": {\n",
+    "        \"module\": \"ragas.metrics._context_precision\",\n",
+    "        \"class_name\": \"LLMContextPrecisionWithReference\",\n",
+    "    },\n",
+    "    \"modern_import\": {\n",
+    "        \"module\": \"ragas.metrics.collections\",\n",
+    "        \"class_name\": \"ContextPrecision\",\n",
+    "    },\n",
+    "    # ===== COMPONENT REQUIREMENTS =====\n",
+    "    \"needs_llm\": True,\n",
+    "    \"needs_embeddings\": False,\n",
+    "    # ===== DATASET FIELD MAPPING =====\n",
+    "    # Context-based metric using user_input, retrieved_contexts, and reference\n",
+    "    \"dataset_fields\": [\"user_input\", \"retrieved_contexts\", \"reference\"],\n",
+    "}"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Setup\n",
+    "\n",
+    "Make sure you have your OpenAI API key set as an environment variable before running this notebook."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import importlib\n",
+    "import sys\n",
+    "from pathlib import Path\n",
+    "\n",
+    "# Add project root to path\n",
+    "project_root = Path.cwd().parent.parent.parent\n",
+    "sys.path.insert(0, str(project_root))\n",
+    "\n",
+    "from tests.utils import check_api_key  # noqa: E402\n",
+    "\n",
+    "# Check for OpenAI API key\n",
+    "check_api_key(\"openai\")\n",
+    "print(\"✓ Setup complete\")\n",
+    "\n",
+    "\n",
+    "# ===== DYNAMIC METRIC LOADING =====\n",
+    "def load_metric_class(import_config):\n",
+    "    \"\"\"Dynamically load a metric class from module and class name.\"\"\"\n",
+    "    try:\n",
+    "        module = importlib.import_module(import_config[\"module\"])\n",
+    "        return getattr(module, import_config[\"class_name\"])\n",
+    "    except (ImportError, AttributeError) as e:\n",
+    "        raise ValueError(\n",
+    "            f\"Failed to load {import_config['class_name']} from {import_config['module']}: {e}\"\n",
+    "        )\n",
+    "\n",
+    "\n",
+    "# Load metric classes from config\n",
+    "LegacyMetric = load_metric_class(METRIC_CONFIG[\"legacy_import\"])\n",
+    "ModernMetric = load_metric_class(METRIC_CONFIG[\"modern_import\"])\n",
+    "\n",
+    "print(\"✓ Metric classes loaded:\")\n",
+    "print(\n",
+    "    f\"  Legacy: {METRIC_CONFIG['legacy_import']['class_name']} from {METRIC_CONFIG['legacy_import']['module']}\"\n",
+    ")\n",
+    "print(\n",
+    "    f\"  Modern: {METRIC_CONFIG['modern_import']['class_name']} from {METRIC_CONFIG['modern_import']['module']}\"\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Import Comparison Utilities\n",
+    "\n",
+    "The `compare_metrics` function is imported from `tests.utils` and provides:\n",
+    "- Concurrent processing for better performance\n",
+    "- Parallel or sequential metric execution\n",
+    "- Built-in result aggregation and statistics"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "✓ Comparison utilities loaded\n"
+     ]
+    }
+   ],
+   "source": [
+    "from tests.utils import compare_metrics\n",
+    "\n",
+    "print(\"✓ Comparison utilities loaded\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Create LLM and Embeddings Components\n",
+    "\n",
+    "Use shared test utilities to create legacy and modern components based on configuration."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "✓ LLM components created\n",
+      "✓ All required components created\n"
+     ]
+    }
+   ],
+   "source": [
+    "from tests.utils import (\n",
+    "    create_legacy_embeddings,\n",
+    "    create_legacy_llm,\n",
+    "    create_modern_embeddings,\n",
+    "    create_modern_llm,\n",
+    ")\n",
+    "\n",
+    "# ===== CREATE COMPONENTS BASED ON CONFIGURATION =====\n",
+    "components_config = {\n",
+    "    \"legacy_llm\": None,\n",
+    "    \"legacy_embeddings\": None,\n",
+    "    \"modern_llm\": None,\n",
+    "    \"modern_embeddings\": None,\n",
+    "}\n",
+    "\n",
+    "if METRIC_CONFIG[\"needs_llm\"]:\n",
+    "    components_config[\"legacy_llm\"] = create_legacy_llm(model=\"gpt-4o-mini\")\n",
+    "    components_config[\"modern_llm\"] = create_modern_llm(\n",
+    "        provider=\"openai\", model=\"gpt-4o-mini\"\n",
+    "    )\n",
+    "    print(\"✓ LLM components created\")\n",
+    "\n",
+    "if METRIC_CONFIG[\"needs_embeddings\"]:\n",
+    "    components_config[\"legacy_embeddings\"] = create_legacy_embeddings(\n",
+    "        model=\"text-embedding-ada-002\"\n",
+    "    )\n",
+    "    components_config[\"modern_embeddings\"] = create_modern_embeddings(\n",
+    "        provider=\"openai\", model=\"text-embedding-ada-002\"\n",
+    "    )\n",
+    "    print(\"✓ Embeddings components created\")\n",
+    "\n",
+    "print(\"✓ All required components created\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Initialize Metrics\n",
+    "\n",
+    "Uses the dynamically loaded metric classes and configured components."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "✓ Metrics initialized:\n",
+      "  Legacy: llm_context_precision_with_reference\n",
+      "  Modern: context_precision\n",
+      "  Dataset fields required: ['user_input', 'retrieved_contexts', 'reference']\n"
+     ]
+    }
+   ],
+   "source": [
+    "# ===== INITIALIZE METRICS DYNAMICALLY =====\n",
+    "def init_metric(metric_class, components_config, is_legacy=True):\n",
+    "    \"\"\"Initialize a metric with available components.\"\"\"\n",
+    "    prefix = \"legacy_\" if is_legacy else \"modern_\"\n",
+    "\n",
+    "    # Build kwargs from available components\n",
+    "    kwargs = {}\n",
+    "    if components_config[f\"{prefix}llm\"]:\n",
+    "        kwargs[\"llm\"] = components_config[f\"{prefix}llm\"]\n",
+    "    if components_config[f\"{prefix}embeddings\"]:\n",
+    "        kwargs[\"embeddings\"] = components_config[f\"{prefix}embeddings\"]\n",
+    "\n",
+    "    return metric_class(**kwargs)\n",
+    "\n",
+    "\n",
+    "# Initialize metrics\n",
+    "legacy_metric = init_metric(LegacyMetric, components_config, is_legacy=True)\n",
+    "modern_metric = init_metric(ModernMetric, components_config, is_legacy=False)\n",
+    "\n",
+    "# Display initialized metrics\n",
+    "legacy_name = getattr(legacy_metric, \"name\", legacy_metric.__class__.__name__)\n",
+    "modern_name = getattr(modern_metric, \"name\", modern_metric.__class__.__name__)\n",
+    "\n",
+    "print(\"✓ Metrics initialized:\")\n",
+    "print(f\"  Legacy: {legacy_name}\")\n",
+    "print(f\"  Modern: {modern_name}\")\n",
+    "print(f\"  Dataset fields required: {METRIC_CONFIG['dataset_fields']}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "---\n",
+    "\n",
+    "## PRIMARY: Dataset-Based Testing\n",
+    "\n",
+    "### Load Amnesty QA Dataset"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Loading amnesty_qa dataset...\n",
+      "✓ Loaded 20 samples from amnesty_qa\n",
+      "✓ Prepared 20 samples for testing\n",
+      "\n",
+      "First sample fields:\n",
+      "  user_input: What are the global implications of the USA Supreme Court ruling on abortion?...\n",
+      "  retrieved_contexts: 3 item(s)\n",
+      "  reference: The global implications of the USA Supreme Court ruling on abortion are signific...\n"
+     ]
+    }
+   ],
+   "source": [
+    "from tests.e2e.test_dataset_utils import load_amnesty_dataset_safe\n",
+    "\n",
+    "print(\"Loading amnesty_qa dataset...\")\n",
+    "amnesty_dataset = load_amnesty_dataset_safe(\"english_v3\")\n",
+    "print(f\"✓ Loaded {len(amnesty_dataset)} samples from amnesty_qa\")\n",
+    "\n",
+    "# Convert to format expected by metric using configured fields\n",
+    "amnesty_test_data = []\n",
+    "for i, sample in enumerate(amnesty_dataset):\n",
+    "    if i >= 20:  # Start with 20 samples, adjust as needed\n",
+    "        break\n",
+    "\n",
+    "    # Extract only configured fields\n",
+    "    test_sample = {}\n",
+    "    for field in METRIC_CONFIG[\"dataset_fields\"]:\n",
+    "        if field == \"reference_contexts\" and field not in sample:\n",
+    "            # Handle transform case: split retrieved_contexts\n",
+    "            retrieved_contexts = sample.get(\"retrieved_contexts\", [])\n",
+    "            if retrieved_contexts and len(retrieved_contexts) > 1:\n",
+    "                mid = len(retrieved_contexts) // 2\n",
+    "                test_sample[field] = retrieved_contexts[mid:]\n",
+    "        elif field in sample:\n",
+    "            test_sample[field] = sample[field]\n",
+    "        elif field == \"response\":\n",
+    "            # Default for response if not in sample\n",
+    "            test_sample[field] = sample.get(\"response\", \"\")\n",
+    "        elif field == \"reference\":\n",
+    "            # Rename reference_contexts to reference if needed\n",
+    "            test_sample[field] = sample.get(\n",
+    "                \"reference_contexts\", sample.get(\"reference\", \"\")\n",
+    "            )\n",
+    "\n",
+    "    if test_sample:  # Only add if we have data\n",
+    "        amnesty_test_data.append(test_sample)\n",
+    "\n",
+    "print(f\"✓ Prepared {len(amnesty_test_data)} samples for testing\")\n",
+    "if amnesty_test_data:\n",
+    "    print(\"\\nFirst sample fields:\")\n",
+    "    first_sample = amnesty_test_data[0]\n",
+    "    for key, value in first_sample.items():\n",
+    "        if isinstance(value, list):\n",
+    "            print(f\"  {key}: {len(value)} item(s)\")\n",
+    "        elif isinstance(value, str):\n",
+    "            print(f\"  {key}: {value[:80]}...\")\n",
+    "        else:\n",
+    "            print(f\"  {key}: {value}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Compare on Amnesty QA (Optimized & Parallel)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "======================================================================\n",
+      "AMNESTY QA DATASET COMPARISON\n",
+      "======================================================================\n",
+      "Dataset: 20 samples\n",
+      "Mode: Concurrent processing + Parallel metrics\n",
+      "======================================================================\n",
+      "Running both metrics in parallel on 20 samples (max 10 concurrent)...\n",
+      "============================================================\n",
+      "METRIC COMPARISON SUMMARY\n",
+      "============================================================\n",
+      "\n",
+      "Score Statistics:\n",
+      "  Old Metric Mean: 0.8583\n",
+      "  New Metric Mean: 0.8292\n",
+      "\n",
+      "Difference Statistics (new - old):\n",
+      "  Mean Diff:   -0.0292\n",
+      "  Max Diff:    0.4167\n",
+      "  Min Diff:    -0.5000\n",
+      "  Std Dev:     0.1565\n",
+      "\n",
+      "Execution Time:\n",
+      "  Old Metric:  10.74s\n",
+      "  New Metric:  10.18s\n",
+      "  Speedup:     1.06x\n",
+      "============================================================\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(\"\\n\" + \"=\" * 70)\n",
+    "print(\"AMNESTY QA DATASET COMPARISON\")\n",
+    "print(\"=\" * 70)\n",
+    "print(f\"Dataset: {len(amnesty_test_data)} samples\")\n",
+    "print(\"Mode: Concurrent processing + Parallel metrics\")\n",
+    "print(\"=\" * 70)\n",
+    "\n",
+    "amnesty_result = await compare_metrics(\n",
+    "    old_metric=legacy_metric,\n",
+    "    new_metric=modern_metric,\n",
+    "    dataset=amnesty_test_data,\n",
+    "    old_metric_type=\"old\",\n",
+    "    new_metric_type=\"new\",\n",
+    "    max_concurrent=10,\n",
+    "    parallel_metrics=True,\n",
+    ")\n",
+    "\n",
+    "amnesty_result.print_summary()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Analyze Amnesty QA Results in Detail\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "======================================================================\n",
+      "DETAILED STATISTICAL ANALYSIS\n",
+      "======================================================================\n",
+      "\n",
+      "Dataset: amnesty_qa (20 samples)\n",
+      "\n",
+      "Score Statistics:\n",
+      "  Legacy Mean:  0.8583\n",
+      "  New Mean:     0.8292\n",
+      "  Score Shift:  -0.0292\n",
+      "\n",
+      "Difference Statistics:\n",
+      "  Mean |Diff|:  0.0708\n",
+      "  Std Dev:      0.1565\n",
+      "  Max Diff:     0.4167\n",
+      "  Min Diff:     -0.5000\n",
+      "  Median Diff:  0.0000\n",
+      "\n",
+      "Tolerance Analysis:\n",
+      "  < 0.10:   15/20 ( 75.0%)\n",
+      "  < 0.15:   15/20 ( 75.0%)\n",
+      "  < 0.20:   18/20 ( 90.0%)\n",
+      "  < 0.25:   18/20 ( 90.0%)\n",
+      "  < 0.30:   18/20 ( 90.0%)\n",
+      "\n",
+      "======================================================================\n",
+      "TOP 10 LARGEST DIFFERENCES\n",
+      "======================================================================\n",
+      "\n",
+      "#4: What action did Amnesty International urge its supporters to...\n",
+      "  Legacy: 1.0000  |  New: 0.5000  |  Diff: 0.5000\n",
+      "\n",
+      "#20: When did the government of Qatar start repealing restriction...\n",
+      "  Legacy: 0.5833  |  New: 1.0000  |  Diff: 0.4167\n",
+      "\n",
+      "#7: Which right guarantees access to comprehensive information a...\n",
+      "  Legacy: 1.0000  |  New: 0.8333  |  Diff: 0.1667\n",
+      "\n",
+      "#12: What conditions designate wetlands as Ramsar sites?...\n",
+      "  Legacy: 1.0000  |  New: 0.8333  |  Diff: 0.1667\n",
+      "\n",
+      "#19: What labor abuses were documented by Amnesty International i...\n",
+      "  Legacy: 1.0000  |  New: 0.8333  |  Diff: 0.1667\n",
+      "\n",
+      "#10: When does the prosecution consider statements contrary to th...\n",
+      "  Legacy: 1.0000  |  New: 1.0000  |  Diff: 0.0000\n",
+      "\n",
+      "#1: What are the global implications of the USA Supreme Court ru...\n",
+      "  Legacy: 1.0000  |  New: 1.0000  |  Diff: 0.0000\n",
+      "\n",
+      "#2: Which companies are the main contributors to GHG emissions a...\n",
+      "  Legacy: 1.0000  |  New: 1.0000  |  Diff: 0.0000\n",
+      "\n",
+      "#3: Which private companies in the Americas are the largest GHG ...\n",
+      "  Legacy: 0.8333  |  New: 0.8333  |  Diff: 0.0000\n",
+      "\n",
+      "#5: What are the recommendations made by Amnesty International t...\n",
+      "  Legacy: 0.5833  |  New: 0.5833  |  Diff: 0.0000\n"
+     ]
+    }
+   ],
+   "source": [
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "# Get detailed DataFrame\n",
+    "df_amnesty = amnesty_result.to_dataframe()\n",
+    "df_amnesty[\"sample_idx\"] = range(len(df_amnesty))\n",
+    "\n",
+    "\n",
+    "# Create description from first available string field in your test data\n",
+    "def get_description(sample):\n",
+    "    \"\"\"Extract a short description from sample data.\"\"\"\n",
+    "    for key in [\"user_input\", \"response\", \"reference\", \"question\"]:\n",
+    "        if key in sample and isinstance(sample[key], str):\n",
+    "            return sample[key][:60] + \"...\"\n",
+    "    return f\"Sample with {len(sample)} fields\"\n",
+    "\n",
+    "\n",
+    "df_amnesty[\"description\"] = [get_description(s) for s in amnesty_test_data]\n",
+    "\n",
+    "# Statistical Analysis\n",
+    "print(\"\\n\" + \"=\" * 70)\n",
+    "print(\"DETAILED STATISTICAL ANALYSIS\")\n",
+    "print(\"=\" * 70)\n",
+    "print(f\"\\nDataset: amnesty_qa ({len(df_amnesty)} samples)\")\n",
+    "print(\"\\nScore Statistics:\")\n",
+    "print(f\"  Legacy Mean:  {amnesty_result.old_mean:.4f}\")\n",
+    "print(f\"  New Mean:     {amnesty_result.new_mean:.4f}\")\n",
+    "print(f\"  Score Shift:  {amnesty_result.mean_diff:+.4f}\")\n",
+    "\n",
+    "print(\"\\nDifference Statistics:\")\n",
+    "print(f\"  Mean |Diff|:  {df_amnesty['abs_diff'].mean():.4f}\")\n",
+    "print(f\"  Std Dev:      {amnesty_result.std_diff:.4f}\")\n",
+    "print(f\"  Max Diff:     {amnesty_result.max_diff:.4f}\")\n",
+    "print(f\"  Min Diff:     {amnesty_result.min_diff:.4f}\")\n",
+    "print(f\"  Median Diff:  {df_amnesty['abs_diff'].median():.4f}\")\n",
+    "\n",
+    "# Tolerance Analysis (adjust for your metric type)\n",
+    "# For LLM-based metrics: use [0.1, 0.15, 0.2, 0.25, 0.3]\n",
+    "# For deterministic metrics: use [1e-10, 1e-8, 1e-6, 1e-4, 0.01]\n",
+    "tolerance_levels = [0.1, 0.15, 0.2, 0.25, 0.3]\n",
+    "print(\"\\nTolerance Analysis:\")\n",
+    "for tol in tolerance_levels:\n",
+    "    within = (df_amnesty[\"abs_diff\"] < tol).sum()\n",
+    "    pct = within / len(df_amnesty) * 100\n",
+    "    print(f\"  < {tol:.2f}:  {within:3d}/{len(df_amnesty)} ({pct:5.1f}%)\")\n",
+    "\n",
+    "# Identify problematic cases\n",
+    "print(\"\\n\" + \"=\" * 70)\n",
+    "print(\"TOP 10 LARGEST DIFFERENCES\")\n",
+    "print(\"=\" * 70)\n",
+    "top_diffs = df_amnesty.nlargest(10, \"abs_diff\")\n",
+    "for idx, row in top_diffs.iterrows():\n",
+    "    print(f\"\\n#{row['sample_idx'] + 1}: {row['description']}\")\n",
+    "    print(\n",
+    "        f\"  Legacy: {row['old_score']:.4f}  |  New: {row['new_score']:.4f}  |  Diff: {row['abs_diff']:.4f}\"\n",
+    "    )"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/var/folders/2y/02fp70k56p75ldrkgtx7z10r0000gn/T/ipykernel_39797/1485780648.py:59: MatplotlibDeprecationWarning: The 'labels' parameter of boxplot() has been renamed 'tick_labels' since Matplotlib 3.9; support for the old name will be dropped in 3.11.\n",
+      "  ax5.boxplot([df_amnesty[\"old_score\"], df_amnesty[\"new_score\"]], labels=['Legacy', 'New'])\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1600x1200 with 7 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "### Visualize Amnesty QA Results\n",
+    "\n",
+    "# Comprehensive Visualization\n",
+    "fig = plt.figure(figsize=(16, 12))\n",
+    "gs = fig.add_gridspec(3, 3, hspace=0.3, wspace=0.3)\n",
+    "\n",
+    "# 1. Scatter: Legacy vs New scores\n",
+    "ax1 = fig.add_subplot(gs[0, 0])\n",
+    "ax1.scatter(df_amnesty[\"old_score\"], df_amnesty[\"new_score\"], alpha=0.5, s=30)\n",
+    "ax1.plot([0, 1], [0, 1], \"r--\", label=\"Perfect match\", linewidth=2)\n",
+    "ax1.set_xlabel(\"Legacy Score\", fontsize=10)\n",
+    "ax1.set_ylabel(\"New Score\", fontsize=10)\n",
+    "ax1.set_title(\"Score Correlation\", fontsize=12, fontweight=\"bold\")\n",
+    "ax1.legend()\n",
+    "ax1.grid(True, alpha=0.3)\n",
+    "ax1.set_xlim(-0.05, 1.05)\n",
+    "ax1.set_ylim(-0.05, 1.05)\n",
+    "\n",
+    "# 2. Histogram: Difference distribution\n",
+    "ax2 = fig.add_subplot(gs[0, 1])\n",
+    "ax2.hist(df_amnesty[\"diff\"], bins=40, alpha=0.7, edgecolor=\"black\")\n",
+    "ax2.axvline(x=0, color=\"r\", linestyle=\"--\", linewidth=2, label=\"Zero diff\")\n",
+    "ax2.axvline(\n",
+    "    x=df_amnesty[\"diff\"].mean(),\n",
+    "    color=\"g\",\n",
+    "    linestyle=\"--\",\n",
+    "    linewidth=2,\n",
+    "    label=f\"Mean: {df_amnesty['diff'].mean():.3f}\",\n",
+    ")\n",
+    "ax2.set_xlabel(\"Difference (New - Legacy)\", fontsize=10)\n",
+    "ax2.set_ylabel(\"Frequency\", fontsize=10)\n",
+    "ax2.set_title(\"Difference Distribution\", fontsize=12, fontweight=\"bold\")\n",
+    "ax2.legend()\n",
+    "ax2.grid(True, alpha=0.3)\n",
+    "\n",
+    "# 3. Histogram: Absolute difference (log scale for deterministic metrics)\n",
+    "ax3 = fig.add_subplot(gs[0, 2])\n",
+    "non_zero_diffs = df_amnesty[df_amnesty[\"abs_diff\"] > 0][\"abs_diff\"]\n",
+    "if len(non_zero_diffs) > 0:\n",
+    "    ax3.hist(\n",
+    "        np.log10(non_zero_diffs), bins=40, alpha=0.7, color=\"orange\", edgecolor=\"black\"\n",
+    "    )\n",
+    "    ax3.axvline(x=-10, color=\"r\", linestyle=\"--\", linewidth=2, label=\"1e-10 tolerance\")\n",
+    "    ax3.set_xlabel(\"Log10(Absolute Difference)\", fontsize=10)\n",
+    "else:\n",
+    "    ax3.text(\n",
+    "        0.5, 0.5, \"All differences are zero!\", ha=\"center\", va=\"center\", fontsize=12\n",
+    "    )\n",
+    "ax3.set_ylabel(\"Frequency\", fontsize=10)\n",
+    "ax3.set_title(\"Absolute Difference Distribution (Log)\", fontsize=12, fontweight=\"bold\")\n",
+    "ax3.legend()\n",
+    "ax3.grid(True, alpha=0.3)\n",
+    "\n",
+    "# 4. Line plot: Score trends\n",
+    "ax4 = fig.add_subplot(gs[1, :])\n",
+    "x = df_amnesty[\"sample_idx\"]\n",
+    "ax4.plot(x, df_amnesty[\"old_score\"], \"o-\", label=\"Legacy\", alpha=0.6, markersize=4)\n",
+    "ax4.plot(x, df_amnesty[\"new_score\"], \"s-\", label=\"New\", alpha=0.6, markersize=4)\n",
+    "ax4.set_xlabel(\"Sample Index\", fontsize=10)\n",
+    "ax4.set_ylabel(\"Score\", fontsize=10)\n",
+    "ax4.set_title(\"Score Trends Across Dataset\", fontsize=12, fontweight=\"bold\")\n",
+    "ax4.legend()\n",
+    "ax4.grid(True, alpha=0.3)\n",
+    "ax4.set_ylim(-0.05, 1.05)\n",
+    "\n",
+    "# 5. Box plots: Score distributions\n",
+    "ax5 = fig.add_subplot(gs[2, 0])\n",
+    "ax5.boxplot(\n",
+    "    [df_amnesty[\"old_score\"], df_amnesty[\"new_score\"]], labels=[\"Legacy\", \"New\"]\n",
+    ")\n",
+    "ax5.set_ylabel(\"Score\", fontsize=10)\n",
+    "ax5.set_title(\"Score Distribution Comparison\", fontsize=12, fontweight=\"bold\")\n",
+    "ax5.grid(True, alpha=0.3, axis=\"y\")\n",
+    "\n",
+    "# 6. Cumulative distribution of absolute differences\n",
+    "ax6 = fig.add_subplot(gs[2, 1])\n",
+    "sorted_diffs = np.sort(df_amnesty[\"abs_diff\"])\n",
+    "cumulative = np.arange(1, len(sorted_diffs) + 1) / len(sorted_diffs) * 100\n",
+    "ax6.plot(sorted_diffs, cumulative, linewidth=2)\n",
+    "ax6.axvline(x=0.2, color=\"r\", linestyle=\"--\", linewidth=2, label=\"0.2 tolerance\")\n",
+    "ax6.axhline(y=90, color=\"g\", linestyle=\"--\", linewidth=1, alpha=0.5, label=\"90%\")\n",
+    "ax6.set_xlabel(\"Absolute Difference\", fontsize=10)\n",
+    "ax6.set_ylabel(\"Cumulative Percentage\", fontsize=10)\n",
+    "ax6.set_title(\"Cumulative Distribution\", fontsize=12, fontweight=\"bold\")\n",
+    "ax6.set_xscale(\"log\")\n",
+    "ax6.legend()\n",
+    "ax6.grid(True, alpha=0.3)\n",
+    "\n",
+    "# 7. Scatter: Difference vs Legacy score\n",
+    "ax7 = fig.add_subplot(gs[2, 2])\n",
+    "ax7.scatter(df_amnesty[\"old_score\"], df_amnesty[\"abs_diff\"], alpha=0.5, s=30)\n",
+    "ax7.axhline(y=0.2, color=\"r\", linestyle=\"--\", linewidth=2, label=\"0.2 tolerance\")\n",
+    "ax7.set_xlabel(\"Legacy Score\", fontsize=10)\n",
+    "ax7.set_ylabel(\"Absolute Difference\", fontsize=10)\n",
+    "ax7.set_title(\"Difference vs Score\", fontsize=12, fontweight=\"bold\")\n",
+    "ax7.set_yscale(\"log\")\n",
+    "ax7.legend()\n",
+    "ax7.grid(True, alpha=0.3)\n",
+    "\n",
+    "plt.suptitle(\n",
+    "    f\"Amnesty QA Migration Analysis ({len(df_amnesty)} samples)\",\n",
+    "    fontsize=14,\n",
+    "    fontweight=\"bold\",\n",
+    "    y=0.995,\n",
+    ")\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "🎯 AMNESTY QA VALIDATION COMPLETE\n",
+      "======================================================================\n",
+      "   Mean |Diff|: 0.0708\n",
+      "   Within 0.2:  18/20 (90.0%)\n",
+      "   Within 0.3:  18/20 (90.0%)\n",
+      "\n",
+      "📊 Validation Criteria (LLM-based metrics):\n",
+      "   ✅ Mean |diff| < 0.15: 0.0708\n",
+      "   ⚠️ >90% within 0.2: 90.0%\n",
+      "   ⚠️ >95% within 0.3: 90.0%\n",
+      "   ✅ No systematic bias (|mean diff| < 0.05): 0.0292\n",
+      "\n",
+      "💡 For deterministic metrics, use stricter criteria:\n",
+      "   - Mean |diff| < 1e-10\n",
+      "   - 100% within 1e-10\n"
+     ]
+    }
+   ],
+   "source": [
+    "### Validate Amnesty QA Results\n",
+    "\n",
+    "print(\"🎯 AMNESTY QA VALIDATION COMPLETE\")\n",
+    "print(\"=\" * 70)\n",
+    "print(f\"   Mean |Diff|: {df_amnesty['abs_diff'].mean():.4f}\")\n",
+    "print(\n",
+    "    f\"   Within 0.2:  {(df_amnesty['abs_diff'] < 0.2).sum()}/{len(df_amnesty)} \"\n",
+    "    f\"({(df_amnesty['abs_diff'] < 0.2).sum() / len(df_amnesty) * 100:.1f}%)\"\n",
+    ")\n",
+    "print(\n",
+    "    f\"   Within 0.3:  {(df_amnesty['abs_diff'] < 0.3).sum()}/{len(df_amnesty)} \"\n",
+    "    f\"({(df_amnesty['abs_diff'] < 0.3).sum() / len(df_amnesty) * 100:.1f}%)\"\n",
+    ")\n",
+    "\n",
+    "# Validation criteria for LLM-based metrics\n",
+    "# For deterministic metrics, use stricter tolerances (1e-10, 1e-6)\n",
+    "mean_abs_diff = df_amnesty[\"abs_diff\"].mean()\n",
+    "pct_within_02 = (df_amnesty[\"abs_diff\"] < 0.2).sum() / len(df_amnesty) * 100\n",
+    "pct_within_03 = (df_amnesty[\"abs_diff\"] < 0.3).sum() / len(df_amnesty) * 100\n",
+    "\n",
+    "print(\"\\n📊 Validation Criteria (LLM-based metrics):\")\n",
+    "print(\n",
+    "    f\"   {'✅' if mean_abs_diff < 0.15 else '❌'} Mean |diff| < 0.15: {mean_abs_diff:.4f}\"\n",
+    ")\n",
+    "print(f\"   {'✅' if pct_within_02 > 90 else '⚠️'} >90% within 0.2: {pct_within_02:.1f}%\")\n",
+    "print(f\"   {'✅' if pct_within_03 > 95 else '⚠️'} >95% within 0.3: {pct_within_03:.1f}%\")\n",
+    "print(\n",
+    "    f\"   {'✅' if abs(amnesty_result.mean_diff) < 0.05 else '⚠️'} \"\n",
+    "    f\"No systematic bias (|mean diff| < 0.05): {abs(amnesty_result.mean_diff):.4f}\"\n",
+    ")\n",
+    "\n",
+    "print(\"\\n💡 For deterministic metrics, use stricter criteria:\")\n",
+    "print(\"   - Mean |diff| < 1e-10\")\n",
+    "print(\"   - 100% within 1e-10\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "---\n",
+    "\n",
+    "## FIQA Dataset Testing (Domain Generalization)\n",
+    "\n",
+    "Test on financial Q&A dataset to validate metric works across different domains."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "======================================================================\n",
+      "FIQA DATASET COMPARISON\n",
+      "======================================================================\n",
+      "Testing on financial Q&A dataset for domain generalization...\n",
+      "✓ Loaded 30 samples from fiqa\n",
+      "✓ Prepared 30 samples for testing\n",
+      "\n",
+      "First sample fields:\n",
+      "  user_input: How to deposit a cheque issued to an associate in my business into my business a...\n",
+      "  retrieved_contexts: 1 item(s)\n",
+      "  reference: [\"Have the check reissued to the proper payee.Just have the associate sign the b...\n"
+     ]
+    }
+   ],
+   "source": [
+    "### Load FIQA Dataset\n",
+    "\n",
+    "from tests.e2e.test_dataset_utils import load_fiqa_dataset_safe\n",
+    "\n",
+    "print(\"\\n\" + \"=\" * 70)\n",
+    "print(\"FIQA DATASET COMPARISON\")\n",
+    "print(\"=\" * 70)\n",
+    "print(\"Testing on financial Q&A dataset for domain generalization...\")\n",
+    "\n",
+    "fiqa_dataset = load_fiqa_dataset_safe(\"ragas_eval_v3\")\n",
+    "print(f\"✓ Loaded {len(fiqa_dataset)} samples from fiqa\")\n",
+    "\n",
+    "# Convert to format expected by metric using configured fields\n",
+    "fiqa_test_data = []\n",
+    "for i, sample in enumerate(fiqa_dataset):\n",
+    "    if i >= 30:  # Use up to 30 samples from ragas_eval_v3\n",
+    "        break\n",
+    "\n",
+    "    # Extract only configured fields (same logic as Amnesty QA)\n",
+    "    test_sample = {}\n",
+    "    for field in METRIC_CONFIG[\"dataset_fields\"]:\n",
+    "        if field == \"reference_contexts\" and field not in sample:\n",
+    "            # Handle transform case: split retrieved_contexts\n",
+    "            retrieved_contexts = sample.get(\"retrieved_contexts\", [])\n",
+    "            if retrieved_contexts and len(retrieved_contexts) > 1:\n",
+    "                mid = len(retrieved_contexts) // 2\n",
+    "                test_sample[field] = retrieved_contexts[mid:]\n",
+    "            elif retrieved_contexts:\n",
+    "                test_sample[field] = retrieved_contexts\n",
+    "        elif field in sample:\n",
+    "            test_sample[field] = sample[field]\n",
+    "        elif field == \"response\":\n",
+    "            test_sample[field] = sample.get(\"response\", \"\")\n",
+    "        elif field == \"reference\":\n",
+    "            test_sample[field] = sample.get(\n",
+    "                \"reference_contexts\", sample.get(\"reference\", \"\")\n",
+    "            )\n",
+    "\n",
+    "    if test_sample:  # Only add if we have data\n",
+    "        fiqa_test_data.append(test_sample)\n",
+    "\n",
+    "print(f\"✓ Prepared {len(fiqa_test_data)} samples for testing\")\n",
+    "if fiqa_test_data:\n",
+    "    print(\"\\nFirst sample fields:\")\n",
+    "    first_sample = fiqa_test_data[0]\n",
+    "    for key, value in first_sample.items():\n",
+    "        if isinstance(value, list):\n",
+    "            print(f\"  {key}: {len(value)} item(s)\")\n",
+    "        elif isinstance(value, str):\n",
+    "            print(f\"  {key}: {value[:80]}...\")\n",
+    "        else:\n",
+    "            print(f\"  {key}: {value}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "======================================================================\n",
+      "Dataset: 30 samples\n",
+      "Mode: Concurrent processing + Parallel metrics\n",
+      "======================================================================\n",
+      "Running both metrics in parallel on 30 samples (max 10 concurrent)...\n",
+      "============================================================\n",
+      "METRIC COMPARISON SUMMARY\n",
+      "============================================================\n",
+      "\n",
+      "Score Statistics:\n",
+      "  Old Metric Mean: 0.8667\n",
+      "  New Metric Mean: 0.8667\n",
+      "\n",
+      "Difference Statistics (new - old):\n",
+      "  Mean Diff:   0.0000\n",
+      "  Max Diff:    1.0000\n",
+      "  Min Diff:    -1.0000\n",
+      "  Std Dev:     0.2582\n",
+      "\n",
+      "Execution Time:\n",
+      "  Old Metric:  5.70s\n",
+      "  New Metric:  6.35s\n",
+      "  Speedup:     0.90x\n",
+      "============================================================\n"
+     ]
+    }
+   ],
+   "source": [
+    "### Compare on FIQA (Optimized & Parallel)\n",
+    "\n",
+    "print(\"\\n\" + \"=\" * 70)\n",
+    "print(f\"Dataset: {len(fiqa_test_data)} samples\")\n",
+    "print(\"Mode: Concurrent processing + Parallel metrics\")\n",
+    "print(\"=\" * 70)\n",
+    "\n",
+    "fiqa_result = await compare_metrics(\n",
+    "    old_metric=legacy_metric,\n",
+    "    new_metric=modern_metric,\n",
+    "    dataset=fiqa_test_data,\n",
+    "    old_metric_type=\"old\",\n",
+    "    new_metric_type=\"new\",\n",
+    "    max_concurrent=10,\n",
+    "    parallel_metrics=True,\n",
+    ")\n",
+    "\n",
+    "fiqa_result.print_summary()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "======================================================================\n",
+      "DETAILED STATISTICAL ANALYSIS\n",
+      "======================================================================\n",
+      "\n",
+      "Dataset: fiqa (30 samples)\n",
+      "\n",
+      "Score Statistics:\n",
+      "  Legacy Mean:  0.8667\n",
+      "  New Mean:     0.8667\n",
+      "  Score Shift:  +0.0000\n",
+      "\n",
+      "Difference Statistics:\n",
+      "  Mean |Diff|:  0.0667\n",
+      "  Std Dev:      0.2582\n",
+      "  Max Diff:     1.0000\n",
+      "  Min Diff:     -1.0000\n",
+      "  Median Diff:  0.0000\n",
+      "\n",
+      "Tolerance Analysis:\n",
+      "  < 0.10:   28/30 ( 93.3%)\n",
+      "  < 0.15:   28/30 ( 93.3%)\n",
+      "  < 0.20:   28/30 ( 93.3%)\n",
+      "  < 0.25:   28/30 ( 93.3%)\n",
+      "  < 0.30:   28/30 ( 93.3%)\n",
+      "\n",
+      "======================================================================\n",
+      "TOP 10 LARGEST DIFFERENCES\n",
+      "======================================================================\n",
+      "\n",
+      "#5: 401k Transfer After Business Closure...\n",
+      "  Legacy: 1.0000  |  New: 0.0000  |  Diff: 1.0000\n",
+      "\n",
+      "#24: Employer options when setting up 401k for employees...\n",
+      "  Legacy: 0.0000  |  New: 1.0000  |  Diff: 1.0000\n",
+      "\n",
+      "#1: How to deposit a cheque issued to an associate in my busines...\n",
+      "  Legacy: 1.0000  |  New: 1.0000  |  Diff: 0.0000\n",
+      "\n",
+      "#2: Can I send a money order from USPS as a business?...\n",
+      "  Legacy: 1.0000  |  New: 1.0000  |  Diff: 0.0000\n",
+      "\n",
+      "#3: 1 EIN doing business under multiple business names...\n",
+      "  Legacy: 1.0000  |  New: 1.0000  |  Diff: 0.0000\n",
+      "\n",
+      "#4: Applying for and receiving business credit...\n",
+      "  Legacy: 1.0000  |  New: 1.0000  |  Diff: 0.0000\n",
+      "\n",
+      "#6: What are the ins/outs of writing equipment purchases off as ...\n",
+      "  Legacy: 1.0000  |  New: 1.0000  |  Diff: 0.0000\n",
+      "\n",
+      "#7: Can a entrepreneur hire a self-employed business owner?...\n",
+      "  Legacy: 1.0000  |  New: 1.0000  |  Diff: 0.0000\n",
+      "\n",
+      "#8: Intentions of Deductible Amount for Small Business...\n",
+      "  Legacy: 0.0000  |  New: 0.0000  |  Diff: 0.0000\n",
+      "\n",
+      "#9: How can I deposit a check made out to my business into my pe...\n",
+      "  Legacy: 1.0000  |  New: 1.0000  |  Diff: 0.0000\n"
+     ]
+    }
+   ],
+   "source": [
+    "### Analyze FIQA Results in Detail\n",
+    "\n",
+    "# Get detailed DataFrame\n",
+    "df_fiqa = fiqa_result.to_dataframe()\n",
+    "df_fiqa[\"sample_idx\"] = range(len(df_fiqa))\n",
+    "df_fiqa[\"description\"] = [get_description(s) for s in fiqa_test_data]\n",
+    "\n",
+    "# Statistical Analysis\n",
+    "print(\"\\n\" + \"=\" * 70)\n",
+    "print(\"DETAILED STATISTICAL ANALYSIS\")\n",
+    "print(\"=\" * 70)\n",
+    "print(f\"\\nDataset: fiqa ({len(df_fiqa)} samples)\")\n",
+    "print(\"\\nScore Statistics:\")\n",
+    "print(f\"  Legacy Mean:  {fiqa_result.old_mean:.4f}\")\n",
+    "print(f\"  New Mean:     {fiqa_result.new_mean:.4f}\")\n",
+    "print(f\"  Score Shift:  {fiqa_result.mean_diff:+.4f}\")\n",
+    "\n",
+    "print(\"\\nDifference Statistics:\")\n",
+    "print(f\"  Mean |Diff|:  {df_fiqa['abs_diff'].mean():.4f}\")\n",
+    "print(f\"  Std Dev:      {fiqa_result.std_diff:.4f}\")\n",
+    "print(f\"  Max Diff:     {fiqa_result.max_diff:.4f}\")\n",
+    "print(f\"  Min Diff:     {fiqa_result.min_diff:.4f}\")\n",
+    "print(f\"  Median Diff:  {df_fiqa['abs_diff'].median():.4f}\")\n",
+    "\n",
+    "# Tolerance Analysis (adjust for your metric type)\n",
+    "# For LLM-based metrics: use [0.1, 0.15, 0.2, 0.25, 0.3]\n",
+    "# For deterministic metrics: use [1e-10, 1e-8, 1e-6, 1e-4, 0.01]\n",
+    "tolerance_levels = [0.1, 0.15, 0.2, 0.25, 0.3]\n",
+    "print(\"\\nTolerance Analysis:\")\n",
+    "for tol in tolerance_levels:\n",
+    "    within = (df_fiqa[\"abs_diff\"] < tol).sum()\n",
+    "    pct = within / len(df_fiqa) * 100\n",
+    "    print(f\"  < {tol:.2f}:  {within:3d}/{len(df_fiqa)} ({pct:5.1f}%)\")\n",
+    "\n",
+    "# Identify problematic cases\n",
+    "print(\"\\n\" + \"=\" * 70)\n",
+    "print(\"TOP 10 LARGEST DIFFERENCES\")\n",
+    "print(\"=\" * 70)\n",
+    "top_diffs = df_fiqa.nlargest(10, \"abs_diff\")\n",
+    "for idx, row in top_diffs.iterrows():\n",
+    "    print(f\"\\n#{row['sample_idx'] + 1}: {row['description']}\")\n",
+    "    print(\n",
+    "        f\"  Legacy: {row['old_score']:.4f}  |  New: {row['new_score']:.4f}  |  Diff: {row['abs_diff']:.4f}\"\n",
+    "    )"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/var/folders/2y/02fp70k56p75ldrkgtx7z10r0000gn/T/ipykernel_39797/2878535787.py:59: MatplotlibDeprecationWarning: The 'labels' parameter of boxplot() has been renamed 'tick_labels' since Matplotlib 3.9; support for the old name will be dropped in 3.11.\n",
+      "  ax5.boxplot([df_fiqa[\"old_score\"], df_fiqa[\"new_score\"]], labels=['Legacy', 'New'])\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1600x1200 with 7 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "### Visualize FIQA Results\n",
+    "\n",
+    "# Comprehensive Visualization\n",
+    "fig = plt.figure(figsize=(16, 12))\n",
+    "gs = fig.add_gridspec(3, 3, hspace=0.3, wspace=0.3)\n",
+    "\n",
+    "# 1. Scatter: Legacy vs New scores\n",
+    "ax1 = fig.add_subplot(gs[0, 0])\n",
+    "ax1.scatter(df_fiqa[\"old_score\"], df_fiqa[\"new_score\"], alpha=0.5, s=30)\n",
+    "ax1.plot([0, 1], [0, 1], \"r--\", label=\"Perfect match\", linewidth=2)\n",
+    "ax1.set_xlabel(\"Legacy Score\", fontsize=10)\n",
+    "ax1.set_ylabel(\"New Score\", fontsize=10)\n",
+    "ax1.set_title(\"Score Correlation\", fontsize=12, fontweight=\"bold\")\n",
+    "ax1.legend()\n",
+    "ax1.grid(True, alpha=0.3)\n",
+    "ax1.set_xlim(-0.05, 1.05)\n",
+    "ax1.set_ylim(-0.05, 1.05)\n",
+    "\n",
+    "# 2. Histogram: Difference distribution\n",
+    "ax2 = fig.add_subplot(gs[0, 1])\n",
+    "ax2.hist(df_fiqa[\"diff\"], bins=40, alpha=0.7, edgecolor=\"black\")\n",
+    "ax2.axvline(x=0, color=\"r\", linestyle=\"--\", linewidth=2, label=\"Zero diff\")\n",
+    "ax2.axvline(\n",
+    "    x=df_fiqa[\"diff\"].mean(),\n",
+    "    color=\"g\",\n",
+    "    linestyle=\"--\",\n",
+    "    linewidth=2,\n",
+    "    label=f\"Mean: {df_fiqa['diff'].mean():.3f}\",\n",
+    ")\n",
+    "ax2.set_xlabel(\"Difference (New - Legacy)\", fontsize=10)\n",
+    "ax2.set_ylabel(\"Frequency\", fontsize=10)\n",
+    "ax2.set_title(\"Difference Distribution\", fontsize=12, fontweight=\"bold\")\n",
+    "ax2.legend()\n",
+    "ax2.grid(True, alpha=0.3)\n",
+    "\n",
+    "# 3. Histogram: Absolute difference (log scale for deterministic metrics)\n",
+    "ax3 = fig.add_subplot(gs[0, 2])\n",
+    "non_zero_diffs = df_fiqa[df_fiqa[\"abs_diff\"] > 0][\"abs_diff\"]\n",
+    "if len(non_zero_diffs) > 0:\n",
+    "    ax3.hist(\n",
+    "        np.log10(non_zero_diffs), bins=40, alpha=0.7, color=\"orange\", edgecolor=\"black\"\n",
+    "    )\n",
+    "    ax3.axvline(x=-10, color=\"r\", linestyle=\"--\", linewidth=2, label=\"1e-10 tolerance\")\n",
+    "    ax3.set_xlabel(\"Log10(Absolute Difference)\", fontsize=10)\n",
+    "else:\n",
+    "    ax3.text(\n",
+    "        0.5, 0.5, \"All differences are zero!\", ha=\"center\", va=\"center\", fontsize=12\n",
+    "    )\n",
+    "ax3.set_ylabel(\"Frequency\", fontsize=10)\n",
+    "ax3.set_title(\"Absolute Difference Distribution (Log)\", fontsize=12, fontweight=\"bold\")\n",
+    "ax3.legend()\n",
+    "ax3.grid(True, alpha=0.3)\n",
+    "\n",
+    "# 4. Line plot: Score trends\n",
+    "ax4 = fig.add_subplot(gs[1, :])\n",
+    "x = df_fiqa[\"sample_idx\"]\n",
+    "ax4.plot(x, df_fiqa[\"old_score\"], \"o-\", label=\"Legacy\", alpha=0.6, markersize=4)\n",
+    "ax4.plot(x, df_fiqa[\"new_score\"], \"s-\", label=\"New\", alpha=0.6, markersize=4)\n",
+    "ax4.set_xlabel(\"Sample Index\", fontsize=10)\n",
+    "ax4.set_ylabel(\"Score\", fontsize=10)\n",
+    "ax4.set_title(\"Score Trends Across Dataset\", fontsize=12, fontweight=\"bold\")\n",
+    "ax4.legend()\n",
+    "ax4.grid(True, alpha=0.3)\n",
+    "ax4.set_ylim(-0.05, 1.05)\n",
+    "\n",
+    "# 5. Box plots: Score distributions\n",
+    "ax5 = fig.add_subplot(gs[2, 0])\n",
+    "ax5.boxplot([df_fiqa[\"old_score\"], df_fiqa[\"new_score\"]], labels=[\"Legacy\", \"New\"])\n",
+    "ax5.set_ylabel(\"Score\", fontsize=10)\n",
+    "ax5.set_title(\"Score Distribution Comparison\", fontsize=12, fontweight=\"bold\")\n",
+    "ax5.grid(True, alpha=0.3, axis=\"y\")\n",
+    "\n",
+    "# 6. Cumulative distribution of absolute differences\n",
+    "ax6 = fig.add_subplot(gs[2, 1])\n",
+    "sorted_diffs = np.sort(df_fiqa[\"abs_diff\"])\n",
+    "cumulative = np.arange(1, len(sorted_diffs) + 1) / len(sorted_diffs) * 100\n",
+    "ax6.plot(sorted_diffs, cumulative, linewidth=2)\n",
+    "ax6.axvline(x=0.2, color=\"r\", linestyle=\"--\", linewidth=2, label=\"0.2 tolerance\")\n",
+    "ax6.axhline(y=90, color=\"g\", linestyle=\"--\", linewidth=1, alpha=0.5, label=\"90%\")\n",
+    "ax6.set_xlabel(\"Absolute Difference\", fontsize=10)\n",
+    "ax6.set_ylabel(\"Cumulative Percentage\", fontsize=10)\n",
+    "ax6.set_title(\"Cumulative Distribution\", fontsize=12, fontweight=\"bold\")\n",
+    "ax6.set_xscale(\"log\")\n",
+    "ax6.legend()\n",
+    "ax6.grid(True, alpha=0.3)\n",
+    "\n",
+    "# 7. Scatter: Difference vs Legacy score\n",
+    "ax7 = fig.add_subplot(gs[2, 2])\n",
+    "ax7.scatter(df_fiqa[\"old_score\"], df_fiqa[\"abs_diff\"], alpha=0.5, s=30)\n",
+    "ax7.axhline(y=0.2, color=\"r\", linestyle=\"--\", linewidth=2, label=\"0.2 tolerance\")\n",
+    "ax7.set_xlabel(\"Legacy Score\", fontsize=10)\n",
+    "ax7.set_ylabel(\"Absolute Difference\", fontsize=10)\n",
+    "ax7.set_title(\"Difference vs Score\", fontsize=12, fontweight=\"bold\")\n",
+    "ax7.set_yscale(\"log\")\n",
+    "ax7.legend()\n",
+    "ax7.grid(True, alpha=0.3)\n",
+    "\n",
+    "plt.suptitle(\n",
+    "    f\"FIQA Migration Analysis ({len(df_fiqa)} samples)\",\n",
+    "    fontsize=14,\n",
+    "    fontweight=\"bold\",\n",
+    "    y=0.995,\n",
+    ")\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "🎯 FIQA VALIDATION COMPLETE\n",
+      "======================================================================\n",
+      "   Mean |Diff|: 0.0667\n",
+      "   Within 0.2:  28/30 (93.3%)\n",
+      "   Within 0.3:  28/30 (93.3%)\n",
+      "\n",
+      "📊 Validation Criteria (LLM-based metrics):\n",
+      "   ✅ Mean |diff| < 0.15: 0.0667\n",
+      "   ✅ >90% within 0.2: 93.3%\n",
+      "   ⚠️ >95% within 0.3: 93.3%\n",
+      "   ✅ No systematic bias (|mean diff| < 0.05): 0.0000\n",
+      "\n",
+      "💡 Domain Generalization Check:\n",
+      "   ✅ Amnesty QA Mean |Diff|: 0.0708\n",
+      "   ✅ FIQA Mean |Diff|:       0.0667\n",
+      "   ✅ Consistent across domains\n"
+     ]
+    }
+   ],
+   "source": [
+    "### Validate FIQA Results\n",
+    "\n",
+    "print(\"🎯 FIQA VALIDATION COMPLETE\")\n",
+    "print(\"=\" * 70)\n",
+    "print(f\"   Mean |Diff|: {df_fiqa['abs_diff'].mean():.4f}\")\n",
+    "print(\n",
+    "    f\"   Within 0.2:  {(df_fiqa['abs_diff'] < 0.2).sum()}/{len(df_fiqa)} \"\n",
+    "    f\"({(df_fiqa['abs_diff'] < 0.2).sum() / len(df_fiqa) * 100:.1f}%)\"\n",
+    ")\n",
+    "print(\n",
+    "    f\"   Within 0.3:  {(df_fiqa['abs_diff'] < 0.3).sum()}/{len(df_fiqa)} \"\n",
+    "    f\"({(df_fiqa['abs_diff'] < 0.3).sum() / len(df_fiqa) * 100:.1f}%)\"\n",
+    ")\n",
+    "\n",
+    "# Validation criteria for LLM-based metrics\n",
+    "mean_abs_diff = df_fiqa[\"abs_diff\"].mean()\n",
+    "pct_within_02 = (df_fiqa[\"abs_diff\"] < 0.2).sum() / len(df_fiqa) * 100\n",
+    "pct_within_03 = (df_fiqa[\"abs_diff\"] < 0.3).sum() / len(df_fiqa) * 100\n",
+    "\n",
+    "print(\"\\n📊 Validation Criteria (LLM-based metrics):\")\n",
+    "print(\n",
+    "    f\"   {'✅' if mean_abs_diff < 0.15 else '❌'} Mean |diff| < 0.15: {mean_abs_diff:.4f}\"\n",
+    ")\n",
+    "print(f\"   {'✅' if pct_within_02 > 90 else '⚠️'} >90% within 0.2: {pct_within_02:.1f}%\")\n",
+    "print(f\"   {'✅' if pct_within_03 > 95 else '⚠️'} >95% within 0.3: {pct_within_03:.1f}%\")\n",
+    "print(\n",
+    "    f\"   {'✅' if abs(fiqa_result.mean_diff) < 0.05 else '⚠️'} \"\n",
+    "    f\"No systematic bias (|mean diff| < 0.05): {abs(fiqa_result.mean_diff):.4f}\"\n",
+    ")\n",
+    "\n",
+    "print(\"\\n💡 Domain Generalization Check:\")\n",
+    "print(f\"   ✅ Amnesty QA Mean |Diff|: {df_amnesty['abs_diff'].mean():.4f}\")\n",
+    "print(f\"   ✅ FIQA Mean |Diff|:       {df_fiqa['abs_diff'].mean():.4f}\")\n",
+    "print(\n",
+    "    f\"   {'✅' if abs(df_amnesty['abs_diff'].mean() - df_fiqa['abs_diff'].mean()) < 0.1 else '⚠️'} \"\n",
+    "    f\"Consistent across domains\"\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": ".venv",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
\ No newline at end of file
diff --git a/tests/e2e/metrics_migration/plan-for-metrics-migration.md b/tests/e2e/metrics_migration/plan-for-metrics-migration.md
new file mode 100644
index 000000000..d5103b2e9
--- /dev/null
+++ b/tests/e2e/metrics_migration/plan-for-metrics-migration.md
@@ -0,0 +1,798 @@
+# Comprehensive Generalizable Metrics Migration Plan
+
+## Overview
+This document provides a complete, step-by-step plan for migrating any metric from legacy implementation to the modern collections pattern, incorporating all learnings from Context Recall migration, test infrastructure refactoring, and notebook-based testing approaches.
+
+---
+
+## Phase 0: Pre-Migration Study & Planning
+
+### Study Existing Migrated Metrics
+
+**Metrics to analyze**:
+1. Answer Relevancy (LLM + Embeddings based)
+2. Answer Similarity (Embeddings only)
+3. BLEU/ROUGE (No LLM/embeddings)
+4. String metrics (Simple comparison)
+5. Context Recall (LLM with statement classification)
+
+**What to look for in legacy metrics** (`src/ragas/metrics/_*.py`):
+- [ ] **Core algorithm logic**: How is the score calculated?
+- [ ] **LLM/Embeddings usage**: Which components are required?
+- [ ] **Prompt structure**: PydanticPrompt classes and examples
+- [ ] **Input parameters**: What data does it need?
+- [ ] **Edge cases**: How are empty inputs, errors handled?
+- [ ] **Ensembling**: Does it run multiple times and aggregate?
+- [ ] **Deprecated methods**: Old APIs to maintain compatibility with
+- [ ] **Output format**: Float score vs structured output
+
+**Important patterns from legacy**:
+1. `_single_turn_ascore()` is the main method to replicate
+2. `MetricWithLLM`, `MetricWithEmbeddings` mixins show dependencies
+3. `PydanticPrompt` examples become inline examples in new prompts
+4. Score normalization and range validation (0.0-1.0)
+5. Error handling and nan score returns
+
+---
+
+## Phase 1: Implement New Metric
+
+### 1.1 Create Prompt Function
+**File**: `src/ragas/prompts/metrics/{metric_name}.py`
+
+**Structure**:
+```python
+"""Prompt for {MetricName} evaluation."""
+
+import json
+
+def {metric_name}_prompt(param1: str, param2: str, ...) -> str:
+    """
+    Generate prompt for {metric_name} evaluation.
+
+    Args:
+        param1: Description
+        param2: Description
+
+    Returns:
+        Formatted prompt string for LLM
+    """
+    # Use json.dumps() for safe string escaping
+    safe_param1 = json.dumps(param1)
+    safe_param2 = json.dumps(param2)
+
+    return f"""Task description here.
+
+--------EXAMPLES-----------
+Example 1
+Input: {{
+    "param1": "example value",
+    "param2": "example value"
+}}
+Output: {{
+    "result": "expected output format"
+}}
+
+Example 2
+[Add 2-3 examples covering different scenarios]
+-----------------------------
+
+Now perform the same with the following input
+Input: {{
+    "param1": {safe_param1},
+    "param2": {safe_param2}
+}}
+Output: """
+```
+
+**Key points**:
+- Use `json.dumps()` for escaping user inputs
+- Include 2-3 examples showing different cases
+- Clear output format specification
+- Match the logic from legacy PydanticPrompt
+
+### 1.2 Define Output Models
+**File**: `src/ragas/metrics/collections/_{metric_name}.py`
+
+```python
+from pydantic import BaseModel
+import typing as t
+
+class {MetricName}Item(BaseModel):
+    """Single classification/item result."""
+    field1: str
+    field2: int
+    # ... based on legacy output model
+
+class {MetricName}Output(BaseModel):
+    """Complete structured output."""
+    items: t.List[{MetricName}Item]
+    # or whatever structure the LLM returns
+```
+
+**Guidelines**:
+- Match field names from legacy output models
+- Use appropriate types (str, int, float, List, etc.)
+- Add docstrings for clarity
+
+### 1.3 Implement Metric Class
+**File**: `src/ragas/metrics/collections/_{metric_name}.py`
+
+```python
+"""MetricName v2 - Modern implementation with instructor LLMs."""
+
+import typing as t
+import numpy as np
+from ragas.metrics.collections.base import BaseMetric
+from ragas.metrics.result import MetricResult
+from ragas.prompts.metrics.{metric_name} import {metric_name}_prompt
+
+if t.TYPE_CHECKING:
+    from ragas.llms.base import InstructorBaseRagasLLM
+    from ragas.embeddings.base import BaseRagasEmbeddings
+
+class {MetricName}(BaseMetric):
+    """
+    {Metric description - what it measures}.
+
+    This implementation uses modern instructor LLMs with structured output.
+    Only supports modern components - legacy wrappers rejected with clear errors.
+
+    Usage:
+        >>> from openai import AsyncOpenAI
+        >>> from ragas.llms.base import instructor_llm_factory
+        >>> from ragas.metrics.collections import {MetricName}
+        >>>
+        >>> client = AsyncOpenAI()
+        >>> llm = instructor_llm_factory("openai", client=client, model="gpt-4o-mini")
+        >>>
+        >>> metric = {MetricName}(llm=llm)
+        >>> result = await metric.ascore(param1="value1", param2="value2")
+        >>> print(f"Score: {result.value}")
+
+    Attributes:
+        llm: Modern instructor-based LLM (if needed)
+        embeddings: Modern embeddings (if needed)
+        name: Metric name
+        allowed_values: Score range (0.0 to 1.0)
+    """
+
+    # Type hints for components
+    llm: "InstructorBaseRagasLLM"  # If LLM-based
+    embeddings: "BaseRagasEmbeddings"  # If embeddings-based
+
+    def __init__(
+        self,
+        llm: t.Optional["InstructorBaseRagasLLM"] = None,
+        embeddings: t.Optional["BaseRagasEmbeddings"] = None,
+        name: str = "{metric_name}",
+        **kwargs,
+    ):
+        """Initialize metric with required components."""
+        # Set attributes before super() for validation
+        if llm:
+            self.llm = llm
+        if embeddings:
+            self.embeddings = embeddings
+
+        # BaseMetric validates components are modern (not legacy wrappers)
+        super().__init__(name=name, **kwargs)
+
+    async def ascore(
+        self,
+        param1: str,
+        param2: str,
+        # ... other parameters based on metric needs
+    ) -> MetricResult:
+        """
+        Calculate score asynchronously.
+
+        Args:
+            param1: Description
+            param2: Description
+
+        Returns:
+            MetricResult with score (0.0-1.0)
+        """
+        # 1. Validate inputs (handle empty/None cases)
+        if not param1 or not param2:
+            return MetricResult(value=0.0)
+
+        # 2. For LLM-based metrics: Generate prompt and get structured output
+        prompt = {metric_name}_prompt(param1=param1, param2=param2)
+        output = await self.llm.agenerate(prompt, {MetricName}Output)
+
+        # 3. For embeddings-based metrics: Get embeddings and compute similarity
+        # embedding1 = await self.embeddings.embed_text(param1)
+        # embedding2 = await self.embeddings.embed_text(param2)
+        # score = cosine_similarity(embedding1, embedding2)
+
+        # 4. Calculate score from output (match legacy logic exactly)
+        score = self._calculate_score(output)
+
+        # 5. Return MetricResult
+        return MetricResult(value=float(score))
+
+    def _calculate_score(self, output: {MetricName}Output) -> float:
+        """Calculate final score from LLM output."""
+        # Implement exact logic from legacy _single_turn_ascore
+        # This is where the core algorithm lives
+        pass
+```
+
+**Key patterns**:
+- `__init__` sets attributes before `super()` for validation
+- `ascore()` is the main public method (not `_single_turn_ascore`)
+- Return `MetricResult` not raw float
+- Match legacy calculation logic exactly
+- Handle edge cases (empty inputs, None values)
+- Type hints use `TYPE_CHECKING` for circular imports
+
+### 1.4 Update Exports
+**File**: `src/ragas/metrics/collections/__init__.py`
+
+```python
+from ._metric_name import MetricName
+
+__all__ = [
+    # ... existing exports
+    "MetricName",
+]
+```
+
+---
+
+## Phase 2: Manual Testing with General-Purpose Notebook
+
+### 2.1 Use General-Purpose Testing Notebook
+
+**File**: `tests/notebooks/metric_score_diff.ipynb` (already exists - reusable for all metrics)
+
+**Purpose**: Validate migration on real-world datasets (PRIMARY) and test edge cases (SECONDARY)
+
+**Testing Priority**:
+1. **PRIMARY**: Large-scale dataset testing (amnesty_qa, fiqa) - proves migration quality
+2. **SECONDARY**: Hand-crafted edge cases - validates specific behaviors
+
+**Key Advantage**: This notebook is configuration-driven. You only need to edit ONE cell (Cell 2) with your metric configuration, then run all cells without any other modifications!
+
+**What the notebook provides**:
+- Automatic component creation (LLM/embeddings) based on your needs
+- Dynamic metric loading from your configuration
+- Dataset-based testing (Amnesty QA + FIQA)
+- Comprehensive statistical analysis and visualizations
+- Validation criteria checking
+- Optional edge case testing
+
+---
+
+### 2.2 Generate Metric Configuration
+
+Generate the `METRIC_CONFIG` dictionary for Cell 2 of the notebook. Print it to console for easy copy-pasting. Use the template below based on your metric type:
+
+#### Configuration Template
+
+```python
+METRIC_CONFIG = {
+    # ===== METRIC IMPORTS =====
+    "legacy_import": {
+        "module": "ragas.metrics._{legacy_module_name}",  # e.g., "ragas.metrics._answer_relevance"
+        "class_name": "{LegacyMetricClassName}",           # e.g., "AnswerRelevancy"
+    },
+    "modern_import": {
+        "module": "ragas.metrics.collections",
+        "class_name": "{ModernMetricClassName}",           # e.g., "AnswerRelevancy"
+    },
+
+    # ===== COMPONENT REQUIREMENTS =====
+    # Set to False if your metric doesn't need this component
+    "needs_llm": True,      # Does your metric use an LLM?
+    "needs_embeddings": True,  # Does your metric use embeddings?
+
+    # ===== DATASET FIELD MAPPING =====
+    # Choose ONE option based on your metric type (uncomment the appropriate one)
+
+    # OPTION 1: Answer-based metrics (AnswerRelevancy, AnswerSimilarity, AnswerCorrectness, etc.)
+    "dataset_fields": ["user_input", "response"],
+
+    # OPTION 2: Context-based metrics (ContextRecall, ContextPrecision, Faithfulness, etc.)
+    # "dataset_fields": ["user_input", "retrieved_contexts", "reference"],
+
+    # OPTION 3: Deterministic/Non-LLM metrics (NonLLMContextRecall, etc.)
+    # "dataset_fields": ["retrieved_contexts", "reference_contexts"],
+}
+```
+
+#### Configuration Examples
+
+**Example 1: AnswerRelevancy (LLM + Embeddings)**
+```python
+METRIC_CONFIG = {
+    "legacy_import": {
+        "module": "ragas.metrics._answer_relevance",
+        "class_name": "AnswerRelevancy",
+    },
+    "modern_import": {
+        "module": "ragas.metrics.collections",
+        "class_name": "AnswerRelevancy",
+    },
+    "needs_llm": True,
+    "needs_embeddings": True,
+    "dataset_fields": ["user_input", "response"],
+}
+```
+
+**Example 2: ContextRecall (LLM only)**
+```python
+METRIC_CONFIG = {
+    "legacy_import": {
+        "module": "ragas.metrics._context_recall",
+        "class_name": "ContextRecall",
+    },
+    "modern_import": {
+        "module": "ragas.metrics.collections",
+        "class_name": "ContextRecall",
+    },
+    "needs_llm": True,
+    "needs_embeddings": False,
+    "dataset_fields": ["user_input", "retrieved_contexts", "reference"],
+}
+```
+
+**Example 3: NonLLMContextRecall (No LLM/Embeddings)**
+```python
+METRIC_CONFIG = {
+    "legacy_import": {
+        "module": "ragas.metrics._context_recall",
+        "class_name": "NonLLMContextRecall",
+    },
+    "modern_import": {
+        "module": "ragas.metrics.collections",
+        "class_name": "NonLLMContextRecall",
+    },
+    "needs_llm": False,
+    "needs_embeddings": False,
+    "dataset_fields": ["retrieved_contexts", "reference_contexts"],
+}
+```
+
+**Example 4: ContextPrecision (LLM only)**
+```python
+METRIC_CONFIG = {
+    "legacy_import": {
+        "module": "ragas.metrics._context_precision",
+        "class_name": "ContextPrecision",
+    },
+    "modern_import": {
+        "module": "ragas.metrics.collections",
+        "class_name": "ContextPrecision",
+    },
+    "needs_llm": True,
+    "needs_embeddings": False,
+    "dataset_fields": ["user_input", "retrieved_contexts", "reference"],
+}
+```
+
+#### How to Choose `dataset_fields`
+
+The `dataset_fields` list tells the notebook which fields to extract from the test datasets (Amnesty QA, FIQA) for your metric:
+
+1. **Answer-based metrics**: Use `["user_input", "response"]`
+   - Metrics that evaluate the quality of generated answers
+   - Examples: AnswerRelevancy, AnswerSimilarity, AnswerCorrectness
+
+2. **Context-based metrics**: Use `["user_input", "retrieved_contexts", "reference"]`
+   - Metrics that evaluate retrieved context quality
+   - Examples: ContextRecall, ContextPrecision, Faithfulness
+
+3. **Deterministic metrics**: Use `["retrieved_contexts", "reference_contexts"]`
+   - Metrics that don't use LLMs and compare contexts directly
+   - Examples: NonLLMContextRecall
+   - Note: The notebook will automatically split `retrieved_contexts` to create `reference_contexts` if needed
+
+**Available dataset fields**:
+- **Amnesty QA**: `user_input`, `response`, `retrieved_contexts`, `reference_contexts`
+- **FIQA**: `user_input`, `response`, `retrieved_contexts`, `reference`
+
+---
+
+### 2.3 Run Notebook and Analyze Results
+
+**Steps**:
+
+1. **Open the notebook**: `tests/notebooks/metric_score_diff.ipynb`
+
+2. **Edit Cell 2**: Replace the `METRIC_CONFIG` dictionary with your generated configuration from Section 2.2
+
+3. **Run all cells**: The notebook handles everything automatically:
+   - Loads your metric classes dynamically
+   - Creates only the required components (LLM/embeddings)
+   - Initializes both legacy and modern metrics
+   - Loads and transforms datasets based on your `dataset_fields`
+   - Runs concurrent comparisons on Amnesty QA and FIQA
+   - Generates comprehensive statistical analysis
+   - Creates 7-plot visualizations for each dataset
+   - Validates results against migration criteria
+
+4. **Review results**: The notebook displays inline:
+   - Score comparison statistics (mean, std dev, differences)
+   - Tolerance analysis (% of samples within various thresholds)
+   - Top 10 largest differences with descriptions
+   - Comprehensive visualizations (scatter, histograms, trends, distributions)
+   - Validation criteria checkmarks (✅/❌)
+
+5. **Iterate if needed**:
+   - If scores don't match well, review the problematic cases
+   - Adjust your metric implementation
+   - Re-run the notebook to verify improvements
+
+6. **Document findings**: Print a migration summary with the following information:
+   - Mean absolute difference
+   - Percentage of samples within tolerance
+   - Recommended tolerance level
+   - Any patterns or anomalies observed
+   - Edge cases that need special handling
+   - Key implementation details and algorithm differences
+
+**Output approach**: Print the METRIC_CONFIG and migration summary directly to console/output instead of creating files. This allows for easy copy-pasting without cluttering the repository.
+
+---
+
+---
+
+### 2.4 Migration Validation Criteria
+
+After running the notebook, the migration is considered successful if:
+
+**Amnesty QA Dataset** (PRIMARY criterion):
+- ✅ Mean absolute difference < 0.15 (stricter than per-case tolerance)
+- ✅ >90% of samples within 0.2 tolerance for LLM-based metrics
+- ✅ >95% of samples within 1e-6 tolerance for deterministic metrics
+- ✅ No systematic bias (mean diff close to 0, ideally < 0.05)
+- ✅ Similar score distributions (check box plots and histograms)
+
+**FIQA Dataset** (if available):
+- ✅ Similar criteria as amnesty_qa
+- ✅ Validates generalization across different domains
+
+**Edge Cases** (SECONDARY criterion):
+- ✅ All edge cases handle gracefully (no crashes)
+- ✅ Empty inputs return 0.0 or handle appropriately
+- ✅ Special characters don't break the metric
+
+**Performance**:
+- ✅ New implementation not significantly slower (< 2x)
+- ✅ Concurrent processing works correctly
+
+**Documentation**:
+For the migration, review and document in the notebook:
+- Dataset comparison statistics (displayed inline)
+- Top 10 largest differences with analysis (displayed inline)
+- Visual analysis with 7 comprehensive plots (displayed inline)
+- Any patterns or anomalies observed
+- Recommended tolerance for E2E tests
+
+**This becomes the proof that migration works correctly!**
+
+**Note**: All results are displayed inline in the notebook - no CSV or PNG files are saved.
+
+---
+
+## Phase 3: Write E2E Migration Tests
+
+### 3.1 Create Test File
+**File**: `tests/e2e/metrics_migration/test_{metric_name}_migration.py`
+
+**Structure**:
+```python
+"""E2E tests for {MetricName} migration from v1 to v2."""
+
+import pytest
+
+from ragas.metrics import {LegacyMetricName}
+from ragas.metrics.collections import {MetricName}
+
+from .base_migration_test import BaseMigrationTest
+
+class Test{MetricName}E2EMigration(BaseMigrationTest):
+    """E2E compatibility tests between legacy and v2 implementations."""
+
+    @pytest.fixture
+    def sample_data(self):
+        """Test cases for {metric_name} evaluation.
+
+        Based on dataset testing in notebook: tests/notebooks/metric_score_diff.ipynb
+
+        Dataset validation results:
+        - Amnesty QA: Mean |diff|={mean_diff:.4f}, {pct_within_tolerance}% within tolerance
+        - FIQA: Mean |diff|={mean_diff:.4f}, {pct_within_tolerance}% within tolerance (if tested)
+
+        These test cases focus on edge cases and specific behaviors not fully covered by datasets.
+        The primary validation comes from the dataset comparisons documented in the notebook.
+        """
+        return [
+            # Edge cases from notebook testing
+            # Cases with interesting/problematic behavior from dataset analysis
+            # Specific scenarios requiring validation
+            {
+                "param1": "value1",
+                "param2": "value2",
+                "description": "Test case description",
+            },
+        ]
+
+    @pytest.mark.asyncio
+    async def test_legacy_vs_v2_e2e_compatibility(
+        self,
+        sample_data,
+        legacy_llm,  # from conftest.py
+        modern_llm,  # from conftest.py
+        legacy_embeddings,  # if needed
+        modern_embeddings,  # if needed
+    ):
+        """E2E test that legacy and v2 produce similar scores."""
+        await self.run_e2e_compatibility_test(
+            sample_data=sample_data,
+            legacy_metric_factory={LegacyMetricName},
+            v2_metric_factory={MetricName},
+            legacy_components={"llm": legacy_llm, "embeddings": legacy_embeddings},
+            v2_components={"llm": modern_llm, "embeddings": modern_embeddings},
+            tolerance=0.2,  # Adjust based on notebook findings
+            metric_name="{MetricName}",
+            additional_info_keys=["param1", "param2"],  # For debug output
+        )
+
+    @pytest.mark.asyncio
+    async def test_{metric_specific_behavior}(
+        self,
+        legacy_llm,
+        modern_llm,
+    ):
+        """Test metric-specific behavior."""
+
+        test_cases = [
+            {
+                "param1": "specific case",
+                "param2": "for testing",
+                "expected_high": True,  # or other expected behavior
+                "description": "Specific behavior description",
+            },
+            # Add 2-3 cases testing specific behaviors
+        ]
+
+        def assertion_fn(case, legacy_score, v2_result):
+            """Custom assertions for metric-specific behavior."""
+            if case.get("expected_high"):
+                assert legacy_score > 0.8
+                assert v2_result.value > 0.8
+                print("   ✅ High score as expected")
+            # Add other assertions based on metric logic
+
+        await self.run_metric_specific_test(
+            test_cases=test_cases,
+            legacy_metric_factory={LegacyMetricName},
+            v2_metric_factory={MetricName},
+            legacy_components={"llm": legacy_llm},
+            v2_components={"llm": modern_llm},
+            test_name="{specific behavior}",
+            assertion_fn=assertion_fn,
+        )
+
+    def test_migration_requirements_documented(self):
+        """Document requirements for running E2E tests."""
+        requirements = {
+            "llm": "OpenAI GPT or compatible LLM",
+            "embeddings": "OpenAI embeddings (if needed)",
+            "environment": "API keys configured",
+            "purpose": "Verify v2 produces similar scores to legacy",
+        }
+
+        self.create_requirements_documentation(
+            metric_name="{MetricName}",
+            requirements=requirements,
+            test_file_name="test_{metric_name}_migration.py",
+        )
+
+        assert True
+```
+
+**Key points**:
+- Inherit from `BaseMigrationTest` for reusable test methods
+- Use fixtures from `conftest.py` (no local fixture definitions)
+- `sample_data` comes from notebook testing (working cases)
+- Tolerance based on notebook findings
+- Add metric-specific behavior tests
+- Document requirements
+
+### 3.2 Run Tests
+```bash
+# Run the new tests
+uv run pytest tests/e2e/metrics_migration/test_{metric_name}_migration.py -v -s
+
+# Check they collect properly
+uv run pytest tests/e2e/metrics_migration/test_{metric_name}_migration.py --collect-only
+```
+
+---
+
+## Phase 4: Code Quality & Finalization
+
+### 4.1 Run Linting & Formatting
+```bash
+# Format code
+make format
+
+# Type check
+make type
+
+# Quick health check
+make check
+```
+
+### 4.2 Run All Tests
+```bash
+# Unit tests
+make test
+
+# E2E tests
+make test-e2e
+
+# Or run specific test
+uv run pytest tests/e2e/metrics_migration/ -v
+```
+
+### 4.3 Update Documentation
+**File**: `docs/howtos/migrations/{metric_name}.md` (if needed)
+
+Document:
+- Migration rationale
+- API changes
+- Usage examples (before/after)
+- Breaking changes (if any)
+
+### 4.4 Create PR Checklist
+- [ ] New metric implementation complete
+- [ ] Prompt function with examples
+- [ ] E2E migration tests passing
+- [ ] Notebook testing completed
+- [ ] Code formatted and linted
+- [ ] Type checking passes
+- [ ] Documentation updated
+- [ ] Exports added to `__init__.py`
+
+---
+
+## Key Learnings & Best Practices
+
+### From Context Recall Migration
+1. **Components validation**: Base class rejects legacy wrappers automatically
+2. **Structured output**: Use Pydantic models with instructor LLMs
+3. **Prompt format**: Inline examples with json.dumps() escaping
+4. **Score calculation**: Extract to separate method for clarity
+5. **Edge cases**: Handle empty inputs gracefully
+
+### From Test Infrastructure
+1. **Use shared fixtures**: `conftest.py` provides llm/embeddings
+2. **Base test class**: `BaseMigrationTest` eliminates boilerplate
+3. **Test utilities**: `test_utils.py` for common operations
+4. **Consistent patterns**: All tests follow same structure
+5. **Proper skipping**: Tests skip gracefully without API keys
+
+### From Notebook Testing
+1. **Manual testing first**: Catches issues before E2E tests
+2. **User modifications matter**: Inform final test design
+3. **Performance tools**: Use optimized `compare_metrics` function
+4. **Diverse test cases**: Cover normal, edge, high/low score scenarios
+5. **Iteration speed**: Faster to debug in notebook than pytest
+
+### Tolerance Guidelines
+- **LLM-based metrics**: 0.2-0.3 (accounts for randomness)
+- **Embeddings-based**: 1e-6 to 1e-10 (deterministic)
+- **String/rule-based**: 1e-10 (exact match expected)
+- **Adjust based on**: Notebook findings and metric nature
+
+---
+
+## Complete Checklist
+
+### Pre-Migration
+- [ ] Study legacy metric implementation thoroughly
+- [ ] Identify required components (LLM/embeddings/neither)
+- [ ] Document core algorithm logic
+- [ ] Note edge cases and special handling
+- [ ] Review existing migrated metrics for patterns
+
+### Implementation
+- [ ] Create prompt function with examples
+- [ ] Define Pydantic output models
+- [ ] Implement metric class inheriting from BaseMetric
+- [ ] Match legacy calculation logic exactly
+- [ ] Handle edge cases (empty, None, errors)
+- [ ] Update `__init__.py` exports
+
+### Manual Testing (Notebook)
+- [ ] Open general-purpose notebook: `tests/notebooks/metric_score_diff.ipynb`
+- [ ] Generate `METRIC_CONFIG` for your metric (Section 2.2)
+- [ ] Edit Cell 2 with your configuration
+- [ ] Run all cells (no other modifications needed)
+- [ ] Review Amnesty QA and FIQA comparison results
+- [ ] Iterate on implementation until scores match
+- [ ] Document findings (mean |diff|, tolerance, patterns)
+
+### E2E Testing
+- [ ] Create test file inheriting from BaseMigrationTest
+- [ ] Use fixtures from conftest.py
+- [ ] Copy working test cases from notebook
+- [ ] Set appropriate tolerance
+- [ ] Add metric-specific behavior tests
+- [ ] Document requirements
+- [ ] Run tests and verify they pass
+
+### Quality & Finalization
+- [ ] Run `make format`
+- [ ] Run `make type`
+- [ ] Run `make check`
+- [ ] Run `make test`
+- [ ] Run `make test-e2e`
+- [ ] Update documentation if needed
+- [ ] Create PR with checklist
+
+---
+
+## File Structure Reference
+
+```
+ragas/
+├── src/ragas/
+│   ├── prompts/metrics/
+│   │   └── {metric_name}.py          # NEW: Prompt function
+│   └── metrics/
+│       ├── collections/
+│       │   ├── _{metric_name}.py     # NEW: V2 implementation
+│       │   └── __init__.py           # MODIFIED: Add export
+│       └── _{metric_name}.py         # EXISTING: Legacy implementation
+├── tests/
+│   ├── utils/                        # EXISTING: Shared utilities
+│   │   ├── __init__.py
+│   │   └── llm_setup.py
+│   ├── notebooks/
+│   │   └── metric_score_diff.ipynb  # EXISTING: General-purpose testing notebook
+│   └── e2e/metrics_migration/
+│       ├── conftest.py               # EXISTING: Shared fixtures
+│       ├── test_utils.py             # EXISTING: Test utilities
+│       ├── base_migration_test.py   # EXISTING: Base test class
+│       └── test_{metric_name}_migration.py  # NEW: E2E tests
+└── docs/
+    └── howtos/migrations/
+        └── {metric_name}.md          # OPTIONAL: Migration guide
+```
+
+---
+
+## Success Criteria
+
+✅ **Implementation**:
+- New metric produces similar scores to legacy (within tolerance)
+- Works only with modern components (rejects legacy wrappers)
+- Handles all edge cases properly
+- Code is clean, typed, and documented
+
+✅ **Testing**:
+- E2E tests pass
+- Manual notebook testing completed
+- User satisfied with score matching
+- All code quality checks pass
+
+✅ **Documentation**:
+- Usage examples clear
+- Requirements documented
+- Migration path explained (if needed)
+
+✅ **Integration**:
+- Exports added
+- No regressions in existing tests
+- Ready for PR and review
+
+---
+
+This plan provides a complete, battle-tested workflow for migrating any metric from legacy to modern implementation, incorporating all learnings from previous migrations and leveraging the full testing infrastructure.
diff --git a/tests/e2e/metrics_migration/test_utils.py b/tests/e2e/metrics_migration/test_utils.py
new file mode 100644
index 000000000..edd26bc3d
--- /dev/null
+++ b/tests/e2e/metrics_migration/test_utils.py
@@ -0,0 +1,146 @@
+"""Utility functions for metrics migration E2E tests."""
+
+from typing import Any, Dict, Optional
+
+from ragas.dataset_schema import SingleTurnSample
+from ragas.metrics import MetricResult
+
+
+def create_legacy_sample(
+    data: Dict[str, Any],
+    user_input_key: str = "user_input",
+    response_key: str = "response",
+    reference_key: Optional[str] = "reference",
+    retrieved_contexts_key: Optional[str] = "retrieved_contexts",
+) -> SingleTurnSample:
+    """Create a SingleTurnSample from a data dictionary for legacy metrics.
+
+    Args:
+        data: Dictionary containing sample data
+        user_input_key: Key for user input in data dict
+        response_key: Key for response in data dict
+        reference_key: Key for reference in data dict (optional)
+        retrieved_contexts_key: Key for retrieved contexts in data dict (optional)
+
+    Returns:
+        SingleTurnSample instance
+    """
+    kwargs = {
+        "user_input": data.get(user_input_key, "dummy"),
+    }
+
+    if response_key and response_key in data:
+        kwargs["response"] = data[response_key]
+
+    if reference_key and reference_key in data:
+        kwargs["reference"] = data[reference_key]
+
+    if retrieved_contexts_key and retrieved_contexts_key in data:
+        kwargs["retrieved_contexts"] = data[retrieved_contexts_key]
+
+    return SingleTurnSample(**kwargs)
+
+
+def compare_scores_with_tolerance(
+    legacy_score: float,
+    v2_score: float,
+    tolerance: float,
+    case_description: str,
+    case_num: int,
+) -> None:
+    """Compare scores and assert they are within tolerance.
+
+    Args:
+        legacy_score: Score from legacy implementation
+        v2_score: Score from v2 implementation
+        tolerance: Maximum allowed difference
+        case_description: Description of the test case
+        case_num: Test case number
+
+    Raises:
+        AssertionError: If scores differ by more than tolerance
+    """
+    score_diff = abs(legacy_score - v2_score)
+    assert score_diff < tolerance, (
+        f"Case {case_num} ({case_description}): "
+        f"Large difference: {legacy_score} vs {v2_score} (diff: {score_diff})"
+    )
+
+
+def assert_score_types(legacy_score: Any, v2_result: MetricResult) -> None:
+    """Assert that scores have correct types and values are in valid range.
+
+    Args:
+        legacy_score: Score from legacy implementation
+        v2_result: MetricResult from v2 implementation
+
+    Raises:
+        AssertionError: If types or ranges are invalid
+    """
+    assert isinstance(legacy_score, float), (
+        f"Legacy score should be float, got {type(legacy_score)}"
+    )
+    assert isinstance(v2_result, MetricResult), (
+        f"V2 result should be MetricResult, got {type(v2_result)}"
+    )
+    assert 0.0 <= legacy_score <= 1.0, f"Legacy score out of range: {legacy_score}"
+    assert 0.0 <= v2_result.value <= 1.0, f"V2 score out of range: {v2_result.value}"
+
+
+def print_test_header(
+    metric_name: str,
+    case_num: int,
+    description: str,
+    additional_info: Optional[Dict[str, str]] = None,
+) -> None:
+    """Print a standardized test case header.
+
+    Args:
+        metric_name: Name of the metric being tested
+        case_num: Test case number
+        description: Description of the test case
+        additional_info: Optional dictionary of additional info to print
+    """
+    print(f"\n🧪 Testing {metric_name} - Case {case_num}: {description}")
+    if additional_info:
+        for key, value in additional_info.items():
+            # Truncate long values
+            display_value = value[:100] + "..." if len(value) > 100 else value
+            print(f"   {key}: {display_value}")
+
+
+def print_score_comparison(
+    legacy_score: float,
+    v2_score: float,
+    precision: int = 6,
+) -> None:
+    """Print a standardized score comparison.
+
+    Args:
+        legacy_score: Score from legacy implementation
+        v2_score: Score from v2 implementation
+        precision: Number of decimal places to display
+    """
+    score_diff = abs(legacy_score - v2_score)
+    print(f"   Legacy:    {legacy_score:.{precision}f}")
+    print(f"   V2 Class:  {v2_score:.{precision}f}")
+    print(f"   Diff:      {score_diff:.{precision}f}")
+
+
+def print_test_success(message: str = "Scores within tolerance!") -> None:
+    """Print a standardized success message.
+
+    Args:
+        message: Success message to display
+    """
+    print(f"   ✅ {message}")
+
+
+def print_metric_specific_info(metric_name: str, description: str) -> None:
+    """Print metric-specific test information.
+
+    Args:
+        metric_name: Name of the metric
+        description: Description of what's being tested
+    """
+    print(f"\n🎯 Testing {metric_name}: {description}")
diff --git a/tests/e2e/test_dataset_utils.py b/tests/e2e/test_dataset_utils.py
index 4f1861466..0f4cb7a0a 100644
--- a/tests/e2e/test_dataset_utils.py
+++ b/tests/e2e/test_dataset_utils.py
@@ -30,6 +30,39 @@
     },
 ]
 
+# Sample data structure matching the fiqa dataset
+SAMPLE_FIQA_DATA = [
+    {
+        "user_input": "How to deposit a cheque issued to an associate in my business account?",
+        "reference": "Have the check reissued to the proper payee. Just have the associate sign the back and then deposit it. It's called a third party cheque and is perfectly legal. I wouldn't be surprised if it has a longer hold period and, as always, you don't get the money if the cheque doesn't clear.",
+        "response": "The best way to deposit a cheque issued to an associate in your business account is to have the associate sign the back of the cheque and deposit it as a third party cheque.",
+        "retrieved_contexts": [
+            "Just have the associate sign the back and then deposit it. It's called a third party cheque and is perfectly legal.",
+            "I wouldn't be surprised if it has a longer hold period and, as always, you don't get the money if the cheque doesn't clear.",
+        ],
+    },
+    {
+        "user_input": "What is the difference between a mutual fund and an ETF?",
+        "reference": "Mutual funds are actively managed investment vehicles that pool money from multiple investors. ETFs are passively managed and trade on exchanges like stocks. ETFs typically have lower fees and can be bought and sold throughout the trading day.",
+        "response": "A mutual fund pools money from investors and is actively managed, while an ETF trades like a stock and typically tracks an index with lower fees.",
+        "retrieved_contexts": [
+            "Mutual funds pool money from multiple investors and are actively managed by professional fund managers.",
+            "ETFs trade on exchanges like stocks and can be bought and sold throughout the trading day.",
+            "ETFs typically have lower expense ratios compared to mutual funds.",
+        ],
+    },
+    {
+        "user_input": "Should I pay off my mortgage early or invest the money?",
+        "reference": "It depends on your mortgage interest rate and expected investment returns. If your mortgage rate is low and you expect higher returns from investments, investing may be better. Consider your risk tolerance and financial goals.",
+        "response": "The decision depends on comparing your mortgage interest rate to expected investment returns, along with your risk tolerance and financial security needs.",
+        "retrieved_contexts": [
+            "Compare your mortgage interest rate to expected investment returns to make an informed decision.",
+            "Consider your risk tolerance and overall financial situation before making this decision.",
+            "Having no mortgage provides peace of mind and guaranteed savings equal to the interest rate.",
+        ],
+    },
+]
+
 
 def load_amnesty_dataset_safe(config: str = "english_v3"):
     """
@@ -54,3 +87,28 @@ def load_amnesty_dataset_safe(config: str = "english_v3"):
         local_dataset = Dataset.from_list(SAMPLE_AMNESTY_DATA)
         logger.info(f"Created local dataset with {len(local_dataset)} samples")
         return local_dataset
+
+
+def load_fiqa_dataset_safe(config: str = "ragas_eval_v3"):
+    """
+    Safely load the fiqa dataset, falling back to local data if remote fails.
+
+    Args:
+        config: Dataset configuration name (default: "ragas_eval_v3" - recommended)
+
+    Returns:
+        Dataset: The loaded dataset
+    """
+    try:
+        logger.info(f"Attempting to load fiqa dataset with config '{config}'")
+        dataset = load_dataset("explodinggradients/fiqa", config)["baseline"]
+        logger.info(f"Successfully loaded dataset with {len(dataset)} samples")
+        return dataset
+    except Exception as e:
+        logger.warning(f"Failed to load remote dataset: {e}")
+        logger.info("Using local sample data as fallback")
+
+        # Create a local dataset from sample data
+        local_dataset = Dataset.from_list(SAMPLE_FIQA_DATA)
+        logger.info(f"Created local dataset with {len(local_dataset)} samples")
+        return local_dataset
diff --git a/tests/notebooks/metric_score_diff.ipynb b/tests/notebooks/metric_score_diff.ipynb
deleted file mode 100644
index cca6ced1c..000000000
--- a/tests/notebooks/metric_score_diff.ipynb
+++ /dev/null
@@ -1,498 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Metric Score Diff Checker\n",
-    "\n",
-    "This notebook provides utilities to compare scores between different metric versions, algorithms, LLMs, or datasets.\n",
-    "\n",
-    "## Dataset\n",
-    "This notebook uses the amnesty_qa dataset which contains human rights related Q&A pairs. It will attempt to load from HuggingFace and fallback to local samples if unavailable."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import time\n",
-    "from dataclasses import dataclass\n",
-    "from typing import Any, Dict, List, Tuple\n",
-    "\n",
-    "import numpy as np\n",
-    "import pandas as pd\n",
-    "\n",
-    "# Ragas imports\n",
-    "from ragas.dataset_schema import SingleTurnSample"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Setup\n",
-    "\n",
-    "Make sure you have your OpenAI API key set as an environment variable before running this notebook."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import os\n",
-    "\n",
-    "# Check for OpenAI API key\n",
-    "if not os.getenv(\"OPENAI_API_KEY\"):\n",
-    "    raise ValueError(\n",
-    "        \"OPENAI_API_KEY environment variable not set. \"\n",
-    "        \"Please set it before running this notebook:\\n\"\n",
-    "        \"  export OPENAI_API_KEY='your-api-key-here'\"\n",
-    "    )\n",
-    "\n",
-    "print(\"✓ OpenAI API key found\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Utility Functions"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "@dataclass\n",
-    "class MetricDiffResult:\n",
-    "    \"\"\"Container for metric comparison results.\"\"\"\n",
-    "\n",
-    "    old_scores: List[float]\n",
-    "    new_scores: List[float]\n",
-    "    diffs: List[float]\n",
-    "    mean_diff: float\n",
-    "    max_diff: float\n",
-    "    min_diff: float\n",
-    "    std_diff: float\n",
-    "    old_mean: float\n",
-    "    new_mean: float\n",
-    "    old_time: float\n",
-    "    new_time: float\n",
-    "\n",
-    "    def to_dataframe(self) -> pd.DataFrame:\n",
-    "        \"\"\"Convert results to a pandas DataFrame.\"\"\"\n",
-    "        return pd.DataFrame(\n",
-    "            {\n",
-    "                \"old_score\": self.old_scores,\n",
-    "                \"new_score\": self.new_scores,\n",
-    "                \"diff\": self.diffs,\n",
-    "                \"abs_diff\": [abs(d) for d in self.diffs],\n",
-    "            }\n",
-    "        )\n",
-    "\n",
-    "    def print_summary(self):\n",
-    "        \"\"\"Print a summary of the comparison.\"\"\"\n",
-    "        print(\"=\" * 60)\n",
-    "        print(\"METRIC COMPARISON SUMMARY\")\n",
-    "        print(\"=\" * 60)\n",
-    "        print(\"\\nScore Statistics:\")\n",
-    "        print(f\"  Old Metric Mean: {self.old_mean:.4f}\")\n",
-    "        print(f\"  New Metric Mean: {self.new_mean:.4f}\")\n",
-    "        print(\"\\nDifference Statistics (new - old):\")\n",
-    "        print(f\"  Mean Diff:   {self.mean_diff:.4f}\")\n",
-    "        print(f\"  Max Diff:    {self.max_diff:.4f}\")\n",
-    "        print(f\"  Min Diff:    {self.min_diff:.4f}\")\n",
-    "        print(f\"  Std Dev:     {self.std_diff:.4f}\")\n",
-    "        print(\"\\nExecution Time:\")\n",
-    "        print(f\"  Old Metric:  {self.old_time:.2f}s\")\n",
-    "        print(f\"  New Metric:  {self.new_time:.2f}s\")\n",
-    "        print(\n",
-    "            f\"  Speedup:     {self.old_time / self.new_time:.2f}x\"\n",
-    "            if self.new_time > 0\n",
-    "            else \"  N/A\"\n",
-    "        )\n",
-    "        print(\"=\" * 60)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "async def run_metric_on_dataset(\n",
-    "    metric: Any, dataset: List[Dict[str, Any]], metric_type: str = \"old\"\n",
-    ") -> Tuple[List[float], float]:\n",
-    "    \"\"\"\n",
-    "    Run a metric on a dataset and return scores with execution time.\n",
-    "\n",
-    "    Args:\n",
-    "        metric: The metric instance (either old or new style)\n",
-    "        dataset: List of dictionaries containing the data samples\n",
-    "        metric_type: \"old\" for legacy metrics, \"new\" for collections metrics\n",
-    "\n",
-    "    Returns:\n",
-    "        Tuple of (scores list, execution time in seconds)\n",
-    "    \"\"\"\n",
-    "    scores = []\n",
-    "    start_time = time.time()\n",
-    "\n",
-    "    for sample_dict in dataset:\n",
-    "        try:\n",
-    "            if metric_type == \"old\":\n",
-    "                # Old metrics use SingleTurnSample\n",
-    "                sample = SingleTurnSample(**sample_dict)\n",
-    "                score = await metric._single_turn_ascore(sample, callbacks=None)\n",
-    "            else:\n",
-    "                # New metrics use direct kwargs\n",
-    "                result = await metric.ascore(**sample_dict)\n",
-    "                score = result.value\n",
-    "\n",
-    "            scores.append(float(score))\n",
-    "        except Exception as e:\n",
-    "            print(f\"Error processing sample: {e}\")\n",
-    "            scores.append(np.nan)\n",
-    "\n",
-    "    execution_time = time.time() - start_time\n",
-    "    return scores, execution_time"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "async def compare_metrics(\n",
-    "    old_metric: Any,\n",
-    "    new_metric: Any,\n",
-    "    dataset: List[Dict[str, Any]],\n",
-    "    old_metric_type: str = \"old\",\n",
-    "    new_metric_type: str = \"new\",\n",
-    ") -> MetricDiffResult:\n",
-    "    \"\"\"\n",
-    "    Compare two metrics on the same dataset.\n",
-    "\n",
-    "    Args:\n",
-    "        old_metric: The baseline/old metric instance\n",
-    "        new_metric: The new/updated metric instance\n",
-    "        dataset: List of dictionaries containing the data samples\n",
-    "        old_metric_type: Type identifier for old metric (\"old\" or \"new\")\n",
-    "        new_metric_type: Type identifier for new metric (\"old\" or \"new\")\n",
-    "\n",
-    "    Returns:\n",
-    "        MetricDiffResult containing comparison statistics\n",
-    "    \"\"\"\n",
-    "    print(f\"Running old metric on {len(dataset)} samples...\")\n",
-    "    old_scores, old_time = await run_metric_on_dataset(\n",
-    "        old_metric, dataset, old_metric_type\n",
-    "    )\n",
-    "\n",
-    "    print(f\"Running new metric on {len(dataset)} samples...\")\n",
-    "    new_scores, new_time = await run_metric_on_dataset(\n",
-    "        new_metric, dataset, new_metric_type\n",
-    "    )\n",
-    "\n",
-    "    # Calculate differences\n",
-    "    diffs = [new - old for old, new in zip(old_scores, new_scores)]\n",
-    "\n",
-    "    return MetricDiffResult(\n",
-    "        old_scores=old_scores,\n",
-    "        new_scores=new_scores,\n",
-    "        diffs=diffs,\n",
-    "        mean_diff=float(np.mean(diffs)),\n",
-    "        max_diff=float(np.max(diffs)),\n",
-    "        min_diff=float(np.min(diffs)),\n",
-    "        std_diff=float(np.std(diffs)),\n",
-    "        old_mean=float(np.mean(old_scores)),\n",
-    "        new_mean=float(np.mean(new_scores)),\n",
-    "        old_time=old_time,\n",
-    "        new_time=new_time,\n",
-    "    )"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Example 1: Compare Answer Relevancy (Old vs New Implementation)\n",
-    "\n",
-    "Compare the legacy `AnswerRelevancy` from `ragas.metrics` with the new `AnswerRelevancy` from `ragas.metrics.collections`."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": "# Setup LLMs and Embeddings\nfrom langchain_openai import ChatOpenAI, OpenAIEmbeddings\nfrom openai import AsyncOpenAI\n\nfrom ragas.embeddings.base import LangchainEmbeddingsWrapper, embedding_factory\nfrom ragas.llms.base import LangchainLLMWrapper, instructor_llm_factory\n\n# For old metric (legacy) - wrap langchain components\nlangchain_llm = ChatOpenAI(model=\"gpt-4o-mini\")\nlegacy_llm = LangchainLLMWrapper(langchain_llm)\n\nlangchain_embeddings = OpenAIEmbeddings(model=\"text-embedding-ada-002\")\nlegacy_embeddings = LangchainEmbeddingsWrapper(langchain_embeddings)\n\n# For new metric (modern)\nclient = AsyncOpenAI()\nmodern_llm = instructor_llm_factory(\"openai\", client=client, model=\"gpt-4o-mini\")\nmodern_embeddings = embedding_factory(\n    \"openai\", model=\"text-embedding-ada-002\", client=client, interface=\"modern\"\n)"
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Import metrics\n",
-    "from ragas.metrics._answer_relevance import AnswerRelevancy as OldAnswerRelevancy\n",
-    "from ragas.metrics.collections._answer_relevancy import (\n",
-    "    AnswerRelevancy as NewAnswerRelevancy,\n",
-    ")\n",
-    "\n",
-    "# Initialize metrics\n",
-    "old_metric = OldAnswerRelevancy(\n",
-    "    llm=legacy_llm, embeddings=legacy_embeddings, strictness=3\n",
-    ")\n",
-    "\n",
-    "new_metric = NewAnswerRelevancy(\n",
-    "    llm=modern_llm, embeddings=modern_embeddings, strictness=3\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": "# Load amnesty dataset\nimport sys\nfrom pathlib import Path\n\nfrom tests.e2e.test_dataset_utils import load_amnesty_dataset_safe\n\n# Add tests directory to path\ntests_dir = Path.cwd().parent if Path.cwd().name == \"notebooks\" else Path.cwd()\nif tests_dir.name == \"tests\":\n    sys.path.insert(0, str(tests_dir.parent))\nelse:\n    sys.path.insert(0, str(tests_dir))\n\n# Load the dataset (will use HuggingFace or fallback to local samples)\namnesty_dataset = load_amnesty_dataset_safe(\"english_v3\")\n\n# Convert to list of dicts for our utility functions\n# We'll use a subset for faster testing\ntest_dataset = []\nfor i, sample in enumerate(amnesty_dataset):\n    if i >= 5:  # Limit to 5 samples for faster testing\n        break\n    test_dataset.append(\n        {\"user_input\": sample[\"user_input\"], \"response\": sample[\"response\"]}\n    )\n\nprint(f\"Test dataset contains {len(test_dataset)} samples from amnesty_qa\")\nprint(\"\\nFirst sample:\")\nprint(f\"Question: {test_dataset[0]['user_input']}\")\nprint(f\"Response: {test_dataset[0]['response'][:100]}...\")"
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Run comparison\n",
-    "result = await compare_metrics(\n",
-    "    old_metric=old_metric,\n",
-    "    new_metric=new_metric,\n",
-    "    dataset=test_dataset,\n",
-    "    old_metric_type=\"old\",\n",
-    "    new_metric_type=\"new\",\n",
-    ")\n",
-    "\n",
-    "# Print summary\n",
-    "result.print_summary()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# View detailed results\n",
-    "df = result.to_dataframe()\n",
-    "df[\"user_input\"] = [s[\"user_input\"] for s in test_dataset]\n",
-    "df = df[[\"user_input\", \"old_score\", \"new_score\", \"diff\", \"abs_diff\"]]\n",
-    "df"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Visualize the differences\n",
-    "import matplotlib.pyplot as plt\n",
-    "\n",
-    "fig, axes = plt.subplots(1, 2, figsize=(14, 5))\n",
-    "\n",
-    "# Plot 1: Score comparison\n",
-    "x = range(len(result.old_scores))\n",
-    "axes[0].plot(x, result.old_scores, \"o-\", label=\"Old Metric\", linewidth=2)\n",
-    "axes[0].plot(x, result.new_scores, \"s-\", label=\"New Metric\", linewidth=2)\n",
-    "axes[0].set_xlabel(\"Sample Index\")\n",
-    "axes[0].set_ylabel(\"Score\")\n",
-    "axes[0].set_title(\"Metric Scores Comparison\")\n",
-    "axes[0].legend()\n",
-    "axes[0].grid(True, alpha=0.3)\n",
-    "\n",
-    "# Plot 2: Difference distribution\n",
-    "axes[1].bar(x, result.diffs, alpha=0.7)\n",
-    "axes[1].axhline(y=0, color=\"r\", linestyle=\"--\", linewidth=1)\n",
-    "axes[1].set_xlabel(\"Sample Index\")\n",
-    "axes[1].set_ylabel(\"Difference (New - Old)\")\n",
-    "axes[1].set_title(\"Score Differences\")\n",
-    "axes[1].grid(True, alpha=0.3)\n",
-    "\n",
-    "plt.tight_layout()\n",
-    "plt.show()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Example 2: Compare Same Metric with Different LLMs\n",
-    "\n",
-    "Compare how the same metric performs with different LLM models."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Create two instances with different LLMs\n",
-    "client = AsyncOpenAI()\n",
-    "\n",
-    "llm_gpt4_mini = instructor_llm_factory(\"openai\", client=client, model=\"gpt-4o-mini\")\n",
-    "llm_gpt4 = instructor_llm_factory(\"openai\", client=client, model=\"gpt-4o\")\n",
-    "\n",
-    "embeddings = embedding_factory(\n",
-    "    \"openai\", model=\"text-embedding-ada-002\", client=client, interface=\"modern\"\n",
-    ")\n",
-    "\n",
-    "metric_gpt4_mini = NewAnswerRelevancy(\n",
-    "    llm=llm_gpt4_mini, embeddings=embeddings, strictness=3\n",
-    ")\n",
-    "\n",
-    "metric_gpt4 = NewAnswerRelevancy(llm=llm_gpt4, embeddings=embeddings, strictness=3)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Compare LLMs\n",
-    "result_llm = await compare_metrics(\n",
-    "    old_metric=metric_gpt4_mini,\n",
-    "    new_metric=metric_gpt4,\n",
-    "    dataset=test_dataset,\n",
-    "    old_metric_type=\"new\",\n",
-    "    new_metric_type=\"new\",\n",
-    ")\n",
-    "\n",
-    "result_llm.print_summary()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Example 3: Compare with Different Datasets\n",
-    "\n",
-    "Load different datasets to test metric consistency."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Use different subsets of amnesty dataset\n",
-    "# First 2 samples\n",
-    "dataset_subset_1 = test_dataset[:2]\n",
-    "\n",
-    "# Next 2 samples (if available)\n",
-    "dataset_subset_2 = test_dataset[2:4] if len(test_dataset) >= 4 else test_dataset[:2]\n",
-    "\n",
-    "print(f\"Subset 1: {len(dataset_subset_1)} samples\")\n",
-    "print(f\"Subset 2: {len(dataset_subset_2)} samples\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Compare same metric on different dataset subsets\n",
-    "print(\"\\n=== Dataset Subset 1 ===\")\n",
-    "scores_subset_1, time_subset_1 = await run_metric_on_dataset(\n",
-    "    new_metric, dataset_subset_1, \"new\"\n",
-    ")\n",
-    "print(f\"Mean score: {np.mean(scores_subset_1):.4f}\")\n",
-    "print(f\"Execution time: {time_subset_1:.2f}s\")\n",
-    "\n",
-    "print(\"\\n=== Dataset Subset 2 ===\")\n",
-    "scores_subset_2, time_subset_2 = await run_metric_on_dataset(\n",
-    "    new_metric, dataset_subset_2, \"new\"\n",
-    ")\n",
-    "print(f\"Mean score: {np.mean(scores_subset_2):.4f}\")\n",
-    "print(f\"Execution time: {time_subset_2:.2f}s\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Utility: Export Results to CSV"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def export_comparison_results(\n",
-    "    result: MetricDiffResult,\n",
-    "    dataset: List[Dict[str, Any]],\n",
-    "    filename: str = \"metric_comparison_results.csv\",\n",
-    "):\n",
-    "    \"\"\"Export comparison results to CSV file.\"\"\"\n",
-    "    df = result.to_dataframe()\n",
-    "\n",
-    "    # Add dataset information\n",
-    "    for key in dataset[0].keys():\n",
-    "        df[key] = [sample[key] for sample in dataset]\n",
-    "\n",
-    "    # Add summary statistics as a separate row\n",
-    "    summary = pd.DataFrame(\n",
-    "        [\n",
-    "            {\n",
-    "                \"user_input\": \"SUMMARY\",\n",
-    "                \"old_score\": result.old_mean,\n",
-    "                \"new_score\": result.new_mean,\n",
-    "                \"diff\": result.mean_diff,\n",
-    "                \"abs_diff\": np.mean([abs(d) for d in result.diffs]),\n",
-    "            }\n",
-    "        ]\n",
-    "    )\n",
-    "\n",
-    "    df = pd.concat([df, summary], ignore_index=True)\n",
-    "    df.to_csv(filename, index=False)\n",
-    "    print(f\"Results exported to {filename}\")\n",
-    "\n",
-    "\n",
-    "# Example usage\n",
-    "export_comparison_results(result, test_dataset, \"answer_relevancy_comparison.csv\")"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.10.0"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 4
-}
\ No newline at end of file
diff --git a/tests/utils/__init__.py b/tests/utils/__init__.py
new file mode 100644
index 000000000..7d7733305
--- /dev/null
+++ b/tests/utils/__init__.py
@@ -0,0 +1,35 @@
+"""Shared test utilities for Ragas tests.
+
+This module provides reusable utilities for both pytest tests and Jupyter notebooks,
+including LLM setup, embeddings configuration, and common test helpers.
+"""
+
+from .llm_setup import (
+    check_api_key,
+    create_legacy_embeddings,
+    create_legacy_llm,
+    create_modern_embeddings,
+    create_modern_llm,
+)
+from .metric_comparison import (
+    MetricDiffResult,
+    compare_metrics,
+    export_comparison_results,
+    run_metric_on_dataset,
+    run_metric_on_dataset_with_batching,
+)
+
+__all__ = [
+    # LLM and embeddings setup
+    "check_api_key",
+    "create_legacy_llm",
+    "create_modern_llm",
+    "create_legacy_embeddings",
+    "create_modern_embeddings",
+    # Metric comparison utilities
+    "MetricDiffResult",
+    "compare_metrics",
+    "export_comparison_results",
+    "run_metric_on_dataset",
+    "run_metric_on_dataset_with_batching",
+]
diff --git a/tests/utils/llm_setup.py b/tests/utils/llm_setup.py
new file mode 100644
index 000000000..79caf75d4
--- /dev/null
+++ b/tests/utils/llm_setup.py
@@ -0,0 +1,229 @@
+"""Factory functions for creating LLMs and embeddings for testing.
+
+This module provides reusable functions for creating both legacy and modern
+LLM and embedding instances. These can be used in both pytest tests (via fixtures)
+and Jupyter notebooks (directly).
+"""
+
+import os
+from typing import Optional
+
+
+def check_api_key(provider: str = "openai") -> bool:
+    """Check if required API key is set.
+
+    Args:
+        provider: The provider to check for (default: "openai")
+
+    Returns:
+        True if API key is set
+
+    Raises:
+        ValueError: If API key is not set
+    """
+    env_vars = {
+        "openai": "OPENAI_API_KEY",
+        "anthropic": "ANTHROPIC_API_KEY",
+    }
+
+    env_var = env_vars.get(provider.lower())
+    if not env_var:
+        raise ValueError(f"Unknown provider: {provider}")
+
+    if not os.getenv(env_var):
+        raise ValueError(
+            f"{env_var} environment variable not set. "
+            f"Please set it before running:\n"
+            f"  export {env_var}='your-api-key-here'"
+        )
+
+    return True
+
+
+def create_legacy_llm(model: str = "gpt-3.5-turbo", **kwargs):
+    """Create a legacy LLM instance for old-style metrics.
+
+    Args:
+        model: The model name to use
+        **kwargs: Additional arguments to pass to llm_factory
+
+    Returns:
+        Legacy LLM instance
+
+    Raises:
+        ImportError: If llm_factory is not available
+        Exception: If LLM creation fails (e.g., missing API key)
+    """
+    try:
+        from ragas.llms.base import llm_factory
+
+        return llm_factory(model, **kwargs)
+    except ImportError as e:
+        raise ImportError(f"LLM factory not available: {e}")
+    except Exception as e:
+        raise Exception(f"Could not create LLM (API key may be missing): {e}")
+
+
+def create_modern_llm(
+    provider: str = "openai",
+    model: str = "gpt-3.5-turbo",
+    client: Optional[any] = None,
+    **kwargs,
+):
+    """Create a modern instructor LLM instance for v2 metrics.
+
+    Args:
+        provider: The LLM provider (e.g., "openai", "anthropic")
+        model: The model name to use
+        client: Optional async client instance. If None, will create one.
+        **kwargs: Additional arguments to pass to instructor_llm_factory
+
+    Returns:
+        Modern instructor LLM instance
+
+    Raises:
+        ImportError: If required libraries are not available
+        Exception: If LLM creation fails
+    """
+    try:
+        from ragas.llms.base import instructor_llm_factory
+
+        # Create client if not provided
+        if client is None:
+            if provider == "openai":
+                import openai
+
+                client = openai.AsyncOpenAI()
+            else:
+                raise ValueError(f"Auto-client creation not supported for {provider}")
+
+        return instructor_llm_factory(provider, model=model, client=client, **kwargs)
+    except ImportError as e:
+        raise ImportError(f"Instructor LLM factory not available: {e}")
+    except Exception as e:
+        raise Exception(f"Could not create modern LLM (API key may be missing): {e}")
+
+
+def create_legacy_embeddings(model: str = "text-embedding-ada-002", **kwargs):
+    """Create legacy embeddings for old-style metrics.
+
+    Args:
+        model: The embedding model name to use
+        **kwargs: Additional arguments to pass to embedding_factory
+
+    Returns:
+        Legacy embeddings instance
+
+    Raises:
+        ImportError: If embedding_factory is not available
+        Exception: If embeddings creation fails
+    """
+    try:
+        from ragas.embeddings.base import embedding_factory
+
+        return embedding_factory(model, **kwargs)
+    except ImportError as e:
+        raise ImportError(f"Embedding factory not available: {e}")
+    except Exception as e:
+        raise Exception(
+            f"Could not create legacy embeddings (API key may be missing): {e}"
+        )
+
+
+def create_modern_embeddings(
+    provider: str = "openai",
+    model: str = "text-embedding-ada-002",
+    client: Optional[any] = None,
+    interface: str = "modern",
+    **kwargs,
+):
+    """Create modern embeddings for v2 metrics.
+
+    Args:
+        provider: The embeddings provider (e.g., "openai")
+        model: The embedding model name to use
+        client: Optional async client instance. If None, will create one.
+        interface: Interface type (default: "modern")
+        **kwargs: Additional arguments to pass to embedding_factory
+
+    Returns:
+        Modern embeddings instance
+
+    Raises:
+        ImportError: If required libraries are not available
+        Exception: If embeddings creation fails
+    """
+    try:
+        from ragas.embeddings.base import embedding_factory
+
+        # Create client if not provided
+        if client is None:
+            if provider == "openai":
+                import openai
+
+                client = openai.AsyncOpenAI()
+            else:
+                raise ValueError(f"Auto-client creation not supported for {provider}")
+
+        return embedding_factory(
+            provider=provider,
+            model=model,
+            client=client,
+            interface=interface,
+            **kwargs,
+        )
+    except ImportError as e:
+        raise ImportError(f"OpenAI or embedding factory not available: {e}")
+    except Exception as e:
+        raise Exception(
+            f"Could not create modern embeddings (API key may be missing): {e}"
+        )
+
+
+# Legacy-style factory functions for backward compatibility with langchain wrappers
+def create_legacy_llm_with_langchain(model: str = "gpt-4o-mini", **kwargs):
+    """Create a legacy LLM using Langchain wrapper.
+
+    This is for compatibility with older code that uses Langchain wrappers.
+
+    Args:
+        model: The model name to use
+        **kwargs: Additional arguments
+
+    Returns:
+        LangchainLLMWrapper instance
+    """
+    try:
+        from langchain_openai import ChatOpenAI
+
+        from ragas.llms.base import LangchainLLMWrapper
+
+        langchain_llm = ChatOpenAI(model=model, **kwargs)
+        return LangchainLLMWrapper(langchain_llm)
+    except ImportError as e:
+        raise ImportError(f"Langchain or LangchainLLMWrapper not available: {e}")
+
+
+def create_legacy_embeddings_with_langchain(
+    model: str = "text-embedding-ada-002", **kwargs
+):
+    """Create legacy embeddings using Langchain wrapper.
+
+    This is for compatibility with older code that uses Langchain wrappers.
+
+    Args:
+        model: The embedding model name to use
+        **kwargs: Additional arguments
+
+    Returns:
+        LangchainEmbeddingsWrapper instance
+    """
+    try:
+        from langchain_openai import OpenAIEmbeddings
+
+        from ragas.embeddings.base import LangchainEmbeddingsWrapper
+
+        langchain_embeddings = OpenAIEmbeddings(model=model, **kwargs)
+        return LangchainEmbeddingsWrapper(langchain_embeddings)
+    except ImportError as e:
+        raise ImportError(f"Langchain or LangchainEmbeddingsWrapper not available: {e}")
diff --git a/tests/utils/metric_comparison.py b/tests/utils/metric_comparison.py
new file mode 100644
index 000000000..2adc6171b
--- /dev/null
+++ b/tests/utils/metric_comparison.py
@@ -0,0 +1,351 @@
+"""Utilities for comparing metrics across different implementations.
+
+This module provides tools for comparing legacy and modern metric implementations,
+including concurrent execution, statistical analysis, and result export capabilities.
+"""
+
+import asyncio
+import time
+from dataclasses import dataclass
+from typing import Any, Dict, List, Tuple
+
+import numpy as np
+import pandas as pd
+
+from ragas.dataset_schema import SingleTurnSample
+
+
+@dataclass
+class MetricDiffResult:
+    """Container for metric comparison results.
+
+    Attributes:
+        old_scores: List of scores from the baseline/old metric
+        new_scores: List of scores from the new metric
+        diffs: List of differences (new - old)
+        mean_diff: Mean of differences
+        max_diff: Maximum difference
+        min_diff: Minimum difference
+        std_diff: Standard deviation of differences
+        old_mean: Mean of old metric scores
+        new_mean: Mean of new metric scores
+        old_time: Execution time for old metric (seconds)
+        new_time: Execution time for new metric (seconds)
+    """
+
+    old_scores: List[float]
+    new_scores: List[float]
+    diffs: List[float]
+    mean_diff: float
+    max_diff: float
+    min_diff: float
+    std_diff: float
+    old_mean: float
+    new_mean: float
+    old_time: float
+    new_time: float
+
+    def to_dataframe(self) -> pd.DataFrame:
+        """Convert results to a pandas DataFrame.
+
+        Returns:
+            DataFrame with columns: old_score, new_score, diff, abs_diff
+        """
+        return pd.DataFrame(
+            {
+                "old_score": self.old_scores,
+                "new_score": self.new_scores,
+                "diff": self.diffs,
+                "abs_diff": [abs(d) for d in self.diffs],
+            }
+        )
+
+    def print_summary(self):
+        """Print a formatted summary of the comparison results."""
+        print("=" * 60)
+        print("METRIC COMPARISON SUMMARY")
+        print("=" * 60)
+        print("\nScore Statistics:")
+        print(f"  Old Metric Mean: {self.old_mean:.4f}")
+        print(f"  New Metric Mean: {self.new_mean:.4f}")
+        print("\nDifference Statistics (new - old):")
+        print(f"  Mean Diff:   {self.mean_diff:.4f}")
+        print(f"  Max Diff:    {self.max_diff:.4f}")
+        print(f"  Min Diff:    {self.min_diff:.4f}")
+        print(f"  Std Dev:     {self.std_diff:.4f}")
+        print("\nExecution Time:")
+        print(f"  Old Metric:  {self.old_time:.2f}s")
+        print(f"  New Metric:  {self.new_time:.2f}s")
+        print(
+            f"  Speedup:     {self.old_time / self.new_time:.2f}x"
+            if self.new_time > 0
+            else "  N/A"
+        )
+        print("=" * 60)
+
+
+async def run_metric_on_dataset(
+    metric: Any,
+    dataset: List[Dict[str, Any]],
+    metric_type: str = "old",
+    max_concurrent: int = 10,
+) -> Tuple[List[float], float]:
+    """
+    Run a metric on a dataset with concurrent processing for better performance.
+
+    This function processes all samples concurrently with a semaphore to limit
+    the number of simultaneous API calls, preventing rate limiting issues.
+
+    Args:
+        metric: The metric instance (either old or new style)
+        dataset: List of dictionaries containing the data samples
+        metric_type: "old" for legacy metrics, "new" for collections metrics
+        max_concurrent: Maximum number of concurrent requests (default: 10)
+
+    Returns:
+        Tuple of (scores list, execution time in seconds)
+
+    Example:
+        >>> scores, time = await run_metric_on_dataset(
+        ...     metric=my_metric,
+        ...     dataset=[{"user_input": "q1", "response": "a1"}],
+        ...     metric_type="new",
+        ...     max_concurrent=5,
+        ... )
+    """
+
+    async def score_single_sample(sample_dict: Dict[str, Any]) -> float:
+        """Score a single sample using the appropriate metric interface."""
+        try:
+            if metric_type == "old":
+                # Old metrics use SingleTurnSample
+                sample = SingleTurnSample(**sample_dict)
+                score = await metric._single_turn_ascore(sample, callbacks=None)
+            else:
+                # New metrics use direct kwargs
+                result = await metric.ascore(**sample_dict)
+                score = result.value
+
+            return float(score)
+        except Exception as e:
+            print(f"Error processing sample: {e}")
+            return np.nan
+
+    start_time = time.time()
+
+    # Use semaphore to limit concurrent requests (prevents API rate limiting)
+    semaphore = asyncio.Semaphore(max_concurrent)
+
+    async def score_with_limit(sample_dict: Dict[str, Any]) -> float:
+        """Score with concurrency control."""
+        async with semaphore:
+            return await score_single_sample(sample_dict)
+
+    # Process all samples concurrently
+    scores = await asyncio.gather(*[score_with_limit(s) for s in dataset])
+
+    execution_time = time.time() - start_time
+    return list(scores), execution_time
+
+
+async def compare_metrics(
+    old_metric: Any,
+    new_metric: Any,
+    dataset: List[Dict[str, Any]],
+    old_metric_type: str = "old",
+    new_metric_type: str = "new",
+    max_concurrent: int = 10,
+    parallel_metrics: bool = True,
+) -> MetricDiffResult:
+    """
+    Compare two metrics on the same dataset with optional parallel execution.
+
+    This function runs both metrics on the dataset and computes detailed
+    comparison statistics. Metrics can be run in parallel (faster) or
+    sequentially (more accurate individual timing).
+
+    Args:
+        old_metric: The baseline/old metric instance
+        new_metric: The new/updated metric instance
+        dataset: List of dictionaries containing the data samples
+        old_metric_type: Type identifier for old metric ("old" or "new")
+        new_metric_type: Type identifier for new metric ("old" or "new")
+        max_concurrent: Maximum number of concurrent requests per metric (default: 10)
+        parallel_metrics: If True, run both metrics in parallel. If False, run sequentially
+                         for more accurate individual timing (default: True)
+
+    Returns:
+        MetricDiffResult containing detailed comparison statistics
+
+    Example:
+        >>> result = await compare_metrics(
+        ...     old_metric=legacy_metric,
+        ...     new_metric=modern_metric,
+        ...     dataset=test_data,
+        ...     max_concurrent=5,
+        ...     parallel_metrics=True,
+        ... )
+        >>> result.print_summary()
+    """
+    if parallel_metrics:
+        print(
+            f"Running both metrics in parallel on {len(dataset)} samples (max {max_concurrent} concurrent)..."
+        )
+
+        # Run both metrics concurrently using asyncio.gather
+        (old_scores, old_time), (new_scores, new_time) = await asyncio.gather(
+            run_metric_on_dataset(old_metric, dataset, old_metric_type, max_concurrent),
+            run_metric_on_dataset(new_metric, dataset, new_metric_type, max_concurrent),
+        )
+    else:
+        # Sequential execution for more accurate individual timing
+        print(
+            f"Running old metric on {len(dataset)} samples (max {max_concurrent} concurrent)..."
+        )
+        old_scores, old_time = await run_metric_on_dataset(
+            old_metric, dataset, old_metric_type, max_concurrent
+        )
+
+        print(
+            f"Running new metric on {len(dataset)} samples (max {max_concurrent} concurrent)..."
+        )
+        new_scores, new_time = await run_metric_on_dataset(
+            new_metric, dataset, new_metric_type, max_concurrent
+        )
+
+    # Calculate differences
+    diffs = [new - old for old, new in zip(old_scores, new_scores)]
+
+    return MetricDiffResult(
+        old_scores=old_scores,
+        new_scores=new_scores,
+        diffs=diffs,
+        mean_diff=float(np.mean(diffs)),
+        max_diff=float(np.max(diffs)),
+        min_diff=float(np.min(diffs)),
+        std_diff=float(np.std(diffs)),
+        old_mean=float(np.mean(old_scores)),
+        new_mean=float(np.mean(new_scores)),
+        old_time=old_time,
+        new_time=new_time,
+    )
+
+
+async def run_metric_on_dataset_with_batching(
+    metric: Any,
+    dataset: List[Dict[str, Any]],
+    metric_type: str = "new",
+    batch_size: int = 5,
+) -> Tuple[List[float], float]:
+    """
+    Run metric using batch processing if available (for better performance).
+
+    This function attempts to use the metric's abatch_score method if available,
+    which can be more efficient than individual scoring. Falls back to concurrent
+    processing if batching is not supported.
+
+    Args:
+        metric: The metric instance
+        dataset: List of dictionaries containing the data samples
+        metric_type: "old" or "new" - old metrics don't support batching
+        batch_size: Number of samples per batch (default: 5)
+
+    Returns:
+        Tuple of (scores list, execution time in seconds)
+
+    Example:
+        >>> scores, time = await run_metric_on_dataset_with_batching(
+        ...     metric=my_metric,
+        ...     dataset=test_data,
+        ...     metric_type="new",
+        ...     batch_size=10,
+        ... )
+    """
+    # Check if metric supports batching
+    has_batch = hasattr(metric, "abatch_score")
+
+    if not has_batch or metric_type == "old":
+        # Fall back to concurrent processing
+        print("  Batching not available, using concurrent processing...")
+        return await run_metric_on_dataset(metric, dataset, metric_type)
+
+    start_time = time.time()
+    all_scores = []
+
+    # Process in batches
+    num_batches = (len(dataset) + batch_size - 1) // batch_size
+    print(
+        f"  Processing {len(dataset)} samples in {num_batches} batches of {batch_size}..."
+    )
+
+    for i in range(0, len(dataset), batch_size):
+        batch = dataset[i : i + batch_size]
+        try:
+            results = await metric.abatch_score(batch)
+            scores = [r.value for r in results]
+            all_scores.extend(scores)
+        except Exception as e:
+            print(
+                f"  Warning: Batch {i // batch_size + 1} failed ({e}), falling back to individual processing..."
+            )
+            # Fall back to individual processing for this batch
+            for sample in batch:
+                try:
+                    result = await metric.ascore(**sample)
+                    all_scores.append(result.value)
+                except Exception as e2:
+                    print(f"  Error processing sample: {e2}")
+                    all_scores.append(np.nan)
+
+    execution_time = time.time() - start_time
+    return all_scores, execution_time
+
+
+def export_comparison_results(
+    result: MetricDiffResult,
+    dataset: List[Dict[str, Any]],
+    filename: str = "metric_comparison_results.csv",
+):
+    """
+    Export comparison results to CSV file.
+
+    The CSV includes all scores, differences, and the original dataset fields,
+    plus a summary row with aggregate statistics.
+
+    Args:
+        result: MetricDiffResult object containing comparison data
+        dataset: Original dataset (to include context in export)
+        filename: Output CSV filename (default: "metric_comparison_results.csv")
+
+    Example:
+        >>> export_comparison_results(
+        ...     result=comparison_result,
+        ...     dataset=test_data,
+        ...     filename="context_recall_results.csv",
+        ... )
+    """
+    df = result.to_dataframe()
+
+    # Add dataset information
+    for key in dataset[0].keys():
+        df[key] = [sample.get(key, "") for sample in dataset]
+
+    # Add summary statistics as a separate row
+    summary = pd.DataFrame(
+        [
+            {
+                **{
+                    key: "SUMMARY" if i == 0 else ""
+                    for i, key in enumerate(dataset[0].keys())
+                },
+                "old_score": result.old_mean,
+                "new_score": result.new_mean,
+                "diff": result.mean_diff,
+                "abs_diff": np.mean([abs(d) for d in result.diffs]),
+            }
+        ]
+    )
+
+    df = pd.concat([df, summary], ignore_index=True)
+    df.to_csv(filename, index=False)
+    print(f"Results exported to {filename}")