hjmmm

app.py

@@ -4,67 +4,53 @@ import os
 import asyncio
 import logging
 
-from utils.auth import login as auth_login  # simple login function
-from config.chain_configs import chain_configs  # chain configurations dictionary
+from utils.auth import login as auth_login  # Simple authentication
+from config.chain_configs import chain_configs
+from config.llm_config import llms
 
 logger = logging.getLogger(__name__)
 
-
-async def run_chain(chain_name: str, input_variables: dict):
-    """
-    A generic async function to run a given structured chain.
-    Handles prompt formatting, invoking the LLM asynchronously, and returning results.
-
-    Args:
-        chain_name (str): The key for the desired chain in the chain_configs.
-        input_variables (dict): A dictionary of variables to format the chain's prompt.
-
-    Returns:
-        The result of invoking the chain's LLM with the formatted prompt.
-    """
+# A generic async runner for chains.
+async def run_chain(chain_name: str, input_variables: dict, selected_model: str):
     try:
-        # Resolve the chain configuration by its name.
         chain_config = chain_configs.get(chain_name)
         if not chain_config:
-            raise KeyError(f"Chain '{chain_name}' not found in the chain configuration.")
-
-        # Generate the prompt using the chain's template.
-        prompt_value = chain_config["template"].format_prompt(**input_variables)
-
-        # Invoke the chain's LLM asynchronously.
-        result = await chain_config["chain"].ainvoke(prompt_value.to_messages())
-
+            raise KeyError(f"Chain '{chain_name}' not found.")
+
+        # Override the LLM based on user selection.
+        chosen_llm = llms.get(selected_model)
+        if not chosen_llm:
+            raise KeyError(f"LLM '{selected_model}' is not configured.")
+
+        # Instantiate the chain with the chosen LLM.
+        if chain_name == "diagnoser":
+            chain_instance = chain_config["class"](
+                template_standardize=chain_config["template_standardize"],
+                template_diagnose=chain_config["template_diagnose"],
+                llm=chosen_llm,
+            )
+        elif chain_name == "distractors":
+            chain_instance = chain_config["class"](
+                template=chain_config["template"],
+                llm=chosen_llm,
+            )
+        else:
+            raise KeyError(f"Chain '{chain_name}' is not implemented.")
+
+        result = await chain_instance.run(input_variables["user_query"])
         logger.info(f"Chain '{chain_name}' executed successfully.")
         return result
 
-    except KeyError as e:
-        logger.error(f"Chain configuration error: {e}")
-        raise ValueError(f"Invalid chain structure: missing {e}")
-
     except Exception as e:
-        logger.error(f"Error running chain '{chain_name}': {e}")
-        raise RuntimeError(f"Failed to execute chain: {e}")
+        logger.error(f"Error in run_chain for '{chain_name}': {e}")
+        return f"Error: {e}"
 
+# Async wrappers for each chain.
+async def run_diagnoser(user_query: str, model_choice: str) -> str:
+    return await run_chain("diagnoser", {"user_query": user_query}, model_choice)
 
-async def run_diagnoser(user_query: str) -> str:
-    """
-    Async function to run the diagnoser chain.
-    Prepares the input variables and awaits the chain's result.
-    """
-    input_vars = {"user_query": user_query}
-    result = await run_chain("diagnoser", input_vars)
-    return result
-
-
-async def run_distractors(user_query: str) -> str:
-    """
-    Async function to run the distractors brainstorm chain.
-    Prepares the input variables and awaits the chain's result.
-    """
-    input_vars = {"user_query": user_query}
-    result = await run_chain("distractors", input_vars)
-    return result
-
+async def run_distractors(user_query: str, model_choice: str) -> str:
+    return await run_chain("distractors", {"user_query": user_query}, model_choice)
 
 # -------------------------------
 # Build the Gradio Interface
@@ -73,59 +59,53 @@ with gr.Blocks() as demo:
     # --- Login Page ---
     with gr.Column(visible=True, elem_id="login_page") as login_container:
         gr.Markdown("## 🔒 Please Login")
-        password_input = gr.Textbox(
-            label="Enter Password",
-            type="password",
-            placeholder="Enter password to access the app"
-        )
+        password_input = gr.Textbox(label="Enter Password", type="password", placeholder="Enter password to access the app")
         login_button = gr.Button("Login")
-        login_error = gr.Markdown(value="")  # For error messages
+        login_error = gr.Markdown(value="")
 
     # --- Main App (initially hidden) ---
     with gr.Column(visible=False, elem_id="main_app") as app_container:
         gr.Markdown("## Core Functionalities")
+        # Dropdown for LLM selection.
+        model_choice = gr.Dropdown(
+            choices=list(llms.keys()),
+            value="OpenAI",
+            label="Select LLM Model",
+            interactive=True,
+        )
         with gr.Tabs():
             with gr.TabItem("Diagnoser"):
                 gr.Markdown("### Diagnoser")
