refactor into app/ui

app.py

@@ -1,140 +1,18 @@
 # app.py
 import gradio as gr
-import os
-import asyncio
 import logging
 
-from config.exercise_standardizer import standardize_exercise
+from app.ui.common import update_exercise_format
+from app.ui.diagnoser_tab import build_diagnoser_tab
+from app.ui.distractors_tab import build_distractors_tab
+from chains.diagnoser.runner import run_diagnoser
+from chains.distractors.runner import run_distractors
 from utils.auth import login as auth_login
 from config.chain_configs import chain_configs
 from config.llm_config import llms
 
 logger = logging.getLogger(__name__)
 
-# --- Callback to update the exercise format dropdown based on LLM selection ---
-def update_exercise_format(selected_model: str):
-    # When "Claude3.5" is selected, default the format to XML; otherwise, default to Markdown.
-    if "Claude" in selected_model:
-        return gr.update(value="XML")
-    else:
-        return gr.update(value="Plaintext")
-
-
-
-# Async wrappers for each chain.
-async def run_diagnoser(user_query: str, model_choice_validate: str, exercise_format_validate: str, sampling_count_validate: str) -> tuple:
-    """
-    Diagnose exercise(s) in parallel using a configured DiagnoserChain.
-
-    This function:
-      1. Standardizes the exercise text once using the chain's fixed LLM.
-      2. Instantiates the DiagnoserChain with a user-selected diagnosing LLM.
-      3. Performs multiple diagnoses in parallel (as many times as `sampling_count_validate`).
-      4. Pads the results to ensure a fixed number of output fields (10).
-
-    Args:
-        user_query (str): Raw exercise data submitted by the user.
-        model_choice_validate (str): The key/name of the chosen LLM for diagnosing.
-        exercise_format_validate (str): The desired format for standardizing the exercise.
-        sampling_count_validate (str): A string representing how many diagnoses to run concurrently (e.g., "3").
-
-    Returns:
-        tuple: A tuple of length 10, each containing a diagnosis result (or empty string if not enough samples).
-    """
-    # figure out how many times to run
-    num_samples = int("".join(filter(str.isdigit, sampling_count_validate)))
-
-    # Fetch the DiagnoserChain configuration.
-    config = chain_configs["diagnoser"]
-
-    # 1) Standardize the user query exactly once
-    standardized_exercise = await standardize_exercise(
-        user_query,
-        exercise_format_validate,
-        config["template_standardize"],  # Only if you kept them in config
-        config["llm_standardize"]
-    )
-
-    # 2) Instantiate the DiagnoserChain using the user-selected LLM for diagnosing
-    chain_instance = config["class"](
-        templates_diagnose=config["templates_diagnose"],
-        llm_diagnose=llms.get(model_choice_validate, config["llm_diagnose"]),
-        template_diagnose_scorecard=config["template_diagnose_scorecard"],
-        llm_4o_mini=config["llm_4o_mini"],
-        llm_4o=config["llm_4o"]
-    )
-
-    # 3) Run the multiple samples in parallel
-    # Create a short helper that does only the "diagnose" steps:
-    tasks = [
-        chain_instance.diagnose_only(standardized_exercise)
-        for _ in range(num_samples)
-    ]
-    # run concurrently
-    responses = await asyncio.gather(*tasks)
-
-    # pad up to 10 if needed
-    all_responses = list(responses) + [""] * (10 - len(responses))
-
-    # Return a tuple of exactly 5 responses.
-    return tuple(all_responses)
-
-
-async def run_distractors(
-    user_query: str,
-    model_choice_distractors_1: str,
-    model_choice_distractors_2: str,
-    model_choice_distractors_3: str,
-    exercise_format_distractors: str,
-    sampling_count_distractors: str,
-    intermediate_distractors_specification: str,
-    final_distractors_specification: str,
-) -> tuple:
-    """
-    Generate distractors by running the DistractorsChain multiple times in parallel.
-
-    1. Standardizes the exercise text once using a fixed LLM.
-    2. Constructs a DistractorsChain, where the user can pick two LLMs
-       (e.g. one low-temp, one mid-temp) for parallel brainstorming steps.
-    3. Invokes the chain ``num_samples`` times in parallel (based on ``sampling_count_distractors``),
-       each time producing one consolidated distractors output.
-    4. Pads the results to fill 10 output fields.
-    """
-    # 0) Parse how many concurrent runs (samples) we want
-    num_samples = int("".join(filter(str.isdigit, sampling_count_distractors)))
-    # Fetch the DistractorsChain configuration.
-    config = chain_configs["distractors"]
-
-    # 1) Standardize the user query exactly once
-    standardized_exercise = await standardize_exercise(
-        user_query,
-        exercise_format_distractors,
-        config["template_standardize"],
-        config["llm_standardize"]
-    )
-
-    # 2) Build the DistractorsChain instance
-    chain_instance = config["class"](
-        template_distractors_brainstorm_1=config["template_distractors_brainstorm_1"],
-        template_distractors_brainstorm_2=config["template_distractors_brainstorm_2"],
-        llm_brainstorm_1=llms.get(model_choice_distractors_1, config["llm_brainstorm_1"]),  # User-selected LLM 1
-        llm_brainstorm_2=llms.get(model_choice_distractors_2, config["llm_brainstorm_2"]),  # User-selected LLM 2
-        template_consolidate=config["template_consolidate"],
-        llm_consolidate=llms.get(model_choice_distractors_3, config["llm_consolidate"]),    # User-selected LLM 3
-    )
-
-    # 3) Create N tasks in parallel (one full distractor generation pipeline per sample)
-    tasks = [
-        chain_instance.run(standardized_exercise, intermediate_distractors_specification, final_distractors_specification) for _ in range(num_samples)
-    ]
-    results = await asyncio.gather(*tasks)
-
-    # 4) Pad up to 10 outputs to correspond to 10 response fields
-    all_responses = list(results) + [""] * (10 - len(results))
-
-    return tuple(all_responses)
-
-
 
 # A generic async runner for simple chains (currently not used)
 async def run_chain(chain_name: str, input_variables: dict, selected_model: str):
