Add prompt templates and utility functions for Med-I-C multi-agent system

app.py

@@ -1,10 +1,13 @@
 """
 Med-I-C: AMR-Guard Demo Application
 Infection Lifecycle Orchestrator - Streamlit Interface
+
+Multi-Agent Architecture powered by MedGemma via LangGraph
 """
 
 import streamlit as st
 import sys
+import json
 from pathlib import Path
 
 # Add project root to path
@@ -12,19 +15,14 @@ PROJECT_ROOT = Path(__file__).parent
 sys.path.insert(0, str(PROJECT_ROOT))
 
 from src.tools import (
-    query_antibiotic_info,
-    get_antibiotics_by_category,
     interpret_mic_value,
-    get_breakpoints_for_pathogen,
-    query_resistance_pattern,
     get_most_effective_antibiotics,
     calculate_mic_trend,
-    check_drug_interactions,
     screen_antibiotic_safety,
     search_clinical_guidelines,
-    get_treatment_recommendation,
     get_empirical_therapy_guidance,
 )
+from src.utils import format_prescription_card
 
 # Page configuration
 st.set_page_config(
@@ -48,6 +46,21 @@ st.markdown("""
         color: #666;
         margin-top: 0;
     }
+    .agent-card {
+        background-color: #F5F5F5;
+        padding: 15px;
+        border-radius: 8px;
+        margin: 10px 0;
+        border-left: 4px solid #1E88E5;
+    }
+    .agent-active {
+        border-left-color: #4CAF50;
+        background-color: #E8F5E9;
+    }
+    .agent-complete {
+        border-left-color: #9E9E9E;
+        background-color: #FAFAFA;
+    }
     .risk-high {
         background-color: #FFCDD2;
         padding: 10px;
@@ -66,6 +79,13 @@ st.markdown("""
         border-radius: 5px;
         border-left: 4px solid #388E3C;
     }
+    .prescription-card {
+        background-color: #E3F2FD;
+        padding: 20px;
+        border-radius: 10px;
+        font-family: monospace;
+        white-space: pre-wrap;
+    }
     .info-box {
         background-color: #E3F2FD;
         padding: 15px;
@@ -79,7 +99,7 @@ st.markdown("""
 def main():
     # Header
     st.markdown('<p class="main-header">🦠 Med-I-C: AMR-Guard</p>', unsafe_allow_html=True)
-    st.markdown('<p class="sub-header">Infection Lifecycle Orchestrator Demo</p>', unsafe_allow_html=True)
+    st.markdown('<p class="sub-header">Infection Lifecycle Orchestrator - Multi-Agent System</p>', unsafe_allow_html=True)
 
     # Sidebar navigation
     st.sidebar.title("Navigation")
@@ -87,85 +107,416 @@ def main():
         "Select Module",
         [
             "🏠 Overview",
-            "💊 Stage 1: Empirical Advisor",
-            "🔬 Stage 2: Lab Interpretation",
+            "🤖 Agent Pipeline",
+            "💊 Empirical Advisor",
+            "🔬 Lab Interpretation",
             "📊 MIC Trend Analysis",
             "⚠️ Drug Safety Check",
-            "📚 Clinical Guidelines Search"
+            "📚 Clinical Guidelines"
         ]
     )
 
     if page == "🏠 Overview":
         show_overview()
-    elif page == "💊 Stage 1: Empirical Advisor":
+    elif page == "🤖 Agent Pipeline":
+        show_agent_pipeline()
+    elif page == "💊 Empirical Advisor":
         show_empirical_advisor()
-    elif page == "🔬 Stage 2: Lab Interpretation":
+    elif page == "🔬 Lab Interpretation":
         show_lab_interpretation()
     elif page == "📊 MIC Trend Analysis":
         show_mic_trend_analysis()
     elif page == "⚠️ Drug Safety Check":
         show_drug_safety()
-    elif page == "📚 Clinical Guidelines Search":
+    elif page == "📚 Clinical Guidelines":
         show_guidelines_search()
 
 
 def show_overview():
     st.header("System Overview")
 
+    st.markdown("""
+    **AMR-Guard** is a multi-agent AI system that orchestrates the complete infection treatment lifecycle,
+    from initial empirical therapy to targeted treatment based on lab results.
+    """)
+
+    # Architecture diagram
+    st.subheader("Multi-Agent Architecture")
+
     col1, col2 = st.columns(2)
 
     with col1:
-        st.subheader("Stage 1: Empirical Phase")
         st.markdown("""
-        **The "First 24 Hours"**
-
-        Before lab results are available, the system:
-        - Analyzes patient history and risk factors
-        - Suggests empirical antibiotics based on:
-            - Suspected pathogen
-            - Local resistance patterns
-            - WHO stewardship guidelines (ACCESS → WATCH → RESERVE)
-        - Checks drug interactions with current medications
+        ### Stage 1: Empirical Phase
+        **Path:** Agent 1 → Agent 4
+
+        *Before lab results are available*
+
+        1. **Intake Historian** (Agent 1)
+           - Parses patient demographics & history
+           - Calculates CrCl for renal dosing
+           - Identifies risk factors for MDR
+
+        2. **Clinical Pharmacologist** (Agent 4)
+           - Recommends empirical antibiotics
+           - Applies WHO AWaRe principles
+           - Performs safety checks
         """)
 
     with col2:
-        st.subheader("Stage 2: Targeted Phase")
         st.markdown("""
-        **The "Lab Interpretation"**
-
-        Once antibiogram is available, the system:
-        - Interprets MIC values against EUCAST breakpoints
-        - Detects "MIC Creep" from historical data
-        - Refines antibiotic selection
-        - Provides evidence-based treatment recommendations
+        ### Stage 2: Targeted Phase
+        **Path:** Agent 1 → Agent 2 → Agent 3 → Agent 4
+
+        *When lab/culture results are available*
+
+        1. **Intake Historian** (Agent 1)
+        2. **Vision Specialist** (Agent 2)
+           - Extracts data from lab reports
+           - Supports any language/format
+        3. **Trend Analyst** (Agent 3)
+           - Detects MIC creep patterns
+           - Calculates resistance velocity
+        4. **Clinical Pharmacologist** (Agent 4)
         """)
 
     st.divider()
 
+    # Knowledge sources
     st.subheader("Knowledge Sources")
 
     col1, col2, col3, col4 = st.columns(4)
 
     with col1:
-        st.metric("WHO EML", "264", "antibiotics classified")
+        st.metric("WHO AWaRe", "264", "antibiotics classified")
     with col2:
-        st.metric("ATLAS Data", "10K+", "susceptibility records")
+        st.metric("EUCAST", "v16.0", "breakpoint tables")
     with col3:
-        st.metric("Breakpoints", "41", "pathogen groups")
+        st.metric("IDSA", "2024", "treatment guidelines")
     with col4:
-        st.metric("Interactions", "191K+", "drug pairs")
+        st.metric("DDInter", "191K+", "drug interactions")
+
+    # Model info
+    st.subheader("AI Models")
+    st.markdown("""
+    | Agent | Primary Model | Fallback |
+    |-------|---------------|----------|
+    | Intake Historian | MedGemma 4B IT | Vertex AI API |
+    | Vision Specialist | MedGemma 4B IT (multimodal) | Vertex AI API |
+    | Trend Analyst | MedGemma 4B IT | Vertex AI API |
+    | Clinical Pharmacologist | MedGemma 4B + TxGemma 2B (safety) | Vertex AI API |
+    """)
+
+
+def show_agent_pipeline():
+    st.header("🤖 Multi-Agent Pipeline")
+    st.markdown("*Run the complete infection lifecycle workflow*")
+
+    # Initialize session state
+    if "pipeline_result" not in st.session_state:
+        st.session_state.pipeline_result = None
+
+    # Patient Information Form
+    with st.expander("Patient Information", expanded=True):
+        col1, col2, col3 = st.columns(3)
+
+        with col1:
+            age = st.number_input("Age (years)", min_value=0, max_value=120, value=65)
+            weight = st.number_input("Weight (kg)", min_value=1.0, max_value=300.0, value=70.0)
+            height = st.number_input("Height (cm)", min_value=50.0, max_value=250.0, value=170.0)
+
+        with col2:
+            sex = st.selectbox("Sex", ["male", "female"])
+            creatinine = st.number_input("Serum Creatinine (mg/dL)", min_value=0.1, max_value=20.0, value=1.2)
+
+        with col3:
+            infection_site = st.selectbox(
+                "Infection Site",
+                ["urinary", "respiratory", "bloodstream", "skin", "intra-abdominal", "CNS", "other"]
+            )
+            suspected_source = st.text_input(
+                "Suspected Source",
+                placeholder="e.g., community UTI, hospital-acquired pneumonia"
+            )
+
+    with st.expander("Medical History"):
+        col1, col2 = st.columns(2)
+
+        with col1:
+            medications = st.text_area(
+                "Current Medications (one per line)",
+                placeholder="Metformin\nLisinopril\nAspirin",
+                height=100
+            )
+            allergies = st.text_area(
+                "Allergies (one per line)",
+                placeholder="Penicillin\nSulfa",
+                height=100
+            )
+
+        with col2:
+            comorbidities = st.multiselect(
+                "Comorbidities",
+                ["Diabetes", "CKD", "Heart Failure", "COPD", "Immunocompromised",
+                 "Recent Surgery", "Malignancy", "Liver Disease"]
+            )
+            risk_factors = st.multiselect(
+                "MDR Risk Factors",
+                ["Prior MRSA infection", "Recent antibiotic use (<90 days)",
+                 "Healthcare-associated", "Recent hospitalization",
+                 "Nursing home resident", "Prior MDR infection"]
+            )
+
+    # Lab Data (Optional - triggers Stage 2)
+    with st.expander("Lab Results (Optional - triggers targeted pathway)"):
+        lab_input_method = st.radio(
+            "Input Method",
+            ["None (Empirical only)", "Paste Lab Text", "Upload File"],
+            horizontal=True
+        )
+
+        labs_raw_text = None
+
+        if lab_input_method == "Paste Lab Text":
+            labs_raw_text = st.text_area(
+                "Lab Report Text",
+                placeholder="""Example:
+Culture: Urine
+Organism: Escherichia coli
+Colony Count: >100,000 CFU/mL
+
+Susceptibility:
+Ampicillin: R (MIC >32)
+Ciprofloxacin: S (MIC 0.25)
+Nitrofurantoin: S (MIC 16)
+Trimethoprim-Sulfamethoxazole: R (MIC >4)""",
+                height=200
+            )
+
+        elif lab_input_method == "Upload File":
+            uploaded_file = st.file_uploader(
+                "Upload Lab Report (PDF or Image)",
+                type=["pdf", "png", "jpg", "jpeg"]
+            )
+            if uploaded_file:
+                st.info("File uploaded. Text extraction will be performed by the Vision Specialist agent.")
+                # In production, would extract text here
+                labs_raw_text = f"[Uploaded file: {uploaded_file.name}]"
+
+    # Run Pipeline Button
+    st.divider()
+
+    col1, col2, col3 = st.columns([1, 2, 1])
+    with col2:
+        run_pipeline_btn = st.button(
+            "🚀 Run Agent Pipeline",
+            type="primary",
+            use_container_width=True
+        )
+
+    if run_pipeline_btn:
+        # Build patient data
+        patient_data = {
+            "age_years": age,
+            "weight_kg": weight,
+            "height_cm": height,
+            "sex": sex,
+            "serum_creatinine_mg_dl": creatinine,
+            "infection_site": infection_site,
+            "suspected_source": suspected_source or f"{infection_site} infection",
+            "medications": [m.strip() for m in medications.split("\n") if m.strip()],
+            "allergies": [a.strip() for a in allergies.split("\n") if a.strip()],
+            "comorbidities": list(comorbidities) + list(risk_factors),
+        }
+
+        # Show pipeline progress
+        st.subheader("Pipeline Execution")
+
+        # Agent progress indicators
+        agents = [
+            ("Intake Historian", "Analyzing patient data..."),
+            ("Vision Specialist", "Processing lab results...") if labs_raw_text else None,
+            ("Trend Analyst", "Analyzing MIC trends...") if labs_raw_text else None,
+            ("Clinical Pharmacologist", "Generating recommendations..."),
+        ]
+        agents = [a for a in agents if a is not None]
+
+        progress_bar = st.progress(0)
+        status_text = st.empty()
+
+        # Simulate pipeline execution (in production, would call actual pipeline)
+        try:
+            # Try to import and run the actual pipeline
+            from src.graph import run_pipeline
+
+            for i, (agent_name, status_msg) in enumerate(agents):
+                status_text.text(f"Agent {i+1}/{len(agents)}: {agent_name} - {status_msg}")
+                progress_bar.progress((i + 1) / len(agents))
+
+            # Run the actual pipeline
+            result = run_pipeline(patient_data, labs_raw_text)
+            st.session_state.pipeline_result = result
+
+        except Exception as e:
+            st.error(f"Pipeline execution error: {e}")
+            st.info("Running in demo mode with simulated output...")
+
+            # Demo mode - simulate results
+            st.session_state.pipeline_result = _generate_demo_result(patient_data, labs_raw_text)
+
+        progress_bar.progress(100)
+        status_text.text("Pipeline complete!")
+
+    # Display Results
+    if st.session_state.pipeline_result:
+        result = st.session_state.pipeline_result
+
+        st.divider()
+        st.subheader("Pipeline Results")
+
+        # Tabs for different result sections
+        tab1, tab2, tab3, tab4 = st.tabs([
+            "📋 Recommendation",
+            "👤 Patient Summary",
+            "🔬 Lab Analysis",
+            "⚠️ Safety Alerts"
+        ])
+
+        with tab1:
+            rec = result.get("recommendation", {})
+            if rec:
+                st.markdown("### Antibiotic Recommendation")
+
+                col1, col2 = st.columns(2)
+
+                with col1:
+                    st.markdown(f"**Primary:** {rec.get('primary_antibiotic', 'N/A')}")
+                    st.markdown(f"**Dose:** {rec.get('dose', 'N/A')}")
+                    st.markdown(f"**Route:** {rec.get('route', 'N/A')}")
+                    st.markdown(f"**Frequency:** {rec.get('frequency', 'N/A')}")
+                    st.markdown(f"**Duration:** {rec.get('duration', 'N/A')}")
+
+                with col2:
+                    if rec.get("backup_antibiotic"):
+                        st.markdown(f"**Alternative:** {rec.get('backup_antibiotic')}")
+
+                st.markdown("---")
+                st.markdown("**Rationale:**")
+                st.markdown(rec.get("rationale", "No rationale provided"))
+
+                if rec.get("references"):
+                    st.markdown("**References:**")
+                    for ref in rec["references"]:
+                        st.markdown(f"- {ref}")
+
+        with tab2:
+            st.markdown("### Patient Assessment")
+            intake_notes = result.get("intake_notes", "")
+            if intake_notes:
+                try:
+                    intake_data = json.loads(intake_notes) if isinstance(intake_notes, str) else intake_notes
+                    st.json(intake_data)
+                except:
+                    st.text(intake_notes)
+
+            if result.get("creatinine_clearance_ml_min"):
+                st.metric("Calculated CrCl", f"{result['creatinine_clearance_ml_min']} mL/min")
+
+        with tab3:
+            st.markdown("### Laboratory Analysis")
+
+            vision_notes = result.get("vision_notes", "No lab data processed")
+            if vision_notes and vision_notes != "No lab data provided":
+                try:
+                    vision_data = json.loads(vision_notes) if isinstance(vision_notes, str) else vision_notes
+                    st.json(vision_data)
+                except:
+                    st.text(vision_notes)
+
+            trend_notes = result.get("trend_notes", "")
+            if trend_notes and trend_notes != "No MIC data available for trend analysis":
+                st.markdown("#### MIC Trend Analysis")
+                try:
+                    trend_data = json.loads(trend_notes) if isinstance(trend_notes, str) else trend_notes
+                    st.json(trend_data)
+                except:
+                    st.text(trend_notes)
+
+        with tab4:
+            st.markdown("### Safety Alerts")
+
+            warnings = result.get("safety_warnings", [])
+            if warnings:
+                for warning in warnings:
+                    st.warning(f"⚠️ {warning}")
+            else:
+                st.success("No safety concerns identified")
+
+            errors = result.get("errors", [])
+            if errors:
+                st.markdown("#### Errors")
+                for error in errors:
+                    st.error(error)
+
+
+def _generate_demo_result(patient_data: dict, labs_raw_text: str | None) -> dict:
+    """Generate demo result when actual pipeline is not available."""
+    result = {
+        "stage": "targeted" if labs_raw_text else "empirical",
+        "creatinine_clearance_ml_min": 58.3,
+        "intake_notes": json.dumps({
+            "patient_summary": f"65-year-old male with {patient_data.get('suspected_source', 'infection')}",
+            "creatinine_clearance_ml_min": 58.3,
+            "renal_dose_adjustment_needed": True,
+            "identified_risk_factors": patient_data.get("comorbidities", []),
+            "infection_severity": "moderate",
+            "recommended_stage": "targeted" if labs_raw_text else "empirical",
+        }),
+        "recommendation": {
+            "primary_antibiotic": "Ciprofloxacin",
+            "dose": "500mg",
+            "route": "PO",
+            "frequency": "Every 12 hours",
+            "duration": "7 days",
+            "backup_antibiotic": "Nitrofurantoin",
+            "rationale": "Based on suspected community-acquired UTI with moderate renal impairment. Ciprofloxacin provides good coverage for common uropathogens. Dose adjusted for CrCl 58 mL/min.",
+            "references": ["IDSA UTI Guidelines 2024", "EUCAST Breakpoint Tables v16.0"],
+            "safety_alerts": [],
+        },
+        "safety_warnings": [],
+        "errors": [],
+    }
+
+    if labs_raw_text:
+        result["vision_notes"] = json.dumps({
+            "specimen_type": "urine",
+            "identified_organisms": [{"organism_name": "Escherichia coli", "significance": "pathogen"}],
+            "susceptibility_results": [
+                {"organism": "E. coli", "antibiotic": "Ciprofloxacin", "mic_value": 0.25, "interpretation": "S"},
+                {"organism": "E. coli", "antibiotic": "Nitrofurantoin", "mic_value": 16, "interpretation": "S"},
+            ],
+            "extraction_confidence": 0.95,
+        })
+        result["trend_notes"] = json.dumps([{
+            "organism": "E. coli",
+            "antibiotic": "Ciprofloxacin",
+            "risk_level": "LOW",
+            "recommendation": "Continue current therapy",
+        }])
+
+    return result
 
 
 def show_empirical_advisor():
-    st.header("💊 Stage 1: Empirical Advisor")
-    st.markdown("*Recommend empirical therapy before lab results*")
+    st.header("💊 Empirical Advisor")
+    st.markdown("*Get empirical therapy recommendations before lab results*")
 
     col1, col2 = st.columns([2, 1])
 
     with col1:
         infection_type = st.selectbox(
             "Infection Type",
-            ["Urinary Tract Infection (UTI)", "Pneumonia", "Sepsis",
+            ["Urinary Tract Infection", "Pneumonia", "Sepsis",
              "Skin/Soft Tissue", "Intra-abdominal", "Meningitis"]
         )
 
@@ -182,269 +533,148 @@ def show_empirical_advisor():
         )
 
     with col2:
-        st.markdown("**WHO Stewardship Categories**")
+        st.markdown("**WHO AWaRe Categories**")
         st.markdown("""
         - **ACCESS**: First-line, low resistance
         - **WATCH**: Higher resistance potential
         - **RESERVE**: Last resort antibiotics
         """)
 
-    if st.button("Get Empirical Recommendation", type="primary"):
-        with st.spinner("Searching guidelines and resistance data..."):
-            # Get recommendations from guidelines
+    if st.button("Get Recommendation", type="primary"):
+        with st.spinner("Searching guidelines..."):
             guidance = get_empirical_therapy_guidance(
-                infection_type.split("(")[0].strip(),
+                infection_type,
                 risk_factors
             )
 
-            st.subheader("Recommendations")
+            st.subheader("Guideline Recommendations")
 
             if guidance.get("recommendations"):
                 for i, rec in enumerate(guidance["recommendations"][:3], 1):
-                    with st.expander(f"Guideline Excerpt {i} (Relevance: {rec.get('relevance_score', 0):.2f})"):
+                    with st.expander(f"Excerpt {i} (Relevance: {rec.get('relevance_score', 0):.2f})"):
                         st.markdown(rec.get("content", ""))
                         st.caption(f"Source: {rec.get('source', 'IDSA Guidelines')}")
 
-            # If pathogen specified, show resistance patterns
             if suspected_pathogen:
-                st.subheader(f"Resistance Patterns for {suspected_pathogen}")
-
+                st.subheader(f"Resistance Data: {suspected_pathogen}")
                 effective = get_most_effective_antibiotics(suspected_pathogen, min_susceptibility=70)
 
                 if effective:
-                    st.markdown("**Most Effective Antibiotics (>70% susceptibility)**")
                     for ab in effective[:5]:
                         st.write(f"- **{ab.get('antibiotic')}**: {ab.get('avg_susceptibility', 0):.1f}% susceptible")
                 else:
-                    st.info("No resistance data found for this pathogen.")
+                    st.info("No resistance data found.")
 
 
 def show_lab_interpretation():
-    st.header("🔬 Stage 2: Lab Interpretation")
+    st.header("🔬 Lab Interpretation")
     st.markdown("*Interpret antibiogram MIC values*")
 
     col1, col2 = st.columns(2)
 
     with col1:
-        pathogen = st.text_input(
-            "Identified Pathogen",
-            placeholder="e.g., Escherichia coli, Pseudomonas aeruginosa"
-        )
-
-        antibiotic = st.text_input(
-            "Antibiotic",
-            placeholder="e.g., Ciprofloxacin, Meropenem"
-        )
-
-        mic_value = st.number_input(
-            "MIC Value (mg/L)",
-            min_value=0.001,
-            max_value=1024.0,
-            value=1.0,
-            step=0.5
-        )
+        pathogen = st.text_input("Pathogen", placeholder="e.g., Escherichia coli")
+        antibiotic = st.text_input("Antibiotic", placeholder="e.g., Ciprofloxacin")
+        mic_value = st.number_input("MIC (mg/L)", min_value=0.001, max_value=1024.0, value=1.0)
 
     with col2:
-        st.markdown("**How to Read Results**")
+        st.markdown("**Interpretation Guide**")
         st.markdown("""
-        - **S (Susceptible)**: MIC ≤ breakpoint - antibiotic likely effective
-        - **I (Intermediate)**: May work with higher doses
-        - **R (Resistant)**: MIC > breakpoint - do not use
+        - **S**: Susceptible - antibiotic effective
+        - **I**: Intermediate - may work at higher doses
+        - **R**: Resistant - do not use
         """)
 
-    if st.button("Interpret MIC", type="primary"):
+    if st.button("Interpret", type="primary"):
         if pathogen and antibiotic:
-            with st.spinner("Checking breakpoints..."):
-                result = interpret_mic_value(pathogen, antibiotic, mic_value)
+            result = interpret_mic_value(pathogen, antibiotic, mic_value)
+            interpretation = result.get("interpretation", "UNKNOWN")
 
-                interpretation = result.get("interpretation", "UNKNOWN")
+            if interpretation == "SUSCEPTIBLE":
+                st.success(f"✅ {interpretation}")
+            elif interpretation == "RESISTANT":
+                st.error(f"❌ {interpretation}")
+            else:
+                st.warning(f"⚠️ {interpretation}")
 
-                if interpretation == "SUSCEPTIBLE":
-                    st.success(f"✅ **{interpretation}**")
-                elif interpretation == "RESISTANT":
-                    st.error(f"❌ **{interpretation}**")
-                elif interpretation == "INTERMEDIATE":
-                    st.warning(f"⚠️ **{interpretation}**")
-                else:
-                    st.info(f"❓ **{interpretation}**")
-
-                st.markdown(f"**Details:** {result.get('message', '')}")
-
-                if result.get("breakpoints"):
-                    bp = result["breakpoints"]
-                    st.markdown(f"""
-                    **Breakpoints:**
-                    - S ≤ {bp.get('susceptible', 'N/A')} mg/L
-                    - R > {bp.get('resistant', 'N/A')} mg/L
-                    """)
-
-                if result.get("notes"):
-                    st.info(f"**Note:** {result.get('notes')}")
-        else:
-            st.warning("Please enter both pathogen and antibiotic names.")
+            st.markdown(f"**Details:** {result.get('message', '')}")
 
 
 def show_mic_trend_analysis():
     st.header("📊 MIC Trend Analysis")
     st.markdown("*Detect MIC creep over time*")
 
-    st.markdown("""
-    Enter historical MIC values to detect resistance velocity.
-    **MIC Creep**: A gradual increase in MIC that may predict treatment failure
-    even when the organism is still classified as "Susceptible".
-    """)
-
-    # Input for historical MICs
-    num_readings = st.slider("Number of historical readings", 2, 6, 3)
+    num_readings = st.slider("Historical readings", 2, 6, 3)
 
     mic_values = []
     cols = st.columns(num_readings)
 
     for i, col in enumerate(cols):
-        with col:
-            mic = col.number_input(
-                f"MIC {i+1}",
-                min_value=0.001,
-                max_value=256.0,
-                value=float(2 ** i),  # Default: 1, 2, 4, ...
-                key=f"mic_{i}"
-            )
-            mic_values.append({"date": f"T{i}", "mic_value": mic})
+        mic = col.number_input(f"MIC {i+1}", min_value=0.001, max_value=256.0, value=float(2 ** i), key=f"mic_{i}")
+        mic_values.append({"date": f"T{i}", "mic_value": mic})
 
-    if st.button("Analyze Trend", type="primary"):
+    if st.button("Analyze", type="primary"):
         result = calculate_mic_trend(mic_values)
-
         risk_level = result.get("risk_level", "UNKNOWN")
 
         if risk_level == "HIGH":
-            st.markdown(f'<div class="risk-high"><strong>🚨 HIGH RISK</strong><br>{result.get("alert", "")}</div>',
-                       unsafe_allow_html=True)
+            st.markdown(f'<div class="risk-high">🚨 HIGH RISK: {result.get("alert", "")}</div>', unsafe_allow_html=True)
         elif risk_level == "MODERATE":
-            st.markdown(f'<div class="risk-moderate"><strong>⚠️ MODERATE RISK</strong><br>{result.get("alert", "")}</div>',
-                       unsafe_allow_html=True)
+            st.markdown(f'<div class="risk-moderate">⚠️ MODERATE: {result.get("alert", "")}</div>', unsafe_allow_html=True)
         else:
-            st.markdown(f'<div class="risk-low"><strong>✅ LOW RISK</strong><br>{result.get("alert", "")}</div>',
-                       unsafe_allow_html=True)
-
-        st.divider()
+            st.markdown(f'<div class="risk-low">✅ LOW RISK: {result.get("alert", "")}</div>', unsafe_allow_html=True)
 
         col1, col2, col3 = st.columns(3)
-
-        with col1:
-            st.metric("Baseline MIC", f"{result.get('baseline_mic', 'N/A')} mg/L")
-        with col2:
-            st.metric("Current MIC", f"{result.get('current_mic', 'N/A')} mg/L")
-        with col3:
-            st.metric("Fold Change", f"{result.get('ratio', 'N/A')}x")
-
-        st.markdown(f"**Trend:** {result.get('trend', 'N/A')}")
-        st.markdown(f"**Resistance Velocity:** {result.get('velocity', 'N/A')}x per time point")
+        col1.metric("Baseline", f"{result.get('baseline_mic', 'N/A')} mg/L")
+        col2.metric("Current", f"{result.get('current_mic', 'N/A')} mg/L")
+        col3.metric("Fold Change", f"{result.get('ratio', 'N/A')}x")
 
 
 def show_drug_safety():
     st.header("⚠️ Drug Safety Check")
-    st.markdown("*Screen for drug interactions*")
 
     col1, col2 = st.columns(2)
 
     with col1:
-        antibiotic = st.text_input(
-            "Proposed Antibiotic",
-            placeholder="e.g., Ciprofloxacin"
-        )
-
-        current_meds = st.text_area(
-            "Current Medications (one per line)",
-            placeholder="Warfarin\nMetformin\nAmlodipine",
-            height=150
-        )
+        antibiotic = st.text_input("Antibiotic", placeholder="e.g., Ciprofloxacin")
+        current_meds = st.text_area("Current Medications", placeholder="Warfarin\nMetformin", height=150)
 
     with col2:
-        allergies = st.text_area(
-            "Known Allergies (one per line)",
-            placeholder="Penicillin\nSulfa",
-            height=100
-        )
+        allergies = st.text_area("Allergies", placeholder="Penicillin\nSulfa", height=100)
 
     if st.button("Check Safety", type="primary"):
         if antibiotic:
             medications = [m.strip() for m in current_meds.split("\n") if m.strip()]
             allergy_list = [a.strip() for a in allergies.split("\n") if a.strip()]
 
-            with st.spinner("Checking interactions..."):
-                result = screen_antibiotic_safety(antibiotic, medications, allergy_list)
+            result = screen_antibiotic_safety(antibiotic, medications, allergy_list)
 
-                if result.get("safe_to_use"):
-                    st.success("✅ No critical safety concerns identified")
-                else:
-                    st.error("❌ SAFETY CONCERNS IDENTIFIED")
-
-                # Show alerts
-                if result.get("alerts"):
-                    st.subheader("Alerts")
-                    for alert in result["alerts"]:
-                        level = alert.get("level", "WARNING")
-                        if level == "CRITICAL":
-                            st.error(f"🚨 {alert.get('message', '')}")
-                        else:
-                            st.warning(f"⚠️ {alert.get('message', '')}")
-
-                # Show allergy warnings
-                if result.get("allergy_warnings"):
-                    st.subheader("Allergy Warnings")
-                    for warn in result["allergy_warnings"]:
-                        st.error(f"🚫 {warn.get('message', '')}")
-
-                # Show interactions
-                if result.get("interactions"):
-                    st.subheader("Drug Interactions Found")
-                    for interaction in result["interactions"][:5]:
-                        severity = interaction.get("severity", "unknown")
-                        icon = "🔴" if severity == "major" else "🟡" if severity == "moderate" else "🟢"
-                        st.markdown(f"""
-                        {icon} **{interaction.get('drug_1')}** ↔ **{interaction.get('drug_2')}**
-                        - Severity: {severity.upper()}
-                        - {interaction.get('interaction_description', '')}
-                        """)
-        else:
-            st.warning("Please enter an antibiotic name.")
+            if result.get("safe_to_use"):
+                st.success("✅ No critical safety concerns")
+            else:
+                st.error("❌ Safety concerns identified")
+
+            for alert in result.get("alerts", []):
+                st.warning(f"⚠️ {alert.get('message', '')}")
 
 
 def show_guidelines_search():
-    st.header("📚 Clinical Guidelines Search")
-    st.markdown("*Search IDSA treatment guidelines*")
+    st.header("📚 Clinical Guidelines")
 
-    query = st.text_input(
-        "Search Query",
-        placeholder="e.g., treatment for ESBL E. coli UTI"
-    )
+    query = st.text_input("Search", placeholder="e.g., ESBL E. coli UTI treatment")
+    pathogen_filter = st.selectbox("Pathogen Filter", ["All", "ESBL-E", "CRE", "CRAB", "DTR-PA"])
 
-    pathogen_filter = st.selectbox(
-        "Filter by Pathogen Type (optional)",
-        ["All", "ESBL-E", "CRE", "CRAB", "DTR-PA", "S.maltophilia", "AmpC-E"]
-    )
-
-    if st.button("Search Guidelines", type="primary"):
+    if st.button("Search", type="primary"):
         if query:
-            with st.spinner("Searching clinical guidelines..."):
-                filter_value = None if pathogen_filter == "All" else pathogen_filter
-
-                results = search_clinical_guidelines(query, pathogen_filter=filter_value, n_results=5)
-
-                if results:
-                    st.subheader(f"Found {len(results)} relevant excerpts")
-
-                    for i, result in enumerate(results, 1):
-                        with st.expander(
-                            f"Result {i} - {result.get('pathogen_type', 'General')} "
-                            f"(Relevance: {result.get('relevance_score', 0):.2f})"
-                        ):
-                            st.markdown(result.get("content", ""))
-                            st.caption(f"Source: {result.get('source', 'IDSA Guidelines')}")
-                else:
-                    st.info("No results found. Try a different query or remove the filter.")
-        else:
-            st.warning("Please enter a search query.")
+            filter_val = None if pathogen_filter == "All" else pathogen_filter
+            results = search_clinical_guidelines(query, pathogen_filter=filter_val, n_results=5)
+
+            if results:
+                for i, r in enumerate(results, 1):
+                    with st.expander(f"Result {i} (Relevance: {r.get('relevance_score', 0):.2f})"):
+                        st.markdown(r.get("content", ""))
+            else:
+                st.info("No results found.")
 
 
 if __name__ == "__main__":

src/agents.py

@@ -1,16 +1,574 @@
-import os
-from langchain.agents import create_agent
-from langchain.chat_models import init_chat_model
-from dotenv import load_dotenv
-
-os.environ["GOOGLE_API_KEY"] = load_dotenv().get("GOOGLE_API_KEY")
-
-model = init_chat_model(
-    "google_genai:gemini-2.5-flash-lite",
-    # Kwargs passed to the model:
-    temperature=0.7,
-    timeout=30,
-    max_tokens=1000,
+"""
+Med-I-C Multi-Agent System.
+
+Implements the 4 specialized agents for the infection lifecycle workflow:
+- Agent 1: Intake Historian - Parse patient data, risk factors, calculate CrCl
+- Agent 2: Vision Specialist - Extract structured data from lab reports
+- Agent 3: Trend Analyst - Detect MIC creep and resistance velocity
+- Agent 4: Clinical Pharmacologist - Final Rx recommendations + safety checks
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+from typing import Any, Dict, Optional
+
+from .config import get_settings
+from .loader import run_inference, TextModelName
+from .prompts import (
+    INTAKE_HISTORIAN_SYSTEM,
+    INTAKE_HISTORIAN_PROMPT,
+    VISION_SPECIALIST_SYSTEM,
+    VISION_SPECIALIST_PROMPT,
+    TREND_ANALYST_SYSTEM,
+    TREND_ANALYST_PROMPT,
+    CLINICAL_PHARMACOLOGIST_SYSTEM,
+    CLINICAL_PHARMACOLOGIST_PROMPT,
+    TXGEMMA_SAFETY_PROMPT,
 )
+from .rag import get_context_for_agent
+from .state import InfectionState
+from .utils import (
+    calculate_crcl,
+    get_renal_dose_category,
+    safe_json_parse,
+    normalize_organism_name,
+    normalize_antibiotic_name,
+)
+
+logger = logging.getLogger(__name__)
+
+
+# =============================================================================
+# AGENT 1: INTAKE HISTORIAN
+# =============================================================================
+
+def run_intake_historian(state: InfectionState) -> InfectionState:
+    """
+    Agent 1: Parse patient data, calculate CrCl, identify risk factors.
+
+    Input state fields used:
+        - age_years, weight_kg, height_cm, sex
+        - serum_creatinine_mg_dl
+        - medications, allergies, comorbidities
+        - suspected_source, infection_site
+
+    Output state fields updated:
+        - creatinine_clearance_ml_min
+        - intake_notes
+        - stage (empirical/targeted)
+        - route_to_vision
+    """
+    logger.info("Running Intake Historian agent...")
+
+    # Calculate CrCl if we have the required data
+    crcl = None
+    if all([
+        state.get("age_years"),
+        state.get("weight_kg"),
+        state.get("serum_creatinine_mg_dl"),
+        state.get("sex"),
+    ]):
+        try:
+            crcl = calculate_crcl(
+                age_years=state["age_years"],
+                weight_kg=state["weight_kg"],
+                serum_creatinine_mg_dl=state["serum_creatinine_mg_dl"],
+                sex=state["sex"],
+                use_ibw=True,
+                height_cm=state.get("height_cm"),
+            )
+            state["creatinine_clearance_ml_min"] = crcl
+            logger.info(f"Calculated CrCl: {crcl} mL/min")
+        except Exception as e:
+            logger.warning(f"Could not calculate CrCl: {e}")
+            state.setdefault("errors", []).append(f"CrCl calculation error: {e}")
+
+    # Build patient data string for prompt
+    patient_data = _format_patient_data(state)
+
+    # Get RAG context
+    query = f"treatment {state.get('suspected_source', '')} {state.get('infection_site', '')}"
+    rag_context = get_context_for_agent(
+        agent_name="intake_historian",
+        query=query,
+        patient_context={
+            "pathogen_type": state.get("suspected_source"),
+        },
+    )
+
+    # Format the prompt
+    prompt = f"{INTAKE_HISTORIAN_SYSTEM}\n\n{INTAKE_HISTORIAN_PROMPT.format(
+        patient_data=patient_data,
+        medications=', '.join(state.get('medications', [])) or 'None reported',
+        allergies=', '.join(state.get('allergies', [])) or 'No known allergies',
+        infection_site=state.get('infection_site', 'Unknown'),
+        suspected_source=state.get('suspected_source', 'Unknown'),
+        rag_context=rag_context,
+    )}"
+
+    # Run inference
+    try:
+        response = run_inference(
+            prompt=prompt,
+            model_name="medgemma_4b",
+            max_new_tokens=1024,
+            temperature=0.2,
+        )
+
+        # Parse response
+        parsed = safe_json_parse(response)
+        if parsed:
+            state["intake_notes"] = json.dumps(parsed, indent=2)
+
+            # Update state from parsed response
+            if parsed.get("creatinine_clearance_ml_min") and crcl is None:
+                state["creatinine_clearance_ml_min"] = parsed["creatinine_clearance_ml_min"]
+
+            # Determine stage
+            recommended_stage = parsed.get("recommended_stage", "empirical")
+            state["stage"] = recommended_stage
+
+            # Route to vision if we have lab data to process
+            state["route_to_vision"] = bool(state.get("labs_raw_text"))
+        else:
+            state["intake_notes"] = response
+            state["stage"] = "empirical"
+            state["route_to_vision"] = bool(state.get("labs_raw_text"))
+
+    except Exception as e:
+        logger.error(f"Intake Historian error: {e}")
+        state.setdefault("errors", []).append(f"Intake Historian error: {e}")
+        state["intake_notes"] = f"Error: {e}"
+        state["stage"] = "empirical"
+
+    logger.info(f"Intake Historian complete. Stage: {state.get('stage')}")
+    return state
+
+
+# =============================================================================
+# AGENT 2: VISION SPECIALIST
+# =============================================================================
+
+def run_vision_specialist(state: InfectionState) -> InfectionState:
+    """
+    Agent 2: Extract structured data from lab reports (text, images, PDFs).
+
+    Input state fields used:
+        - labs_raw_text (extracted text from lab report)
+
+    Output state fields updated:
+        - labs_parsed
+        - mic_data
+        - vision_notes
+        - route_to_trend_analyst
+    """
+    logger.info("Running Vision Specialist agent...")
+
+    labs_raw = state.get("labs_raw_text", "")
+    if not labs_raw:
+        logger.info("No lab data to process, skipping Vision Specialist")
+        state["vision_notes"] = "No lab data provided"
+        state["route_to_trend_analyst"] = False
+        return state
+
+    # Detect language (simplified - in production would use langdetect)
+    language = "English (assumed)"
+
+    # Get RAG context for lab interpretation
+    rag_context = get_context_for_agent(
+        agent_name="vision_specialist",
+        query="culture sensitivity susceptibility interpretation",
+        patient_context={},
+    )
+
+    # Format the prompt
+    prompt = f"{VISION_SPECIALIST_SYSTEM}\n\n{VISION_SPECIALIST_PROMPT.format(
+        report_content=labs_raw,
+        source_format='text',
+        language=language,
+    )}"
+
+    # Run inference
+    try:
+        response = run_inference(
+            prompt=prompt,
+            model_name="medgemma_4b",
+            max_new_tokens=2048,
+            temperature=0.1,
+        )
+
+        # Parse response
+        parsed = safe_json_parse(response)
+        if parsed:
+            state["vision_notes"] = json.dumps(parsed, indent=2)
+
+            # Extract organisms and susceptibility data
+            organisms = parsed.get("identified_organisms", [])
+            susceptibility = parsed.get("susceptibility_results", [])
+
+            # Convert to MICDatum format
+            mic_data = []
+            for result in susceptibility:
+                mic_datum = {
+                    "organism": normalize_organism_name(result.get("organism", "")),
+                    "antibiotic": normalize_antibiotic_name(result.get("antibiotic", "")),
+                    "mic_value": str(result.get("mic_value", "")),
+                    "mic_unit": result.get("mic_unit", "mg/L"),
+                    "interpretation": result.get("interpretation"),
+                }
+                mic_data.append(mic_datum)
+
+            state["mic_data"] = mic_data
+            state["labs_parsed"] = [{
+                "name": org.get("organism_name", "Unknown"),
+                "value": org.get("colony_count", ""),
+                "flag": "pathogen" if org.get("significance") == "pathogen" else None,
+            } for org in organisms]
+
+            # Route to trend analyst if we have MIC data
+            state["route_to_trend_analyst"] = len(mic_data) > 0
+
+            # Check for critical findings
+            critical = parsed.get("critical_findings", [])
+            if critical:
+                state.setdefault("safety_warnings", []).extend(critical)
+
+        else:
+            state["vision_notes"] = response
+            state["route_to_trend_analyst"] = False
+
+    except Exception as e:
+        logger.error(f"Vision Specialist error: {e}")
+        state.setdefault("errors", []).append(f"Vision Specialist error: {e}")
+        state["vision_notes"] = f"Error: {e}"
+        state["route_to_trend_analyst"] = False
+
+    logger.info(f"Vision Specialist complete. MIC data points: {len(state.get('mic_data', []))}")
+    return state
+
+
+# =============================================================================
+# AGENT 3: TREND ANALYST
+# =============================================================================
+
+def run_trend_analyst(state: InfectionState) -> InfectionState:
+    """
+    Agent 3: Analyze MIC trends and detect resistance velocity.
+
+    Input state fields used:
+        - mic_data (current MIC readings)
+        - Historical MIC data (if available)
+
+    Output state fields updated:
+        - mic_trend_summary
+        - trend_notes
+        - safety_warnings (if high risk detected)
+    """
+    logger.info("Running Trend Analyst agent...")
+
+    mic_data = state.get("mic_data", [])
+    if not mic_data:
+        logger.info("No MIC data to analyze, skipping Trend Analyst")
+        state["trend_notes"] = "No MIC data available for trend analysis"
+        return state
+
+    # For each organism-antibiotic pair, analyze trends
+    trend_results = []
+
+    for mic in mic_data:
+        organism = mic.get("organism", "Unknown")
+        antibiotic = mic.get("antibiotic", "Unknown")
+
+        # Get RAG context for breakpoints
+        rag_context = get_context_for_agent(
+            agent_name="trend_analyst",
+            query=f"breakpoint {organism} {antibiotic}",
+            patient_context={
+                "organism": organism,
+                "antibiotic": antibiotic,
+                "region": state.get("country_or_region"),
+            },
+        )
+
+        # Format MIC history (in production, would pull from database)
+        mic_history = [{"date": "current", "mic_value": mic.get("mic_value", "0")}]
+
+        # Format prompt
+        prompt = f"{TREND_ANALYST_SYSTEM}\n\n{TREND_ANALYST_PROMPT.format(
+            organism=organism,
+            antibiotic=antibiotic,
+            mic_history=json.dumps(mic_history, indent=2),
+            breakpoint_data=rag_context,
+            resistance_context='Regional data not available',
+        )}"
+
+        try:
+            response = run_inference(
+                prompt=prompt,
+                model_name="medgemma_4b",
+                max_new_tokens=1024,
+                temperature=0.2,
+            )
+
+            parsed = safe_json_parse(response)
+            if parsed:
+                trend_results.append(parsed)
+
+                # Add safety warning if high/critical risk
+                risk_level = parsed.get("risk_level", "LOW")
+                if risk_level in ["HIGH", "CRITICAL"]:
+                    warning = f"MIC trend alert for {organism}/{antibiotic}: {parsed.get('recommendation', 'Review needed')}"
+                    state.setdefault("safety_warnings", []).append(warning)
+            else:
+                trend_results.append({"raw_response": response})
+
+        except Exception as e:
+            logger.error(f"Trend analysis error for {organism}/{antibiotic}: {e}")
+            trend_results.append({"error": str(e)})
+
+    # Summarize trends
+    state["trend_notes"] = json.dumps(trend_results, indent=2)
+
+    # Create summary
+    high_risk_count = sum(1 for t in trend_results if t.get("risk_level") in ["HIGH", "CRITICAL"])
+    state["mic_trend_summary"] = f"Analyzed {len(trend_results)} organism-antibiotic pairs. High-risk findings: {high_risk_count}"
+
+    logger.info(f"Trend Analyst complete. {state['mic_trend_summary']}")
+    return state
+
+
+# =============================================================================
+# AGENT 4: CLINICAL PHARMACOLOGIST
+# =============================================================================
+
+def run_clinical_pharmacologist(state: InfectionState) -> InfectionState:
+    """
+    Agent 4: Generate final antibiotic recommendation with safety checks.
+
+    Input state fields used:
+        - intake_notes, vision_notes, trend_notes
+        - age_years, weight_kg, creatinine_clearance_ml_min
+        - allergies, medications
+        - infection_site, suspected_source
+
+    Output state fields updated:
+        - recommendation
+        - pharmacology_notes
+        - safety_warnings (additional alerts)
+    """
+    logger.info("Running Clinical Pharmacologist agent...")
+
+    # Gather all previous agent outputs
+    intake_summary = state.get("intake_notes", "No intake data")
+    lab_results = state.get("vision_notes", "No lab data")
+    trend_analysis = state.get("trend_notes", "No trend data")
+
+    # Get RAG context
+    query = f"treatment {state.get('suspected_source', '')} antibiotic recommendation"
+    rag_context = get_context_for_agent(
+        agent_name="clinical_pharmacologist",
+        query=query,
+        patient_context={
+            "proposed_antibiotic": None,  # Will be determined by agent
+        },
+    )
+
+    # Format prompt
+    prompt = f"{CLINICAL_PHARMACOLOGIST_SYSTEM}\n\n{CLINICAL_PHARMACOLOGIST_PROMPT.format(
+        intake_summary=intake_summary,
+        lab_results=lab_results,
+        trend_analysis=trend_analysis,
+        age=state.get('age_years', 'Unknown'),
+        weight=state.get('weight_kg', 'Unknown'),
+        crcl=state.get('creatinine_clearance_ml_min', 'Unknown'),
+        allergies=', '.join(state.get('allergies', [])) or 'No known allergies',
+        current_medications=', '.join(state.get('medications', [])) or 'None reported',
+        infection_site=state.get('infection_site', 'Unknown'),
+        suspected_source=state.get('suspected_source', 'Unknown'),
+        severity=state.get('intake_notes', {}).get('infection_severity', 'Unknown') if isinstance(state.get('intake_notes'), dict) else 'Unknown',
+        rag_context=rag_context,
+    )}"
+
+    try:
+        response = run_inference(
+            prompt=prompt,
+            model_name="medgemma_4b",
+            max_new_tokens=2048,
+            temperature=0.2,
+        )
+
+        parsed = safe_json_parse(response)
+        if parsed:
+            state["pharmacology_notes"] = json.dumps(parsed, indent=2)
+
+            # Build recommendation
+            primary = parsed.get("primary_recommendation", {})
+            recommendation = {
+                "primary_antibiotic": primary.get("antibiotic"),
+                "dose": primary.get("dose"),
+                "route": primary.get("route"),
+                "frequency": primary.get("frequency"),
+                "duration": primary.get("duration"),
+                "rationale": parsed.get("rationale"),
+                "references": parsed.get("guideline_references", []),
+                "safety_alerts": [a.get("message") for a in parsed.get("safety_alerts", [])],
+            }
+
+            # Add alternative if provided
+            alt = parsed.get("alternative_recommendation", {})
+            if alt.get("antibiotic"):
+                recommendation["backup_antibiotic"] = alt.get("antibiotic")
+
+            state["recommendation"] = recommendation
+
+            # Add safety alerts to state
+            for alert in parsed.get("safety_alerts", []):
+                if alert.get("level") in ["WARNING", "CRITICAL"]:
+                    state.setdefault("safety_warnings", []).append(alert.get("message"))
+
+            # Run TxGemma safety check (optional)
+            if primary.get("antibiotic"):
+                safety_result = _run_txgemma_safety_check(
+                    antibiotic=primary.get("antibiotic"),
+                    dose=primary.get("dose"),
+                    route=primary.get("route"),
+                    duration=primary.get("duration"),
+                    age=state.get("age_years"),
+                    crcl=state.get("creatinine_clearance_ml_min"),
+                    medications=state.get("medications", []),
+                )
+                if safety_result:
+                    state.setdefault("debug_log", []).append(f"TxGemma safety: {safety_result}")
+
+        else:
+            state["pharmacology_notes"] = response
+            state["recommendation"] = {"rationale": response}
+
+    except Exception as e:
+        logger.error(f"Clinical Pharmacologist error: {e}")
+        state.setdefault("errors", []).append(f"Clinical Pharmacologist error: {e}")
+        state["pharmacology_notes"] = f"Error: {e}"
+
+    logger.info("Clinical Pharmacologist complete.")
+    return state
+
+
+# =============================================================================
+# HELPER FUNCTIONS
+# =============================================================================
+
+def _format_patient_data(state: InfectionState) -> str:
+    """Format patient data for prompt injection."""
+    lines = []
+
+    if state.get("patient_id"):
+        lines.append(f"Patient ID: {state['patient_id']}")
+
+    demographics = []
+    if state.get("age_years"):
+        demographics.append(f"{state['age_years']} years old")
+    if state.get("sex"):
+        demographics.append(state["sex"])
+    if demographics:
+        lines.append(f"Demographics: {', '.join(demographics)}")
+
+    if state.get("weight_kg"):
+        lines.append(f"Weight: {state['weight_kg']} kg")
+    if state.get("height_cm"):
+        lines.append(f"Height: {state['height_cm']} cm")
+
+    if state.get("serum_creatinine_mg_dl"):
+        lines.append(f"Serum Creatinine: {state['serum_creatinine_mg_dl']} mg/dL")
+    if state.get("creatinine_clearance_ml_min"):
+        crcl = state["creatinine_clearance_ml_min"]
+        category = get_renal_dose_category(crcl)
+        lines.append(f"CrCl: {crcl} mL/min ({category})")
+
+    if state.get("comorbidities"):
+        lines.append(f"Comorbidities: {', '.join(state['comorbidities'])}")
+
+    if state.get("vitals"):
+        vitals_str = ", ".join(f"{k}: {v}" for k, v in state["vitals"].items())
+        lines.append(f"Vitals: {vitals_str}")
+
+    return "\n".join(lines) if lines else "No patient data available"
+
+
+def _run_txgemma_safety_check(
+    antibiotic: str,
+    dose: Optional[str],
+    route: Optional[str],
+    duration: Optional[str],
+    age: Optional[float],
+    crcl: Optional[float],
+    medications: list,
+) -> Optional[str]:
+    """
+    Run TxGemma safety check (supplementary).
+
+    TxGemma is used only for safety validation, not primary recommendations.
+    """
+    try:
+        prompt = TXGEMMA_SAFETY_PROMPT.format(
+            antibiotic=antibiotic,
+            dose=dose or "Not specified",
+            route=route or "Not specified",
+            duration=duration or "Not specified",
+            age=age or "Unknown",
+            crcl=crcl or "Unknown",
+            medications=", ".join(medications) if medications else "None",
+        )
+
+        response = run_inference(
+            prompt=prompt,
+            model_name="txgemma_2b",  # Use smaller TxGemma for safety check
+            max_new_tokens=256,
+            temperature=0.1,
+        )
+
+        return response
+
+    except Exception as e:
+        logger.warning(f"TxGemma safety check failed: {e}")
+        return None
+
+
+# =============================================================================
+# AGENT REGISTRY
+# =============================================================================
+
+AGENTS = {
+    "intake_historian": run_intake_historian,
+    "vision_specialist": run_vision_specialist,
+    "trend_analyst": run_trend_analyst,
+    "clinical_pharmacologist": run_clinical_pharmacologist,
+}
+
+
+def run_agent(agent_name: str, state: InfectionState) -> InfectionState:
+    """
+    Run a specific agent by name.
+
+    Args:
+        agent_name: Name of the agent to run
+        state: Current infection state
+
+    Returns:
+        Updated infection state
+    """
+    if agent_name not in AGENTS:
+        raise ValueError(f"Unknown agent: {agent_name}")
+
+    return AGENTS[agent_name](state)
+
 
