tweaks to layout and text

app.py

@@ -60,11 +60,8 @@ def make_rate_chart(df: pd.DataFrame):
     return fig
 
 def make_leaderboard_plot(df: pd.DataFrame, col: str, title: str, bar_color: str):
-    """
-    Return a horizontal bar chart sorted ascending by `col`.
-    Lowest value (best) at the top.
-    """
-    df_sorted = df.sort_values(col, ascending=False)           # best → worst
+
+    df_sorted = df.sort_values(col, ascending=False)          
     fig = px.bar(
         df_sorted,
         x=col,
@@ -87,6 +84,100 @@ def make_leaderboard_plot(df: pd.DataFrame, col: str, title: str, bar_color: str
     return fig
 
 
+def make_rag_average_plot(df: pd.DataFrame, col: str, title: str, bar_color: str):
+    rag_cols = [
+        "Context in System Prompt (%)",
+        "Context and Question Single-Turn (%)",
+        "Context and Question Two-Turns (%)",
+    ]
+
+    df_plot = df.copy()
+    if col not in df_plot.columns:
+        df_plot[col] = df_plot[rag_cols].mean(axis=1, skipna=True).round(2)
+
+    df_plot["Std Dev"] = df_plot[rag_cols].std(axis=1, skipna=True).round(2)
+
+    df_sorted = df_plot.sort_values(col, ascending=False)
+
+    fig = px.bar(
+        df_sorted,
+        x=col,
+        y="Models",
+        orientation="h",
+        title=title,
+        height=400,
+        color_discrete_sequence=[bar_color],
+        error_x="Std Dev",
+    )
+    fig.update_traces(
+        texttemplate="%{x:.2f}",
+        textposition="inside",
+        insidetextanchor="middle",
+        cliponaxis=False,
+    )
+    fig.update_layout(
+        xaxis_title="Hallucination Rate (%)",
+        yaxis_title="",
+        yaxis=dict(dtick=1),
+        margin=dict(l=140, r=60, t=60, b=40),
+    )
+    return fig
+
+
+def make_rag_method_average_plot(df: pd.DataFrame, title: str, bar_color: str):
+    method_cols = [
+        "Context in System Prompt (%)",
+        "Context and Question Single-Turn (%)",
+        "Context and Question Two-Turns (%)",
+    ]
+
+    averages = df[method_cols].mean().round(2)
+    stds = df[method_cols].std().round(2)
+
+    avg_df = pd.DataFrame(
+        {
+            "RAG Method": averages.index,
+            "Average Hallucination Rate (%)": averages.values,
+            "Std Dev": stds.values,
+        }
+    )
+
+    fig = px.bar(
+        avg_df,
+        x="RAG Method",
+        y="Average Hallucination Rate (%)",
+        error_y="Std Dev",
+        title=title,
+        height=400,
+        color_discrete_sequence=[bar_color],
+    )
+    fig.update_traces(
+        texttemplate="%{y:.2f}" if 'orientation' not in fig.data[0] or fig.data[0].orientation == 'v' else "%{x:.2f}",
+        textposition="inside",
+        insidetextanchor="start", 
+        cliponaxis=False,
+        textfont_color="white",
+    )
+    labels_map = {
+        "Context in System Prompt (%)": "Context in<br>System Prompt",
+        "Context and Question Single-Turn (%)": "Context & Question<br>Single-Turn",
+        "Context and Question Two-Turns (%)": "Context & Question<br>Two-Turns",
+    }
+    fig.update_xaxes(
+        tickmode="array",
+        tickvals=list(labels_map.keys()),
+        ticktext=list(labels_map.values()),
+        tickangle=0,
+        automargin=True,
+    )
+    fig.update_layout(
+        xaxis_title="",
+        yaxis_title="Hallucination Rate (%)",
+        margin=dict(l=40, r=100, t=60, b=120), 
+    )
+    return fig
+
+
 def color_scale(s, cmap):
     """
     Return background-colour styles for a numeric Series (lower = greener,
@@ -120,15 +211,9 @@ except Exception:
     print(f"[WARN] Skipping RESULTS sync: {Exception}")
 
 
-# LEADERBOARD_DF = get_leaderboard_df(EVAL_RESULTS_PATH, EVAL_REQUESTS_PATH, COLS, BENCHMARK_COLS)
 LEADERBOARD_DF = get_leaderboard_df("leaderboard/data/leaderboard.csv")
 RAG_DF = get_rag_leaderboard_df("leaderboard/data/rag_methods_compare.csv")
 
-# (
-#     finished_eval_queue_df,
-#     running_eval_queue_df,
-#     pending_eval_queue_df,
-# ) = get_evaluation_queue_df(EVAL_REQUESTS_PATH, EVAL_COLS)
 
 def init_leaderboard(df: pd.DataFrame):
     if df is None or df.empty:
@@ -199,7 +284,7 @@ with demo:
                         ),
                         show_label=False,
                     )
-                    gr.Markdown("*HaluEval-QA benchmark (RAG): The model receives a question plus supporting context. We report the % of answers that introduce facts not found in that context — lower is better. See the **Details** tab for more information.*", elem_classes="plot-caption")
+                    gr.Markdown("*HaluEval-QA benchmark (RAG): The model receives a question plus supporting context. We report the % of answers that introduce facts not found in that context — lower is better. See the **Methodology** section below for more information.*", elem_classes="plot-caption")
                 with gr.Column():
                     gr.Plot(
                         make_leaderboard_plot(
@@ -210,25 +295,13 @@ with demo:
                         ),
                         show_label=False,
                     )
-                    gr.Markdown("*UltraChat benchmark (~11 k prompts, non-RAG): Evaluates open-domain answers when only the question is given. Score is the % of hallucinated responses — lower is better. See the **Details** tab for more information.*", elem_classes="plot-caption")
+                    gr.Markdown("*UltraChat benchmark (~11 k prompts, non-RAG): Evaluates open-domain answers when only the question is given. Score is the % of hallucinated responses — lower is better. See the **Methodology** section below for more information.*", elem_classes="plot-caption")
 
             # ----------  Leaderboard  ----------
             leaderboard = init_leaderboard(LEADERBOARD_DF)
 
             # ----------  Get Started with Verify  ----------
-            verify_markdown = textwrap.dedent(
-                """
-                ## Get started with Verify by kluster.ai
-
-                Verify is an intelligent agent that validates LLM outputs in real-time.
-
-                - **Blog post:** [Introducing Verify by kluster.ai](https://www.kluster.ai/blog/introducing-verify-by-kluster-ai-the-missing-trust-layer-in-your-ai-stack)  
-                - **Documentation:** [Verify overview & API reference](https://docs.kluster.ai/get-started/verify/overview/)  
-                - **Try it out in your browser:** [kluster.ai platform](https://platform.kluster.ai/verify)
-
-                ### Quick API examples
-                """
-            )
+            verify_markdown = (Path(__file__).parent / "verify.md").read_text()
 
             gr.Markdown(verify_markdown, elem_classes="markdown-text")
 
@@ -260,79 +333,44 @@ with demo:
 
             gr.Code(code_example_chat, language="shell")
 
+            with gr.Accordion("📄 Methodology & Benchmark Details", open=True):
+                gr.Markdown((Path(__file__).parent / "docs.md").read_text(), elem_classes="markdown-text")
+
         
         with gr.TabItem("🧪 RAG Techniques and Hallucinations", elem_id="llm-benchmark-tab-table", id=2):
-            rag_techniques_markdown = textwrap.dedent(
-                """
-                ## Comparison of Different RAG Techniques and Hallucinations
-
-                Many LLMs can generate fluent answers but still hallucinate facts—especially in RAG settings. This experiment aims to understand how different prompting strategies impact hallucination rates across models. It helps answer: Which prompt format is most reliable? Which models are more sensitive to prompt structure? The goal is to inform better design of RAG pipelines for reducing factual errors in downstream tasks.
-
-                We presents hallucination rates for various LLMs under three different RAG prompting strategies. Each method delivers the same document context and question, but differs in how the information is structured during the prompt.
-
-                ### RAG Techniques Evaluated
-
-                **1. Two-Turn Explicit RAG**  
-                The document and question are sent in separate user messages:
-                ```
-                [System]: You are an assistant for question-answering tasks. 
-                        Given the QUESTION and DOCUMENT you must answer the QUESTION using the information in the DOCUMENT. 
-                        You must not offer new information beyond the context provided in the DOCUMENT. Do not add any external knowledge. 
-                        The ANSWER also must not contradict information provided in the DOCUMENT. 
-                        If the DOCUMENT does not contain the facts to answer the QUESTION or you do not know the answer, you truthfully say that you do not know. 
-                        You have access to information provided by the user as DOCUMENT to answer the QUESTION, and nothing else. 
-                        Use three sentences maximum and keep the answer concise.
-
-                [User]: DOCUMENT: <context>  
-                [User]: QUESTION: <prompt>
-                ```
-                This method creates a multi-turn format, which allows the model to treat the context and question independently.  
-                *Note: This method does not work on Gemma 3 27B due to its restriction on consecutive user messages without an intervening assistant response.*
-
-                **2. System-Prompt Injection RAG**  
-                The document is embedded inside the system prompt, and the user sends only the question:
-                ```
-                [System]: You are an assistant for question-answering tasks. 
-                        Given the QUESTION and DOCUMENT you must answer the QUESTION using the information in the DOCUMENT. 
-                        You must not offer new information beyond the context provided in the DOCUMENT. Do not add any external knowledge. 
-                        The ANSWER also must not contradict information provided in the DOCUMENT. 
-                        If the DOCUMENT does not contain the facts to answer the QUESTION or you do not know the answer, you truthfully say that you do not know. 
-                        You have access to information provided by the user as DOCUMENT to answer the QUESTION, and nothing else. 
-                        Use three sentences maximum and keep the answer concise.
-                        DOCUMENT: <context>  
-
-                [User]: <prompt>
-                ```
-                This approach places the grounding context within the model’s instruction space.
-
-                **3. Single-Turn Concatenated RAG**  
-                Both the document and question are concatenated in a single user message:
-                ```
-                [System]: You are an assistant for question-answering tasks. 
-                        Given the QUESTION and DOCUMENT you must answer the QUESTION using the information in the DOCUMENT. 
-                        You must not offer new information beyond the context provided in the DOCUMENT. Do not add any external knowledge. 
-                        The ANSWER also must not contradict information provided in the DOCUMENT. 
-                        If the DOCUMENT does not contain the facts to answer the QUESTION or you do not know the answer, you truthfully say that you do not know. 
-                        You have access to information provided by the user as DOCUMENT to answer the QUESTION, and nothing else. 
-                        Use three sentences maximum and keep the answer concise.
-                        
-                [User]: 
-                DOCUMENT: <context>  
-                QUESTION: <prompt>
-
-                ```
-                This is the most compact format, sending everything as one prompt input.
-
-                ### Metric
-
-                The values in the table indicate the **hallucination rate (%)** of answers deemed factually incorrect or ungrounded given the provided context.
-
-                """
+            rag_intro_markdown = (Path(__file__).parent / "rag_techniques_intro.md").read_text()
+            rag_details_markdown = (Path(__file__).parent / "rag_techniques_details.md").read_text()
 
-            
-            )
+            gr.Markdown(rag_intro_markdown, elem_classes="markdown-text")
 
-            gr.Markdown(rag_techniques_markdown, elem_classes="markdown-text")
+            with gr.Row():
+                with gr.Column():
+                    gr.Plot(
+                        make_rag_method_average_plot(
+                            RAG_DF,
+                            "Average Hallucination Rate by RAG Method (lower is better)",
+                            bar_color="#4CAF50",
+                        ),
+                        show_label=False,
+                    )
+                    gr.Markdown(
+                        "*Mean hallucination rate for each RAG prompting strategy across all models on the HaluEval-QA benchmark. Error bars represent ±1 SD; lower is better.*",
+                        elem_classes="plot-caption",
+                    )
+                with gr.Column():
+                    gr.Plot(
+                        make_rag_average_plot(
+                            RAG_DF,
+                            "Average Hallucination Rate (%)",
+                            "Average Hallucination Rate per Model (lower is better)",
+                            bar_color="#2196F3",
+                        ),
+                        show_label=False,
+                    )
+                    gr.Markdown(
+                        "*Mean hallucination rate across the three RAG prompting settings for each individual model. Error bars show ±1 SD across the three strategies; lower is better.*",
+                        elem_classes="plot-caption",
+                    )
 
 
             rag_leaderboard = Leaderboard(
@@ -341,9 +379,9 @@ with demo:
                 select_columns=SelectColumns(
                     default_selection=[
                         "Models",
-                        "Two-Turn Explicit RAG (%)",
-                        "System-Prompt Injection RAG (%)",
-                        "Single-Turn Concatenated RAG (%)"
+                        "Context in System Prompt (%)",
+                        "Context and Question Single-Turn (%)",
+                        "Context and Question Two-Turns (%)",
                     ],
                     cant_deselect=["Models"],
                     label="Select RAG Method Columns:",
@@ -354,111 +392,16 @@ with demo:
                 height=700 
             )
 
+            with gr.Accordion("📄 RAG Techniques & Benchmark Details", open=True):
+                gr.Markdown(rag_details_markdown, elem_classes="markdown-text")
 
 
 
-        with gr.TabItem("📝 Details", elem_id="llm-benchmark-tab-table", id=3):
-            gr.Markdown((Path(__file__).parent / "docs.md").read_text(), elem_classes="markdown-text")
 
         with gr.TabItem("🚀 Submit Here! ", elem_id="llm-benchmark-tab-table", id=4):
             gr.Markdown((Path(__file__).parent / "submit.md").read_text(), elem_classes="markdown-text")
 
-            # with gr.Column():
-            #     with gr.Row():
-            #         gr.Markdown(EVALUATION_QUEUE_TEXT, elem_classes="markdown-text")
-
-            #     with gr.Column():
-            #         with gr.Accordion(
-            #             f"✅ Finished Evaluations ({len(finished_eval_queue_df)})",
-            #             open=False,
-            #         ):
-            #             with gr.Row():
-            #                 finished_eval_table = gr.components.Dataframe(
-            #                     value=finished_eval_queue_df,
-            #                     headers=EVAL_COLS,
-            #                     datatype=EVAL_TYPES,
-            #                     row_count=5,
-            #                 )
-            #         with gr.Accordion(
-            #             f"🔄 Running Evaluation Queue ({len(running_eval_queue_df)})",
-            #             open=False,
-            #         ):
-            #             with gr.Row():
-            #                 running_eval_table = gr.components.Dataframe(
-            #                     value=running_eval_queue_df,
-            #                     headers=EVAL_COLS,
-            #                     datatype=EVAL_TYPES,
-            #                     row_count=5,
-            #                 )
-
-            #         with gr.Accordion(
-            #             f"⏳ Pending Evaluation Queue ({len(pending_eval_queue_df)})",
-            #             open=False,
-            #         ):
-            #             with gr.Row():
-            #                 pending_eval_table = gr.components.Dataframe(
-            #                     value=pending_eval_queue_df,
-            #                     headers=EVAL_COLS,
-            #                     datatype=EVAL_TYPES,
-            #                     row_count=5,
-            #                 )
-            # with gr.Row():
-            #     gr.Markdown("# ✉️✨ Submit your model here!", elem_classes="markdown-text")
-
-            # with gr.Row():
-            #     with gr.Column():
-            #         model_name_textbox = gr.Textbox(label="Model name")
-            #         revision_name_textbox = gr.Textbox(label="Revision commit", placeholder="main")
-            #         model_type = gr.Dropdown(
-            #             choices=[t.to_str(" : ") for t in ModelType if t != ModelType.Unknown],
-            #             label="Model type",
-            #             multiselect=False,
-            #             value=None,
-            #             interactive=True,
-            #         )
-
-            #     with gr.Column():
-            #         precision = gr.Dropdown(
-            #             choices=[i.value.name for i in Precision if i != Precision.Unknown],
-            #             label="Precision",
-            #             multiselect=False,
-            #             value="float16",
-            #             interactive=True,
-            #         )
-            #         weight_type = gr.Dropdown(
-            #             choices=[i.value.name for i in WeightType],
-            #             label="Weights type",
-            #             multiselect=False,
-            #             value="Original",
-            #             interactive=True,
-            #         )
-            #         base_model_name_textbox = gr.Textbox(label="Base model (for delta or adapter weights)")
-
-            # submit_button = gr.Button("Submit Eval")
-            # submission_result = gr.Markdown()
-            # submit_button.click(
-            #     add_new_eval,
-            #     [
-            #         model_name_textbox,
-            #         base_model_name_textbox,
-            #         revision_name_textbox,
-            #         precision,
-            #         weight_type,
-            #         model_type,
-            #     ],
-            #     submission_result,
-            # )
-
-    # with gr.Row():
-    #     with gr.Accordion("📙 Citation", open=False):
-    #         citation_button = gr.Textbox(
-    #             value=CITATION_BUTTON_TEXT,
-    #             label=CITATION_BUTTON_LABEL,
-    #             lines=20,
-    #             elem_id="citation-button",
-    #             show_copy_button=True,
-    #         )
-
+   
 scheduler = BackgroundScheduler()
 scheduler.add_job(restart_space, "interval", seconds=1800)
 scheduler.start()

docs.md

@@ -1,3 +1,7 @@
+<!--
+keywords: hallucination detection documentation, LLM hallucination benchmark, RAG evaluation guide, Verify API, kluster.ai, retrieval-augmented generation evaluation, large language model accuracy
+-->
+
 # About
 
 As large language models (LLMs) continue to improve, evaluating how well they avoid hallucinations (producing information that is unfaithful or factually incorrect) has become increasingly important. While many models claim to be reliable, their factual grounding can vary significantly across tasks and settings.

introduction.md

@@ -0,0 +1,27 @@
+<!--
+keywords: LLM hallucination detection, hallucination leaderboard, RAG hallucination benchmark, UltraChat hallucination rate, Verify API, kluster.ai, factual accuracy of language models, large language model evaluation
+-->
+
+The **LLM Hallucination Detection Leaderboard** is a public, continuously updated comparison of how well popular Large Language Models (LLMs) avoid *hallucinations*, responses that are factually incorrect, fabricated, or unsupported by evidence. By surfacing transparent metrics across tasks, we help practitioners choose models that they can trust in production.
+
+### Why does hallucination detection matter?
+
+* **User Trust & Safety** – Hallucinations undermine confidence and can damage reputation.
+* **Retrieval-Augmented Generation (RAG) Quality** – In enterprise workflows, LLMs must remain faithful to supplied context. Measuring hallucinations highlights which models respect that constraint.
+* **Regulatory & Compliance Pressure** – Upcoming AI regulations require demonstrable accuracy standards. Reliable hallucination metrics can help you meet these requirements.
+
+### How we measure hallucinations
+
+We evaluate each model on two complementary benchmarks and compute a *hallucination rate* (lower = better):
+
+1. **HaluEval-QA (RAG setting)** – Given a question *and* a supporting document, the model must answer *only* using the provided context.
+2. **UltraChat Filtered (Non-RAG setting)** – Open-domain questions with **no** extra context test the model's internal knowledge.
+
+Outputs are automatically verified by [Verify](https://platform.kluster.ai/verify) from [kluster.ai](https://kluster.ai/), which cross-checks claims against the source document or web results.
+
+> **Note:** Full experiment details, including prompt templates, dataset description, and evaluation methodology, are provided at the end of this page for reference.
+
+---
+
+Stay informed as we add new models and tasks, and follow us on [X](https://x.com/klusterai) or join Discord [here](https://discord.com/invite/klusterai) for the latest updates on trustworthy LLMs.
+

leaderboard/data/leaderboard.csv

@@ -1,16 +1,16 @@
 Models,ha_rag_rate,ha_non_rag_rate
-klusterai/Meta-Llama-3.1-8B-Instruct-Turbo,8.1,12.5
-Qwen/Qwen2.5-VL-7B-Instruct,9.35,4.55
-mistralai/Mistral-Nemo-Instruct-2407,10.63,8.74
-meta-llama/Llama-4-Maverick-17B-128E-Instruct-FP8,3.34,0.69
-meta-llama/Llama-4-Scout-17B-16E-Instruct,4.23,2.48
-mistralai/Mistral-Small-24B-Instruct-2501,4.74,7.85
-mistralai/Magistral-Small-2506,8.62,28.07
-google/gemma-3-27b-it,3.71,0.48
-klusterai/Meta-Llama-3.3-70B-Instruct-Turbo,2.12,1.09
-deepseek-ai/DeepSeek-V3-0324,4.66,0.91
-Qwen/Qwen3-235B-A22B-FP8,5.04,0.88
-deepseek-ai/DeepSeek-R1-0528,2.26,0.78
-openai/gpt-4o,6.05,0.64
-anthropic/claude-sonnet-4,2.21,0.6
-google/gemini-2.5-pro,1.57,0.36
+klusterai-Meta-Llama-3.1-8B-Instruct-Turbo,8.1,12.5
+Qwen2.5-VL-7B-Instruct,9.35,4.55
+Mistral-Nemo-Instruct-2407,10.63,8.74
+Llama-4-Maverick-17B-128E-Instruct-FP8,3.34,0.69
+Llama-4-Scout-17B-16E-Instruct,4.23,2.48
+Mistral-Small-24B-Instruct-2501,4.74,7.85
+Magistral-Small-2506,8.62,28.07
+gemma-3-27b-it,3.71,0.48
+klusterai-Meta-Llama-3.3-70B-Instruct-Turbo,2.12,1.09
+DeepSeek-V3-0324,4.66,0.91
+Qwen3-235B-A22B-FP8,5.04,0.88
+DeepSeek-R1-0528,2.26,0.78
+gpt-4o,6.05,0.64
+claude-sonnet-4,2.21,0.6
+gemini-2.5-pro,1.57,0.36

leaderboard/data/rag_methods_compare.csv

@@ -1,13 +1,13 @@
 Models,rag1,rag2,rag3
-Meta Llama 3.1 8B,11.92,13.09,8.1
-Qwen2.5-VL 7B,13.24,13.39,9.35
-Mistral NeMo,14.42,13.99,10.63
-Meta Llama 4 Maverick,5.72,6.27,3.34
-Meta Llama 4 Scout,6.98,7.17,4.23
-Mistral Small,7.09,7.5,4.74
-Magistral Small,11.87,12.09,8.62
-Gemma 3 27B,-,6.09,3.71
-Meta Llama 3.3 70B,4.65,4.63,2.12
-DeepSeek-V3-0324,7.09,7.71,4.66
-Qwen3-235B-A22B,6.63,6.8,5.04
-DeepSeek-R1-0528,3.58,3.52,2.26
+klusterai-Meta-Llama-3.1-8B-Instruct-Turbo,13.09,8.1,11.92
+Qwen2.5-VL-7B-Instruct,13.39,9.35,13.24
+Mistral-Nemo-Instruct-2407,13.99,10.63,14.42
+Llama-4-Maverick-17B-128E-Instruct-FP8,6.27,3.34,5.72
+Llama-4-Scout-17B-16E-Instruct,7.17,4.23,6.98
+Mistral-Small-24B-Instruct-2501,7.5,4.74,7.09
+Magistral-Small-2506,12.09,8.62,11.87
+gemma-3-27b-it,6.09,3.71,-
+klusterai-Meta-Llama-3.3-70B-Instruct-Turbo,4.63,2.12,4.65
+DeepSeek-V3-0324,7.71,4.66,7.09
+Qwen3-235B-A22B-FP8,6.8,5.04,6.63
+DeepSeek-R1-0528,3.52,2.26,3.58

rag_techniques.md

@@ -0,0 +1,86 @@
+<!--
+keywords: RAG techniques, Retrieval-Augmented Generation prompt engineering, hallucination detection, LLM hallucination rate, kluster.ai, Verify API, prompt design comparison, large language model evaluation
+-->
+# Comparison of Retrieval-Augmented Generation (RAG) Prompting Techniques and Hallucinations
+
+LLMs can generate fluent answers but still hallucinate facts, especially in Retrieval-Augmented Generation (RAG) workflows. This leaderboard aims to understand how different prompt engineering strategies impact hallucination rates across models. In other words: Which prompt format is most reliable? Which models are more sensitive to prompt structure? The goal is to inform better design of RAG pipelines so you can reduce factual errors in downstream applications.
+
+We present hallucination rates for various LLMs under three RAG request strategies. Each method delivers the same document context and question, but differs in how the information is structured during the request.
+
+## Overview
+
+- **What we measure**: Hallucination rate (%) across three RAG request patterns.
+- **RAG patterns compared**:
+    1) **System Prompt**: context is placed in the system message; user sends only the question.
+    2) **Single-Turn**: one user message that includes both the context *and* the question.
+    3) **Two-Turn**: first user message provides the context, a second user message provides the question.
+- **Why it matters**: Request structure can change reliability significantly. Knowing the safest default helps you ship trustworthy RAG systems faster.
+- **Detect & reduce hallucinations**: The same [Verify](https://platform.kluster.ai/verify) API used for these evaluations can be plugged into your pipeline to flag and filter ungrounded answers in real time.
+- **How to read the charts**: Lower bars = fewer hallucinations. Error bars show ±1 SD across models.
+- **Experiment summary**: 10,000 HaluEval-QA examples, temperature 0, judged with [Verify](https://docs.kluster.ai/get-started/verify/overview/).
+
+### RAG Techniques Evaluated
+
+**1. RAG with Context in System Prompt**  
+The document is embedded inside the system prompt, and the user sends only the question:
+```text
+[System]: You are an assistant for question-answering tasks. 
+        Given the QUESTION and DOCUMENT you must answer the QUESTION using the information in the DOCUMENT. 
+        You must not offer new information beyond the context provided in the DOCUMENT. Do not add any external knowledge. 
+        The ANSWER also must not contradict information provided in the DOCUMENT. 
+        If the DOCUMENT does not contain the facts to answer the QUESTION or you do not know the answer, you truthfully say that you do not know. 
+        You have access to information provided by the user as DOCUMENT to answer the QUESTION, and nothing else. 
+        Use three sentences maximum and keep the answer concise.
+        DOCUMENT: <context>  
+
+[User]: <prompt>
+```
+
+**2. RAG with Context and Question in Single-Turn**  
+Both the document and question are concatenated in a single user message:
+```text
+[System]: You are an assistant for question-answering tasks. 
+        Given the QUESTION and DOCUMENT you must answer the QUESTION using the information in the DOCUMENT. 
+        You must not offer new information beyond the context provided in the DOCUMENT. Do not add any external knowledge. 
+        The ANSWER also must not contradict information provided in the DOCUMENT. 
+        If the DOCUMENT does not contain the facts to answer the QUESTION or you do not know the answer, you truthfully say that you do not know. 
+        You have access to information provided by the user as DOCUMENT to answer the QUESTION, and nothing else. 
+        Use three sentences maximum and keep the answer concise.
+        
+[User]: 
+DOCUMENT: <context>  
+QUESTION: <prompt>
+
+```
+
+**3. RAG with Context and Question in Two-Turns**  
+The document and question are sent in separate user messages:
+```text
+[System]: You are an assistant for question-answering tasks. 
+        Given the QUESTION and DOCUMENT you must answer the QUESTION using the information in the DOCUMENT. 
+        You must not offer new information beyond the context provided in the DOCUMENT. Do not add any external knowledge. 
+        The ANSWER also must not contradict information provided in the DOCUMENT. 
+        If the DOCUMENT does not contain the facts to answer the QUESTION or you do not know the answer, you truthfully say that you do not know. 
+        You have access to information provided by the user as DOCUMENT to answer the QUESTION, and nothing else. 
+        Use three sentences maximum and keep the answer concise.
+
+[User]: DOCUMENT: <context>  
+[User]: QUESTION: <prompt>
+```
+*Note: This method did **not** work on Gemma 3 27B with the default chat template due to its restriction on consecutive user messages without an intervening assistant response.*
+
+### Dataset  
+We evaluate all three prompting strategies on the **HaluEval QA** benchmark, a large-scale collection of RAG question-answer examples.  
+- **Source**: [HaluEval QA](https://huggingface.co/datasets/pminervini/HaluEval/viewer/qa?views%5B%5D=qa)  
+- **Size**: 10,000 question-document pairs  
+- **Content**: Each example contains a short passage (extracted primarily from Wikipedia-style articles) and an accompanying question that can be answered **only** from that passage.  
+- **Use case**: Designed to measure whether an LLM can remain faithful to supplied context without inventing new facts.  
+
+All prompts are generated with *temperature = 0* to remove randomness so that differences in hallucination rate stem solely from the prompt format.
+
+### Metric
+
+The values in the table indicate the **hallucination rate (%)** of answers deemed factually incorrect or ungrounded given the provided context.
+
+Hallucination rates are automatically computed using **[Verify](https://platform.kluster.ai/verify)** by [kluster.ai](https://kluster.ai/), the [leading](https://www.kluster.ai/blog/introducing-verify-by-kluster-ai-the-missing-trust-layer-in-your-ai-stack) AI-powered hallucination detection API that cross-checks model claims against the source document.
+

rag_techniques_details.md

@@ -0,0 +1,64 @@
+### RAG Techniques Evaluated
+
+**1. RAG with Context in System Prompt**  
+The document is embedded inside the system prompt, and the user sends only the question:
+```text
+[System]: You are an assistant for question-answering tasks. 
+        Given the QUESTION and DOCUMENT you must answer the QUESTION using the information in the DOCUMENT. 
+        You must not offer new information beyond the context provided in the DOCUMENT. Do not add any external knowledge. 
+        The ANSWER also must not contradict information provided in the DOCUMENT. 
+        If the DOCUMENT does not contain the facts to answer the QUESTION or you do not know the answer, you truthfully say that you do not know. 
+        You have access to information provided by the user as DOCUMENT to answer the QUESTION, and nothing else. 
+        Use three sentences maximum and keep the answer concise.
+        DOCUMENT: <context>  
+
+[User]: <prompt>
+```
+
+**2. RAG with Context and Question in Single-Turn**  
+Both the document and question are concatenated in a single user message:
+```text
+[System]: You are an assistant for question-answering tasks. 
+        Given the QUESTION and DOCUMENT you must answer the QUESTION using the information in the DOCUMENT. 
+        You must not offer new information beyond the context provided in the DOCUMENT. Do not add any external knowledge. 
+        The ANSWER also must not contradict information provided in the DOCUMENT. 
+        If the DOCUMENT does not contain the facts to answer the QUESTION or you do not know the answer, you truthfully say that you do not know. 
+        You have access to information provided by the user as DOCUMENT to answer the QUESTION, and nothing else. 
+        Use three sentences maximum and keep the answer concise.
+        
+[User]: 
+DOCUMENT: <context>  
+QUESTION: <prompt>
+
+```
+
+**3. RAG with Context and Question in Two-Turns**  
+The document and question are sent in separate user messages:
+```text
+[System]: You are an assistant for question-answering tasks. 
+        Given the QUESTION and DOCUMENT you must answer the QUESTION using the information in the DOCUMENT. 
+        You must not offer new information beyond the context provided in the DOCUMENT. Do not add any external knowledge. 
+        The ANSWER also must not contradict information provided in the DOCUMENT. 
+        If the DOCUMENT does not contain the facts to answer the QUESTION or you do not know the answer, you truthfully say that you do not know. 
+        You have access to information provided by the user as DOCUMENT to answer the QUESTION, and nothing else. 
+        Use three sentences maximum and keep the answer concise.
+
+[User]: DOCUMENT: <context>  
+[User]: QUESTION: <prompt>
+```
+*Note: This method did **not** work on Gemma 3 27B with the default chat template due to its restriction on consecutive user messages without an intervening assistant response.*
+
+### Dataset  
+We evaluate all three prompting strategies on the **HaluEval QA** benchmark, a large-scale collection of RAG question-answer examples.  
+- **Source**: [HaluEval QA](https://huggingface.co/datasets/pminervini/HaluEval/viewer/qa?views%5B%5D=qa)  
+- **Size**: 10,000 question-document pairs  
+- **Content**: Each example contains a short passage (extracted primarily from Wikipedia-style articles) and an accompanying question that can be answered **only** from that passage.  
+- **Use case**: Designed to measure whether an LLM can remain faithful to supplied context without inventing new facts.  
+
+All prompts are generated with *temperature = 0* to remove randomness so that differences in hallucination rate stem solely from the prompt format.
+
+### Metric
+
+The values in the table indicate the **hallucination rate (%)** of answers deemed factually incorrect or ungrounded given the provided context.
+
+Hallucination rates are automatically computed using **[Verify](https://platform.kluster.ai/verify)** by [kluster.ai](https://kluster.ai/), the [leading](https://www.kluster.ai/blog/introducing-verify-by-kluster-ai-the-missing-trust-layer-in-your-ai-stack) AI-powered hallucination detection API that cross-checks model claims against the source document. 

rag_techniques_intro.md

@@ -0,0 +1,23 @@
+<!--
+keywords: RAG techniques, Retrieval-Augmented Generation prompt engineering, hallucination detection, LLM hallucination rate, kluster.ai, Verify API, prompt design comparison, large language model evaluation
+-->
+# Comparison of Retrieval-Augmented Generation (RAG) Prompting Techniques and Hallucinations
+
+LLMs can generate fluent answers but still hallucinate facts, especially in Retrieval-Augmented Generation (RAG) workflows. This leaderboard aims to understand how different prompt engineering strategies impact hallucination rates across models. In other words: Which prompt format is most reliable? Which models are more sensitive to prompt structure? The goal is to inform better design of RAG pipelines so you can reduce factual errors in downstream applications.
+
+We present hallucination rates for various LLMs under three RAG request strategies. Each method delivers the same document context and question, but differs in how the information is structured during the request.
+
+## Overview
+
+- **What we measure**: Hallucination rate (%) across three RAG request patterns.
+- **RAG patterns compared**:
+    1) **System Prompt**: context is placed in the system message; user sends only the question.
+    2) **Single-Turn**: one user message that includes both the context *and* the question.
+    3) **Two-Turn**: first user message provides the context, a second user message provides the question.
+- **Why it matters**: Request structure can change reliability significantly. Knowing the safest default helps you ship trustworthy RAG systems faster.
+- **Detect & reduce hallucinations**: The same [Verify](https://platform.kluster.ai/verify) API used for these evaluations can be plugged into your pipeline to flag and filter ungrounded answers in real time.
+- **How to read the charts**: Lower bars = fewer hallucinations. Error bars show ±1 SD across models.
+- **Experiment summary**: 10,000 HaluEval-QA examples, temperature 0, judged with [Verify](https://docs.kluster.ai/get-started/verify/overview/). 
+
+> **Note:** Full experiment details, including prompt templates, dataset description, and evaluation methodology, are provided at the end of this page for reference.
+<br>

src/about.py

@@ -1,5 +1,6 @@
 from dataclasses import dataclass
 from enum import Enum
+from pathlib import Path
 
 @dataclass
 class Task:
@@ -23,32 +24,7 @@ NUM_FEWSHOT = 0 # Change with your few shot
 TITLE = """<h1 align="center" id="space-title">LLM Hallucination Detection Leaderboard</h1>"""
 
 # What does your leaderboard evaluate?
-INTRODUCTION_TEXT = """
-<!--
-keywords: LLM hallucination detection, hallucination leaderboard, RAG hallucination benchmark, UltraChat hallucination rate, Verify API, kluster.ai, factual accuracy of language models, large language model evaluation
--->
-
-The **LLM Hallucination Detection Leaderboard** is a public, continuously updated comparison of how well popular Large Language Models (LLMs) avoid *hallucinations*, responses that are factually incorrect, fabricated, or unsupported by evidence. By surfacing transparent metrics across tasks, we help practitioners choose models that they can trust in production.
-
-### Why does hallucination detection matter?
-
-* **User Trust & Safety** – Hallucinations undermine confidence and can damage reputation.
-* **Retrieval-Augmented Generation (RAG) Quality** – In enterprise workflows, LLMs must remain faithful to supplied context. Measuring hallucinations highlights which models respect that constraint.
-* **Regulatory & Compliance Pressure** – Upcoming AI regulations require demonstrable accuracy standards. Reliable hallucination metrics can help you meet these requirements.
-
-### How we measure hallucinations
-
-We evaluate each model on two complementary benchmarks and compute a *hallucination rate* (lower = better):
-
-1. **HaluEval-QA (RAG setting)** – Given a question *and* a supporting document, the model must answer *only* using the provided context.
-2. **UltraChat Filtered (Non-RAG setting)** – Open-domain questions with **no** extra context test the model's internal knowledge.
-
-Outputs are automatically verified by [Verify](https://platform.kluster.ai/verify) from [kluster.ai](https://kluster.ai/), which cross-checks claims against the source document or web results.
-
----
-
-Stay informed as we add new models and tasks, and follow us on [X](https://x.com/klusterai) or join Discord [here](https://discord.com/invite/klusterai) for the latest updates on trustworthy LLMs.
-"""
+INTRODUCTION_TEXT = (Path(__file__).resolve().parent.parent / "introduction.md").read_text()
 
 LLM_BENCHMARKS_TEXT = f"""
 ## How it works

src/populate.py

@@ -15,11 +15,17 @@ def get_rag_leaderboard_df(csv_path):
 
     pretty = {
         "Models":                 "Models",
-        "rag1":     "Two-Turn Explicit RAG (%)",
-        "rag2": "System-Prompt Injection RAG (%)",
-        "rag3": "Single-Turn Concatenated RAG (%)",
+        "rag1":     "Context in System Prompt (%)",
+        "rag2": "Context and Question Single-Turn (%)",
+        "rag3": "Context and Question Two-Turns (%)",
     }
     df = df.rename(columns=pretty)
+
+    # sort so the lowest Single-Turn hallucination rate appears first
+    df = (
+        df.sort_values("Context and Question Single-Turn (%)", ascending=True)
+          .reset_index(drop=True)
+    )
     
     return df
 

submit.md

@@ -1,3 +1,7 @@
+<!--
+keywords: LLM hallucination leaderboard submission, Verify leaderboard guidelines, kluster.ai, hallucination benchmark contributions, large language model evaluation submission
+-->
+
 # LLM Hallucination Detection Leaderboard Submission Guidelines
 
 Thank you for your interest in contributing to the **LLM Hallucination Detection Leaderboard**!  We welcome submissions from researchers and practitioners who have built or finetuned language models that can be evaluated on our hallucination benchmarks.

verify.md

@@ -0,0 +1,13 @@
+<!--
+keywords: Verify by kluster.ai, LLM verification API, hallucination detection tool, factual accuracy checker, AI output validation, large language model trust layer
+-->
+
+## Get started with Verify by kluster.ai
+
+Verify is an intelligent agent that validates LLM outputs in real-time.
+
+- **Blog post:** [Introducing Verify by kluster.ai](https://www.kluster.ai/blog/introducing-verify-by-kluster-ai-the-missing-trust-layer-in-your-ai-stack)  
+- **Documentation:** [Verify overview & API reference](https://docs.kluster.ai/get-started/verify/overview/)  
+- **Try it out in your browser:** [kluster.ai platform](https://platform.kluster.ai/verify)
+
+### Quick API examples