@@ -194,135 +72,27 @@ with gr.Blocks() as interface:
         gr.Markdown("## Pick the tab for your task of choice")
 
         with gr.Tabs():
-            with gr.TabItem("🩺 Diagnose exercise"):
-                # Insert an HTML info icon with a tooltip at the top of the tab content.
-                gr.HTML(
-                    """
-                    <div style="margin-bottom: 10px;">
-                        <span style="font-size: 1.5em; cursor: help;" title="Diagnoses exercise for their 4 most common issues.\n\nThe exercise format dropdown decides into what standardized format the exercise is converted initially for intermediate processing, to ensure reliable performance irrespective of source format.\nAnthropic models typically work better with XML, OpenAI's with markdown.\n\nResponse count is the amount of times a final response will be generated in the fields below (5-6 LLM queries for each).">
-                            ℹ️ <i>←</i>
-                        </span>
-                    </div>
-                    """
-                )
-
-                # Create a row for the control dropdowns: LLM selection, exercise format, sampling count etc.
-                with gr.Row():
-                    model_choice_validate = gr.Dropdown(
-                        choices=list(llms.keys()),
-                        value="GPT-4o (low temp)",
-                        label="Select LLM",
-                        interactive=True,
-                    )
-                    exercise_format_validate = gr.Dropdown(
-                        choices=["Markdown", "XML", "Plaintext", "Raw (input not reformatted)"],
-                        value="Markdown",
-                        label="Exercise Reformat",
-                        interactive=True,
-                    )
-                    sampling_count_validate = gr.Dropdown(
-                        choices=["1", "2", "3", "4", "5", "6", "7", "8", "9", "10"],
-                        value="1",
-                        label="Response Count",
-                        interactive=True,
-                    )
-                # Set up a change callback so that if the user selects any model with "Claude" in the name, the exercise format updates to "XML"
-                model_choice_validate.change(
-                    fn=update_exercise_format,
-                    inputs=[model_choice_validate],
-                    outputs=[exercise_format_validate]
-                )
+            (model_choice_diagnose,
+             exercise_format_diagnose,
+             sampling_count_diagnose,
+             diagnoser_input,
+             diagnoser_button,
+             diagnoser_responses
+            ) = build_diagnoser_tab()
+
+            (model_choice_distractors_1,
+             model_choice_distractors_2,
+             model_choice_distractors_3,
+             exercise_format_distractors,
+             sampling_count_distractors,
+             distractors_input,
+             distractors_button,
+             distractors_responses,
+             intermediate_distractors_specification,
+             final_distractors_specification,
+             ) = build_distractors_tab()
 
-                diagnoser_input = gr.Textbox(label="Enter exercise in any format", placeholder="Exercise body: <mc:exercise xmlns:mc= ...")
-                diagnoser_button = gr.Button("Submit")
-                diagnoser_response_1 = gr.Textbox(label="Response 1", interactive=False)
-                diagnoser_response_2 = gr.Textbox(label="Response 2", interactive=False)
-                diagnoser_response_3 = gr.Textbox(label="Response 3", interactive=False)
-                diagnoser_response_4 = gr.Textbox(label="Response 4", interactive=False)
-                diagnoser_response_5 = gr.Textbox(label="Response 5", interactive=False)
-                diagnoser_response_6 = gr.Textbox(label="Response 6", interactive=False)
-                diagnoser_response_7 = gr.Textbox(label="Response 7", interactive=False)
-                diagnoser_response_8 = gr.Textbox(label="Response 8", interactive=False)
-                diagnoser_response_9 = gr.Textbox(label="Response 9", interactive=False)
-                diagnoser_response_10 = gr.Textbox(label="Response 10", interactive=False)
 
