first push of 4-track learning_objectives_generator

app/helpers/exercise_standardizer.py

@@ -1,7 +1,7 @@
 # app/helpers/exercise_standardizer.py
 from langchain_core.prompts import ChatPromptTemplate
 from typing import Any
-from config.format_mappings import FORMAT_MAPPINGS
+from config.format_mappings import FORMAT_MAPPINGS_EXERCISES
 
 
 
@@ -12,7 +12,7 @@ async def standardize_exercise(user_query: str, exercise_format: str, template:
     if exercise_format == "Raw (original)":
         return user_query  # No transformation needed
 
-    formatting_instructions = FORMAT_MAPPINGS.get(
+    formatting_instructions = FORMAT_MAPPINGS_EXERCISES.get(
         exercise_format,
         "Please reformat the given exercise to ease further processing."
     )

app/helpers/study_text_standardizer.py

@@ -0,0 +1,30 @@
+# app/helpers/exercise_standardizer.py
+from langchain_core.prompts import ChatPromptTemplate
+from typing import Any
+from config.format_mappings import FORMAT_MAPPINGS_STUDY_TEXTS
+
+
+
+async def standardize_studytext(user_query: str, studytext_format: str, template: ChatPromptTemplate, llm: Any) -> str:
+    """
+    Standardizes a studytext's format using the specified template and LLM, and updates the UI via standardized_format_state.
+    """
+    if studytext_format == "Raw (original)":
+        return user_query  # No transformation needed
+
+    formatting_instructions = FORMAT_MAPPINGS_STUDY_TEXTS.get(
+        studytext_format,
+        "Please reformat the given studytext to ease further processing."
+    )
+
+    prompt_std = await template.aformat_prompt(
+        user_input=user_query,
+        formatting_instructions=formatting_instructions
+    )
+
+    std_messages = prompt_std.to_messages()
+    response = await llm.ainvoke(std_messages)
+    standardized_studytext = getattr(response, "content", response)
+
+    return standardized_studytext
+

app/ui/diagnoser_tab.py

@@ -46,7 +46,7 @@ def build_diagnoser_tab():
         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")
+        diagnoser_button = gr.Button("Diagnose")
 
         # Create 10 Response textboxes
         diagnoser_responses = [

app/ui/distractors_tab.py

@@ -73,7 +73,7 @@ def build_distractors_tab():
 
         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_button = gr.Button("Brainstorm")
 
         # Create 10 Response textboxes
         distractors_responses = [

app/ui/learning_objectives_tab.py

@@ -0,0 +1,54 @@
+import gradio as gr
+from chains.learning_objectives_generator.runner import run_learning_objectives_generator
+from config.llm_config import llms
+
+def build_learning_objectives_tab():
+    with gr.TabItem("🧠 Identify Learning Objectives"):
+        gr.HTML(
+            """
+            <div style="margin-bottom: 10px;">
+                <span style="font-size: 1.5em; cursor: help;" title="Generate learning objectives for the given study text">
+                    ℹ️
+                </span>
+            </div>
+            """
+        )
+        # 2 dropdowns for the user-chosen LLMs:
+        model_choice_1 = gr.Dropdown(
+            choices=list(llms.keys()),
+            label="LLM 1"
+        )
+        model_choice_2 = gr.Dropdown(
+            choices=list(llms.keys()),
+            label="LLM 2"
+        )
+        text_format = gr.Dropdown(
+                choices=["Markdown", "XML", "Plaintext", "Raw (input not reformatted)"],
+                value="Markdown",
+                label="Studytext Reformat",
+                interactive=True,
+        )
+
+        studytext_input = gr.Textbox(label="Enter a study text in any format", placeholder="<h3>Infusie en infuussystemen</h3> <h4>Inleiding</h4> ...")
+        learning_objectives_button = gr.Button("Identify LOs")
+
+        # 2×2 textboxes => 4 total
+        # For clarity: 
+        #   row 1 => (box_0, box_1) 
+        #   row 2 => (box_2, box_3)
+        with gr.Row():
+            box_0 = gr.Textbox(label="Prompt A + LLM 1", interactive=False)
+            box_1 = gr.Textbox(label="Prompt B + LLM 1", interactive=False)
+        with gr.Row():
+            box_2 = gr.Textbox(label="Prompt A + LLM 2", interactive=False)
+            box_3 = gr.Textbox(label="Prompt B + LLM 2", interactive=False)
+
+
+
+    # Return references if needed
+    return (model_choice_1,
+            model_choice_2,
+            text_format,
+            studytext_input,
+            learning_objectives_button,
+            [box_0, box_1, box_2, box_3])

chains/learning_objectives_generator/learning_objectives_chain.py

@@ -6,16 +6,7 @@ from langchain_core.prompts.chat import ChatPromptTemplate
 
 class LearningObjectivesChain(BaseModel):
     """
-    Orchestrates multi-step generation of learning objectives:
-      1) Two parallel calls to 'learning_objective_generator' (LLM1, LLM2).
-      2) Combine those outputs.
-      3) 'learning_objective_eliminator' on the combined output (Main LLM).
-      4) 'learning_objective_finetuner' on the output of that (Main LLM).
-      5) 'learning_objective_presenter' to finalize (Main LLM).
 
-    Each step can have its own ChatPromptTemplate and uses the relevant LLM.
-
-    If you want a separate alt LLM for step #3 or #4, just expand as needed.
     """
 
     # Templates

chains/learning_objectives_generator/runner.py

@@ -0,0 +1,82 @@
+import asyncio
+from typing import AsyncGenerator
+from config.llm_config import llms
+from config.chain_configs import chain_configs
+from app.helpers.study_text_standardizer import standardize_studytext
+
+async def run_learning_objectives_generator(
+    user_input_text: str,
+    model_choice_1: str,
+    model_choice_2: str,
+    text_format: str
+) -> AsyncGenerator:
+    """
+    Orchestrates the entire pipeline:
+      1) Standardize the study text
+      2) Generate (2 prompts × 2 LLMs) => 4 partial results
+      3) Sanitize each partial result
+      4) Yield partial updates in real time as each track completes
+    """
+    # 1) Standardize the text once
+    config = chain_configs["learning_objectives"]  # you define this in chain_configs.py
+    standardized = await standardize_studytext(
+        user_input_text, text_format,
+        config["template_studytext_standardize"],
+        config["llm_standardize_studytext"]
+    )
+
+    # Prepare references for the generation prompts:
+    prompt_a = config["template_gen_prompt_a"]
+    prompt_b = config["template_gen_prompt_b"]
+    sanitize_prompt = config["template_sanitize"]
+
+    # pick the LLMs from user choices (with fallback to config)
+    llm_a = llms.get(model_choice_1, config["default_llm_a"])
+    llm_b = llms.get(model_choice_2, config["default_llm_b"])
+
+    # We will store the final sanitized results in an array of 4 strings
+    # (2 prompts × 2 LLMs)
+    partial_results = ["", "", "", ""]
+
+    # We'll define a short async helper for each track:
+    # 'track_index' is 0..3 so we know which of the 4 textboxes to fill
+    # 'gen_prompt' is either prompt_a or prompt_b
+    # 'gen_llm' is either llm_a or llm_b
+    async def run_track(track_index: int, gen_prompt, gen_llm):
+        # Step: generate
+        gen_msg = await gen_prompt.aformat_prompt(standardized_text=standardized)
+        gen_resp = await gen_llm.ainvoke(gen_msg.to_messages())
+        generation_output = getattr(gen_resp, "content", gen_resp)
+
+        # Step: sanitize
+        sanitize_msg = await sanitize_prompt.aformat_prompt(raw_output=generation_output)
+        sanitize_resp = await llm_a.ainvoke(sanitize_msg.to_messages())  # or use a separate LLM for sanitization
+        sanitized_output = getattr(sanitize_resp, "content", sanitize_resp)
+
+        return (track_index, sanitized_output)
+
+    # Build the 4 tasks:
+    #  - track 0 => prompt A, LLM 1
+    #  - track 1 => prompt B, LLM 1
+    #  - track 2 => prompt A, LLM 2
+    #  - track 3 => prompt B, LLM 2
+
+    tasks = [
+        run_track(0, prompt_a, llm_a),
+        run_track(1, prompt_b, llm_a),
+        run_track(2, prompt_a, llm_b),
+        run_track(3, prompt_b, llm_b),
+    ]
+
+    # We'll run them in parallel and yield updates as each finishes
+    done_count = 0
+    for coro in asyncio.as_completed(tasks):
+        track_index, final_text = await coro
+        partial_results[track_index] = final_text
+        done_count += 1
+
+        # yield partial update
+        # We yield a tuple with the 4 track results.
+        # The UI will map each item to the correct textbox.
+        yield tuple(partial_results) + (standardized, )
+

config/chain_configs.py

@@ -1,6 +1,7 @@
 # config/chain_configs.py
 from config.templates import (
-    standardize_template,
+    template_standardize_exercise,
+    template_standardize_studytext,
     template_diagnose_double_negation,
     template_diagnose_correct_answer_stands_out,
     template_diagnose_distractor_clearly_wrong,
@@ -8,17 +9,21 @@ from config.templates import (
     diagnose_scorecard_template,
     template_distractors_brainstorm_1,
     template_distractors_brainstorm_2,
-    template_consolidate_distractors
+    template_consolidate_distractors,
+    template_gen_prompt_a,
+    template_gen_prompt_b
 )
 from chains.diagnoser.diagnoser_chain import DiagnoserChain
 from chains.distractors.distractors_chain import DistractorsChain
+from chains.learning_objectives_generator.learning_objectives_chain import LearningObjectivesChain
 from config.llm_config import llms
 
 # Note: The default LLM here is GPT-4o (low temp); the UI can override this choice.
+
 chain_configs = {
     "diagnoser": {
         "class": DiagnoserChain,
-        "template_standardize": standardize_template,
+        "template_standardize": template_standardize_exercise,
         "llm_standardize": llms["GPT-4o-mini (zero temp)"],     # Always fixed
         "llm_4o_mini": llms["GPT-4o-mini (low temp)"],
         "llm_4o": llms["GPT-4o (low temp)"],
@@ -34,7 +39,7 @@ chain_configs = {
     },
     "distractors": {
         "class": DistractorsChain,
-        "template_standardize": standardize_template,
+        "template_standardize": template_standardize_exercise,
         "llm_standardize": llms["GPT-4o-mini (zero temp)"],     # Always fixed
         "template_distractors_brainstorm_1": template_distractors_brainstorm_1,
         "template_distractors_brainstorm_2": template_distractors_brainstorm_2,
@@ -43,4 +48,14 @@ chain_configs = {
         "template_consolidate": template_consolidate_distractors,
         "llm_consolidate": llms["GPT-4o (low temp)"],  # or something else
     },
+    "learning_objectives": {
+        "class": LearningObjectivesChain,
+        "template_standardize_studytext": template_standardize_studytext,
+        "llm_standardize": llms["GPT-4o-mini (zero temp)"],     # Always fixed
+        "template_gen_prompt_a": template_gen_prompt_a,
+        "template_gen_prompt_b": template_gen_prompt_b,
+        "default_llm_a": llms["o1"],
+        "default_llm_b": llms["o3-mini (high reasoning_effort)"]
+    },
 }
+

config/format_mappings.py

@@ -1,6 +1,7 @@
 # format_mappings.py
 
-FORMAT_MAPPINGS = {
+# Intermediate plain processing
+FORMAT_MAPPINGS_EXERCISES = {
     "Markdown": (
         "Please reformat in Markdown, following this example:\n"
         "**Theorie:**  \n"
@@ -50,3 +51,38 @@ FORMAT_MAPPINGS = {
         "1. Het gevoel geen connectie te hebben met anderen"
     )
 }
+
+
+FORMAT_MAPPINGS_STUDY_TEXTS = {
+    "Markdown": (
+        "Please reformat into Markdown."
+    ),
+    "XML": (
+        """
+        Please reformat into XML, use tags like <title></title> and <b></b>.
+        """
+    ),
+    "Plaintext": (
+        "Please reformat into neat plaintext, without any tags or other formatting."
+    )
+}
+
+# Final processing
+studytext_HTML = (
+        """
+        Please reformat into XML. The target conventions are:
+        - always start with a title like this: <h3>TITLE</h3>;
+        - subheadings are just in bold. Usually there won't be any subheadings though, just different paragraphs;
+        - for bold text, use <strong></strong>;
+        - divide the text up into <p></p>-blocks;
+        - for lists, adhere to the following capitalization and interpunction rules:
+        <p>This is an example list, pay attention to lowercase beginnings and final interpunction endings of each item:</p>
+            <ul>
+                <li>each item starts with lowercase;</li>
+                <li>always. Even if it's several sentences long. Like this one;</li>
+                <li>each item ends with a semicolon;</li>
+                <li>except for the very latest item;</li>
+                <li>that (this) final item, ends with a full-stop, a period.</li>
+            </ul>
+        """
+)

config/templates.py

@@ -1,8 +1,7 @@
 # config/templates.py
 from langchain_core.prompts.chat import ChatPromptTemplate
 
-# Template to standardize the exercise description.
-standardize_template = ChatPromptTemplate(
+template_standardize_exercise = ChatPromptTemplate(
     messages=[
         ("system", "You reformat a given multiple choice exercise into a standardized format. {formatting_instructions}\n\n"
                    "Only 3 elements are always mandatory:\n"
@@ -18,6 +17,15 @@ standardize_template = ChatPromptTemplate(
     input_variables=["user_input", "formatting_instructions"]
 )
 
+template_standardize_studytext = ChatPromptTemplate(
+    messages=[
+        ("system", "You reformat a given study text into a standardized format. {formatting_instructions}\n\n"
+                   ),
+        ("human", "Here's the given study text:\n{user_input}")
+    ],
+    input_variables=["user_input", "formatting_instructions"]
+)
+
 template_diagnose_double_negation = ChatPromptTemplate(
     messages=[
         ("system", """Analyze a multiple-choice exercise for the presence of double negatives: either two negations in the question/statement itself, or a negation in the question/statement AND in an answer option. 
@@ -221,8 +229,6 @@ 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 and/or trimmed down into one list. "
@@ -238,3 +244,127 @@ template_consolidate_distractors  = ChatPromptTemplate(
     input_variables=["standardized_exercise", "brainstorm_outputs", "final_distractors_specification"]
 )
 
+
+template_gen_prompt_a = ChatPromptTemplate(
+    messages=[
+        ("system", """
+        You are given a study text that is part of an e-learning and an accompanying list of learning objectives based on the text. Your goal is to refine the learning objectives, such that they adhere to the requirements as closely as possible. These learning objectives will later serve as the basis for multiple-choice exercises, and for this purpose it is crucial that they live up to the requirements in every way.
+
+        # General approach
+        - First intensely study and really internalize the requirements for good learning objectives (listed below).
+        - Then, rewrite and improve the learning objectives to better fall in line with the requirements. 
+        
+        # Requirements for individual learning objectives
+        Good learning objectives:
+        - Start with 'The student knows that '
+        - Are unambiguous, and contain what later will become the specific correct answer for any multiple choice exercises that would test the learning objective 
+        - Represent exactly the knowledge as written in the study text 
+        - Use exactly the same terminology that's used in the study text 
+        - Mirror also the general language level of the study text. If the text is written with very simple words, then the learning objectives should be also written in very simple words
+        - Mirror also the voice of the text (passive or active voice) and the perspective of the text (second or third person)
+        - Are as concise as can be: they contain the smallest possible knowledge element. A learning objective does not combine multiple facts, but rather isolates individual facts
+        - Avoid absolute terms that overstate their universality, like 'always' and 'never', unless that actually is true 100% of the time (usually there are exceptions to every rule, so account for those in your phrasing)
+        - Alternatively avoid vague terms that make what they wanna say too meaningless, like 'can', 'could', 'might' and 'may' (many things 'can', 'could' or 'might be', this doesn't say much)
+        - Also avoid subjective terms like 'often', 'sometimes', 'many', 'few', 'common', 'rare'. Instead, make more specific and falsifiable claims like 'in most cases' or 'A is more common than B'
+        - Avoid the use of 'important', again a signal word indicating subjectivity. Only use 'important' in statements that you cannot rephrase, yet are actually indisputable ánd meaningful to know when phrased in this way
+        
+        # Process
+        - For each learning objective, go over all of the requirements, like methodically checking off a checklist.
+        - For any aspect of any learning objective that upon reflection doesn't adhere to the requirements as well as it could, carry out a rewrite (or split up one learning objective into two, for example) of the learning objective.
+        - Iteratively keep doing this for each of the individual learning objectives again and again, until you are certain that they are the best versions they can be: each entirely and maximally satisfying the requirements for good learning objectives. 
+        - Take as much time as you need to get it perfect, then return the list of final learning objectives (for this, use the same language as the study text).
+        """),
+        ("human", "{standardized_text}")
+    ],
+    input_variables=["standardized_text"]
+)
+
+template_gen_prompt_b = ChatPromptTemplate(
+    messages=[
+        ("system", """
+        You are given a study text. Based on this, you will identify learning objectives. Follow the following protocol meticulously:
+
+        # Protocol for Creating Exercises for eLearning Modules
+        ## General Working Method
+        
+        ### Text Orientation  
+        Assigned a study text, your initial task is to read it to understand the topic for creating exercises.
+        
+        ### Learning objectives 
+        Based on the text, define clear, concise learning objectives. Make sure you have enough learning objectives so that all information is covered, but not too many so that learning objectives won't overlap.  It's really important that every learning objective only states 1 single fact and doesn't combine multiple facts. Choose objectives based on text analysis and audience level. Objectives always start with 'The student knows that'. 
+        
+        Observe the following rules meticulously when writing learning objectives:
+        
+        #### Avoid 'always' and 'never' 
+        Don't use words like 'always' or 'never' in learning objectives, it is likely an exception exists. Instead use constructions like 'X *fits with* Y', 'X *suggests* Y', 'X *is more common than* Y'
+        
+        So not:
+        > BAD: The students knows that fever *never* occurs with a viral infection. 
+        > BAD: The students knows that fever *always* occurs with a viral infection. 
+        
+        But:
+        > GOOD: The students knows that fever is a symptom *that fits with* a viral infection. 
+        
+        #### Avoid 'can', 'could', 'may' or 'might' 
+        Don't use words like *'can'*, *'could'*, *'may'* or *'might'* in learning objectives, because almost everything can, could or might be something, so too suggestive. Instead use constructions like 'X *fits with* Y', 'X *suggests* Y', 'X *is more common than* Y'
+        
+        So not:
+        > BAD: The students knows that pain *might* occur with rheumatoid arthritis.
+        > BAD: The students knows that pain *can* occur with rheumatoid arthritis.
+        > BAD: The students knows that pain *could* occur with rheumatoid arthritis.
+        > BAD: The students knows that pain *may* occur with rheumatoid arthritis.
+        
+        But: 
+        > GOOD: The students knows that pain *is a symptom of* rheumatoid arthritis.
+        
+        #### Avoid subjective terminology like many, few and common 
+        Don't use words like *'many'*, *'few'*, *'common'*, *'rare'* et cetera as these are subjective. Instead be specific. Instead use terminology like *'in most cases'* or compare: *'symptom A is more common than symptom B'*. 
+        
+        Example of a bad learning objective, leading to suggestive or subjective answers: 
+        > BAD: The student knows that fever commonly occurs with a viral infection. 
+        
+        #### Avoid important, essential significant
+        Don't use words like *'important'*, *'essential'*, *'significant'* et cetera in learning objectives, as these are prone to subjectivity. 
+        
+        Examples of a bad learning objective, leading to suggestive or subjective answers: 
+        > BAD: The students knows that it's *important* to rest when having a viral infection. 
+        
+        The objective uses the word *'important'* which is subjective.  
+        
+        > BAD: The students knows that it's *essential* to rest when having a viral infection. 
+        
+        The objective uses the word *'essential'* which is subjective. 
+        
+        > BAD: The students knows that fever has a *significant* effect on how people feel when they are sick. 
+        
+        The objective uses the word *'significant'* which is subjective. 
+        
+        > BAD: The student knows that drinking *enough* water is *important* to stay hydrated. 
+        
+        The objective uses the word *'important'* which is subjective. Also the word *'enough'* is subjective. 
+        
+        
+        A good example is: 
+        
+        > GOOD: The student knows that proteinuria is a symptom of nephrotic syndrome. 
+        
+        An example of a bad learning objective: 
+        
+        > BAD: The student knows the symptoms of nephrotic syndrome. 
+        
+        The bad objective does not specify a single fact as symptoms are not specified.
+        
+        A good example is:
+        
+        >  GOOD: The student knows that besides pain, rheumatoid arthritis also causes loss of mobility. 
+        
+        An example of a bad learning objective:
+        
+        > BAD: The student knows that problems with movement due to joint problems, such as rheumatism, can be painful or completely limit movement
+        
+The latter objective does not specify a single fact but combines two (can be painful or completely limit movement). The first objective focuses on the 'loss of mobility' element, while the 'pain- element' is already considered known. The exercises generated by this learning objective will test the 'loss of mobility' element (so not the 'pain-element')
+        """),
+        ("human", "{standardized_text}")
+    ],
+    input_variables=["standardized_text"]
+)

main.py

@@ -3,8 +3,10 @@ import gradio as gr
 import logging
 from app.ui.diagnoser_tab import build_diagnoser_tab
 from app.ui.distractors_tab import build_distractors_tab
+from app.ui.learning_objectives_tab import build_learning_objectives_tab
 from chains.diagnoser.runner import run_diagnoser
 from chains.distractors.runner import run_distractors
+from chains.learning_objectives_generator.runner import run_learning_objectives_generator
 from utils.auth import login as auth_login
 
 logger = logging.getLogger(__name__)
@@ -30,7 +32,7 @@ with gr.Blocks() as interface:
     # --- Main App (initially hidden) ---
     with gr.Column(visible=False, elem_id="main_app") as app_container:
 
-        # --- Standardized Exercise/Studytext Display (Initially Invisible Because it's empty) ---
+        # --- Standardized Exercise/Study text Display (Initially Invisible Because it's empty) ---
         # A row for Title & the standardized text & copy button
         with gr.Row():
             with gr.Column(scale=3):
@@ -73,25 +75,14 @@ with gr.Blocks() as interface:
              final_distractors_specification,
              ) = build_distractors_tab()
 
-            with gr.TabItem("🚧 Generate learning objectives"):
-                # 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="Generate learning objectives for the given study text">
-                            ℹ️
-                        </span>
-                    </div>
-                    """
-                )
-                learning_objectives_input = gr.Textbox(label="Enter a study text in any format", placeholder="<h3>Infusie en infuussystemen</h3> <h4>Inleiding</h4> ...")
-                learning_objectives_button = gr.Button("Submit")
-                gr.Markdown("**Response(s):**")
-                # Create 5 Response textboxes
-                distractors_responses = [
-                    gr.Textbox(label=f"Response {i + 1}", interactive=False, visible=(i == 0))
-                    for i in range(10)
-                ]
+            # Build Learning Objectives Generator tab
+            (model_choice_1,
+            model_choice_2,
+            text_format,
+            studytext_input,
+            learning_objectives_button,
+            [box_0, box_1, box_2, box_3]
+             ) = build_learning_objectives_tab()
 
     # -------------------------------
     # Set Up Interactions
@@ -124,5 +115,17 @@ with gr.Blocks() as interface:
         outputs=distractors_responses + [standardized_format_display],
     )
 
+    learning_objectives_button.click(
+        fn=run_learning_objectives_generator,  # Our async generator
+        inputs=[studytext_input, model_choice_1, model_choice_2, text_format],
+        outputs=[box_0, box_1, box_2, box_3, standardized_format_display],
+        # 'stream=True' is needed to allow partial updates
+        # in a generator function.
+        # In recent Gradio versions, we just do `every=1` or `queue=True`
+        queue=True,
+        api_name=None,
+        # or "stream=True" depending on your version of Gradio
+    )
+
 # Launch the app.
 interface.launch()