-                diagnoser_input = gr.Textbox(
-                    label="Enter Diagnoser Query",
-                    placeholder="Type your query here..."
-                )
+                diagnoser_input = gr.Textbox(label="Enter Diagnoser Query", placeholder="Type your exercise description here...")
                 diagnoser_button = gr.Button("Submit")
-                diagnoser_output = gr.Textbox(label="Response", interactive=False)
+                diagnoser_output = gr.Textbox(label="Diagnosis", interactive=False)
             with gr.TabItem("Distractors brainstorm"):
                 gr.Markdown("### Distractors brainstorm")
-                distractors_input = gr.Textbox(
-                    label="Enter Brainstorm Query",
-                    placeholder="Type your query here..."
-                )
+                distractors_input = gr.Textbox(label="Enter Brainstorm Query", placeholder="Type your query here...")
                 distractors_button = gr.Button("Submit")
                 distractors_output = gr.Textbox(label="Response", interactive=False)
 
     # -------------------------------
     # Set Up Interactions
     # -------------------------------
-
-    # Login button: if the password is correct, hide the login container and reveal the main app.
+    # Login button interaction.
     login_button.click(
         fn=auth_login,
         inputs=[password_input],
         outputs=[login_container, app_container, login_error]
     )
 
-    # Run the Diagnoser chain asynchronously.
+    # Note: Gradio supports async functions as callbacks.
     diagnoser_button.click(
         fn=run_diagnoser,
-        inputs=[diagnoser_input],
+        inputs=[diagnoser_input, model_choice],
         outputs=[diagnoser_output]
     )
-
-    # Run the Distractors brainstorm chain asynchronously.
     distractors_button.click(
         fn=run_distractors,
-        inputs=[distractors_input],
+        inputs=[distractors_input, model_choice],
         outputs=[distractors_output]
     )
 
-# Launch the Gradio app.
+# Launch the app.
 demo.launch()

chains/diagnoser_chain.py

@@ -1,14 +1,31 @@
+# chains/diagnoser_chain.py
 from pydantic import BaseModel
-
+from typing import Any
+from langchain_core.prompts.chat import ChatPromptTemplate
 
 class DiagnoserChain(BaseModel):
-    template: str  # In practice, you might accept a ChatPromptTemplate
-    llm: any  # Type the LLM appropriately (or use typing.Any for now)
-
-    def run(self, user_query: str) -> str:
-        # Here you would plug in your LangChain logic.
-        # For demonstration, we mimic a call to an LLM:
-        # In production, you could use an LLMChain or a sequence of chains.
-        prompt = f"What is wrong with this exercise?\n{user_query}"
-        response = self.llm.call(prompt)
-        return response
+    template_standardize: ChatPromptTemplate
+    template_diagnose: ChatPromptTemplate
+    llm: Any  # This will be an LLM instance (e.g. ChatOpenAI or ChatAnthropic)
+
+    async def run(self, user_query: str) -> str:
+        """
+        Runs the composite chain:
+          1. Standardizes the exercise description.
+          2. Generates a diagnosis from the standardized format.
+        """
+        # Step 1: Standardize the exercise description.
+        # Using async formatting/invocation.
+        prompt_std = await self.template_standardize.aformat_prompt(user_input=user_query)
+        std_messages = prompt_std.to_messages()
+        standardized_exercise = await self.llm.ainvoke(std_messages)
+        # (Optionally extract content here if needed.)
+
+        # Step 2: Generate a diagnosis based on the standardized exercise.
+        prompt_diag = await self.template_diagnose.aformat_prompt(standardized_exercise=standardized_exercise)
+        diag_messages = prompt_diag.to_messages()
+        diagnosis = await self.llm.ainvoke(diag_messages)
+        return diagnosis
+
+    class Config:
+        arbitrary_types_allowed = True

chains/distractors_chain.py

@@ -1,11 +1,17 @@
+# chains/distractors_chain.py
 from pydantic import BaseModel
-
+from typing import Any
+from langchain_core.prompts.chat import ChatPromptTemplate
 
 class DistractorsChain(BaseModel):
-    template: str
-    llm: any
+    template: ChatPromptTemplate
+    llm: Any
+
+    async def run(self, user_query: str) -> str:
+        prompt = await self.template.aformat_prompt(user_input=user_query)
+        messages = prompt.to_messages()
+        result = await self.llm.ainvoke(messages)
+        return result
 
-    def run(self, user_query: str) -> str:
-        prompt = f"Brainstorm some distractors for:\n{user_query}"
-        response = self.llm.call(prompt)
-        return response
+    class Config:
+        arbitrary_types_allowed = True

config/chain_configs.py

@@ -1,18 +1,20 @@
-from config.llm_config import llms
-from config.templates import dummy_template, initial_classification_template
+# config/chain_configs.py
+from config.templates import standardize_template, diagnose_template, distractors_template
 from chains.diagnoser_chain import DiagnoserChain
 from chains.distractors_chain import DistractorsChain
+from config.llm_config import llms
 