-
-            with gr.TabItem("🤔 Brainstorm distractors"):
-                # Insert an HTML info icon with a tooltip at the top of the tab content.
-                gr.HTML(
-                    """
-                    <div style="margin-bottom: 10px;">
-                        <span style="font-size: 1.5em; cursor: help;" title="Generates alternative distractors for the given exercise in two stages. First, 2x2 brainstorming prompts (2 approaches, each using LLM 1 & LLM 2 once) generate a bunch of options, then a final consolidation prompt (using LLM 3) combines all results together for presentation below.\n\nFor both stages, prompts can be customized via dropdowns to influence the amount of distractors that will be generated during each (brainstormed and displayed).\n5-6 LLM calls per final response.">
-                            ℹ️
-                        </span>
-                    </div>
-                    """
-                )
-
-                # Create a row for the control dropdowns: LLM selection, exercise format, sampling count etc.
-                with gr.Row():
-                    model_choice_distractors_1 = gr.Dropdown(
-                        choices=list(llms.keys()),
-                        value="GPT-4o (mid temp)",
-                        label="LLM 1 - for brainstorming",
-                        interactive=True,
-                    )
-                    model_choice_distractors_2 = gr.Dropdown(
-                        choices=list(llms.keys()),
-                        value="Claude 3.5 (mid temp)",
-                        label="LLM 2 - for brainstorming",
-                        interactive=True,
-                    )
-                    exercise_format_distractors = gr.Dropdown(
-                        choices=["Markdown", "XML", "Plaintext", "Raw (input not reformatted)"],
-                        value="Plaintext",
-                        label="Exercise Reformat",
-                        interactive=True,
-                    )
-                    intermediate_distractors_specification = gr.Dropdown(
-                        choices=[" ", " 2 ", " 3 ", " 4 ", " 5 ", " 6 ", " 7 ", " 8 ", " 9 ", " 10 ", " a few ", " some ", " a whole lot of ", " a wide range of ", " novel "],
-                        value=" 8 ",
-                        label="Brainstorm X distractors x4",
-                        interactive=True,
-                    )
-                    model_choice_distractors_3 = gr.Dropdown(
-                        choices=list(llms.keys()),
-                        value="GPT-4o (low temp)",
-                        label="LLM 3 - for consolidation",
-                        interactive=True,
-                    )
-                    final_distractors_specification = gr.Dropdown(
-                        choices=[" ", " of all unique distractors", " of the top 5", " of the best distractors", " of only the very best", " of the best 4", " of the best 5", " of the best 6", " of the best 7", " of the best 8", " of the best 9", " of the best 10", " of the best 11", " of the best 12", " of a few of them", " of some of them", " of most of them",
-                                 " of a wide range of", " of the 3 worst"],
-                        value=" of all unique distractors",
-                        label="Finally display X distractors",
-                        interactive=True,
-                    )
-                    sampling_count_distractors = gr.Dropdown(
-                        choices=["1", "2", "3", "4", "5", "6", "7", "8", "9", "10"],
-                        value="1",
-                        label="Response Count",
-                        interactive=True,
-                    )
-                # Set up a change callback so that if the user selects any model with "Claude" in the name, the exercise format updates to "XML"
-                model_choice_distractors_1.change(
-                    fn=update_exercise_format,
-                    inputs=[model_choice_distractors_1],
-                    outputs=[exercise_format_distractors]
-                )
-                
-                distractors_input = gr.Textbox(label="Enter exercise(s) in any format", placeholder="Stelling: Dit is een ..... voorbeeld van een stelling. A. Mooi B. Lelijk ...")
-                distractors_button = gr.Button("Submit")
-                distractors_response_1 = gr.Textbox(label="Response 1", interactive=False)
-                distractors_response_2 = gr.Textbox(label="Response 2", interactive=False)
-                distractors_response_3 = gr.Textbox(label="Response 3", interactive=False)
-                distractors_response_4 = gr.Textbox(label="Response 4", interactive=False)
-                distractors_response_5 = gr.Textbox(label="Response 5", interactive=False)
-                distractors_response_6 = gr.Textbox(label="Response 6", interactive=False)
-                distractors_response_7 = gr.Textbox(label="Response 7", interactive=False)
-                distractors_response_8 = gr.Textbox(label="Response 8", interactive=False)
-                distractors_response_9 = gr.Textbox(label="Response 9", interactive=False)
-                distractors_response_10 = gr.Textbox(label="Response 10", interactive=False)
             with gr.TabItem("🚧 Generate learning objectives"):
                 # Insert an HTML info icon with a tooltip at the top of the tab content.
                 gr.HTML(
@@ -351,19 +121,8 @@ with gr.Blocks() as interface:
 
     diagnoser_button.click(
         fn=run_diagnoser,
-        inputs=[diagnoser_input, model_choice_validate, exercise_format_validate, sampling_count_validate],
-        outputs=[
-            diagnoser_response_1,
-            diagnoser_response_2,
-            diagnoser_response_3,
-            diagnoser_response_4,
-            diagnoser_response_5,
-            diagnoser_response_6,
-            diagnoser_response_7,
-            diagnoser_response_8,
-            diagnoser_response_9,
-            diagnoser_response_10
-        ]
+        inputs=[diagnoser_input, model_choice_diagnose, exercise_format_diagnose, sampling_count_diagnose],
+        outputs=[diagnoser_responses]
     )
 
     distractors_button.click(
@@ -386,18 +145,7 @@ with gr.Blocks() as interface:
             # 8) final_distractors_specification
             final_distractors_specification,
         ],
-        outputs=[
-            distractors_response_1,
-            distractors_response_2,
-            distractors_response_3,
-            distractors_response_4,
-            distractors_response_5,
-            distractors_response_6,
-            distractors_response_7,
-            distractors_response_8,
-            distractors_response_9,
-            distractors_response_10
-        ]
+        outputs=[distractors_responses]
     )
 
 # Launch the app.