-Intake_Historian = create_agent(model=model, tools=["google_search"], verbose=True)
+__all__ = [
+    "run_intake_historian",
+    "run_vision_specialist",
+    "run_trend_analyst",
+    "run_clinical_pharmacologist",
+    "run_agent",
+    "AGENTS",
+]

src/graph.py

@@ -0,0 +1,300 @@
+"""
+LangGraph Orchestrator for Med-I-C Multi-Agent System.
+
+Implements the infection lifecycle workflow with conditional routing:
+
+Stage 1 (Empirical - no lab results):
+    Intake Historian -> Clinical Pharmacologist
+
+Stage 2 (Targeted - lab results available):
+    Intake Historian -> Vision Specialist -> Trend Analyst -> Clinical Pharmacologist
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Literal
+
+from langgraph.graph import StateGraph, END
+
+from .agents import (
+    run_intake_historian,
+    run_vision_specialist,
+    run_trend_analyst,
+    run_clinical_pharmacologist,
+)
+from .state import InfectionState
+
+logger = logging.getLogger(__name__)
+
+
+# =============================================================================
+# NODE FUNCTIONS (Wrapper for agents)
+# =============================================================================
+
+def intake_historian_node(state: InfectionState) -> InfectionState:
+    """Node 1: Run Intake Historian agent."""
+    logger.info("Graph: Executing Intake Historian node")
+    return run_intake_historian(state)
+
+
+def vision_specialist_node(state: InfectionState) -> InfectionState:
+    """Node 2: Run Vision Specialist agent."""
+    logger.info("Graph: Executing Vision Specialist node")
+    return run_vision_specialist(state)
+
+
+def trend_analyst_node(state: InfectionState) -> InfectionState:
+    """Node 3: Run Trend Analyst agent."""
+    logger.info("Graph: Executing Trend Analyst node")
+    return run_trend_analyst(state)
+
+
+def clinical_pharmacologist_node(state: InfectionState) -> InfectionState:
+    """Node 4: Run Clinical Pharmacologist agent."""
+    logger.info("Graph: Executing Clinical Pharmacologist node")
+    return run_clinical_pharmacologist(state)
+
+
+# =============================================================================
+# CONDITIONAL ROUTING FUNCTIONS
+# =============================================================================
+
+def route_after_intake(state: InfectionState) -> Literal["vision_specialist", "clinical_pharmacologist"]:
+    """
+    Determine routing after Intake Historian.
+
+    Routes to Vision Specialist if:
+    - stage is "targeted" AND
+    - route_to_vision is True (i.e., we have lab data to process)
+
+    Otherwise routes directly to Clinical Pharmacologist (empirical path).
+    """
+    stage = state.get("stage", "empirical")
+    has_lab_data = state.get("route_to_vision", False)
+
+    if stage == "targeted" and has_lab_data:
+        logger.info("Graph: Routing to Vision Specialist (targeted path)")
+        return "vision_specialist"
+    else:
+        logger.info("Graph: Routing to Clinical Pharmacologist (empirical path)")
+        return "clinical_pharmacologist"
+
+
+def route_after_vision(state: InfectionState) -> Literal["trend_analyst", "clinical_pharmacologist"]:
+    """
+    Determine routing after Vision Specialist.
+
+    Routes to Trend Analyst if:
+    - route_to_trend_analyst is True (i.e., we have MIC data to analyze)
+
+    Otherwise skips to Clinical Pharmacologist.
+    """
+    should_analyze_trends = state.get("route_to_trend_analyst", False)
+
+    if should_analyze_trends:
+        logger.info("Graph: Routing to Trend Analyst")
+        return "trend_analyst"
+    else:
+        logger.info("Graph: Skipping Trend Analyst, routing to Clinical Pharmacologist")
+        return "clinical_pharmacologist"
+
+
+# =============================================================================
+# GRAPH CONSTRUCTION
+# =============================================================================
+
+def build_infection_graph() -> StateGraph:
+    """
+    Build the LangGraph StateGraph for the infection lifecycle workflow.
+
+    Returns:
+        Compiled StateGraph ready for execution
+    """
+    # Create the graph with InfectionState as the state schema
+    graph = StateGraph(InfectionState)
+
+    # Add nodes
+    graph.add_node("intake_historian", intake_historian_node)
+    graph.add_node("vision_specialist", vision_specialist_node)
+    graph.add_node("trend_analyst", trend_analyst_node)
+    graph.add_node("clinical_pharmacologist", clinical_pharmacologist_node)
+
+    # Set entry point
+    graph.set_entry_point("intake_historian")
+
+    # Add conditional edges from intake_historian
+    graph.add_conditional_edges(
+        "intake_historian",
+        route_after_intake,
+        {
+            "vision_specialist": "vision_specialist",
+            "clinical_pharmacologist": "clinical_pharmacologist",
+        }
+    )
+
+    # Add conditional edges from vision_specialist
+    graph.add_conditional_edges(
+        "vision_specialist",
+        route_after_vision,
+        {
+            "trend_analyst": "trend_analyst",
+            "clinical_pharmacologist": "clinical_pharmacologist",
+        }
+    )
+
+    # Add edge from trend_analyst to clinical_pharmacologist
+    graph.add_edge("trend_analyst", "clinical_pharmacologist")
+
+    # Add edge from clinical_pharmacologist to END
+    graph.add_edge("clinical_pharmacologist", END)
+
+    return graph
+
+
+def compile_graph():
+    """
+    Build and compile the graph for execution.
+
+    Returns:
+        Compiled graph that can be invoked with .invoke(state)
+    """
+    graph = build_infection_graph()
+    return graph.compile()
+
+
+# =============================================================================
+# EXECUTION HELPERS
+# =============================================================================
+
+def run_pipeline(
+    patient_data: dict,
+    labs_raw_text: str | None = None,
+) -> InfectionState:
+    """
+    Run the full infection lifecycle pipeline.
+
+    This is the main entry point for executing the multi-agent workflow.
+
+    Args:
+        patient_data: Dict containing patient information:
+            - age_years: Patient age
+            - weight_kg: Patient weight
+            - sex: "male" or "female"
+            - serum_creatinine_mg_dl: Serum creatinine (optional)
+            - medications: List of current medications
+            - allergies: List of allergies
+            - comorbidities: List of comorbidities
+            - infection_site: Site of infection
+            - suspected_source: Suspected pathogen/source
+
+        labs_raw_text: Raw text from lab report (if available).
+                      If provided, triggers targeted (Stage 2) pathway.
+
+    Returns:
+        Final InfectionState with recommendation
+
+    Example:
+        >>> state = run_pipeline(
+        ...     patient_data={
+        ...         "age_years": 65,
+        ...         "weight_kg": 70,
+        ...         "sex": "male",
+        ...         "serum_creatinine_mg_dl": 1.2,
+        ...         "medications": ["metformin", "lisinopril"],
+        ...         "allergies": ["penicillin"],
+        ...         "infection_site": "urinary",
+        ...         "suspected_source": "community UTI",
+        ...     },
+        ...     labs_raw_text="E. coli isolated. Ciprofloxacin MIC: 0.5 mg/L (S)"
+        ... )
+        >>> print(state["recommendation"]["primary_antibiotic"])
+    """
+    # Build initial state from patient data
+    initial_state: InfectionState = {
+        "age_years": patient_data.get("age_years"),
+        "weight_kg": patient_data.get("weight_kg"),
+        "height_cm": patient_data.get("height_cm"),
+        "sex": patient_data.get("sex"),
+        "serum_creatinine_mg_dl": patient_data.get("serum_creatinine_mg_dl"),
+        "medications": patient_data.get("medications", []),
+        "allergies": patient_data.get("allergies", []),
+        "comorbidities": patient_data.get("comorbidities", []),
+        "infection_site": patient_data.get("infection_site"),
+        "suspected_source": patient_data.get("suspected_source"),
+        "country_or_region": patient_data.get("country_or_region"),
+        "vitals": patient_data.get("vitals", {}),
+    }
+
+    # Add lab data if provided
+    if labs_raw_text:
+        initial_state["labs_raw_text"] = labs_raw_text
+        initial_state["stage"] = "targeted"
+    else:
+        initial_state["stage"] = "empirical"
+
+    # Compile and run the graph
+    logger.info(f"Starting pipeline execution (stage: {initial_state['stage']})")
+
+    compiled_graph = compile_graph()
+    final_state = compiled_graph.invoke(initial_state)
+
+    logger.info("Pipeline execution complete")
+
+    return final_state
+
+
+def run_empirical_pipeline(patient_data: dict) -> InfectionState:
+    """
+    Run Stage 1 (Empirical) pipeline only.
+
+    Shorthand for run_pipeline without lab data.
+    """
+    return run_pipeline(patient_data, labs_raw_text=None)
+
+
+def run_targeted_pipeline(patient_data: dict, labs_raw_text: str) -> InfectionState:
+    """
+    Run Stage 2 (Targeted) pipeline with lab data.
+
+    Shorthand for run_pipeline with lab data.
+    """
+    return run_pipeline(patient_data, labs_raw_text=labs_raw_text)
+
+
+# =============================================================================
+# VISUALIZATION (for debugging)
+# =============================================================================
+
+def get_graph_mermaid() -> str:
+    """
+    Get Mermaid diagram representation of the graph.
+
+    Useful for documentation and debugging.
+    """
+    graph = build_infection_graph()
+    try:
+        return graph.compile().get_graph().draw_mermaid()
+    except Exception:
+        # Fallback: return manual diagram
+        return """
+graph TD
+    A[intake_historian] --> B{route_after_intake}
+    B -->|targeted + lab data| C[vision_specialist]
+    B -->|empirical| E[clinical_pharmacologist]
+    C --> D{route_after_vision}
+    D -->|has MIC data| F[trend_analyst]
+    D -->|no MIC data| E
+    F --> E
+    E --> G[END]
+"""
+
+
+__all__ = [
+    "build_infection_graph",
+    "compile_graph",
+    "run_pipeline",
+    "run_empirical_pipeline",
+    "run_targeted_pipeline",
+    "get_graph_mermaid",
+]

src/prompts.py

@@ -0,0 +1,355 @@
+"""
+Prompt templates for Med-I-C multi-agent system.
+
+Each agent has a specific role in the infection lifecycle workflow:
+- Agent 1: Intake Historian - Parse patient data, risk factors, calculate CrCl
+- Agent 2: Vision Specialist - Extract structured data from lab reports (images/PDFs)
+- Agent 3: Trend Analyst - Detect MIC creep and resistance velocity
+- Agent 4: Clinical Pharmacologist - Final Rx recommendations + safety checks
+"""
+
+from __future__ import annotations
+
+# =============================================================================
+# AGENT 1: INTAKE HISTORIAN
+# =============================================================================
+
+INTAKE_HISTORIAN_SYSTEM = """You are an expert clinical intake specialist. Your role is to:
+
+1. Parse and structure patient demographics and clinical history
+2. Calculate Creatinine Clearance (CrCl) using the Cockcroft-Gault equation when data is available
+3. Identify key risk factors for antimicrobial-resistant infections
+4. Determine the appropriate treatment stage (empirical vs targeted)
+
+RISK FACTORS TO IDENTIFY:
+- Prior MRSA or MDR infection history
+- Recent antibiotic use (within 90 days)
+- Healthcare-associated vs community-acquired infection
+- Immunocompromised status
+- Recent hospitalization or ICU stay
+- Presence of medical devices (catheters, lines)
+- Travel history to high-resistance regions
+- Renal or hepatic impairment
+
+OUTPUT FORMAT:
+Provide a structured JSON response with the following fields:
+{
+    "patient_summary": "Brief clinical summary",
+    "creatinine_clearance_ml_min": <number or null>,
+    "renal_dose_adjustment_needed": <boolean>,
+    "identified_risk_factors": ["list", "of", "factors"],
+    "suspected_pathogens": ["list", "of", "likely", "organisms"],
+    "infection_severity": "mild|moderate|severe|critical",
+    "recommended_stage": "empirical|targeted",
+    "notes": "Any additional clinical observations"
+}
+"""
+
+INTAKE_HISTORIAN_PROMPT = """Analyze the following patient information and provide a structured clinical assessment.
+
+PATIENT DATA:
+{patient_data}
+
+CURRENT MEDICATIONS:
+{medications}
+
+KNOWN ALLERGIES:
+{allergies}
+
+CLINICAL CONTEXT:
+- Suspected infection site: {infection_site}
+- Suspected source: {suspected_source}
+
+RAG CONTEXT (Relevant Guidelines):
+{rag_context}
+
+Provide your structured assessment following the system instructions."""
+
+
+# =============================================================================
+# AGENT 2: VISION SPECIALIST
+# =============================================================================
+
+VISION_SPECIALIST_SYSTEM = """You are an expert medical laboratory data extraction specialist. Your role is to:
+
+1. Extract structured data from laboratory reports (culture & sensitivity, antibiograms)
+2. Handle reports in ANY language - always output in English
+3. Identify pathogens, antibiotics tested, MIC values, and S/I/R interpretations
+4. Flag any critical or unusual findings
+
+SUPPORTED REPORT TYPES:
+- Culture & Sensitivity reports
+- Antibiogram reports
+- Blood culture reports
+- Urine culture reports
+- Wound culture reports
+- Respiratory culture reports
+
+OUTPUT FORMAT:
+Provide a structured JSON response:
+{
+    "specimen_type": "blood|urine|wound|respiratory|other",
+    "collection_date": "YYYY-MM-DD or null",
+    "identified_organisms": [
+        {
+            "organism_name": "Standardized English name",
+            "original_name": "Name as written in report",
+            "colony_count": "if available",
+            "significance": "pathogen|colonizer|contaminant"
+        }
+    ],
+    "susceptibility_results": [
+        {
+            "organism": "Organism name",
+            "antibiotic": "Standardized antibiotic name",
+            "mic_value": <number or null>,
+            "mic_unit": "mg/L",
+            "interpretation": "S|I|R",
+            "method": "disk diffusion|MIC|E-test"
+        }
+    ],
+    "critical_findings": ["List of urgent findings requiring immediate attention"],
+    "report_quality": "complete|partial|poor",
+    "extraction_confidence": 0.0-1.0,
+    "notes": "Any relevant observations about the report"
+}
+"""
+
+VISION_SPECIALIST_PROMPT = """Extract structured laboratory data from the following report.
+
+REPORT CONTENT:
+{report_content}
+
+REPORT METADATA:
+- Source format: {source_format}
+- Language detected: {language}
+
+Extract all pathogen identifications, susceptibility results, and MIC values.
+Always standardize to English medical terminology.
+Flag any critical findings that require urgent attention.
+
+Provide your structured extraction following the system instructions."""
+
+
+# =============================================================================
+# AGENT 3: TREND ANALYST
+# =============================================================================
+
+TREND_ANALYST_SYSTEM = """You are an expert antimicrobial resistance trend analyst. Your role is to:
+
+1. Analyze MIC trends over time to detect "MIC Creep"
+2. Calculate resistance velocity and predict treatment failure risk
+3. Compare current MICs against EUCAST/CLSI breakpoints
+4. Identify emerging resistance patterns
+
+MIC CREEP DEFINITION:
+MIC creep is a gradual increase in MIC values over time, even while remaining
+technically "Susceptible". This can predict treatment failure before formal
+resistance develops.
+
+RISK STRATIFICATION:
+- LOW: Stable MIC, well below breakpoint (>4x margin)
+- MODERATE: Rising trend but still 2-4x below breakpoint
+- HIGH: Approaching breakpoint (<2x margin) or rapid increase
+- CRITICAL: At or above breakpoint, or >4-fold increase over baseline
+
+OUTPUT FORMAT:
+Provide a structured JSON response:
+{
+    "organism": "Pathogen name",
+    "antibiotic": "Antibiotic name",
+    "mic_history": [
+        {"date": "YYYY-MM-DD", "mic_value": <number>, "interpretation": "S|I|R"}
+    ],
+    "baseline_mic": <number>,
+    "current_mic": <number>,
+    "fold_change": <number>,
+    "trend": "stable|increasing|decreasing|fluctuating",
+    "resistance_velocity": <number per time unit>,
+    "breakpoint_susceptible": <number>,
+    "breakpoint_resistant": <number>,
+    "margin_to_breakpoint": <number>,
+    "risk_level": "LOW|MODERATE|HIGH|CRITICAL",
+    "predicted_time_to_resistance": "estimate or N/A",
+    "recommendation": "Continue current therapy|Consider alternatives|Urgent switch needed",
+    "alternative_antibiotics": ["list", "if", "applicable"],
+    "rationale": "Detailed explanation of risk assessment"
+}
+"""
+
+TREND_ANALYST_PROMPT = """Analyze the MIC trend data and assess resistance risk.
+
+ORGANISM: {organism}
+ANTIBIOTIC: {antibiotic}
+
+HISTORICAL MIC DATA:
+{mic_history}
+
+CURRENT BREAKPOINTS (EUCAST v16.0):
+{breakpoint_data}
+
+REGIONAL RESISTANCE DATA:
+{resistance_context}
+
+Analyze the trend, calculate risk level, and provide recommendations.
+Follow the system instructions for output format."""
+
+
+# =============================================================================
+# AGENT 4: CLINICAL PHARMACOLOGIST
+# =============================================================================
+
+CLINICAL_PHARMACOLOGIST_SYSTEM = """You are an expert clinical pharmacologist specializing in infectious diseases and antimicrobial stewardship. Your role is to:
+
+1. Synthesize all available clinical data into a final antibiotic recommendation
+2. Apply WHO AWaRe classification principles (ACCESS -> WATCH -> RESERVE)
+3. Perform comprehensive drug safety checks
+4. Adjust dosing for renal function
+5. Consider local resistance patterns and guideline recommendations
+
+PRESCRIBING PRINCIPLES:
+1. Start narrow, escalate only when justified
+2. De-escalate when culture results allow
+3. Prefer ACCESS category antibiotics when appropriate
+4. Consider pharmacokinetic/pharmacodynamic (PK/PD) optimization
+5. Document rationale for WATCH/RESERVE antibiotic use
+
+SAFETY CHECKS:
+- Drug-drug interactions (especially warfarin, methotrexate, immunosuppressants)
+- Drug-allergy cross-reactivity (especially beta-lactam allergies)
+- Renal dose adjustments (use CrCl)
+- QT prolongation risk (fluoroquinolones, azithromycin)
+- Pregnancy/lactation considerations
+- Age-related considerations (pediatric/geriatric)
+
+OUTPUT FORMAT:
+Provide a structured JSON response:
+{
+    "primary_recommendation": {
+        "antibiotic": "Drug name",
+        "dose": "Amount and unit",
+        "route": "IV|PO|IM",
+        "frequency": "Dosing interval",
+        "duration": "Expected treatment duration",
+        "aware_category": "ACCESS|WATCH|RESERVE"
+    },
+    "alternative_recommendation": {
+        "antibiotic": "Alternative drug",
+        "dose": "Amount and unit",
+        "route": "IV|PO|IM",
+        "frequency": "Dosing interval",
+        "indication": "When to use alternative"
+    },
+    "dose_adjustments": {
+        "renal": "Adjustment details or 'None needed'",
+        "hepatic": "Adjustment details or 'None needed'"
+    },
+    "safety_alerts": [
+        {
+            "level": "INFO|WARNING|CRITICAL",
+            "type": "interaction|allergy|contraindication|monitoring",
+            "message": "Detailed alert message",
+            "action_required": "What to do"
+        }
+    ],
+    "monitoring_parameters": ["List of labs/vitals to monitor"],
+    "de_escalation_plan": "When and how to de-escalate",
+    "rationale": "Clinical reasoning for recommendation",
+    "guideline_references": ["Supporting guideline citations"],
+    "confidence_level": "high|moderate|low",
+    "requires_id_consult": <boolean>
+}
+"""
+
+CLINICAL_PHARMACOLOGIST_PROMPT = """Synthesize all clinical data and provide a final antibiotic recommendation.
+
+PATIENT SUMMARY (from Intake Historian):
+{intake_summary}
+
+LAB RESULTS (from Vision Specialist):
+{lab_results}
+
+MIC TREND ANALYSIS (from Trend Analyst):
+{trend_analysis}
+
+PATIENT PARAMETERS:
+- Age: {age} years
+- Weight: {weight} kg
+- CrCl: {crcl} mL/min
+- Allergies: {allergies}
+- Current medications: {current_medications}
+
+INFECTION CONTEXT:
+- Site: {infection_site}
+- Source: {suspected_source}
+- Severity: {severity}
+
+RAG CONTEXT (Guidelines & Safety Data):
+{rag_context}
+
+Provide your final recommendation following the system instructions.
+Ensure all safety checks are performed and documented."""
+
+
+# =============================================================================
+# TXGEMMA SAFETY CHECKER (Supplementary)
+# =============================================================================
+
+TXGEMMA_SAFETY_PROMPT = """Evaluate the safety profile of the following antibiotic prescription:
+
+PROPOSED ANTIBIOTIC: {antibiotic}
+DOSE: {dose}
+ROUTE: {route}
+DURATION: {duration}
+
+PATIENT CONTEXT:
+- Age: {age}
+- Renal function (CrCl): {crcl} mL/min
+- Current medications: {medications}
+
+Evaluate for:
+1. Known toxicity concerns
+2. Drug-drug interaction potential
+3. Dose appropriateness for renal function
+
+Provide a brief safety assessment (2-3 sentences) and a risk rating (LOW/MODERATE/HIGH)."""
+
+
+# =============================================================================
+# HELPER TEMPLATES
+# =============================================================================
+
+ERROR_RECOVERY_PROMPT = """The previous agent encountered an error or produced invalid output.
+
+ERROR DETAILS:
+{error_details}
+
+ORIGINAL INPUT:
+{original_input}
+
+Please attempt to recover by providing a valid response or indicating what additional information is needed."""
+
+
+FALLBACK_EMPIRICAL_PROMPT = """No culture data is available. Based on the clinical presentation, provide empirical antibiotic recommendations.
+
+CLINICAL SCENARIO:
+- Infection site: {infection_site}
+- Patient risk factors: {risk_factors}
+- Local resistance patterns: {local_resistance}
+
+Recommend appropriate empirical therapy following WHO AWaRe principles."""
+
+
+__all__ = [
+    "INTAKE_HISTORIAN_SYSTEM",
+    "INTAKE_HISTORIAN_PROMPT",
+    "VISION_SPECIALIST_SYSTEM",
+    "VISION_SPECIALIST_PROMPT",
+    "TREND_ANALYST_SYSTEM",
+    "TREND_ANALYST_PROMPT",
+    "CLINICAL_PHARMACOLOGIST_SYSTEM",
+    "CLINICAL_PHARMACOLOGIST_PROMPT",
+    "TXGEMMA_SAFETY_PROMPT",
+    "ERROR_RECOVERY_PROMPT",
+    "FALLBACK_EMPIRICAL_PROMPT",
+]

src/rag.py

@@ -0,0 +1,482 @@
+"""
+RAG (Retrieval Augmented Generation) module for Med-I-C.
+
+Provides unified retrieval across multiple knowledge collections:
+- antibiotic_guidelines: WHO/IDSA treatment guidelines
+- mic_breakpoints: EUCAST/CLSI breakpoint tables
+- drug_safety: Drug interactions, warnings, contraindications
+- pathogen_resistance: Regional resistance patterns
+"""
+
+from __future__ import annotations
+
+import logging
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+from .config import get_settings
+
+logger = logging.getLogger(__name__)
+
+
+# =============================================================================
+# CHROMA CLIENT & EMBEDDING SETUP
+# =============================================================================
+
+_chroma_client = None
+_embedding_function = None
+
+
+def get_chroma_client():
+    """Get or create ChromaDB persistent client."""
+    global _chroma_client
+    if _chroma_client is None:
+        import chromadb
+
+        settings = get_settings()
+        chroma_path = settings.chroma_db_dir
+        chroma_path.mkdir(parents=True, exist_ok=True)
+        _chroma_client = chromadb.PersistentClient(path=str(chroma_path))
+    return _chroma_client
+
+
+def get_embedding_function():
+    """Get or create the embedding function."""
+    global _embedding_function
+    if _embedding_function is None:
+        from chromadb.utils import embedding_functions
+
+        settings = get_settings()
+        _embedding_function = embedding_functions.SentenceTransformerEmbeddingFunction(
+            model_name=settings.embedding_model_name.split("/")[-1]
+        )
+    return _embedding_function
+
+
+def get_collection(name: str):
+    """
+    Get a ChromaDB collection by name.
+
+    Returns None if collection doesn't exist.
+    """
+    client = get_chroma_client()
+    ef = get_embedding_function()
+
+    try:
+        return client.get_collection(name=name, embedding_function=ef)
+    except Exception:
+        logger.warning(f"Collection '{name}' not found")
+        return None
+
+
+# =============================================================================
+# COLLECTION-SPECIFIC RETRIEVERS
+# =============================================================================
+
+def search_antibiotic_guidelines(
+    query: str,
+    n_results: int = 5,
+    pathogen_filter: Optional[str] = None,
+) -> List[Dict[str, Any]]:
+    """
+    Search antibiotic treatment guidelines.
+
+    Args:
+        query: Search query
+        n_results: Number of results to return
+        pathogen_filter: Optional pathogen type filter (e.g., "ESBL-E", "CRE")
+
+    Returns:
+        List of relevant guideline excerpts with metadata
+    """
+    collection = get_collection("idsa_treatment_guidelines")
+    if collection is None:
+        logger.warning("idsa_treatment_guidelines collection not available")
+        return []
+
+    where_filter = None
+    if pathogen_filter:
+        where_filter = {"pathogen_type": pathogen_filter}
+
+    try:
+        results = collection.query(
+            query_texts=[query],
+            n_results=n_results,
+            where=where_filter,
+            include=["documents", "metadatas", "distances"],
+        )
+    except Exception as e:
+        logger.error(f"Error querying guidelines: {e}")
+        return []
+
+    return _format_results(results)
+
+
+def search_mic_breakpoints(
+    query: str,
+    n_results: int = 5,
+    organism: Optional[str] = None,
+    antibiotic: Optional[str] = None,
+) -> List[Dict[str, Any]]:
+    """
+    Search MIC breakpoint reference documentation.
+
+    Args:
+        query: Search query
+        n_results: Number of results
+        organism: Optional organism name filter
+        antibiotic: Optional antibiotic name filter
+
+    Returns:
+        List of relevant breakpoint information
+    """
+    collection = get_collection("mic_reference_docs")
+    if collection is None:
+        logger.warning("mic_reference_docs collection not available")
+        return []
+
+    # Build query with organism/antibiotic context if provided
+    enhanced_query = query
+    if organism:
+        enhanced_query = f"{organism} {enhanced_query}"
+    if antibiotic:
+        enhanced_query = f"{antibiotic} {enhanced_query}"
+
+    try:
+        results = collection.query(
+            query_texts=[enhanced_query],
+            n_results=n_results,
+            include=["documents", "metadatas", "distances"],
+        )
+    except Exception as e:
+        logger.error(f"Error querying breakpoints: {e}")
+        return []
+
+    return _format_results(results)
+
+
+def search_drug_safety(
+    query: str,
+    n_results: int = 5,
+    drug_name: Optional[str] = None,
+) -> List[Dict[str, Any]]:
+    """
+    Search drug safety information (interactions, warnings, contraindications).
+
+    Args:
+        query: Search query
+        n_results: Number of results
+        drug_name: Optional drug name to focus search
+
+    Returns:
+        List of relevant safety information
+    """
+    collection = get_collection("drug_safety")
+    if collection is None:
+        # Fallback: try existing collections
+        logger.warning("drug_safety collection not available")
+        return []
+
+    enhanced_query = f"{drug_name} {query}" if drug_name else query
+
+    try:
+        results = collection.query(
+            query_texts=[enhanced_query],
+            n_results=n_results,
+            include=["documents", "metadatas", "distances"],
+        )
+    except Exception as e:
+        logger.error(f"Error querying drug safety: {e}")
+        return []
+
+    return _format_results(results)
+
+
+def search_resistance_patterns(
+    query: str,
+    n_results: int = 5,
+    organism: Optional[str] = None,
+    region: Optional[str] = None,
+) -> List[Dict[str, Any]]:
+    """
+    Search pathogen resistance pattern data.
+
+    Args:
+        query: Search query
+        n_results: Number of results
+        organism: Optional organism filter
+        region: Optional geographic region filter
+
+    Returns:
+        List of relevant resistance data
+    """
+    collection = get_collection("pathogen_resistance")
+    if collection is None:
+        logger.warning("pathogen_resistance collection not available")
+        return []
+
+    enhanced_query = query
+    if organism:
+        enhanced_query = f"{organism} {enhanced_query}"
+    if region:
+        enhanced_query = f"{region} {enhanced_query}"
+
+    try:
+        results = collection.query(
+            query_texts=[enhanced_query],
+            n_results=n_results,
+            include=["documents", "metadatas", "distances"],
+        )
+    except Exception as e:
+        logger.error(f"Error querying resistance patterns: {e}")
+        return []
+
+    return _format_results(results)
+
+
+# =============================================================================
+# UNIFIED CONTEXT RETRIEVER
+# =============================================================================
+
+def get_context_for_agent(
+    agent_name: str,
+    query: str,
+    patient_context: Optional[Dict[str, Any]] = None,
+    n_results: int = 3,
+) -> str:
+    """
+    Get formatted RAG context string for a specific agent.
+
+    This is the main entry point for agents to retrieve context.
+
+    Args:
+        agent_name: Name of the requesting agent
+        query: The primary search query
+        patient_context: Optional dict with patient-specific info
+        n_results: Number of results per collection
+
+    Returns:
+        Formatted context string for injection into prompts
+    """
+    context_parts = []
+    patient_context = patient_context or {}
+
+    if agent_name == "intake_historian":
+        # Get empirical therapy guidelines
+        guidelines = search_antibiotic_guidelines(
+            query=query,
+            n_results=n_results,
+            pathogen_filter=patient_context.get("pathogen_type"),
+        )
+        if guidelines:
+            context_parts.append("RELEVANT TREATMENT GUIDELINES:")
+            for g in guidelines:
+                context_parts.append(f"- {g['content'][:500]}...")
+                context_parts.append(f"  [Source: {g.get('source', 'IDSA Guidelines')}]")
+
+    elif agent_name == "vision_specialist":
+        # Get MIC reference info for lab interpretation
+        breakpoints = search_mic_breakpoints(
+            query=query,
+            n_results=n_results,
+            organism=patient_context.get("organism"),
+            antibiotic=patient_context.get("antibiotic"),
+        )
+        if breakpoints:
+            context_parts.append("RELEVANT BREAKPOINT INFORMATION:")
+            for b in breakpoints:
+                context_parts.append(f"- {b['content'][:400]}...")
+
+    elif agent_name == "trend_analyst":
+        # Get breakpoints and resistance trends
+        breakpoints = search_mic_breakpoints(
+            query=f"breakpoint {patient_context.get('organism', '')} {patient_context.get('antibiotic', '')}",
+            n_results=n_results,
+        )
+        resistance = search_resistance_patterns(
+            query=query,
+            n_results=n_results,
+            organism=patient_context.get("organism"),
+            region=patient_context.get("region"),
+        )
+
+        if breakpoints:
+            context_parts.append("EUCAST BREAKPOINT DATA:")
+            for b in breakpoints:
+                context_parts.append(f"- {b['content'][:400]}...")
+
+        if resistance:
+            context_parts.append("\nRESISTANCE PATTERN DATA:")
+            for r in resistance:
+                context_parts.append(f"- {r['content'][:400]}...")
+
+    elif agent_name == "clinical_pharmacologist":
+        # Get comprehensive context for final recommendation
+        guidelines = search_antibiotic_guidelines(
+            query=query,
+            n_results=n_results,
+        )
+        safety = search_drug_safety(
+            query=query,
+            n_results=n_results,
+            drug_name=patient_context.get("proposed_antibiotic"),
+        )
+
+        if guidelines:
+            context_parts.append("TREATMENT GUIDELINES:")
+            for g in guidelines:
+                context_parts.append(f"- {g['content'][:400]}...")
+
+        if safety:
+            context_parts.append("\nDRUG SAFETY INFORMATION:")
+            for s in safety:
+                context_parts.append(f"- {s['content'][:400]}...")
+
+    else:
+        # Generic retrieval
+        guidelines = search_antibiotic_guidelines(query, n_results=n_results)
+        if guidelines:
+            for g in guidelines:
+                context_parts.append(f"- {g['content'][:500]}...")
+
+    if not context_parts:
+        return "No relevant context found in knowledge base."
+
+    return "\n".join(context_parts)
+
+
+def get_context_string(
+    query: str,
+    collections: Optional[List[str]] = None,
+    n_results_per_collection: int = 3,
+    **filters,
+) -> str:
+    """
+    Get a combined context string from multiple collections.
+
+    This is a simpler interface for general-purpose RAG retrieval.
+
+    Args:
+        query: Search query
+        collections: List of collection names to search (defaults to all)
+        n_results_per_collection: Results per collection
+        **filters: Additional filters (organism, antibiotic, region, etc.)
+
+    Returns:
+        Combined context string
+    """
+    default_collections = [
+        "idsa_treatment_guidelines",
+        "mic_reference_docs",
+    ]
+    collections = collections or default_collections
+
+    context_parts = []
+
+    for collection_name in collections:
+        if collection_name == "idsa_treatment_guidelines":
+            results = search_antibiotic_guidelines(
+                query,
+                n_results=n_results_per_collection,
+                pathogen_filter=filters.get("pathogen_type"),
+            )
+        elif collection_name == "mic_reference_docs":
+            results = search_mic_breakpoints(
+                query,
+                n_results=n_results_per_collection,
+                organism=filters.get("organism"),
+                antibiotic=filters.get("antibiotic"),
+            )
+        elif collection_name == "drug_safety":
+            results = search_drug_safety(
+                query,
+                n_results=n_results_per_collection,
+                drug_name=filters.get("drug_name"),
+            )
+        elif collection_name == "pathogen_resistance":
+            results = search_resistance_patterns(
+                query,
+                n_results=n_results_per_collection,
+                organism=filters.get("organism"),
+                region=filters.get("region"),
+            )
+        else:
+            continue
+
+        if results:
+            context_parts.append(f"=== {collection_name.upper()} ===")
+            for r in results:
+                context_parts.append(r["content"])
+                context_parts.append(f"[Relevance: {1 - r.get('distance', 0):.2f}]")
+                context_parts.append("")
+
+    return "\n".join(context_parts) if context_parts else "No relevant context found."
+
+
+# =============================================================================
+# HELPER FUNCTIONS
+# =============================================================================
+
+def _format_results(results: Dict[str, Any]) -> List[Dict[str, Any]]:
+    """Format ChromaDB query results into a standard format."""
+    if not results or not results.get("documents"):
+        return []
+
+    formatted = []
+    documents = results["documents"][0] if results["documents"] else []
+    metadatas = results.get("metadatas", [[]])[0]
+    distances = results.get("distances", [[]])[0]
+
+    for i, doc in enumerate(documents):
+        formatted.append({
+            "content": doc,
+            "metadata": metadatas[i] if i < len(metadatas) else {},
+            "distance": distances[i] if i < len(distances) else None,
+            "source": metadatas[i].get("source", "Unknown") if i < len(metadatas) else "Unknown",
+            "relevance_score": 1 - (distances[i] if i < len(distances) else 0),
+        })
+
+    return formatted
+
+
+def list_available_collections() -> List[str]:
+    """List all available ChromaDB collections."""
+    client = get_chroma_client()
+    try:
+        collections = client.list_collections()
+        return [c.name for c in collections]
+    except Exception as e:
+        logger.error(f"Error listing collections: {e}")
+        return []
+
+
+def get_collection_info(name: str) -> Optional[Dict[str, Any]]:
+    """Get information about a specific collection."""
+    collection = get_collection(name)
+    if collection is None:
+        return None
+
+    try:
+        return {
+            "name": collection.name,
+            "count": collection.count(),
+            "metadata": collection.metadata,
+        }
+    except Exception as e:
+        logger.error(f"Error getting collection info: {e}")
+        return None
+
+
+__all__ = [
+    "get_chroma_client",
+    "get_embedding_function",
+    "get_collection",
+    "search_antibiotic_guidelines",
+    "search_mic_breakpoints",
+    "search_drug_safety",
+    "search_resistance_patterns",
+    "get_context_for_agent",
+    "get_context_string",
+    "list_available_collections",
+    "get_collection_info",
+]

src/utils.py

@@ -0,0 +1,505 @@
+"""
+Utility functions for Med-I-C multi-agent system.
+
+Includes:
+- Creatinine Clearance (CrCl) calculator
+- MIC trend analysis and creep detection
+- Prescription card formatter
+- Data validation helpers
+"""
+
+from __future__ import annotations
+
+import json
+import math
+from typing import Any, Dict, List, Literal, Optional, Tuple
+
+
+# =============================================================================
+# CREATININE CLEARANCE CALCULATOR
+# =============================================================================
+
+def calculate_crcl(
+    age_years: float,
+    weight_kg: float,
+    serum_creatinine_mg_dl: float,
+    sex: Literal["male", "female"],
+    use_ibw: bool = False,
+    height_cm: Optional[float] = None,
+) -> float:
+    """
+    Calculate Creatinine Clearance using the Cockcroft-Gault equation.
+
+    Formula:
+        CrCl = [(140 - age) × weight × (0.85 if female)] / (72 × SCr)
+
+    Args:
+        age_years: Patient age in years
+        weight_kg: Actual body weight in kg
+        serum_creatinine_mg_dl: Serum creatinine in mg/dL
+        sex: Patient sex ("male" or "female")
+        use_ibw: If True, use Ideal Body Weight instead of actual weight
+        height_cm: Height in cm (required if use_ibw=True)
+
+    Returns:
+        Estimated CrCl in mL/min
+    """
+    if serum_creatinine_mg_dl <= 0:
+        raise ValueError("Serum creatinine must be positive")
+
+    if age_years <= 0 or weight_kg <= 0:
+        raise ValueError("Age and weight must be positive")
+
+    # Calculate weight to use
+    weight = weight_kg
+    if use_ibw and height_cm:
+        weight = calculate_ibw(height_cm, sex)
+        # Use adjusted body weight if actual weight > IBW
+        if weight_kg > weight * 1.3:
+            weight = calculate_adjusted_bw(weight, weight_kg)
+
+    # Cockcroft-Gault equation
+    crcl = ((140 - age_years) * weight) / (72 * serum_creatinine_mg_dl)
+
+    # Apply sex factor
+    if sex == "female":
+        crcl *= 0.85
+
+    return round(crcl, 1)
+
+
+def calculate_ibw(height_cm: float, sex: Literal["male", "female"]) -> float:
+    """
+    Calculate Ideal Body Weight using the Devine formula.
+
+    Args:
+        height_cm: Height in centimeters
+        sex: Patient sex
+
+    Returns:
+        Ideal body weight in kg
+    """
+    height_inches = height_cm / 2.54
+    height_over_60 = max(0, height_inches - 60)
+
+    if sex == "male":
+        ibw = 50 + 2.3 * height_over_60
+    else:
+        ibw = 45.5 + 2.3 * height_over_60
+
+    return round(ibw, 1)
+
+
+def calculate_adjusted_bw(ibw: float, actual_weight: float) -> float:
+    """
+    Calculate Adjusted Body Weight for obese patients.
+
+    Formula: AdjBW = IBW + 0.4 × (Actual - IBW)
+    """
+    return round(ibw + 0.4 * (actual_weight - ibw), 1)
+
+
+def get_renal_dose_category(crcl: float) -> str:
+    """
+    Categorize renal function for dosing purposes.
+
+    Returns:
+        Renal function category
+    """
+    if crcl >= 90:
+        return "normal"
+    elif crcl >= 60:
+        return "mild_impairment"
+    elif crcl >= 30:
+        return "moderate_impairment"
+    elif crcl >= 15:
+        return "severe_impairment"
+    else:
+        return "esrd"
+
+
+# =============================================================================
+# MIC TREND ANALYSIS
+# =============================================================================
+
+def calculate_mic_trend(
+    mic_values: List[Dict[str, Any]],
+    susceptible_breakpoint: Optional[float] = None,
+    resistant_breakpoint: Optional[float] = None,
+) -> Dict[str, Any]:
+    """
+    Analyze MIC trend over time and detect MIC creep.
+
+    Args:
+        mic_values: List of dicts with 'date' and 'mic_value' keys
+        susceptible_breakpoint: S breakpoint (optional)
+        resistant_breakpoint: R breakpoint (optional)
+
+    Returns:
+        Dict with trend analysis results
+    """
+    if len(mic_values) < 2:
+        return {
+            "trend": "insufficient_data",
+            "risk_level": "UNKNOWN",
+            "alert": "Need at least 2 MIC values for trend analysis",
+        }
+
+    # Extract MIC values
+    mics = [float(v["mic_value"]) for v in mic_values]
+
+    baseline_mic = mics[0]
+    current_mic = mics[-1]
+
+    # Calculate fold change
+    if baseline_mic > 0:
+        fold_change = current_mic / baseline_mic
+    else:
+        fold_change = float("inf")
+
+    # Calculate trend
+    if len(mics) >= 3:
+        # Linear regression slope
+        n = len(mics)
+        x_mean = (n - 1) / 2
+        y_mean = sum(mics) / n
+        numerator = sum((i - x_mean) * (mics[i] - y_mean) for i in range(n))
+        denominator = sum((i - x_mean) ** 2 for i in range(n))
+        slope = numerator / denominator if denominator != 0 else 0
+
+        if slope > 0.5:
+            trend = "increasing"
+        elif slope < -0.5:
+            trend = "decreasing"
+        else:
+            trend = "stable"
+    else:
+        if current_mic > baseline_mic * 1.5:
+            trend = "increasing"
+        elif current_mic < baseline_mic * 0.67:
+            trend = "decreasing"
+        else:
+            trend = "stable"
+
+    # Calculate resistance velocity (fold change per time point)
+    velocity = fold_change ** (1 / (len(mics) - 1)) if len(mics) > 1 else 1.0
+
+    # Determine risk level
+    risk_level, alert = _assess_mic_risk(
+        current_mic, baseline_mic, fold_change, trend,
+        susceptible_breakpoint, resistant_breakpoint
+    )
+
+    return {
+        "baseline_mic": baseline_mic,
+        "current_mic": current_mic,
+        "ratio": round(fold_change, 2),
+        "trend": trend,
+        "velocity": round(velocity, 3),
+        "risk_level": risk_level,
+        "alert": alert,
+        "n_readings": len(mics),
+    }
+
+
+def _assess_mic_risk(
+    current_mic: float,
+    baseline_mic: float,
+    fold_change: float,
+    trend: str,
+    s_breakpoint: Optional[float],
+    r_breakpoint: Optional[float],
+) -> Tuple[str, str]:
+    """
+    Assess risk level based on MIC trends and breakpoints.
+
+    Returns:
+        Tuple of (risk_level, alert_message)
+    """
+    # If we have breakpoints, use them for risk assessment
+    if s_breakpoint is not None and r_breakpoint is not None:
+        margin = s_breakpoint / current_mic if current_mic > 0 else float("inf")
+
+        if current_mic > r_breakpoint:
+            return "CRITICAL", f"MIC ({current_mic}) exceeds resistant breakpoint ({r_breakpoint}). Organism is RESISTANT."
+
+        if current_mic > s_breakpoint:
+            return "HIGH", f"MIC ({current_mic}) exceeds susceptible breakpoint ({s_breakpoint}). Consider alternative therapy."
+
+        if margin < 2:
+            if trend == "increasing":
+                return "HIGH", f"MIC approaching breakpoint (margin: {margin:.1f}x) with increasing trend. High risk of resistance emergence."
+            else:
+                return "MODERATE", f"MIC close to breakpoint (margin: {margin:.1f}x). Monitor closely."
+
+        if margin < 4:
+            if trend == "increasing":
+                return "MODERATE", f"MIC rising with {margin:.1f}x margin to breakpoint. Consider enhanced monitoring."
+            else:
+                return "LOW", "MIC stable with adequate margin to breakpoint."
+
+        return "LOW", "MIC well below breakpoint with good safety margin."
+
+    # Without breakpoints, use fold change and trend
+    if fold_change >= 8:
+        return "CRITICAL", f"MIC increased {fold_change:.1f}-fold from baseline. Urgent review needed."
+
+    if fold_change >= 4:
+        return "HIGH", f"MIC increased {fold_change:.1f}-fold from baseline. High risk of treatment failure."
+
+    if fold_change >= 2:
+        if trend == "increasing":
+            return "MODERATE", f"MIC increased {fold_change:.1f}-fold with rising trend. Enhanced monitoring recommended."
+        else:
+            return "LOW", f"MIC increased {fold_change:.1f}-fold but trend is {trend}."
+
+    if trend == "increasing":
+        return "MODERATE", "MIC showing upward trend. Continue monitoring."
+
+    return "LOW", "MIC stable or decreasing. Current therapy appropriate."
+
+
+def detect_mic_creep(
+    organism: str,
+    antibiotic: str,
+    mic_history: List[Dict[str, Any]],
+    breakpoints: Dict[str, float],
+) -> Dict[str, Any]:
+    """
+    Detect MIC creep for a specific organism-antibiotic pair.
+
+    Args:
+        organism: Pathogen name
+        antibiotic: Antibiotic name
+        mic_history: Historical MIC values with dates
+        breakpoints: Dict with 'susceptible' and 'resistant' keys
+
+    Returns:
+        Comprehensive MIC creep analysis
+    """
+    trend_analysis = calculate_mic_trend(
+        mic_history,
+        susceptible_breakpoint=breakpoints.get("susceptible"),
+        resistant_breakpoint=breakpoints.get("resistant"),
+    )
+
+    # Add organism/antibiotic context
+    trend_analysis["organism"] = organism
+    trend_analysis["antibiotic"] = antibiotic
+    trend_analysis["breakpoint_susceptible"] = breakpoints.get("susceptible")
+    trend_analysis["breakpoint_resistant"] = breakpoints.get("resistant")
+
+    # Calculate time to resistance estimate
+    if trend_analysis["trend"] == "increasing" and trend_analysis["velocity"] > 1.0:
+        current = trend_analysis["current_mic"]
+        s_bp = breakpoints.get("susceptible")
+        if s_bp and current < s_bp:
+            # Estimate doublings needed to reach breakpoint
+            doublings_needed = math.log2(s_bp / current) if current > 0 else 0
+            # Estimate time based on velocity
+            if trend_analysis["velocity"] > 1.0:
+                log_velocity = math.log(trend_analysis["velocity"]) / math.log(2)
+                if log_velocity > 0:
+                    time_estimate = doublings_needed / log_velocity
+                    trend_analysis["estimated_readings_to_resistance"] = round(time_estimate, 1)
+
+    return trend_analysis
+
+
+# =============================================================================
+# PRESCRIPTION FORMATTER
+# =============================================================================
+
+def format_prescription_card(recommendation: Dict[str, Any]) -> str:
+    """
+    Format a recommendation into a readable prescription card.
+
+    Args:
+        recommendation: Dict with recommendation details
+
+    Returns:
+        Formatted prescription card as string
+    """
+    lines = []
+    lines.append("=" * 50)
+    lines.append("ANTIBIOTIC PRESCRIPTION")
+    lines.append("=" * 50)
+
+    primary = recommendation.get("primary_recommendation", recommendation)
+
+    lines.append(f"\nDRUG: {primary.get('antibiotic', 'N/A')}")
+    lines.append(f"DOSE: {primary.get('dose', 'N/A')}")
+    lines.append(f"ROUTE: {primary.get('route', 'N/A')}")
+    lines.append(f"FREQUENCY: {primary.get('frequency', 'N/A')}")
+    lines.append(f"DURATION: {primary.get('duration', 'N/A')}")
+
+    if primary.get("aware_category"):
+        lines.append(f"WHO AWaRe: {primary.get('aware_category')}")
+
+    # Dose adjustments
+    adjustments = recommendation.get("dose_adjustments", {})
+    if adjustments.get("renal") and adjustments["renal"] != "None needed":
+        lines.append(f"\nRENAL ADJUSTMENT: {adjustments['renal']}")
+    if adjustments.get("hepatic") and adjustments["hepatic"] != "None needed":
+        lines.append(f"HEPATIC ADJUSTMENT: {adjustments['hepatic']}")
+
+    # Safety alerts
+    alerts = recommendation.get("safety_alerts", [])
+    if alerts:
+        lines.append("\n" + "-" * 50)
+        lines.append("SAFETY ALERTS:")
+        for alert in alerts:
+            level = alert.get("level", "INFO")
+            marker = {"CRITICAL": "[!!!]", "WARNING": "[!!]", "INFO": "[i]"}.get(level, "[?]")
+            lines.append(f"  {marker} {alert.get('message', '')}")
+
+    # Monitoring
+    monitoring = recommendation.get("monitoring_parameters", [])
+    if monitoring:
+        lines.append("\n" + "-" * 50)
+        lines.append("MONITORING:")
+        for param in monitoring:
+            lines.append(f"  - {param}")
+
+    # Rationale
+    if recommendation.get("rationale"):
+        lines.append("\n" + "-" * 50)
+        lines.append("RATIONALE:")
+        lines.append(f"  {recommendation['rationale']}")
+
+    lines.append("\n" + "=" * 50)
+
+    return "\n".join(lines)
+
+
+# =============================================================================
+# JSON PARSING HELPERS
+# =============================================================================
+
+def safe_json_parse(text: str) -> Optional[Dict[str, Any]]:
+    """
+    Safely parse JSON from agent output, handling common issues.
+
+    Attempts to extract JSON from text that may contain markdown code blocks
+    or other formatting.
+    """
+    if not text:
+        return None
+
+    # Try direct parse first
+    try:
+        return json.loads(text)
+    except json.JSONDecodeError:
+        pass
+
+    # Try to extract JSON from markdown code block
+    import re
+
+    json_patterns = [
+        r"```json\s*\n?(.*?)\n?```",  # ```json ... ```
+        r"```\s*\n?(.*?)\n?```",       # ``` ... ```
+        r"\{[\s\S]*\}",                 # Raw JSON object
+    ]
+
+    for pattern in json_patterns:
+        match = re.search(pattern, text, re.DOTALL)
+        if match:
+            try:
+                json_str = match.group(1) if match.lastindex else match.group(0)
+                return json.loads(json_str)
+            except (json.JSONDecodeError, IndexError):
+                continue
+
+    return None
+
+
+def validate_agent_output(output: Dict[str, Any], required_fields: List[str]) -> Tuple[bool, List[str]]:
+    """
+    Validate that agent output contains required fields.
+
+    Args:
+        output: Agent output dict
+        required_fields: List of required field names
+
+    Returns:
+        Tuple of (is_valid, list_of_missing_fields)
+    """
+    missing = [field for field in required_fields if field not in output]
+    return len(missing) == 0, missing
+
+
+# =============================================================================
+# DATA NORMALIZATION
+# =============================================================================
+
+def normalize_antibiotic_name(name: str) -> str:
+    """
+    Normalize antibiotic name to standard format.
+    """
+    # Common name mappings
+    mappings = {
+        "amox": "amoxicillin",
+        "amox/clav": "amoxicillin-clavulanate",
+        "augmentin": "amoxicillin-clavulanate",
+        "pip/tazo": "piperacillin-tazobactam",
+        "zosyn": "piperacillin-tazobactam",
+        "tmp/smx": "trimethoprim-sulfamethoxazole",
+        "bactrim": "trimethoprim-sulfamethoxazole",
+        "cipro": "ciprofloxacin",
+        "levo": "levofloxacin",
+        "moxi": "moxifloxacin",
+        "vanc": "vancomycin",
+        "vanco": "vancomycin",
+        "mero": "meropenem",
+        "imi": "imipenem",
+        "gent": "gentamicin",
+        "tobra": "tobramycin",
+        "ceftriax": "ceftriaxone",
+        "rocephin": "ceftriaxone",
+        "cefepime": "cefepime",
+        "maxipime": "cefepime",
+    }
+
+    normalized = name.lower().strip()
+    return mappings.get(normalized, normalized)
+
+
+def normalize_organism_name(name: str) -> str:
+    """
+    Normalize organism name to standard format.
+    """
+    name = name.strip()
+
+    # Common abbreviations
+    abbreviations = {
+        "e. coli": "Escherichia coli",
+        "e.coli": "Escherichia coli",
+        "k. pneumoniae": "Klebsiella pneumoniae",
+        "k.pneumoniae": "Klebsiella pneumoniae",
+        "p. aeruginosa": "Pseudomonas aeruginosa",
+        "p.aeruginosa": "Pseudomonas aeruginosa",
+        "s. aureus": "Staphylococcus aureus",
+        "s.aureus": "Staphylococcus aureus",
+        "mrsa": "Staphylococcus aureus (MRSA)",
+        "mssa": "Staphylococcus aureus (MSSA)",
+        "enterococcus": "Enterococcus species",
+        "vre": "Enterococcus (VRE)",
+    }
+
+    lower_name = name.lower()
+    return abbreviations.get(lower_name, name)
+
+
+__all__ = [
+    "calculate_crcl",
+    "calculate_ibw",
+    "calculate_adjusted_bw",
+    "get_renal_dose_category",
+    "calculate_mic_trend",
+    "detect_mic_creep",
+    "format_prescription_card",
+    "safe_json_parse",
+    "validate_agent_output",
+    "normalize_antibiotic_name",
+    "normalize_organism_name",
+]