diff --git a/backend/tests/Ragas/utils/README.md b/backend/tests/Ragas/utils/README.md
index 8eaf5aaa..f95fc2fe 100644
--- a/backend/tests/Ragas/utils/README.md
+++ b/backend/tests/Ragas/utils/README.md
@@ -68,13 +68,10 @@ python enhanced_run_evaluation_pipeline.py /path/to/your/document.pdf 3
 After running the enhanced pipeline which produces the `ragas_evaluation_with_responses.jsonl` file, you must run the RAGAS evaluation script:
 
 ```bash
-python ragas_evaluate.py
+python ragas_evaluate.py --llm 'name-of-llm'
 
 # With custom input/output paths
-python ragas_evaluate.py --input path/to/input.jsonl --output path/to/output.json
-
-# Skip chart generation
-python ragas_evaluate.py --no-chart
+python ragas_evaluate.py --llm 'name-of-llm' --input path/to/input.jsonl --output path/to/output.csv
 ```
 
 ## Environment Variables
@@ -116,8 +113,7 @@ All output files are stored in `../files/`:
 
 - `ragas_evaluation_dataset.jsonl`: Initial questions and references
 - `ragas_evaluation_with_responses.jsonl`: Questions with API responses
-- `ragas_eval_result.json`: Evaluation metrics as configured in RAGAS_METRICS (default: factual_correctness, semantic_similarity, answer_accuracy)
-- `ragas_eval_result_chart.png`: Visualization of evaluation results
+- `ragas_eval_result.csv`: CSV of evaluation metrics, which is appended to on each run. Includes a column for the LLM name to support retrospective graph generation.
 
 ## Troubleshooting
 
diff --git a/backend/tests/Ragas/utils/modules/ragas_evaluation.py b/backend/tests/Ragas/utils/modules/ragas_evaluation.py
index 21affb21..20900c38 100644
--- a/backend/tests/Ragas/utils/modules/ragas_evaluation.py
+++ b/backend/tests/Ragas/utils/modules/ragas_evaluation.py
@@ -6,15 +6,15 @@
 
 import os
 from pathlib import Path
-from typing import Optional
 import pandas as pd
 from ragas import evaluate, EvaluationDataset, SingleTurnSample
 from ragas.llms import LangchainLLMWrapper
 from langchain_openai.chat_models import ChatOpenAI
-from ragas.metrics import answer_relevancy, ContextRelevance, SemanticSimilarity, context_precision
+from ragas.metrics import AnswerAccuracy, SemanticSimilarity, FactualCorrectness
 from ragas.embeddings import LangchainEmbeddingsWrapper
 from langchain_openai import OpenAIEmbeddings
 from dotenv import load_dotenv
+from .ragas_utils import load_jsonl_data
 
 
 # Find the project root (where .env is located)
@@ -67,7 +67,6 @@ def create_ragas_dataset(data):
         # Create a sample using the RAGAS SingleTurnSample class
         eval_sample = SingleTurnSample(
             user_input=sample.get("user_input", ""),
-            retrieved_contexts=[context for context in sample.get("reference_contexts", []) if context],
             response=sample.get("response", ""),
             reference=reference,  # Use either provided reference or first context
         )
@@ -119,23 +118,17 @@ def create_ragas_llm():
     return LangchainLLMWrapper(chat_model), ragas_embeddings
 
 
-async def evaluate_with_ragas(
-    jsonl_path: str, output_json_path: Optional[str] = None, skip_chart: bool = False
-) -> pd.DataFrame:
+async def evaluate_with_ragas(jsonl_path: str) -> pd.DataFrame:
     """
     Evaluate responses using RAGAS metrics
 
     Args:
         jsonl_path: Path to the input JSONL file with responses
-        output_json_path: Path to save the JSON results
-        skip_chart: Whether to skip generating the bar chart
 
     Returns:
         DataFrame with evaluation results
     """
     # Import locally to avoid circular imports
-    from .ragas_utils import load_jsonl_data, save_results_to_json
-    from .ragas_visualization import generate_bar_chart
 
     print("Setting up RAGAS evaluation...")
     print(f"Loading data from {jsonl_path}...")