app/ui/common.py

@@ -0,0 +1,33 @@
+# ui/common.py
+import gradio as gr
+
+# --- Callback to update the exercise format dropdown based on LLM selection ---
+def update_exercise_format(selected_model: str):
+    """
+    When the user picks a new model:
+    - If it has 'Claude' in the name, default format to XML.
+    - Otherwise, default to Plaintext.
+    """
+    if "Claude" in selected_model:
+        return gr.update(value="XML")
+    else:
+        return gr.update(value="Plaintext")
+
+
+def update_response_textboxes_amount(sampling_count: str):
+    """
+    Dynamically show/hide Response textboxes based on sampling count.
+    """
+    # Convert string to integer
+    num = int(sampling_count)
+
+    # We'll return a list of 10 updates, one for each textbox.
+    updates = []
+    for i in range(10):
+        if i < num:
+            # Show and label (i+1), if you like
+            updates.append(gr.Textbox.update(visible=True, label=f"Response {i+1}"))
+        else:
+            # Hide the rest
+            updates.append(gr.Textbox.update(visible=False, label=f"Response {i+1}"))
+    return updates

app/ui/diagnoser_tab.py

@@ -0,0 +1,77 @@
+# ui/diagnoser_tab.py
+import gradio as gr
+from config.llm_config import llms
+from common import update_exercise_format, update_response_textboxes_amount
+
+
+def build_diagnoser_tab():
+    """
+    Builds and returns the Diagnoser tab UI elements (and any references).
+    """
+    with gr.TabItem("🩺 Diagnose exercise"):
+        # Insert an HTML info icon with a tooltip at the top of the tab content.
+        gr.HTML(
+            """
+            <div style="margin-bottom: 10px;">
+                <span style="font-size: 1.5em; cursor: help;" title="Diagnoses exercise for their 4 most common issues.\n\nThe exercise format dropdown decides into what standardized format the exercise is converted initially for intermediate processing, to ensure reliable performance irrespective of source format.\nAnthropic models typically work better with XML, OpenAI's with markdown.\n\nResponse count is the amount of times a final response will be generated in the fields below (5-6 LLM queries for each).">
+                    ℹ️ <i>←</i>
+                </span>
+            </div>
+            """
+        )
+
+        # Create a row for the control dropdowns: LLM selection, exercise format, sampling count etc.
+        with gr.Row():
+            model_choice_diagnose = gr.Dropdown(
+                choices=list(llms.keys()),
+                value="GPT-4o (low temp)",
+                label="Select LLM",
+                interactive=True,
+            )
+            exercise_format_diagnose = gr.Dropdown(
+                choices=["Markdown", "XML", "Plaintext", "Raw (input not reformatted)"],
+                value="Markdown",
+                label="Exercise Reformat",
+                interactive=True,
+            )
+            sampling_count_diagnose = gr.Dropdown(
+                choices=["1", "2", "3", "4", "5", "6", "7", "8", "9", "10"],
+                value="1",
+                label="Response Count",
+                interactive=True,
+            )
+
+        # The user input
+        diagnoser_input = gr.Textbox(label="Enter exercise in any format",
+                                     placeholder="Exercise body: <mc:exercise xmlns:mc= ...")
+        # A button to run the chain
+        diagnoser_button = gr.Button("Submit")
+
+        # Create 10 Response textboxes
+        diagnoser_responses = [
+            gr.Textbox(label=f"Response {i + 1}", interactive=False, visible=(i == 0))
+            for i in range(10)
+        ]
+
+        # Set up a change callback so that if the user selects any model with "Claude" in the name, the exercise format updates to "XML"
+        model_choice_diagnose.change(
+            fn=update_exercise_format,
+            inputs=[model_choice_diagnose],
+            outputs=[exercise_format_diagnose]
+        )
+
+        # Callback to show/hide Response textboxes
+        sampling_count_diagnose.change(
+            fn=update_response_textboxes_amount,
+            inputs=[sampling_count_diagnose],
+            outputs=diagnoser_responses
+        )
+
+    return (
+        model_choice_diagnose,
+        exercise_format_diagnose,
+        sampling_count_diagnose,
+        diagnoser_input,
+        diagnoser_button,
+        diagnoser_responses
+    )