+# Note: The default LLM here is OpenAI; the UI can override this choice.
 chain_configs = {
     "diagnoser": {
-        "template": dummy_template,
         "class": DiagnoserChain,
-        "llm": llms["mini"],
+        "template_standardize": standardize_template,
+        "template_diagnose": diagnose_template,
+        "llm": llms["OpenAI"],
     },
     "distractors": {
-        "template": dummy_template,  # Replace with a specific template if needed.
         "class": DistractorsChain,
-        "llm": llms["mini"],
+        "template": distractors_template,
+        "llm": llms["OpenAI"],
     },
-    # More chains can be added here.
-}
+}

config/llm_config.py

@@ -1,14 +1,35 @@
+# config/llm_config.py
+import os
 from langchain_openai import ChatOpenAI
+from langchain_anthropic import ChatAnthropic
 
+# Retrieve API keys from environment variables
+OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
+ANTHROPIC_API_KEY = os.getenv("ANTHROPIC_API_KEY")
+DEEPSEEK_API_KEY = os.getenv("DEEPSEEK_API_KEY")
+
+# Define temperature presets (adjust as needed)
 ZERO = 0
 LOW = 0.2
 MID = 0.7
 HIGH = 1.2
 
+# Factory functions for each provider
+def create_openai_llm(model_name: str, temperature: float):
+    return ChatOpenAI(api_key=OPENAI_API_KEY, model_name=model_name, temperature=temperature)
+
+def create_anthropic_llm(model_name: str, temperature: float):
+    return ChatAnthropic(api_key=ANTHROPIC_API_KEY, model_name=model_name, temperature=temperature)
+
+def create_deepseek_llm(model_name: str, temperature: float):
+    return ChatAnthropic(api_key=ANTHROPIC_API_KEY, model_name=model_name, temperature=temperature)
+
 llms = {
-    "gpt4o": ChatOpenAI(model_name="gpt-4o", temperature=LOW),
-    "mini": ChatOpenAI(model_name="gpt-4o-mini", temperature=LOW),
-    "gpt4o_high_temp": ChatOpenAI(model_name="gpt-4o", temperature=HIGH),
-    "mini_high_temp": ChatOpenAI(model_name="gpt-4o-mini", temperature=HIGH),
-    "o1": ChatOpenAI(model_name="o1"),
+    "gpt4o": create_openai_llm("gpt-4o", LOW),
+    "mini": create_openai_llm("gpt-4o-mini", LOW),
+    "gpt4o_high_temp": create_openai_llm("gpt-4o", HIGH),
+    "mini_high_temp": create_openai_llm("gpt-4o-mini", HIGH),
+    "o1": create_openai_llm("o1"),
+    "Claude35": create_anthropic_llm("claude-v1", LOW),
+    "R1": create_anthropic_llm("deepseek-reasoner", LOW),
 }

config/templates.py

@@ -1,25 +1,29 @@
-from langchain_core.prompts import ChatPromptTemplate
+# config/templates.py
+from langchain_core.prompts.chat import ChatPromptTemplate
 
-dummy_template = ChatPromptTemplate([
-    ("system", """
-    SYSTEM MESSAGE 
-    {bot_name} {weekday} {now}
-    """),
-    ("human", """
-    USER MESSAGE 
-    {user_message}
-    """),
-])
+# Template to standardize the exercise description.
+standardize_template = ChatPromptTemplate(
+    messages=[
+        ("system", "You are an exercise standardizer. Convert the following exercise description into a standardized format."),
+        ("human", "{user_input}")
+    ],
+    input_variables=["user_input"]
+)
 
-initial_classification_template = ChatPromptTemplate([
-    ("system", """
-    # Answer structure
-    1. First pick the user_message_language: choose from Literal['English', 'German', 'Dutch', 'other']. 
-       Look only at the user message. When multiple languages are present, pick the dominant one.
-    2. Then, state your classification: 'Goals', 'Reminders', 'Meta', or 'Other'.
-    """),
-    ("human", """
-    USER MESSAGE 
-    {user_message}
-    """),
-])
+# Template to generate a diagnosis from the standardized exercise.
+diagnose_template = ChatPromptTemplate(
+    messages=[
+        ("system", "You are a diagnostic assistant. Based on the standardized exercise description, provide a detailed diagnosis of potential issues and improvements."),
+        ("human", "{standardized_exercise}")
+    ],
+    input_variables=["standardized_exercise"]
+)
+
+# Template for the distractors brainstorm (a single-step chain).
+distractors_template = ChatPromptTemplate(
+    messages=[
+        ("system", "You are a brainstorming assistant. Provide creative distractors and brainstorm ideas based on the user input."),
+        ("human", "{user_input}")
+    ],
+    input_variables=["user_input"]
+)

requirements.txt

@@ -1,6 +1,7 @@
 gradio>=3.42.0
 openai==1.57.3
-langchain-openai==0.2.12
+langchain-openai==0.3.4
+langchain-anthropic==0.3.7
 langchain-core==0.3.24
 pydantic==2.9.2
 typing_extensions==4.12.2