@@ -150,28 +143,22 @@ async def evaluate_with_ragas(
         dataset, samples, processed_data = create_ragas_dataset(data)
 
         # Define metrics to use for evaluation
-        print(
-            "Configuring default RAGAS metrics: semantic_similarity, "
-            "answer_relevancy, context_relevance, context_precision"
-        )
+        print("Configuring default RAGAS metrics: semantic_similarity,factual_correctness, answer_accuracy")
         metrics = [
             SemanticSimilarity(),
-            answer_relevancy,
-            context_precision,
-            ContextRelevance(llm=llm),
+            FactualCorrectness(llm=llm),
+            AnswerAccuracy(llm=llm),
         ]
 
         # Run the evaluation
         print("Running RAGAS evaluation (this may take a while)...")
         results = evaluate(dataset=dataset, metrics=metrics, llm=llm)
-
         try:
             print("Processing evaluation results including llm_usage if present...")
             # Define expected metrics for alignment and output naming
             expected_metrics = [
-                ("nv_context_relevance", "recontext_relevance"),
-                ("context_precision", "context_precision"),
-                ("answer_relevancy", "answer_relevancy"),
+                ("factual_correctness(mode=f1)", "factual_correctness"),
+                ("nv_accuracy", "answer_accuracy"),
                 ("semantic_similarity", "semantic_similarity"),
             ]
 
@@ -198,7 +185,8 @@ async def evaluate_with_ragas(
                     row_dict[mapped] = df.loc[idx, raw]
                 # Attach llm_usage if supplied in original input sample
                 if "llm_usage" in processed_data[idx]:
-                    row_dict["llm_usage"] = processed_data[idx]["llm_usage"]
+                    for key, val in processed_data[idx]["llm_usage"].items():
+                        row_dict[key] = val
                 rows.append(row_dict)
 
             results_df = pd.DataFrame(rows)
@@ -232,20 +220,6 @@ async def evaluate_with_ragas(
             print(f"Could not process RAGAS results with llm_usage: {e}")
             raise
 
-        # Save results and generate visualization
-        if output_json_path:
-            # Save results to JSON
-            save_results_to_json(results_df, output_json_path)
-
-            # Generate visualization if not disabled
-            if not skip_chart:
-                try:
-                    chart_path = generate_bar_chart(output_json_path)
-                    if chart_path:
-                        print(f"Chart generated: {chart_path}")
-                except Exception as e:
-                    print(f"Chart generation failed: {e}")
-
         return results_df
 
     except Exception as e:
diff --git a/backend/tests/Ragas/utils/ragas_evaluate.py b/backend/tests/Ragas/utils/ragas_evaluate.py
index 4479919d..7ae7bedd 100644
--- a/backend/tests/Ragas/utils/ragas_evaluate.py
+++ b/backend/tests/Ragas/utils/ragas_evaluate.py
@@ -9,33 +9,30 @@
 import sys
 import argparse
 import asyncio
-import pandas as pd
 from modules.ragas_evaluation import evaluate_with_ragas
 
 
-async def run_evaluation(input_path: str, output_path: str, skip_chart: bool = False) -> pd.DataFrame:
+async def run_evaluation(input_path: str, output_path: str, llm: str) -> None:
     """
     Run the RAGAS evaluation process end-to-end
 
     Args:
         input_path: Path to input JSONL file with responses
         output_path: Path to save JSON output results
-        skip_chart: Whether to skip chart generation
-
-    Returns:
-        DataFrame with evaluation results
+        llm: The LLM model to use for evaluation
     """
 
     # Run RAGAS evaluation
     print(f"Running RAGAS evaluation on {input_path}...")
-    results_df = await evaluate_with_ragas(input_path, output_path, skip_chart)
+    results_df = await evaluate_with_ragas(input_path)
+    results_df["llm"] = llm
+    print("RAGAS evaluation completed.")
+    print(f"Appending results to CSV file... {output_path}")
 
-    print(f"Evaluation complete! Results saved to {output_path}")
-    if not skip_chart:
-        chart_path = output_path.replace(".json", "_chart.png")
-        print(f"Chart saved to {chart_path}")
+    file_exists = os.path.isfile(output_path)
+    results_df.to_csv(output_path, mode="a", header=not file_exists, index=False)
 
-    return results_df
+    print("Results appended to CSV file.")
 
 
 async def main():
@@ -44,13 +41,13 @@ async def main():
     # Set up default file paths
     base_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))  # Navigate to Ragas root
     default_input = os.path.normpath(os.path.join(base_dir, "files/ragas_evaluation_with_responses.jsonl"))
-    default_output = os.path.normpath(os.path.join(base_dir, "files/ragas_eval_result.json"))
+    default_output = os.path.normpath(os.path.join(base_dir, "files/ragas_eval_result.csv"))
 
     # Parse command line arguments
     parser = argparse.ArgumentParser(description="Evaluate responses using RAGAS metrics")
+    parser.add_argument("--llm", "-l", help="LLM model to use for evaluation")
     parser.add_argument("--input", "-i", dest="input_jsonl", help="Path to input JSONL file", default=default_input)
-    parser.add_argument("--output", "-o", help="Path to save JSON output", default=default_output)
-    parser.add_argument("--no-chart", action="store_true", help="Skip chart visualization")
+    parser.add_argument("--output", "-o", help="Path to save CSV output", default=default_output)
     args = parser.parse_args()
 
     # Validate input file
@@ -60,12 +57,11 @@ async def main():
 
     print(f"Input file: {args.input_jsonl}")
     print(f"Output file: {args.output}")
-    if args.no_chart:
-        print("Chart generation is disabled")
+    print(f"LLM model: {args.llm}")
 
     # Run evaluation
     try:
-        await run_evaluation(args.input_jsonl, args.output, args.no_chart)
+        await run_evaluation(args.input_jsonl, args.output, args.llm)
     except Exception as e:
         print(f"Error during evaluation: {str(e)}")
         sys.exit(1)
diff --git a/backend/tests/Ragas/utils/requirements.txt b/backend/tests/Ragas/utils/requirements.txt
index f18c544a..b8220885 100644
--- a/backend/tests/Ragas/utils/requirements.txt
+++ b/backend/tests/Ragas/utils/requirements.txt
@@ -10,3 +10,4 @@ python-dotenv>=1.0.0
 pandas>=2.0.0
 nest_asyncio>=1.5.6
 matplotlib>=3.10.5
+ipykernel==7.0.1
diff --git a/backend/tests/Ragas/utils/visualise.ipynb b/backend/tests/Ragas/utils/visualise.ipynb
new file mode 100644
index 00000000..1d8868b8
--- /dev/null
+++ b/backend/tests/Ragas/utils/visualise.ipynb
@@ -0,0 +1,547 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "e3f8e408",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "DataFrame shape: (207, 10)\n",
+      "Columns: ['question', 'recontext_relevance', 'context_precision', 'answer_relevancy', 'semantic_similarity', 'prompt_tokens', 'completion_tokens', 'total_tokens', 'duration_seconds', 'llm']\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>question</th>\n",
+       "      <th>recontext_relevance</th>\n",
+       "      <th>context_precision</th>\n",
+       "      <th>answer_relevancy</th>\n",
+       "      <th>semantic_similarity</th>\n",
+       "      <th>prompt_tokens</th>\n",
+       "      <th>completion_tokens</th>\n",
+       "      <th>total_tokens</th>\n",
+       "      <th>duration_seconds</th>\n",
+       "      <th>llm</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>What is the main focus of AstraZeneca's sustai...</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.000000</td>\n",
+       "      <td>0.926802</td>\n",
+       "      <td>42899.0</td>\n",
+       "      <td>5146.0</td>\n",
+       "      <td>48045.0</td>\n",
+       "      <td>103.87</td>\n",
+       "      <td>deepseek</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>What are the three main areas of AstraZeneca's...</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.978140</td>\n",
+       "      <td>0.931793</td>\n",
+       "      <td>65717.0</td>\n",
+       "      <td>18606.0</td>\n",
+       "      <td>84323.0</td>\n",
+       "      <td>348.09</td>\n",
+       "      <td>deepseek</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>What is AstraZeneca's target for reducing emis...</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.962785</td>\n",
+       "      <td>0.928104</td>\n",
+       "      <td>43570.0</td>\n",
+       "      <td>3915.0</td>\n",
+       "      <td>47485.0</td>\n",
+       "      <td>81.96</td>\n",
+       "      <td>deepseek</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>What is AstraZeneca's commitment towards water...</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.994569</td>\n",
+       "      <td>0.940814</td>\n",
+       "      <td>43595.0</td>\n",
+       "      <td>6976.0</td>\n",
+       "      <td>50571.0</td>\n",
+       "      <td>142.40</td>\n",
+       "      <td>deepseek</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>What is the My Green Lab Certification?</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.950364</td>\n",
+       "      <td>0.861575</td>\n",
+       "      <td>57642.0</td>\n",
+       "      <td>13906.0</td>\n",
+       "      <td>71548.0</td>\n",
+       "      <td>268.12</td>\n",
+       "      <td>deepseek</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                                            question  recontext_relevance  \\\n",
+       "0  What is the main focus of AstraZeneca's sustai...                  1.0   \n",
+       "1  What are the three main areas of AstraZeneca's...                  1.0   \n",
+       "2  What is AstraZeneca's target for reducing emis...                  1.0   \n",
+       "3  What is AstraZeneca's commitment towards water...                  1.0   \n",
+       "4            What is the My Green Lab Certification?                  0.0   \n",
+       "\n",
+       "   context_precision  answer_relevancy  semantic_similarity  prompt_tokens  \\\n",
+       "0                1.0          1.000000             0.926802        42899.0   \n",
+       "1                1.0          0.978140             0.931793        65717.0   \n",
+       "2                1.0          0.962785             0.928104        43570.0   \n",
+       "3                1.0          0.994569             0.940814        43595.0   \n",
+       "4                1.0          0.950364             0.861575        57642.0   \n",
+       "\n",
+       "   completion_tokens  total_tokens  duration_seconds       llm  \n",
+       "0             5146.0       48045.0            103.87  deepseek  \n",
+       "1            18606.0       84323.0            348.09  deepseek  \n",
+       "2             3915.0       47485.0             81.96  deepseek  \n",
+       "3             6976.0       50571.0            142.40  deepseek  \n",
+       "4            13906.0       71548.0            268.12  deepseek  "
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Load data from CSV into DataFrame\n",
+    "import pandas as pd\n",
+    "\n",
+    "# Load CSV file into DataFrame\n",
+    "df = pd.read_csv(\"../files/ragas_eval_result.csv\")\n",
+    "\n",
+    "# Display basic information about the DataFrame\n",
+    "print(f\"DataFrame shape: {df.shape}\")\n",
+    "print(f\"Columns: {list(df.columns)}\")\n",
+    "\n",
+    "# Display first few rows\n",
+    "df.head()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "536a9c62",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Original DataFrame shape: (207, 10)\n",
+      "Cleaned DataFrame shape: (193, 10)\n",
+      "Removed 14 rows\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>question</th>\n",
+       "      <th>recontext_relevance</th>\n",
+       "      <th>context_precision</th>\n",
+       "      <th>answer_relevancy</th>\n",
+       "      <th>semantic_similarity</th>\n",
+       "      <th>prompt_tokens</th>\n",
+       "      <th>completion_tokens</th>\n",
+       "      <th>total_tokens</th>\n",
+       "      <th>duration_seconds</th>\n",
+       "      <th>llm</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>What is the main focus of AstraZeneca's sustai...</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.000000</td>\n",
+       "      <td>0.926802</td>\n",
+       "      <td>42899.0</td>\n",
+       "      <td>5146.0</td>\n",
+       "      <td>48045.0</td>\n",
+       "      <td>103.87</td>\n",
+       "      <td>deepseek</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>What are the three main areas of AstraZeneca's...</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.978140</td>\n",
+       "      <td>0.931793</td>\n",
+       "      <td>65717.0</td>\n",
+       "      <td>18606.0</td>\n",
+       "      <td>84323.0</td>\n",
+       "      <td>348.09</td>\n",
+       "      <td>deepseek</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>What is AstraZeneca's target for reducing emis...</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.962785</td>\n",
+       "      <td>0.928104</td>\n",
+       "      <td>43570.0</td>\n",
+       "      <td>3915.0</td>\n",
+       "      <td>47485.0</td>\n",
+       "      <td>81.96</td>\n",
+       "      <td>deepseek</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>What is AstraZeneca's commitment towards water...</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.994569</td>\n",
+       "      <td>0.940814</td>\n",
+       "      <td>43595.0</td>\n",
+       "      <td>6976.0</td>\n",
+       "      <td>50571.0</td>\n",
+       "      <td>142.40</td>\n",
+       "      <td>deepseek</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>What is the My Green Lab Certification?</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.950364</td>\n",
+       "      <td>0.861575</td>\n",
+       "      <td>57642.0</td>\n",
+       "      <td>13906.0</td>\n",
+       "      <td>71548.0</td>\n",
+       "      <td>268.12</td>\n",
+       "      <td>deepseek</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                                            question  recontext_relevance  \\\n",
+       "0  What is the main focus of AstraZeneca's sustai...                  1.0   \n",
+       "1  What are the three main areas of AstraZeneca's...                  1.0   \n",
+       "2  What is AstraZeneca's target for reducing emis...                  1.0   \n",
+       "3  What is AstraZeneca's commitment towards water...                  1.0   \n",
+       "4            What is the My Green Lab Certification?                  0.0   \n",
+       "\n",
+       "   context_precision  answer_relevancy  semantic_similarity  prompt_tokens  \\\n",
+       "0                1.0          1.000000             0.926802        42899.0   \n",
+       "1                1.0          0.978140             0.931793        65717.0   \n",
+       "2                1.0          0.962785             0.928104        43570.0   \n",
+       "3                1.0          0.994569             0.940814        43595.0   \n",
+       "4                1.0          0.950364             0.861575        57642.0   \n",
+       "\n",
+       "   completion_tokens  total_tokens  duration_seconds       llm  \n",
+       "0             5146.0       48045.0            103.87  deepseek  \n",
+       "1            18606.0       84323.0            348.09  deepseek  \n",
+       "2             3915.0       47485.0             81.96  deepseek  \n",
+       "3             6976.0       50571.0            142.40  deepseek  \n",
+       "4            13906.0       71548.0            268.12  deepseek  "
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Tidy data\n",
+    "\n",
+    "# Remove rows with 'AVERAGE' question value or empty question values\n",
+    "print(f\"Original DataFrame shape: {df.shape}\")\n",
+    "\n",
+    "# Remove rows where question is 'AVERAGE' or empty/null\n",
+    "df_clean = df[\n",
+    "    (df[\"question\"] != \"AVERAGE\")\n",
+    "    & (df[\"question\"].notna())\n",
+    "    & (df[\"question\"] != \"\")\n",
+    "    & (df[\"question\"].str.strip() != \"\")\n",
+    "].copy()\n",
+    "\n",
+    "print(f\"Cleaned DataFrame shape: {df_clean.shape}\")\n",
+    "print(f\"Removed {df.shape[0] - df_clean.shape[0]} rows\")\n",
+    "\n",
+    "# Update df to use the cleaned version\n",
+    "df = df_clean\n",
+    "\n",
+    "# Display first few rows of cleaned data\n",
+    "df.head()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "de9bea4b",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Average Semantic Similarity Scores by LLM:\n",
+      "=============================================\n",
+      "qwen3-30b: 0.8952\n",
+      "deepseek: 0.8868\n",
+      "gpt-oss-20b: 0.8863\n",
+      "gpt-4o-mini: 0.8783\n",
+      "gpt-4o: 0.8680\n",
+      "gemma-3-1b: 0.8597\n",
+      "lfm2-1.2: 0.8533\n",
+      "\n",
+      "All Metrics Averages by LLM:\n",
+      "===================================\n",
+      "             recontext_relevance  context_precision  answer_relevancy  \\\n",
+      "llm                                                                     \n",
+      "deepseek                  0.9310             0.9655            0.9619   \n",
+      "gemma-3-1b                0.9483             0.9655            0.8479   \n",
+      "gpt-4o                    0.9286             0.9643            0.9352   \n",
+      "gpt-4o-mini               0.9200             0.9600            0.9726   \n",
+      "gpt-oss-20b               0.9310             0.9655            0.9684   \n",
+      "lfm2-1.2                  0.9375             0.9643            0.8810   \n",
+      "qwen3-30b                 0.9400             0.9600            0.8991   \n",
+      "\n",
+      "             semantic_similarity  prompt_tokens  completion_tokens  \\\n",
+      "llm                                                                  \n",
+      "deepseek                  0.8868     56192.0000          9417.3448   \n",
+      "gemma-3-1b                0.8597     63705.1724           608.7586   \n",
+      "gpt-4o                    0.8680         0.0000             0.0000   \n",
+      "gpt-4o-mini               0.8783     43922.0400          1485.8000   \n",
+      "gpt-oss-20b               0.8863     78507.3793          1269.5517   \n",
+      "lfm2-1.2                  0.8533     50803.0357          4197.6429   \n",
+      "qwen3-30b                 0.8952     70819.5600          3658.0400   \n",
+      "\n",
+      "             total_tokens  duration_seconds  \n",
+      "llm                                          \n",
+      "deepseek       65609.3448          269.0445  \n",
+      "gemma-3-1b     64313.9310           11.3731  \n",
+      "gpt-4o             0.0000            0.0000  \n",
+      "gpt-4o-mini    45407.8400           63.8500  \n",
+      "gpt-oss-20b    79776.9310           53.0290  \n",
+      "lfm2-1.2       55000.6786           69.0129  \n",
+      "qwen3-30b      74477.6000          876.4252  \n"
+     ]
+    }
+   ],
+   "source": [
+    "# Calculate and display average values for each LLM\n",
+    "print(\"Average Semantic Similarity Scores by LLM:\")\n",
+    "print(\"=\" * 45)\n",
+    "\n",
+    "# Calculate averages for semantic_similarity by LLM\n",
+    "llm_averages = df.groupby(\"llm\")[\"semantic_similarity\"].mean().sort_values(ascending=False)\n",
+    "\n",
+    "for llm, avg_score in llm_averages.items():\n",
+    "    print(f\"{llm}: {avg_score:.4f}\")\n",
+    "\n",
+    "print(\"\\nAll Metrics Averages by LLM:\")\n",
+    "print(\"=\" * 35)\n",
+    "\n",
+    "# Calculate averages for all numeric columns by LLM\n",
+    "numeric_columns = df.select_dtypes(include=[\"number\"]).columns\n",
+    "llm_all_averages = df.groupby(\"llm\")[numeric_columns].mean()\n",
+    "\n",
+    "# Display in a formatted table\n",
+    "print(llm_all_averages.round(4))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "4d06a2f7",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<Figure size 1200x600 with 0 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1400x800 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<Figure size 1200x600 with 0 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1400x800 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<Figure size 1200x600 with 0 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1400x800 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<Figure size 1200x600 with 0 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1400x800 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Create visualizations using matplotlib\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "\n",
+    "def generate_chart(frame, key, title):\n",
+    "    # Set up the plot style\n",
+    "    plt.style.use(\"default\")\n",
+    "\n",
+    "    # Create column chart for semantic_similarity by question, grouped by LLM\n",
+    "    plt.figure(figsize=(12, 6))\n",
+    "\n",
+    "    # Group by question and LLM, then plot\n",
+    "    pivot_data = frame.pivot(index=\"question\", columns=\"llm\", values=key)\n",
+    "\n",
+    "    # Create grouped bar chart\n",
+    "    ax = pivot_data.plot(kind=\"bar\", figsize=(14, 8))\n",
+    "    plt.title(title, fontsize=16, fontweight=\"bold\")\n",
+    "    plt.xlabel(\"Questions\", fontsize=12)\n",
+    "    plt.ylabel(title, fontsize=12)\n",
+    "    plt.xticks([])  # Hide x-axis text labels\n",
+    "    plt.legend(title=\"LLM\", bbox_to_anchor=(1.05, 1), loc=\"upper left\")\n",
+    "    plt.tight_layout()\n",
+    "    plt.grid(axis=\"y\", alpha=0.3)\n",
+    "    plt.show()  # Show each chart individually\n",
+    "\n",
+    "\n",
+    "generate_chart(df, \"recontext_relevance\", \"Recontext Relevance Scores by Question and LLM\")\n",
+    "generate_chart(df, \"context_precision\", \"Context Precision Scores by Question and LLM\")\n",
+    "generate_chart(df, \"answer_relevancy\", \"Answer Relevancy Scores by Question and LLM\")\n",
+    "generate_chart(df, \"semantic_similarity\", \"Semantic Similarity Scores by Question and LLM\")"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "OpenInferESG",
+   "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.13.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}