app/ui/distractors_tab.py

@@ -0,0 +1,98 @@
+# ui/distractors_tab.py
+import gradio as gr
+from common import update_response_textboxes_amount, update_exercise_format
+from config.llm_config import llms
+
+
+def build_distractors_tab():
+    """
+    Builds and returns the Diagnoser tab UI elements (and any references).
+    """
+    with gr.TabItem("🤔 Brainstorm distractors"):
+        # Insert an HTML info icon with a tooltip at the top of the tab content.
+        gr.HTML(
+            """
+            <div style="margin-bottom: 10px;">
+                <span style="font-size: 1.5em; cursor: help;" title="Generates alternative distractors for the given exercise in two stages. First, 2x2 brainstorming prompts (2 approaches, each using LLM 1 & LLM 2 once) generate a bunch of options, then a final consolidation prompt (using LLM 3) combines all results together for presentation below.\n\nFor both stages, prompts can be customized via dropdowns to influence the amount of distractors that will be generated during each (brainstormed and displayed).\n5-6 LLM calls per final response.">
+                    ℹ️
+                </span>
+            </div>
+            """
+        )
+
+        # Create a row for the control dropdowns: LLM selection, exercise format, sampling count etc.
+        with gr.Row():
+            model_choice_distractors_1 = gr.Dropdown(
+                choices=list(llms.keys()),
+                value="GPT-4o (mid temp)",
+                label="LLM 1 - for brainstorming",
+                interactive=True,
+            )
+            model_choice_distractors_2 = gr.Dropdown(
+                choices=list(llms.keys()),
+                value="Claude 3.5 (mid temp)",
+                label="LLM 2 - for brainstorming",
+                interactive=True,
+            )
+            exercise_format_distractors = gr.Dropdown(
+                choices=["Markdown", "XML", "Plaintext", "Raw (input not reformatted)"],
+                value="Plaintext",
+                label="Exercise Reformat",
+                interactive=True,
+            )
+            intermediate_distractors_specification = gr.Dropdown(
+                choices=[" ", " 2 ", " 3 ", " 4 ", " 5 ", " 6 ", " 7 ", " 8 ", " 9 ", " 10 ", " a few ", " some ",
+                         " a whole lot of ", " a wide range of ", " novel "],
+                value=" 8 ",
+                label="Brainstorm X distractors x4",
+                interactive=True,
+            )
+            model_choice_distractors_3 = gr.Dropdown(
+                choices=list(llms.keys()),
+                value="GPT-4o (low temp)",
+                label="LLM 3 - for consolidation",
+                interactive=True,
+            )
+            final_distractors_specification = gr.Dropdown(
+                choices=[" ", " of all unique distractors", " of the top 5", " of the best distractors",
+                         " of only the very best", " of the best 4", " of the best 5", " of the best 6",
+                         " of the best 7", " of the best 8", " of the best 9", " of the best 10", " of the best 11",
+                         " of the best 12", " of a few of them", " of some of them", " of most of them",
+                         " of a wide range of", " of the 3 worst"],
+                value=" of all unique distractors",
+                label="Finally display X distractors",
+                interactive=True,
+            )
+            sampling_count_distractors = gr.Dropdown(
+                choices=["1", "2", "3", "4", "5", "6", "7", "8", "9", "10"],
+                value="1",
+                label="Response Count",
+                interactive=True,
+            )
+
+        distractors_input = gr.Textbox(label="Enter exercise(s) in any format",
+                                       placeholder="Stelling: Dit is een ..... voorbeeld van een stelling. A. Mooi B. Lelijk ...")
+        distractors_button = gr.Button("Submit")
+
+        # Create 10 Response textboxes
+        distractors_responses = [
+            gr.Textbox(label=f"Response {i + 1}", interactive=False, visible=(i == 0))
+            for i in range(10)
+        ]
+
+
+        # Set up a change callback so that if the user selects any model with "Claude" in the name, the exercise format updates to "XML"
+        model_choice_distractors_1.change(
+            fn=update_exercise_format,
+            inputs=[model_choice_distractors_1],
+            outputs=[exercise_format_distractors]
+        )
+
+        # Callback to show/hide Response textboxes
+        sampling_count_distractors.change(
+            fn=update_response_textboxes_amount,
+            inputs=[sampling_count_distractors],
+            outputs=distractors_responses
+        )
+
+    return()

chains/{diagnoser_chain.py → diagnoser/diagnoser_chain.py}

@@ -1,4 +1,4 @@
-# chains/diagnoser_chain.py
+# chains/diagnoser/diagnoser_chain.py
 import asyncio
 from pydantic import BaseModel
 from typing import Any, List

