The AI Micro-Tutor: Bridging Clinical Reasoning and Automated Instruction

A Technical and Pedagogical Deep Dive

The Micro-Tutor is a specialized, interactive learning module designed to simulate the “Grand Rounds” experience found in medical education. Unlike generic chatbots, this system uses a Case-Based Learning (CBL) framework to force students into active problem-solving rather than passive reading. By leveraging Google’s Gemma 3 (via the GenAI SDK) and a Svelte/Firebase architecture, the module provides a 24/7 Socratic tutor that creates a safe environment for students to practice diagnostic reasoning without the pressure of a real clinic.

Part 1: Technical Architecture

The system is built on a “Brain and Body” architecture. The Body (Frontend) handles the visual engagement (tabs, images, chats), while the Brain (Backend) manages the pedagogical logic (context switching, rules, and scoring).

1. The Brain: Context-Aware Backend (main.py)

The Python backend does not just “chat”; it acts as a Game Master. It dynamically loads patient files (.txt) and enforces strict rules, such as the “2-Strike Rule” (if a student fails twice, give the answer) and the “Unlock Protocol” (reveal images only when requested).

Key Python Logic:

@https_fn.on_request()
def chat_with_professor(req: https_fn.Request) -> https_fn.Response:
    # 1. Dynamic Context Loading
    # The AI swaps its "Brain" based on the caseId sent by the user
    case_id = request_json.get('caseId', 'Case1')
    filename = f"{case_id}_main_data.txt" 
    
    # 2. Image Inventory System
    # Maps user typos (e.g., "shoe me the xray") to exact filenames
    CASE_IMAGES = {
        "Case1": ["Case1_histo", "Case1_normal_rad", "Case1_T2_mri"],
        "Case2": ["Case2_ECG", "Case2_skin_lesion", "Case2_WB"],
        # ...
    }
    
    # 3. The Pedagogical System Prompt
    # This is not just a persona; it is a set of binding rules.
    system_instructions = (
        f"You are Prof. Aris. ...\n"
        f"RULES:\n"
        f"1. Socratic Guidance: Never give the diagnosis. Ask leading questions.\n"
        f"2. Image Unlocking: If clinically appropriate, output [UNLOCK_IMAGE: filename].\n"
        f"3. 2-Strike Rule: If they fail twice, explain and move on."
    )
    
    # ... GenAI Call ...

2. The Body: Reactive Frontend (MicroTutor.svelte)

The Svelte frontend is responsible for the “Magic” of the interface—specifically, listening for the hidden codes the AI sends. It uses Regular Expressions (Regex) to intercept commands like [UNLOCK_IMAGE: Case1_T2_mri] and convert them into interactive UI elements.

Key Svelte Logic:

// The "Listener" Loop
const unlockRegex = /\[UNLOCK_IMAGE:\s*(.*?)\]/g;
let match;

// Scan the AI's text for hidden commands
while ((match = unlockRegex.exec(aiText)) !== null) {
    const imgName = match[1];
    
    // If we haven't unlocked this image yet, add it to the tray
    if (!unlockedImages.includes(imgName)) {
        unlockedImages = [...unlockedImages, imgName];
    }
}

// Clean the text so the user sees "Handing you the image..." instead of code
aiText = aiText.replace(unlockRegex, " *(Handing you the image...)* ");

Part 2: Pedagogical Foundation (Why This Works)

Case-Based Learning (CBL) in Microbiology

Microbiology is often taught via rote memorization of bug characteristics (e.g., “Staph aureus is Gram-positive”). However, in clinical practice, doctors encounter patients, not lists.
CBL reverses the learning process: it presents a patient history first, forcing the student to identify the pathogen based on clues.

· Active Recall: By asking the student “What labs would you order?”, the module forces retrieval practice, which significantly improves retention compared to passive lectures.
· Clinical Context: Studies show that students trained via CBL in microbiology demonstrate better clinical correlation and problem-solving skills than those trained via traditional didactic lectures.
· Safe Failure: The AI’s “2-Strike Rule” mitigates the anxiety of being wrong. In a classroom, a student might stay silent to avoid embarrassment. Here, they can guess “Is it flu?” and receive a gentle, constructive correction from Prof. Aris.

CBL vs. Problem-Based Learning (PBL)

While often used interchangeably, there is a distinct difference that makes CBL better for this specific module:

· CBL (This Module): Uses guided inquiry. The case has a correct answer (e.g., “Lyme Disease”), and the instructor (AI) keeps the student on the path. This is ideal for foundational knowledge in microbiology where specific diagnostic steps must be learned.
· PBL: Uses open-ended inquiry. The problem might be “A village has an outbreak.” Students must define the learning objectives themselves. PBL is often less structured and can overwhelm novice learners.

Why Micro-Tutor uses CBL: It ensures that every student walks away understanding the specific diagnostic criteria for the target pathogens (e.g., Borrelia, Staph, Meningococcus).

Part 3: Future Roadmap & Group Learning

1. The “Panic Button” (Professor Intervention)

If a student is stuck or the AI is hallucinating, we can add a “Report/Help” button. This uses a simple SMTP relay to send the transcript to the professor.

Python Concept Code (Future Addition):

# Function to email the transcript to the Professor
def send_transcript_to_prof(student_email, chat_history, case_id):
    import smtplib
    from email.mime.text import MIMEText
    
    # Format the chat into a readable string
    body = f"Student {student_email} is stuck on {case_id}.\n\nTRANSCRIPT:\n"
    for msg in chat_history:
        body += f"{msg['role']}: {msg['content']}\n"
        
    msg = MIMEText(body)
    msg['Subject'] = f"Micro-Tutor Alert: {case_id}"
    msg['From'] = "ai-tutor@university.edu"
    msg['To'] = "professor@university.edu"
    
    # Send via SMTP (e.g., SendGrid or University Mail)
    s = smtplib.SMTP('smtp.university.edu')
    s.send_message(msg)
    s.quit()

2. “Multiplayer” Mode (Collaborative Diagnosis)

We can transform the module into a group activity where 4-5 students join the same “Room.”

· How: Use Firebase Realtime Database.
· Logic: When Student A types “Order CBC,” it appears on Student B’s screen. The AI responds to the group.
· Benefit: This promotes peer teaching, which creates even stronger memory channels than individual study.

3. Transition to PBL (Advanced Modules)

Once students master the CBL modules (Specific Diseases), we can introduce PBL Modules:

· Scenario: “You are the public health officer. 40 students at a dorm are sick. Go.”
· AI Change: The AI stops giving “2-Strike” hints and instead acts as a “World Simulator,” returning data only when specifically asked (e.g., “I call the dorm manager” -> AI: “The manager tells you…”).
· Goal: To test synthesis and epidemiology skills rather than just pathogen identification.

Conclusion

The Micro-Tutor represents a shift from “learning about bugs” to “diagnosing patients.” By combining the structural rigor of Case-Based Learning with the infinite patience of Generative AI, we provide a scalable, effective tool that allows students to practice clinical reasoning anytime, anywhere. As validated by recent medical education research, this approach not only improves exam scores but builds the confidence required for real-world medical practice.