chains/diagnoser/runner.py

@@ -0,0 +1,64 @@
+# chains/diagnoser/diagnoser_runner.py
+import asyncio
+
+from config.chain_configs import chain_configs
+from config.exercise_standardizer import standardize_exercise
+from config.llm_config import llms
+
+
+async def run_diagnoser(user_query: str, model_choice_validate: str, exercise_format_validate: str, sampling_count_validate: str) -> tuple:
+    """
+    Diagnose exercise(s) in parallel using a configured DiagnoserChain.
+
+    This function:
+      1. Standardizes the exercise text once using the chain's fixed LLM.
+      2. Instantiates the DiagnoserChain with a user-selected diagnosing LLM.
+      3. Performs multiple diagnoses in parallel (as many times as `sampling_count_validate`).
+      4. Pads the results to ensure a fixed number of output fields (10).
+
+    Args:
+        user_query (str): Raw exercise data submitted by the user.
+        model_choice_validate (str): The key/name of the chosen LLM for diagnosing.
+        exercise_format_validate (str): The desired format for standardizing the exercise.
+        sampling_count_validate (str): A string representing how many diagnoses to run concurrently (e.g., "3").
+
+    Returns:
+        tuple: A tuple of length 10, each containing a diagnosis result (or empty string if not enough samples).
+    """
+    # figure out how many times to run
+    num_samples = int("".join(filter(str.isdigit, sampling_count_validate)))
+
+    # Fetch the DiagnoserChain configuration.
+    config = chain_configs["diagnoser"]
+
+    # 1) Standardize the user query exactly once
+    standardized_exercise = await standardize_exercise(
+        user_query,
+        exercise_format_validate,
+        config["template_standardize"],  # Only if you kept them in config
+        config["llm_standardize"]
+    )
+
+    # 2) Instantiate the DiagnoserChain using the user-selected LLM for diagnosing
+    chain_instance = config["class"](
+        templates_diagnose=config["templates_diagnose"],
+        llm_diagnose=llms.get(model_choice_validate, config["llm_diagnose"]),
+        template_diagnose_scorecard=config["template_diagnose_scorecard"],
+        llm_4o_mini=config["llm_4o_mini"],
+        llm_4o=config["llm_4o"]
+    )
+
+    # 3) Run the multiple samples in parallel
+    # Create a short helper that does only the "diagnose" steps:
+    tasks = [
+        chain_instance.diagnose_only(standardized_exercise)
+        for _ in range(num_samples)
+    ]
+    # run concurrently
+    responses = await asyncio.gather(*tasks)
+
+    # pad up to 10 if needed
+    all_responses = list(responses) + [""] * (10 - len(responses))
+
+    # Return a tuple of exactly 5 responses.
+    return tuple(all_responses)

chains/{distractors_chain.py → distractors/distractors_chain.py}

@@ -1,4 +1,4 @@
-# chains/distractors_chain.py
+# chains/distractors/distractors_chain.py
 import asyncio
 from pydantic import BaseModel
 from typing import Any
@@ -73,7 +73,7 @@ class DistractorsChain(BaseModel):
         brainstorm_results = await asyncio.gather(*tasks)
 
         # Combine them in a single multiline string
-        combined_brainstorms = "\n\n--- separator between lists ---\n\n".join(brainstorm_results)
+        combined_brainstorms = "\n\n".join(brainstorm_results)
 
         # --- Step 3: Consolidate the 4 partial outputs into a final response ---
         consolidation_prompt = await self.template_consolidate.aformat_prompt(

chains/distractors/runner.py

@@ -0,0 +1,60 @@
+# chains/distractors/runner.py
+import asyncio
+
+from config.chain_configs import chain_configs
+from config.exercise_standardizer import standardize_exercise
+from config.llm_config import llms
+
+async def run_distractors(
+    user_query: str,
+    model_choice_distractors_1: str,
+    model_choice_distractors_2: str,
+    model_choice_distractors_3: str,
+    exercise_format_distractors: str,
+    sampling_count_distractors: str,
+    intermediate_distractors_specification: str,
+    final_distractors_specification: str,
+) -> tuple:
+    """
+    Generate distractors by running the DistractorsChain multiple times in parallel.
+
+    1. Standardizes the exercise text once using a fixed LLM.
+    2. Constructs a DistractorsChain, where the user can pick two LLMs
+       (e.g. one low-temp, one mid-temp) for parallel brainstorming steps.
+    3. Invokes the chain ``num_samples`` times in parallel (based on ``sampling_count_distractors``),
+       each time producing one consolidated distractors output.
+    4. Pads the results to fill 10 output fields.
+    """
+    # 0) Parse how many concurrent runs (samples) we want
+    num_samples = int("".join(filter(str.isdigit, sampling_count_distractors)))
+    # Fetch the DistractorsChain configuration.
+    config = chain_configs["distractors"]
+
+    # 1) Standardize the user query exactly once
+    standardized_exercise = await standardize_exercise(
+        user_query,
+        exercise_format_distractors,
+        config["template_standardize"],
+        config["llm_standardize"]
+    )
+
+    # 2) Build the DistractorsChain instance
+    chain_instance = config["class"](
+        template_distractors_brainstorm_1=config["template_distractors_brainstorm_1"],
+        template_distractors_brainstorm_2=config["template_distractors_brainstorm_2"],
+        llm_brainstorm_1=llms.get(model_choice_distractors_1, config["llm_brainstorm_1"]),  # User-selected LLM 1
+        llm_brainstorm_2=llms.get(model_choice_distractors_2, config["llm_brainstorm_2"]),  # User-selected LLM 2
+        template_consolidate=config["template_consolidate"],
+        llm_consolidate=llms.get(model_choice_distractors_3, config["llm_consolidate"]),    # User-selected LLM 3
+    )
+
+    # 3) Create N tasks in parallel (one full distractors generation pipeline per sample)
+    tasks = [
+        chain_instance.run(standardized_exercise, intermediate_distractors_specification, final_distractors_specification) for _ in range(num_samples)
+    ]
+    results = await asyncio.gather(*tasks)
+
+    # 4) Pad up to 10 outputs to correspond to 10 response fields
+    all_responses = list(results) + [""] * (10 - len(results))
+
+    return tuple(all_responses)

config/chain_configs.py

@@ -10,8 +10,8 @@ from config.templates import (
     template_distractors_brainstorm_2,
     template_consolidate_distractors
 )
-from chains.diagnoser_chain import DiagnoserChain
-from chains.distractors_chain import DistractorsChain
+from chains.diagnoser.diagnoser_chain import DiagnoserChain
+from chains.distractors.distractors_chain import DistractorsChain
 from config.llm_config import llms
 
 # Note: The default LLM here is GPT-4o (low temp); the UI can override this choice.

config/templates.py

@@ -144,9 +144,9 @@ template_diagnose_distractor_partially_correct = ChatPromptTemplate(
     messages=[
         ("system", """You analyze a multiple-choice exercise to detect distractors that are 
         partially correct. Some answer choices may contain elements of truth, leading to 
-        ambiguity. Identify such cases. Really stress-test them: is there a story you could tell where the distractor, in the context of this exercise, could be considered a (partially) correct answer?
+        ambiguity. Identify such cases. Really stress-test them: is there a story you could tell where the distractors, in the context of this exercise, could be considered a (partially) correct answer?
         After this, consider if this is bad enough in the context of this question. It's fine if the correct answer is still obviously most correct, and some distractors that contain elements of truth. This is only a problem if the gap becomes too small. 
-        As an intuition pump, ask this question: would there be any experts that would consider this distractor also a correct answer? If so, diagnose the problem. If not, it's fine.  
+        As an intuition pump, ask this question: would there be any experts that would consider this distractors also a correct answer? If so, diagnose the problem. If not, it's fine.  
         Your only focus is to accurately diagnose this issue, no need to provide a fix. If all distractors in the given exercise clearly are or aren't unambiguously false, just give a short one-sentence diagnosis on this. 
         If the issue is more nuanced, do some reasoning first, and give your diagnosis then.
         """),
@@ -160,8 +160,8 @@ diagnose_scorecard_template = ChatPromptTemplate(
         ("system", """You analyze the results of the diagnoses of 4 potential issues that multiple choice exercises sometimes have, and consolidate those into a very simple one-line visual scorecard that summarizes all issues' diagnoses, to show the results clearly in one overview. The diagnoses concern the following 4 potential issues:
         1. Double negatives (if the exercise contains something like 'to not not do something', this is undesirable)
         2. The correct multiple choice answer option stands out from the rest (this is a hint for the student)
-        3. A distractor answer option is too obviously false (it's useless, no student would ever pick it)
-        4. A distractor answer option is actually also kinda correct (it's misleading, if a student picks it they're not 100% wrong) 
+        3. A distractors answer option is too obviously false (it's useless, no student would ever pick it)
+        4. A distractors answer option is actually also kinda correct (it's misleading, if a student picks it they're not 100% wrong) 
         Use these two icons: 
         - ✅ means the diagnosis of the issue came back negative, so the issue is not present.
         - ❌ means the diagnosis of the issue came back positive, so the issue is present.
@@ -204,17 +204,17 @@ template_distractors_brainstorm_2 = ChatPromptTemplate(
                    "You can think about this as a spectrum between 'too correct' & 'too obviously false'. Or, in other words, a spectrum between two extreme ends that can be described as: "
                    "'An answer option that is not the correct answer to the question, yet extremely similar in meaning and scope to the correct answer, such that it's very debatable whether this answer option is not in fact also actually correct' & "
                    "'An answer option that is exceedingly unlikely, fantastical, off-base or ridiculous and therefore maximally obviously incorrect, such that no one who can read would think this could ever be the correct answer to the question'\n"
-                   "Whether any particular distractor falls on the 'too correct' or 'too obviously incorrect' parts of the spectrum, is highly context-dependent. "
+                   "Whether any particular distractors falls on the 'too correct' or 'too obviously incorrect' parts of the spectrum, is highly context-dependent. "
                    "This often depends on many aspects to do with question, for example its exact phrasing, specific (background) domain-knowledge related to the subject, "
                    "and assumptions about what test takers in the target group for this exercise already can be assumed to know or not know, and their intelligence.\n"
                    "In other words, it is not easy to pick distractors that are positioned inside the acceptable range on this spectrum. "
                    "Therefore, really try to go about your task here methodically: first establish the borders of the acceptable range of distractors by lingering there for a bit; taking into account the specific context of the given question, as follows.\n\n"
                    "Before drafting the final list, first come up with one or two faulty distractors, that are faulty in the sense that they would be júst too much on the 'too correct' side of the aforementioned spectrum.\n"
                    "Then, come up with one or two distractors that are júst faulty on the other side of that spectrum: júst too much on the side of 'too obviously false'.\n"
-                   "As an intuition pump for the first category (distractors that are júst too correct), try to imagine experts in the question's domain discussing the answer option, and some of them arguing that the distractor would also be a valid answer to the given question. "
-                   "As an intuition pump for the second category (distractors that are júst too obviously incorrect), try to image a student who is both generally stupid (bottom of his class) ánd uninformed about the given topic (didn't prepare for the test). Would even they júst so find it easy to eliminate the faulty distractor as clearly false?\n"
+                   "As an intuition pump for the first category (distractors that are júst too correct), try to imagine experts in the question's domain discussing the answer option, and some of them arguing that the distractors would also be a valid answer to the given question. "
+                   "As an intuition pump for the second category (distractors that are júst too obviously incorrect), try to image a student who is both generally stupid (bottom of his class) ánd uninformed about the given topic (didn't prepare for the test). Would even they júst so find it easy to eliminate the faulty distractors as clearly false?\n"
                    "Those are the two bounds of the spectrum range we aim to operate between during brainstorming.\n"
-                   "So, through the above process of picking some júst faulty distractors in the context of the given question, both barely too correct and barely too obviously false, you establish the two bounds of acceptable distractors. When brainstorming, don't play it entirely safe though; when in doubt about where exactly on the spectrum the distractor would lie, just list the distractor you came up with anyway.\n\n"
+                   "So, through the above process of picking some júst faulty distractors in the context of the given question, both barely too correct and barely too obviously false, you establish the two bounds of acceptable distractors. When brainstorming, don't play it entirely safe though; when in doubt about where exactly on the spectrum the distractors would lie, just list the distractors you came up with anyway.\n\n"
                    "Next, in the brainstorming phase, it's most important that you get really creative and really try to think outside the box, to come up with the required potential alternative answer options to the exercise. We want to approach this task from all different angles, "
                    "to arrive at a varied selection of options, to serve as inspiration for a later stage of final selection (not now) to make the exercise the best it can be. For now, carry out the above-described prep in writing, then draft the list of{intermediate_distractors_specification} alternative distractors (in the same language as the existing exercise)."),
         ("human", "{standardized_exercise}")
@@ -227,13 +227,15 @@ template_distractors_brainstorm_2 = ChatPromptTemplate(
 
 template_consolidate_distractors  = ChatPromptTemplate(
     messages=[
-        ("system", "You are given several lists of potential distractors (answer options to a multiple choice exercise), that need to be consolidated into one list. "
-                   "Filter out duplicates, do some logical sorting, and just return one plain list{final_distractors_specification}. "
-                   "Only focus on the distractors (answer options) themselves, ignore any reasoning about them. Return only the list, nothing else. Format the list without numbering or bullet points, just put every distractor on its own line. Use the same language as the existing exercise.\n\n"
+        ("system", "You are given several lists of potential distractors (answer options to a multiple choice exercise), that need to be consolidated and/or trimmed down into one list. "
+                   "Always at least filter out duplicates, do some logical sorting, and return one plain list{final_distractors_specification}. "
+                   "Only focus on the distractors (answer options) themselves, don't carry over any reasoning about them. Return only the list. Format the list without numbering or bullet points, just put one distractors per line. Use the same language as the existing exercise.\n\n"
                    "For context, this is the exercise that the distractors are about:\n "
                    "{standardized_exercise}"),
         ("human", "Here are the lists:\n "
-                  "{brainstorm_outputs} ")
+                  "{brainstorm_outputs}\n\n "
+                  "--- end of lists ---\n\n"
+                  "Now, your task is to return one plain list{final_distractors_specification}.")
     ],
     input_variables=["standardized_exercise", "brainstorm_outputs", "final_distractors_specification"]
 )