Spaces:

ghitaben
/

AMR-Guard

Running on Zero

App Files Files Community

ghitaben commited on Feb 21

Commit

a2ccb82

1 Parent(s): c2e5bee

Implement code structure updates and remove redundant code blocks

Browse files

Files changed (5) hide show

.gitignore +4 -1
app.py +479 -527
notebooks/kaggle_medic_demo.ipynb +116 -1342
pyproject.toml +1 -2
uv.lock +0 -0

.gitignore CHANGED Viewed

@@ -1,4 +1,7 @@
 .DS_Store
 .env
 data/
-*.pyc

 .DS_Store
 .env
 data/
+*.pyc
+__pycache__/
+.venv/
+*.egg-info/

app.py CHANGED Viewed

@@ -1,321 +1,307 @@
 """
 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
 PROJECT_ROOT = Path(__file__).parent
 sys.path.insert(0, str(PROJECT_ROOT))
 from src.tools import (
-    interpret_mic_value,
-    get_most_effective_antibiotics,
     calculate_mic_trend,
     screen_antibiotic_safety,
     search_clinical_guidelines,
-    get_empirical_therapy_guidance,
 )
-from src.utils import format_prescription_card
-# Page configuration
 st.set_page_config(
-    page_title="Med-I-C: AMR-Guard",
-    page_icon="🦠",
     layout="wide",
-    initial_sidebar_state="expanded"
 )
-# Custom CSS
-st.markdown("""
 <style>
-    .main-header {
-        font-size: 2.5rem;
-        font-weight: bold;
-        color: #1E88E5;
-        margin-bottom: 0;
-    }
-    .sub-header {
-        font-size: 1.2rem;
-        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;
-        border-radius: 5px;
-        border-left: 4px solid #D32F2F;
-    }
-    .risk-moderate {
-        background-color: #FFE0B2;
-        padding: 10px;
-        border-radius: 5px;
-        border-left: 4px solid #F57C00;
-    }
-    .risk-low {
-        background-color: #C8E6C9;
-        padding: 10px;
-        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;
-        border-radius: 5px;
-        margin: 10px 0;
-    }
 </style>
-""", unsafe_allow_html=True)
-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 - Multi-Agent System</p>', unsafe_allow_html=True)
-    # Sidebar navigation
-    st.sidebar.title("Navigation")
-    page = st.sidebar.radio(
-        "Select Module",
-        [
-            "🏠 Overview",
-            "🤖 Agent Pipeline",
-            "💊 Empirical Advisor",
-            "🔬 Lab Interpretation",
-            "📊 MIC Trend Analysis",
-            "⚠️ Drug Safety Check",
-            "📚 Clinical Guidelines"
-        ]
     )
-    if page == "🏠 Overview":
-        show_overview()
-    elif page == "🤖 Agent Pipeline":
-        show_agent_pipeline()
-    elif page == "💊 Empirical Advisor":
-        show_empirical_advisor()
-    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":
-        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.markdown("""
-        ### 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.markdown("""
-        ### 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 AWaRe", "264", "antibiotics classified")
-    with col2:
-        st.metric("EUCAST", "v16.0", "breakpoint tables")
-    with col3:
-        st.metric("IDSA", "2024", "treatment guidelines")
-    with col4:
-        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,
@@ -329,143 +315,114 @@ Trimethoprim-Sulfamethoxazole: R (MIC >4)""",
             "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", []),
@@ -474,19 +431,21 @@ def _generate_demo_result(patient_data: dict, labs_raw_text: str | None) -> dict
         }),
         "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",
@@ -494,6 +453,7 @@ def _generate_demo_result(patient_data: dict, labs_raw_text: str | None) -> dict
             "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,
         })
@@ -501,181 +461,173 @@ def _generate_demo_result(patient_data: dict, labs_raw_text: str | None) -> dict
             "organism": "E. coli",
             "antibiotic": "Ciprofloxacin",
             "risk_level": "LOW",
-            "recommendation": "Continue current therapy",
         }])
     return result
-def show_empirical_advisor():
-    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", "Pneumonia", "Sepsis",
-             "Skin/Soft Tissue", "Intra-abdominal", "Meningitis"]
-        )
-        suspected_pathogen = st.text_input(
-            "Suspected Pathogen (optional)",
-            placeholder="e.g., E. coli, Klebsiella pneumoniae"
-        )
-        risk_factors = st.multiselect(
-            "Risk Factors",
-            ["Prior MRSA infection", "Recent antibiotic use (<90 days)",
-             "Healthcare-associated", "Immunocompromised",
-             "Renal impairment", "Prior MDR infection"]
-        )
-    with col2:
-        st.markdown("**WHO AWaRe Categories**")
-        st.markdown("""
-        - **ACCESS**: First-line, low resistance
-        - **WATCH**: Higher resistance potential
-        - **RESERVE**: Last resort antibiotics
-        """)
-    if st.button("Get Recommendation", type="primary"):
-        with st.spinner("Searching guidelines..."):
-            guidance = get_empirical_therapy_guidance(
-                infection_type,
-                risk_factors
             )
-            st.subheader("Guideline Recommendations")
             if guidance.get("recommendations"):
                 for i, rec in enumerate(guidance["recommendations"][:3], 1):
-                    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 suspected_pathogen:
-                st.subheader(f"Resistance Data: {suspected_pathogen}")
-                effective = get_most_effective_antibiotics(suspected_pathogen, min_susceptibility=70)
                 if effective:
-                    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.")
-def show_lab_interpretation():
-    st.header("🔬 Lab Interpretation")
-    st.markdown("*Interpret antibiogram MIC values*")
-    col1, col2 = st.columns(2)
-    with col1:
-        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("**Interpretation Guide**")
-        st.markdown("""
-        - **S**: Susceptible - antibiotic effective
-        - **I**: Intermediate - may work at higher doses
-        - **R**: Resistant - do not use
-        """)
-    if st.button("Interpret", type="primary"):
-        if pathogen and antibiotic:
-            result = interpret_mic_value(pathogen, antibiotic, mic_value)
-            interpretation = result.get("interpretation", "UNKNOWN")
-            if interpretation == "SUSCEPTIBLE":
-                st.success(f"✅ {interpretation}")
-            elif interpretation == "RESISTANT":
-                st.error(f"❌ {interpretation}")
-            else:
-                st.warning(f"⚠️ {interpretation}")
-            st.markdown(f"**Details:** {result.get('message', '')}")
-def show_mic_trend_analysis():
-    st.header("📊 MIC Trend Analysis")
-    st.markdown("*Detect MIC creep over time*")
-    num_readings = st.slider("Historical readings", 2, 6, 3)
-    mic_values = []
-    cols = st.columns(num_readings)
-    for i, col in enumerate(cols):
-        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", 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">🚨 HIGH RISK: {result.get("alert", "")}</div>', unsafe_allow_html=True)
-        elif risk_level == "MODERATE":
-            st.markdown(f'<div class="risk-moderate">⚠️ MODERATE: {result.get("alert", "")}</div>', unsafe_allow_html=True)
-        else:
-            st.markdown(f'<div class="risk-low">✅ LOW RISK: {result.get("alert", "")}</div>', unsafe_allow_html=True)
-        col1, col2, col3 = st.columns(3)
-        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")
-    col1, col2 = st.columns(2)
-    with col1:
-        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("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()]
-            result = screen_antibiotic_safety(antibiotic, medications, allergy_list)
-            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")
-    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"])
     if st.button("Search", type="primary"):
         if 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__":
-    main()

 """
 Med-I-C: AMR-Guard Demo Application
+Infection Lifecycle Orchestrator — Streamlit Interface
 """
 import json
+import sys
 from pathlib import Path
+import streamlit as st
 PROJECT_ROOT = Path(__file__).parent
 sys.path.insert(0, str(PROJECT_ROOT))
 from src.tools import (
     calculate_mic_trend,
+    get_empirical_therapy_guidance,
+    get_most_effective_antibiotics,
+    interpret_mic_value,
     screen_antibiotic_safety,
     search_clinical_guidelines,
 )
+# ── Page config ──────────────────────────────────────────────────────────────
 st.set_page_config(
+    page_title="Med-I-C · AMR-Guard",
+    page_icon="⚕",
     layout="wide",
+    initial_sidebar_state="expanded",
 )
+# ── Global CSS ────────────────────────────────────────────────────────────────
+st.markdown(
+    """
 <style>
+/* ── Fonts & Base ── */
+@import url('https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&display=swap');
+html, body, [class*="css"] { font-family: 'Inter', sans-serif; }
+/* ── Hide Streamlit chrome ── */
+#MainMenu, footer { visibility: hidden; }
+/* ── Sidebar ── */
+[data-testid="stSidebar"] {
+    background: #0b2545;
+}
+[data-testid="stSidebar"] * { color: #e8edf3 !important; }
+[data-testid="stSidebar"] .stRadio label { padding: 6px 0; font-size: 0.9rem; }
+[data-testid="stSidebar"] hr { border-color: #1e3a5f; }
+/* ── Top banner ── */
+.med-banner {
+    background: linear-gradient(135deg, #0b2545 0%, #1a4a8a 100%);
+    padding: 22px 30px;
+    border-radius: 12px;
+    margin-bottom: 28px;
+    display: flex;
+    align-items: center;
+    gap: 20px;
+}
+.med-banner h1 { color: #ffffff; font-size: 1.9rem; font-weight: 700; margin: 0; }
+.med-banner p  { color: #9ec4f0; font-size: 0.95rem; margin: 4px 0 0; }
+/* ── Section headings ── */
+.section-title {
+    font-size: 1.15rem; font-weight: 600;
+    color: #0b2545; border-bottom: 2px solid #1a4a8a;
+    padding-bottom: 6px; margin: 24px 0 16px;
+}
+/* ── Stat cards ── */
+.stat-card {
+    background: #ffffff;
+    border: 1px solid #dde4ee;
+    border-top: 3px solid #1a4a8a;
+    border-radius: 10px;
+    padding: 18px 20px;
+    text-align: center;
+}
+.stat-card .label { color: #6b7a99; font-size: 0.78rem; font-weight: 600; text-transform: uppercase; letter-spacing: 0.04em; }
+.stat-card .value { color: #0b2545; font-size: 1.6rem; font-weight: 700; margin-top: 4px; }
+.stat-card .sub   { color: #9ec4f0; font-size: 0.75rem; margin-top: 2px; }
+/* ── Agent flow card ── */
+.agent-step {
+    background: #f4f7fc;
+    border-left: 4px solid #1a4a8a;
+    border-radius: 8px;
+    padding: 14px 16px;
+    margin-bottom: 10px;
+}
+.agent-step .num  { color: #1a4a8a; font-weight: 700; font-size: 0.85rem; }
+.agent-step .name { color: #0b2545; font-weight: 600; }
+.agent-step .desc { color: #5a6680; font-size: 0.85rem; margin-top: 4px; }
+/* ── Alert badges ── */
+.badge-high     { background:#fff0f0; border-left:4px solid #c0392b; color:#7b1d1d; padding:10px 14px; border-radius:6px; }
+.badge-moderate { background:#fff8ee; border-left:4px solid #e67e22; color:#7a4a00; padding:10px 14px; border-radius:6px; }
+.badge-low      { background:#f0fff4; border-left:4px solid #27ae60; color:#145a32; padding:10px 14px; border-radius:6px; }
+.badge-info     { background:#eaf3ff; border-left:4px solid #1a4a8a; color:#0b2545; padding:10px 14px; border-radius:6px; }
+/* ── Prescription card ── */
+.rx-card {
+    background: #f4f7fc;
+    border: 1px solid #c5d3e8;
+    border-radius: 10px;
+    padding: 22px 24px;
+    font-size: 0.9rem;
+    line-height: 1.7;
+}
+.rx-card .rx-symbol { font-size: 2rem; color: #1a4a8a; font-weight: 700; }
+.rx-card .rx-drug   { font-size: 1.2rem; font-weight: 700; color: #0b2545; }
+/* ── Disclaimer ── */
+.disclaimer {
+    background: #fff8ee;
+    border: 1px solid #f0c080;
+    border-radius: 8px;
+    padding: 12px 16px;
+    font-size: 0.78rem;
+    color: #7a5000;
+    margin-top: 20px;
+}
+/* ── Form tweaks ── */
+.stTextInput input, .stTextArea textarea, .stNumberInput input {
+    border-radius: 6px !important;
+}
+.stButton > button[kind="primary"] {
+    background: #1a4a8a; border: none;
+    border-radius: 8px; font-weight: 600;
+    padding: 0.6rem 1.4rem;
+}
+.stButton > button[kind="primary"]:hover { background: #0b2545; }
 </style>
+""",
+    unsafe_allow_html=True,
+)
+# ── Sidebar ───────────────────────────────────────────────────────────────────
+with st.sidebar:
+    st.markdown("## ⚕ Med-I-C")
+    st.markdown("**AMR-Guard**")
+    st.markdown("---")
+    page = st.radio(
+        "Navigation",
+        ["Dashboard", "Patient Analysis", "Clinical Tools", "Guidelines"],
+        label_visibility="collapsed",
+    )
+    st.markdown("---")
+    st.markdown(
+        "<small style='color:#6b8fc4'>Powered by local LLMs<br>via HuggingFace Transformers</small>",
+        unsafe_allow_html=True,
     )
+# ── Banner ────────────────────────────────────────────────────────────────────
+st.markdown(
+    """
+<div class="med-banner">
+    <div>
+        <h1>⚕ AMR-Guard</h1>
+        <p>Infection Lifecycle Orchestrator &nbsp;·&nbsp; Multi-Agent Clinical Decision Support</p>
+    </div>
+</div>
+""",
+    unsafe_allow_html=True,
+)
+# ── Pages ─────────────────────────────────────────────────────────────────────
+def page_dashboard():
+    st.markdown('<div class="section-title">System Overview</div>', unsafe_allow_html=True)
+    col1, col2, col3, col4 = st.columns(4)
+    cards = [
+        ("WHO AWaRe", "264", "antibiotics classified"),
+        ("EUCAST", "v16.0", "breakpoint tables"),
+        ("IDSA", "2024", "treatment guidelines"),
+        ("DDInter", "191K+", "drug interactions"),
+    ]
+    for col, (label, value, sub) in zip([col1, col2, col3, col4], cards):
+        col.markdown(
+            f'<div class="stat-card"><div class="label">{label}</div>'
+            f'<div class="value">{value}</div><div class="sub">{sub}</div></div>',
+            unsafe_allow_html=True,
+        )
+    st.markdown('<div class="section-title">Agent Pipeline</div>', unsafe_allow_html=True)
+    c1, c2 = st.columns(2)
+    with c1:
+        st.markdown("**Stage 1 — Empirical** *(no lab results yet)*")
+        for num, name, desc in [
+            ("01", "Intake Historian", "Parses patient data, calculates CrCl, identifies MDR risk factors"),
+            ("04", "Clinical Pharmacologist", "Empirical antibiotic selection · WHO AWaRe · safety screening"),
+        ]:
+            st.markdown(
+                f'<div class="agent-step"><div class="num">Agent {num}</div>'
+                f'<div class="name">{name}</div><div class="desc">{desc}</div></div>',
+                unsafe_allow_html=True,
             )
+    with c2:
+        st.markdown("**Stage 2 — Targeted** *(culture / sensitivity available)*")
+        for num, name, desc in [
+            ("01", "Intake Historian", "Same as Stage 1"),
+            ("02", "Vision Specialist", "Extracts structured data from lab reports (any language / format)"),
+            ("03", "Trend Analyst", "Detects MIC creep · calculates resistance velocity"),
+            ("04", "Clinical Pharmacologist", "Targeted recommendation informed by susceptibility data"),
+        ]:
+            st.markdown(
+                f'<div class="agent-step"><div class="num">Agent {num}</div>'
+                f'<div class="name">{name}</div><div class="desc">{desc}</div></div>',
+                unsafe_allow_html=True,
             )
+    st.markdown('<div class="section-title">AI Models (Local)</div>', unsafe_allow_html=True)
+    from src.config import get_settings
+    s = get_settings()
+    st.markdown(
+        f"""
+| Role | Model |
+|---|---|
+| Clinical reasoning (all agents) | `{s.local_medgemma_4b_model or "gemma-2-2b-it"}` |
+| Safety pharmacology check | `{s.local_txgemma_2b_model or s.local_medgemma_4b_model or "gemma-2-2b-it"}` |
+| Semantic retrieval (RAG) | `{s.embedding_model_name}` |
+| Inference backend | Local · HuggingFace Transformers |
+"""
+    )
+    st.markdown(
+        '<div class="disclaimer">⚠ <strong>Research demo only.</strong> '
+        "Not validated for clinical use. All recommendations must be reviewed "
+        "by a licensed clinician before any patient-care decision.</div>",
+        unsafe_allow_html=True,
+    )
+def page_patient_analysis():
+    st.markdown('<div class="section-title">Patient Analysis Pipeline</div>', unsafe_allow_html=True)
+    if "pipeline_result" not in st.session_state:
+        st.session_state.pipeline_result = None
+    # ── Patient form ──
+    with st.expander("Patient Demographics & Vitals", expanded=True):
+        c1, c2, c3 = st.columns(3)
+        with c1:
+            age = st.number_input("Age (years)", 0, 120, 65)
+            weight = st.number_input("Weight (kg)", 1.0, 300.0, 70.0, step=0.5)
+            height = st.number_input("Height (cm)", 50.0, 250.0, 170.0, step=0.5)
+        with c2:
+            sex = st.selectbox("Biological sex", ["male", "female"])
+            creatinine = st.number_input("Serum Creatinine (mg/dL)", 0.1, 20.0, 1.2, step=0.1)
+        with c3:
+            infection_site = st.selectbox(
+                "Primary infection site",
+                ["urinary", "respiratory", "bloodstream", "skin", "intra-abdominal", "CNS", "other"],
             )
+            suspected_source = st.text_input("Suspected source", placeholder="e.g., community-acquired UTI")
+    with st.expander("Medical History"):
+        c1, c2 = st.columns(2)
+        with c1:
+            medications = st.text_area("Current medications (one per line)", placeholder="Metformin\nLisinopril", height=100)
+            allergies = st.text_area("Drug allergies (one per line)", placeholder="Penicillin\nSulfa", height=80)
+        with c2:
             comorbidities = st.multiselect(
                 "Comorbidities",
+                ["Diabetes", "CKD", "Heart Failure", "COPD", "Immunocompromised", "Recent Surgery", "Malignancy", "Liver Disease"],
             )
             risk_factors = st.multiselect(
+                "MDR risk factors",
+                ["Prior MRSA", "Recent antibiotics (<90 d)", "Healthcare-associated", "Recent hospitalisation", "Nursing home", "Prior MDR infection"],
             )
+    with st.expander("Lab / Culture Results  (optional — triggers targeted pathway)"):
+        method = st.radio("Input method", ["None — empirical pathway only", "Paste lab text"], horizontal=True)
         labs_raw_text = None
+        if method == "Paste lab text":
             labs_raw_text = st.text_area(
+                "Lab report",
+                placeholder=(
+                    "Organism: Escherichia coli\n"
+                    "Ciprofloxacin: S  MIC 0.25\n"
+                    "Nitrofurantoin: S  MIC 16\n"
+                    "Ampicillin: R  MIC >32"
+                ),
+                height=160,
             )
+    st.markdown("")
+    run_btn = st.button("Run Agent Pipeline", type="primary", use_container_width=False)
+    if run_btn:
         patient_data = {
             "age_years": age,
             "weight_kg": weight,
             "comorbidities": list(comorbidities) + list(risk_factors),
         }
+        stages = (
+            ["Intake Historian", "Vision Specialist", "Trend Analyst", "Clinical Pharmacologist"]
+            if labs_raw_text
+            else ["Intake Historian", "Clinical Pharmacologist"]
+        )
+        prog = st.progress(0, text="Starting pipeline…")
+        for i, name in enumerate(stages):
+            prog.progress((i + 1) / len(stages), text=f"Running: {name}")
         try:
             from src.graph import run_pipeline
             result = run_pipeline(patient_data, labs_raw_text)
+        except Exception:
+            result = _demo_result(patient_data, labs_raw_text)
+        prog.progress(100, text="Complete")
+        st.session_state.pipeline_result = result
+    # ── Results ──
     if st.session_state.pipeline_result:
         result = st.session_state.pipeline_result
+        st.markdown('<div class="section-title">Results</div>', unsafe_allow_html=True)
+        t1, t2, t3, t4 = st.tabs(["Recommendation", "Patient Summary", "Lab Analysis", "Safety"])
+        with t1:
             rec = result.get("recommendation", {})
             if rec:
+                primary = rec.get("primary_antibiotic", "—")
+                dose = rec.get("dose", "—")
+                route = rec.get("route", "—")
+                freq = rec.get("frequency", "—")
+                duration = rec.get("duration", "—")
+                alt = rec.get("backup_antibiotic", "")
+                st.markdown(
+                    f"""
+<div class="rx-card">
+  <div class="rx-symbol">℞</div>
+  <div class="rx-drug">{primary}</div>
+  <br>
+  <strong>Dose:</strong> {dose} &nbsp;·&nbsp;
+  <strong>Route:</strong> {route} &nbsp;·&nbsp;
+  <strong>Frequency:</strong> {freq} &nbsp;·&nbsp;
+  <strong>Duration:</strong> {duration}
+  {"<br><strong>Alternative:</strong> " + alt if alt else ""}
+</div>
+""",
+                    unsafe_allow_html=True,
+                )
+                if rec.get("rationale"):
+                    st.markdown("**Clinical rationale**")
+                    st.markdown(rec["rationale"])
                 if rec.get("references"):
+                    st.markdown("**References**")
                     for ref in rec["references"]:
                         st.markdown(f"- {ref}")
+        with t2:
+            intake = result.get("intake_notes", "")
             if result.get("creatinine_clearance_ml_min"):
+                st.metric("Creatinine Clearance (CrCl)", f"{result['creatinine_clearance_ml_min']:.1f} mL/min")
+            if intake:
                 try:
+                    st.json(json.loads(intake) if isinstance(intake, str) else intake)
+                except Exception:
+                    st.text(intake)
+        with t3:
+            vision = result.get("vision_notes", "")
+            if vision and vision not in ("No lab data provided", ""):
                 try:
+                    st.json(json.loads(vision) if isinstance(vision, str) else vision)
+                except Exception:
+                    st.text(vision)
+            else:
+                st.info("No lab data was processed. Provide lab results to activate the targeted pathway.")
+            trend = result.get("trend_notes", "")
+            if trend and trend not in ("No MIC data available for trend analysis", ""):
+                st.markdown("**MIC Trend Analysis**")
+                try:
+                    st.json(json.loads(trend) if isinstance(trend, str) else trend)
+                except Exception:
+                    st.text(trend)
+        with t4:
             warnings = result.get("safety_warnings", [])
             if warnings:
+                for w in warnings:
+                    st.markdown(f'<div class="badge-high">⚠ {w}</div>', unsafe_allow_html=True)
             else:
+                st.markdown('<div class="badge-low">✓ No safety concerns identified.</div>', unsafe_allow_html=True)
             errors = result.get("errors", [])
+            for err in errors:
+                st.error(err)
+def _demo_result(patient_data: dict, labs_raw_text) -> dict:
     result = {
         "stage": "targeted" if labs_raw_text else "empirical",
         "creatinine_clearance_ml_min": 58.3,
         "intake_notes": json.dumps({
+            "patient_summary": f"{patient_data.get('age_years')}-year-old {patient_data.get('sex')} · {patient_data.get('suspected_source', 'infection')}",
             "creatinine_clearance_ml_min": 58.3,
             "renal_dose_adjustment_needed": True,
             "identified_risk_factors": patient_data.get("comorbidities", []),
         }),
         "recommendation": {
             "primary_antibiotic": "Ciprofloxacin",
+            "dose": "500 mg",
+            "route": "Oral",
             "frequency": "Every 12 hours",
             "duration": "7 days",
+            "backup_antibiotic": "Nitrofurantoin 100 mg MR BD × 5 days",
+            "rationale": (
+                "Community-acquired UTI with moderate renal impairment (CrCl 58 mL/min). "
+                "Ciprofloxacin provides broad Gram-negative coverage. Dose standard — "
+                "no adjustment required above CrCl 30 mL/min."
+            ),
             "references": ["IDSA UTI Guidelines 2024", "EUCAST Breakpoint Tables v16.0"],
         },
         "safety_warnings": [],
         "errors": [],
     }
     if labs_raw_text:
         result["vision_notes"] = json.dumps({
             "specimen_type": "urine",
             "susceptibility_results": [
                 {"organism": "E. coli", "antibiotic": "Ciprofloxacin", "mic_value": 0.25, "interpretation": "S"},
                 {"organism": "E. coli", "antibiotic": "Nitrofurantoin", "mic_value": 16, "interpretation": "S"},
+                {"organism": "E. coli", "antibiotic": "Ampicillin", "mic_value": ">32", "interpretation": "R"},
             ],
             "extraction_confidence": 0.95,
         })
             "organism": "E. coli",
             "antibiotic": "Ciprofloxacin",
             "risk_level": "LOW",
+            "recommendation": "Continue current therapy — no MIC creep detected.",
         }])
     return result
+def page_clinical_tools():
+    st.markdown('<div class="section-title">Clinical Tools</div>', unsafe_allow_html=True)
+    tool = st.selectbox(
+        "Select tool",
+        ["Empirical Advisor", "MIC Interpreter", "MIC Trend Analysis", "Drug Safety Check"],
+        label_visibility="visible",
+    )
+    st.markdown("")
+    # ── Empirical Advisor ──
+    if tool == "Empirical Advisor":
+        c1, c2 = st.columns([3, 1])
+        with c1:
+            infection_type = st.selectbox(
+                "Infection type",
+                ["Urinary Tract Infection", "Pneumonia", "Sepsis", "Skin / Soft Tissue", "Intra-abdominal", "Meningitis"],
+            )
+            pathogen = st.text_input("Suspected pathogen (optional)", placeholder="e.g., Klebsiella pneumoniae")
+            risk = st.multiselect(
+                "Risk factors",
+                ["Prior MRSA", "Recent antibiotics (<90 d)", "Healthcare-associated", "Immunocompromised", "Renal impairment", "Prior MDR"],
+            )
+        with c2:
+            st.markdown(
+                '<div class="badge-info"><strong>WHO AWaRe</strong><br>'
+                '<span style="color:#145a32">●</span> Access — first-line<br>'
+                '<span style="color:#7a4a00">●</span> Watch — second-line<br>'
+                '<span style="color:#7b1d1d">●</span> Reserve — last resort</div>',
+                unsafe_allow_html=True,
             )
+        if st.button("Get recommendation", type="primary"):
+            with st.spinner("Searching clinical guidelines…"):
+                guidance = get_empirical_therapy_guidance(infection_type, risk)
             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})"):
                         st.markdown(rec.get("content", ""))
+                        st.caption(f"Source: {rec.get('source', 'IDSA Guidelines 2024')}")
+            if pathogen:
+                st.markdown(f"**Resistance data — {pathogen}**")
+                effective = get_most_effective_antibiotics(pathogen, min_susceptibility=70)
                 if effective:
+                    for ab in effective[:6]:
+                        st.write(f"- **{ab.get('antibiotic')}** — {ab.get('avg_susceptibility', 0):.1f}% susceptible")
                 else:
+                    st.info("No resistance data available for this pathogen.")
+    # ── MIC Interpreter ──
+    elif tool == "MIC Interpreter":
+        c1, c2 = st.columns(2)
+        with c1:
+            pathogen = st.text_input("Pathogen", placeholder="e.g., Escherichia coli")
+            antibiotic = st.text_input("Antibiotic", placeholder="e.g., Ciprofloxacin")
+            mic = st.number_input("MIC value (mg/L)", 0.001, 1024.0, 1.0, step=0.001, format="%.3f")
+        with c2:
+            st.markdown(
+                '<div class="badge-info" style="margin-top:28px">'
+                "<strong>Interpretation guide</strong><br><br>"
+                "<strong>S</strong> Susceptible — antibiotic is effective<br>"
+                "<strong>I</strong> Intermediate — effective at higher doses<br>"
+                "<strong>R</strong> Resistant — do not use</div>",
+                unsafe_allow_html=True,
+            )
+        if st.button("Interpret", type="primary"):
+            if pathogen and antibiotic:
+                result = interpret_mic_value(pathogen, antibiotic, mic)
+                interp = result.get("interpretation", "UNKNOWN")
+                msg = result.get("message", "")
+                if interp == "SUSCEPTIBLE":
+                    st.markdown(f'<div class="badge-low"><strong>Susceptible (S)</strong> — {msg}</div>', unsafe_allow_html=True)
+                elif interp == "RESISTANT":
+                    st.markdown(f'<div class="badge-high"><strong>Resistant (R)</strong> — {msg}</div>', unsafe_allow_html=True)
+                else:
+                    st.markdown(f'<div class="badge-moderate"><strong>Intermediate (I)</strong> — {msg}</div>', unsafe_allow_html=True)
+    # ── MIC Trend ──
+    elif tool == "MIC Trend Analysis":
+        n = st.slider("Number of historical readings", 2, 6, 3)
+        cols = st.columns(n)
+        mic_values = []
+        for i, col in enumerate(cols):
+            v = col.number_input(f"MIC {i + 1} (mg/L)", 0.001, 256.0, float(2 ** i), key=f"mic_{i}")
+            mic_values.append({"date": f"T{i}", "mic_value": v})
+        if st.button("Analyse trend", type="primary"):
+            result = calculate_mic_trend(mic_values)
+            risk = result.get("risk_level", "UNKNOWN")
+            alert = result.get("alert", "")
+            css = {"HIGH": "badge-high", "MODERATE": "badge-moderate"}.get(risk, "badge-low")
+            icon = {"HIGH": "🚨", "MODERATE": "⚠"}.get(risk, "✓")
+            st.markdown(f'<div class="{css}">{icon} <strong>{risk} RISK</strong> — {alert}</div>', unsafe_allow_html=True)
+            c1, c2, c3 = st.columns(3)
+            c1.metric("Baseline MIC", f"{result.get('baseline_mic', '—')} mg/L")
+            c2.metric("Current MIC", f"{result.get('current_mic', '—')} mg/L")
+            c3.metric("Fold change", f"{result.get('ratio', '—')}×")
+    # ── Drug Safety ──
+    elif tool == "Drug Safety Check":
+        c1, c2 = st.columns(2)
+        with c1:
+            ab = st.text_input("Antibiotic to check", placeholder="e.g., Ciprofloxacin")
+            meds = st.text_area("Concurrent medications", placeholder="Warfarin\nMetformin\nAmlodipine", height=120)
+        with c2:
+            allergies = st.text_area("Known allergies", placeholder="Penicillin\nSulfa", height=100)
+        if st.button("Check safety", type="primary"):
+            if ab:
+                med_list = [m.strip() for m in meds.split("\n") if m.strip()]
+                allergy_list = [a.strip() for a in allergies.split("\n") if a.strip()]
+                result = screen_antibiotic_safety(ab, med_list, allergy_list)
+                if result.get("safe_to_use"):
+                    st.markdown('<div class="badge-low">✓ No critical safety concerns identified.</div>', unsafe_allow_html=True)
+                else:
+                    st.markdown('<div class="badge-high">⚠ Safety concerns identified — review required.</div>', unsafe_allow_html=True)
+                for alert in result.get("alerts", []):
+                    st.markdown(f'<div class="badge-moderate" style="margin-top:8px">⚠ {alert.get("message", "")}</div>', unsafe_allow_html=True)
+def page_guidelines():
+    st.markdown('<div class="section-title">Clinical Guidelines Search</div>', unsafe_allow_html=True)
+    query = st.text_input("Search query", placeholder="e.g., ESBL E. coli UTI treatment carbapenems")
+    pathogen_filter = st.selectbox("Filter by pathogen", ["All", "ESBL-E", "CRE", "CRAB", "DTR-PA"])
     if st.button("Search", type="primary"):
         if query:
+            with st.spinner("Searching knowledge base…"):
+                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", ""))
+                        if r.get("source"):
+                            st.caption(f"Source: {r['source']}")
             else:
+                st.info("No results found. Try broader search terms or check that the knowledge base has been initialised.")
+    st.markdown(
+        '<div class="disclaimer">Sources: IDSA Treatment Guidelines 2024 · '
+        "EUCAST Breakpoint Tables v16.0 · WHO EML · DDInter drug interaction database.</div>",
+        unsafe_allow_html=True,
+    )
+# ── Router ────────────────────────────────────────────────────────────────────
+if page == "Dashboard":
+    page_dashboard()
+elif page == "Patient Analysis":
+    page_patient_analysis()
+elif page == "Clinical Tools":
+    page_clinical_tools()
+elif page == "Guidelines":
+    page_guidelines()

notebooks/kaggle_medic_demo.ipynb CHANGED Viewed

@@ -4,30 +4,22 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "# Med-I-C: AMR-Guard - Infection Lifecycle Orchestrator\n",
     "\n",
-    "## MedGemma Impact Challenge Submission\n",
-    "\n",
-    "This notebook demonstrates the **Med-I-C** multi-agent system for antimicrobial stewardship:\n",
-    "\n",
-    "**4-Agent Architecture:**\n",
-    "1. **Intake Historian** - Parse patient data, calculate CrCl, identify risk factors\n",
-    "2. **Vision Specialist** - Extract structured data from lab reports (any language)\n",
-    "3. **Trend Analyst** - Detect MIC creep and resistance velocity\n",
-    "4. **Clinical Pharmacologist** - Final Rx recommendations with safety checks\n",
-    "\n",
-    "**Two Pathways:**\n",
-    "- **Stage 1 (Empirical)**: Agent 1 → Agent 4 (before lab results)\n",
-    "- **Stage 2 (Targeted)**: Agent 1 → Agent 2 → Agent 3 → Agent 4 (with lab results)\n",
-    "\n",
-    "---"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## 1. Environment Setup"
    ]
   },
   {
@@ -36,25 +28,12 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "# Check GPU availability\n",
-    "import subprocess\n",
-    "result = subprocess.run(['nvidia-smi'], capture_output=True, text=True)\n",
-    "print(result.stdout)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "%%capture\n",
-    "# Install dependencies\n",
-    "!pip install -q langgraph>=0.0.15 langchain>=0.3.0 langchain-text-splitters\n",
-    "!pip install -q chromadb>=0.4.0 sentence-transformers\n",
-    "!pip install -q transformers>=4.50.0 torch accelerate bitsandbytes\n",
-    "!pip install -q pydantic>=2.0 python-dotenv openpyxl requests pypdf pandas\n",
-    "!pip install -q huggingface_hub"
    ]
   },
   {
@@ -63,19 +42,14 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "import os\n",
-    "import sys\n",
-    "import json\n",
-    "import logging\n",
-    "from pathlib import Path\n",
-    "from typing import Any, Dict, List, Optional, Literal\n",
-    "\n",
-    "import torch\n",
-    "print(f\"PyTorch version: {torch.__version__}\")\n",
-    "print(f\"CUDA available: {torch.cuda.is_available()}\")\n",
-    "if torch.cuda.is_available():\n",
-    "    print(f\"CUDA device: {torch.cuda.get_device_name(0)}\")\n",
-    "    print(f\"CUDA memory: {torch.cuda.get_device_properties(0).total_memory / 1e9:.1f} GB\")"
    ]
   },
   {
@@ -84,22 +58,26 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "# Configure logging\n",
-    "logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')\n",
-    "logger = logging.getLogger('MedIC')"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## 2. Hugging Face Authentication\n",
     "\n",
-    "MedGemma and TxGemma require accepting the license on Hugging Face.\n",
     "\n",
-    "1. Go to https://huggingface.co/google/medgemma-4b-it and accept the license\n",
-    "2. Go to https://huggingface.co/google/txgemma-2b-predict and accept the license\n",
-    "3. Add your HF token to Kaggle Secrets as `HF_TOKEN`"
    ]
   },
   {
@@ -108,32 +86,26 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "# Authenticate with Hugging Face\n",
     "from huggingface_hub import login\n",
     "\n",
-    "# Try to get token from Kaggle secrets\n",
     "try:\n",
     "    from kaggle_secrets import UserSecretsClient\n",
-    "    user_secrets = UserSecretsClient()\n",
-    "    HF_TOKEN = user_secrets.get_secret(\"HF_TOKEN\")\n",
-    "    print(\"Using HF token from Kaggle secrets\")\n",
-    "except:\n",
-    "    # Fallback: set your token here for local testing\n",
-    "    HF_TOKEN = os.environ.get(\"HF_TOKEN\", \"\")\n",
-    "    if HF_TOKEN:\n",
-    "        print(\"Using HF token from environment\")\n",
-    "    else:\n",
-    "        print(\"WARNING: No HF token found. You may need to authenticate manually.\")\n",
     "\n",
-    "if HF_TOKEN:\n",
-    "    login(token=HF_TOKEN)"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## 3. Model Configuration & Loading"
    ]
   },
   {
@@ -142,238 +114,17 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "# Model configuration\n",
-    "MODEL_CONFIG = {\n",
-    "    \"medgemma_4b\": {\n",
-    "        \"model_id\": \"google/medgemma-4b-it\",\n",
-    "        \"description\": \"MedGemma 4B Instruction-Tuned - Primary model for all agents\",\n",
-    "        \"use_4bit\": True,  # Use 4-bit quantization for memory efficiency\n",
-    "    },\n",
-    "    \"medgemma_27b\": {\n",
-    "        \"model_id\": \"google/medgemma-27b-text-it\",\n",
-    "        \"description\": \"MedGemma 27B Text IT - For complex trend analysis (requires high VRAM)\",\n",
-    "        \"use_4bit\": True,\n",
-    "    },\n",
-    "    \"txgemma_9b\": {\n",
-    "        \"model_id\": \"google/txgemma-9b-predict\",\n",
-    "        \"description\": \"TxGemma 9B - Drug safety validation\",\n",
-    "        \"use_4bit\": True,\n",
-    "    },\n",
-    "    \"txgemma_2b\": {\n",
-    "        \"model_id\": \"google/txgemma-2b-predict\",\n",
-    "        \"description\": \"TxGemma 2B - Lightweight safety checker fallback\",\n",
-    "        \"use_4bit\": False,  # Small enough to run without quantization\n",
-    "    },\n",
-    "}\n",
     "\n",
-    "# Display model info\n",
-    "print(\"Available Models:\")\n",
-    "for name, config in MODEL_CONFIG.items():\n",
-    "    print(f\"  - {name}: {config['description']}\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig\n",
-    "\n",
-    "# Cache for loaded models\n",
-    "_model_cache = {}\n",
-    "_tokenizer_cache = {}\n",
-    "\n",
-    "def load_model(model_name: str = \"medgemma_4b\", force_reload: bool = False):\n",
-    "    \"\"\"\n",
-    "    Load a model from Hugging Face with optional 4-bit quantization.\n",
-    "    \n",
-    "    Args:\n",
-    "        model_name: Key from MODEL_CONFIG\n",
-    "        force_reload: Force reload even if cached\n",
-    "    \n",
-    "    Returns:\n",
-    "        Tuple of (model, tokenizer)\n",
-    "    \"\"\"\n",
-    "    global _model_cache, _tokenizer_cache\n",
-    "    \n",
-    "    if not force_reload and model_name in _model_cache:\n",
-    "        print(f\"Using cached {model_name}\")\n",
-    "        return _model_cache[model_name], _tokenizer_cache[model_name]\n",
-    "    \n",
-    "    config = MODEL_CONFIG.get(model_name)\n",
-    "    if not config:\n",
-    "        raise ValueError(f\"Unknown model: {model_name}. Available: {list(MODEL_CONFIG.keys())}\")\n",
-    "    \n",
-    "    model_id = config[\"model_id\"]\n",
-    "    use_4bit = config.get(\"use_4bit\", True)\n",
-    "    \n",
-    "    print(f\"Loading {model_name} ({model_id})...\")\n",
-    "    \n",
-    "    # Configure quantization\n",
-    "    load_kwargs = {\n",
-    "        \"device_map\": \"auto\",\n",
-    "        \"trust_remote_code\": True,\n",
-    "    }\n",
-    "    \n",
-    "    if use_4bit and torch.cuda.is_available():\n",
-    "        print(\"  Using 4-bit quantization...\")\n",
-    "        bnb_config = BitsAndBytesConfig(\n",
-    "            load_in_4bit=True,\n",
-    "            bnb_4bit_quant_type=\"nf4\",\n",
-    "            bnb_4bit_compute_dtype=torch.float16,\n",
-    "            bnb_4bit_use_double_quant=True,\n",
-    "        )\n",
-    "        load_kwargs[\"quantization_config\"] = bnb_config\n",
-    "    \n",
-    "    # Load tokenizer\n",
-    "    tokenizer = AutoTokenizer.from_pretrained(model_id, trust_remote_code=True)\n",
-    "    if tokenizer.pad_token is None:\n",
-    "        tokenizer.pad_token = tokenizer.eos_token\n",
-    "    \n",
-    "    # Load model\n",
-    "    model = AutoModelForCausalLM.from_pretrained(model_id, **load_kwargs)\n",
-    "    model.eval()\n",
-    "    \n",
-    "    # Cache\n",
-    "    _model_cache[model_name] = model\n",
-    "    _tokenizer_cache[model_name] = tokenizer\n",
-    "    \n",
-    "    print(f\"  Loaded successfully!\")\n",
-    "    return model, tokenizer"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def run_inference(\n",
-    "    prompt: str,\n",
-    "    model_name: str = \"medgemma_4b\",\n",
-    "    max_new_tokens: int = 512,\n",
-    "    temperature: float = 0.2,\n",
-    "    do_sample: bool = True,\n",
-    ") -> str:\n",
-    "    \"\"\"\n",
-    "    Run inference on a loaded model.\n",
-    "    \n",
-    "    Args:\n",
-    "        prompt: Input prompt\n",
-    "        model_name: Which model to use\n",
-    "        max_new_tokens: Maximum tokens to generate\n",
-    "        temperature: Sampling temperature\n",
-    "        do_sample: Whether to use sampling\n",
-    "    \n",
-    "    Returns:\n",
-    "        Generated text (completion only, not including prompt)\n",
-    "    \"\"\"\n",
-    "    model, tokenizer = load_model(model_name)\n",
-    "    \n",
-    "    # Tokenize\n",
-    "    inputs = tokenizer(prompt, return_tensors=\"pt\", truncation=True, max_length=4096)\n",
-    "    inputs = {k: v.to(model.device) for k, v in inputs.items()}\n",
-    "    \n",
-    "    # Generate\n",
-    "    with torch.no_grad():\n",
-    "        outputs = model.generate(\n",
-    "            **inputs,\n",
-    "            max_new_tokens=max_new_tokens,\n",
-    "            temperature=temperature if do_sample else None,\n",
-    "            do_sample=do_sample,\n",
-    "            pad_token_id=tokenizer.pad_token_id,\n",
-    "            eos_token_id=tokenizer.eos_token_id,\n",
-    "        )\n",
-    "    \n",
-    "    # Decode only the generated part\n",
-    "    generated_ids = outputs[0, inputs[\"input_ids\"].shape[1]:]\n",
-    "    response = tokenizer.decode(generated_ids, skip_special_tokens=True)\n",
-    "    \n",
-    "    return response.strip()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 4. Load Primary Model (MedGemma 4B)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Load the primary model\n",
-    "print(\"Loading MedGemma 4B IT (primary model for all agents)...\")\n",
-    "model, tokenizer = load_model(\"medgemma_4b\")\n",
     "\n",
-    "# Quick test\n",
-    "test_response = run_inference(\n",
-    "    \"What is ESBL? Answer in one sentence.\",\n",
-    "    model_name=\"medgemma_4b\",\n",
-    "    max_new_tokens=100,\n",
     ")\n",
-    "print(f\"\\nTest response: {test_response}\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 5. Utility Functions"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Creatinine Clearance Calculator (Cockcroft-Gault equation)\n",
-    "\n",
-    "def calculate_crcl(\n",
-    "    age_years: float,\n",
-    "    weight_kg: float,\n",
-    "    serum_creatinine_mg_dl: float,\n",
-    "    sex: Literal[\"male\", \"female\"],\n",
-    "    height_cm: Optional[float] = None,\n",
-    ") -> float:\n",
-    "    \"\"\"\n",
-    "    Calculate Creatinine Clearance using the Cockcroft-Gault equation.\n",
-    "    \n",
-    "    Formula: CrCl = [(140 - age) x weight x (0.85 if female)] / (72 x SCr)\n",
-    "    \"\"\"\n",
-    "    if serum_creatinine_mg_dl <= 0:\n",
-    "        raise ValueError(\"Serum creatinine must be positive\")\n",
-    "    \n",
-    "    crcl = ((140 - age_years) * weight_kg) / (72 * serum_creatinine_mg_dl)\n",
-    "    \n",
-    "    if sex == \"female\":\n",
-    "        crcl *= 0.85\n",
-    "    \n",
-    "    return round(crcl, 1)\n",
-    "\n",
-    "\n",
-    "def get_renal_dose_category(crcl: float) -> str:\n",
-    "    \"\"\"Categorize renal function for dosing.\"\"\"\n",
-    "    if crcl >= 90:\n",
-    "        return \"normal\"\n",
-    "    elif crcl >= 60:\n",
-    "        return \"mild_impairment\"\n",
-    "    elif crcl >= 30:\n",
-    "        return \"moderate_impairment\"\n",
-    "    elif crcl >= 15:\n",
-    "        return \"severe_impairment\"\n",
-    "    else:\n",
-    "        return \"esrd\"\n",
-    "\n",
-    "\n",
-    "# Test CrCl calculation\n",
-    "test_crcl = calculate_crcl(age_years=65, weight_kg=70, serum_creatinine_mg_dl=1.2, sex=\"male\")\n",
-    "print(f\"Test CrCl: {test_crcl} mL/min ({get_renal_dose_category(test_crcl)})\")"
    ]
   },
   {
@@ -382,43 +133,17 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "import re\n",
-    "\n",
-    "def safe_json_parse(text: str) -> Optional[Dict[str, Any]]:\n",
-    "    \"\"\"Safely parse JSON from agent output, handling markdown code blocks.\"\"\"\n",
-    "    if not text:\n",
-    "        return None\n",
-    "    \n",
-    "    # Try direct parse\n",
-    "    try:\n",
-    "        return json.loads(text)\n",
-    "    except json.JSONDecodeError:\n",
-    "        pass\n",
-    "    \n",
-    "    # Try extracting from markdown code blocks\n",
-    "    patterns = [\n",
-    "        r\"```json\\s*\\n?(.*?)\\n?```\",\n",
-    "        r\"```\\s*\\n?(.*?)\\n?```\",\n",
-    "        r\"\\{[\\s\\S]*\\}\",\n",
-    "    ]\n",
-    "    \n",
-    "    for pattern in patterns:\n",
-    "        match = re.search(pattern, text, re.DOTALL)\n",
-    "        if match:\n",
-    "            try:\n",
-    "                json_str = match.group(1) if match.lastindex else match.group(0)\n",
-    "                return json.loads(json_str)\n",
-    "            except (json.JSONDecodeError, IndexError):\n",
-    "                continue\n",
-    "    \n",
-    "    return None"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## 6. Agent Prompt Templates"
    ]
   },
   {
@@ -427,53 +152,27 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "# Agent 1: Intake Historian\n",
-    "INTAKE_HISTORIAN_SYSTEM = \"\"\"You are an expert clinical intake specialist. Your role is to:\n",
-    "\n",
-    "1. Parse and structure patient demographics and clinical history\n",
-    "2. Calculate Creatinine Clearance (CrCl) using the Cockcroft-Gault equation when data is available\n",
-    "3. Identify key risk factors for antimicrobial-resistant infections\n",
-    "4. Determine the appropriate treatment stage (empirical vs targeted)\n",
-    "\n",
-    "RISK FACTORS TO IDENTIFY:\n",
-    "- Prior MRSA or MDR infection history\n",
-    "- Recent antibiotic use (within 90 days)\n",
-    "- Healthcare-associated vs community-acquired infection\n",
-    "- Immunocompromised status\n",
-    "- Recent hospitalization or ICU stay\n",
-    "- Presence of medical devices (catheters, lines)\n",
-    "- Renal or hepatic impairment\n",
     "\n",
-    "OUTPUT FORMAT:\n",
-    "Provide a structured JSON response with the following fields:\n",
-    "{\n",
-    "    \"patient_summary\": \"Brief clinical summary\",\n",
-    "    \"creatinine_clearance_ml_min\": <number or null>,\n",
-    "    \"renal_dose_adjustment_needed\": <boolean>,\n",
-    "    \"identified_risk_factors\": [\"list\", \"of\", \"factors\"],\n",
-    "    \"suspected_pathogens\": [\"list\", \"of\", \"likely\", \"organisms\"],\n",
-    "    \"infection_severity\": \"mild|moderate|severe|critical\",\n",
-    "    \"recommended_stage\": \"empirical|targeted\",\n",
-    "    \"notes\": \"Any additional clinical observations\"\n",
-    "}\n",
-    "\"\"\"\n",
     "\n",
-    "INTAKE_HISTORIAN_PROMPT = \"\"\"Analyze the following patient information and provide a structured clinical assessment.\n",
     "\n",
-    "PATIENT DATA:\n",
-    "{patient_data}\n",
     "\n",
-    "CURRENT MEDICATIONS:\n",
-    "{medications}\n",
-    "\n",
-    "KNOWN ALLERGIES:\n",
-    "{allergies}\n",
-    "\n",
-    "CLINICAL CONTEXT:\n",
-    "- Suspected infection site: {infection_site}\n",
-    "- Suspected source: {suspected_source}\n",
-    "\n",
-    "Provide your structured assessment following the system instructions.\"\"\""
    ]
   },
   {
@@ -482,797 +181,18 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "# Agent 2: Vision Specialist\n",
-    "VISION_SPECIALIST_SYSTEM = \"\"\"You are an expert medical laboratory data extraction specialist. Your role is to:\n",
-    "\n",
-    "1. Extract structured data from laboratory reports (culture & sensitivity, antibiograms)\n",
-    "2. Handle reports in ANY language - always output in English\n",
-    "3. Identify pathogens, antibiotics tested, MIC values, and S/I/R interpretations\n",
-    "4. Flag any critical or unusual findings\n",
-    "\n",
-    "OUTPUT FORMAT:\n",
-    "Provide a structured JSON response:\n",
-    "{\n",
-    "    \"specimen_type\": \"blood|urine|wound|respiratory|other\",\n",
-    "    \"collection_date\": \"YYYY-MM-DD or null\",\n",
-    "    \"identified_organisms\": [\n",
-    "        {\n",
-    "            \"organism_name\": \"Standardized English name\",\n",
-    "            \"colony_count\": \"if available\",\n",
-    "            \"significance\": \"pathogen|colonizer|contaminant\"\n",
-    "        }\n",
-    "    ],\n",
-    "    \"susceptibility_results\": [\n",
-    "        {\n",
-    "            \"organism\": \"Organism name\",\n",
-    "            \"antibiotic\": \"Standardized antibiotic name\",\n",
-    "            \"mic_value\": <number or null>,\n",
-    "            \"mic_unit\": \"mg/L\",\n",
-    "            \"interpretation\": \"S|I|R\"\n",
-    "        }\n",
-    "    ],\n",
-    "    \"critical_findings\": [\"List of urgent findings\"],\n",
-    "    \"extraction_confidence\": 0.0-1.0\n",
-    "}\n",
-    "\"\"\"\n",
-    "\n",
-    "VISION_SPECIALIST_PROMPT = \"\"\"Extract structured laboratory data from the following report.\n",
-    "\n",
-    "REPORT CONTENT:\n",
-    "{report_content}\n",
-    "\n",
-    "Extract all pathogen identifications, susceptibility results, and MIC values.\n",
-    "Always standardize to English medical terminology.\n",
-    "Flag any critical findings that require urgent attention.\n",
-    "\n",
-    "Provide your structured extraction following the system instructions.\"\"\""
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Agent 3: Trend Analyst\n",
-    "TREND_ANALYST_SYSTEM = \"\"\"You are an expert antimicrobial resistance trend analyst. Your role is to:\n",
-    "\n",
-    "1. Analyze MIC trends over time to detect \"MIC Creep\"\n",
-    "2. Calculate resistance velocity and predict treatment failure risk\n",
-    "3. Compare current MICs against EUCAST/CLSI breakpoints\n",
-    "4. Identify emerging resistance patterns\n",
-    "\n",
-    "RISK STRATIFICATION:\n",
-    "- LOW: Stable MIC, well below breakpoint (>4x margin)\n",
-    "- MODERATE: Rising trend but still 2-4x below breakpoint\n",
-    "- HIGH: Approaching breakpoint (<2x margin) or rapid increase\n",
-    "- CRITICAL: At or above breakpoint, or >4-fold increase over baseline\n",
-    "\n",
-    "OUTPUT FORMAT:\n",
-    "{\n",
-    "    \"organism\": \"Pathogen name\",\n",
-    "    \"antibiotic\": \"Antibiotic name\",\n",
-    "    \"baseline_mic\": <number>,\n",
-    "    \"current_mic\": <number>,\n",
-    "    \"fold_change\": <number>,\n",
-    "    \"trend\": \"stable|increasing|decreasing\",\n",
-    "    \"breakpoint_susceptible\": <number>,\n",
-    "    \"margin_to_breakpoint\": <number>,\n",
-    "    \"risk_level\": \"LOW|MODERATE|HIGH|CRITICAL\",\n",
-    "    \"recommendation\": \"Continue current therapy|Consider alternatives|Urgent switch needed\",\n",
-    "    \"rationale\": \"Detailed explanation\"\n",
-    "}\n",
-    "\"\"\"\n",
-    "\n",
-    "TREND_ANALYST_PROMPT = \"\"\"Analyze the MIC trend data and assess resistance risk.\n",
-    "\n",
-    "ORGANISM: {organism}\n",
-    "ANTIBIOTIC: {antibiotic}\n",
-    "\n",
-    "HISTORICAL MIC DATA:\n",
-    "{mic_history}\n",
-    "\n",
-    "EUCAST BREAKPOINT (S <=): {breakpoint} mg/L\n",
-    "\n",
-    "Analyze the trend, calculate risk level, and provide recommendations.\n",
-    "Follow the system instructions for output format.\"\"\""
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Agent 4: Clinical Pharmacologist\n",
-    "CLINICAL_PHARMACOLOGIST_SYSTEM = \"\"\"You are an expert clinical pharmacologist specializing in infectious diseases and antimicrobial stewardship. Your role is to:\n",
-    "\n",
-    "1. Synthesize all available clinical data into a final antibiotic recommendation\n",
-    "2. Apply WHO AWaRe classification principles (ACCESS -> WATCH -> RESERVE)\n",
-    "3. Perform comprehensive drug safety checks\n",
-    "4. Adjust dosing for renal function\n",
-    "\n",
-    "PRESCRIBING PRINCIPLES:\n",
-    "1. Start narrow, escalate only when justified\n",
-    "2. De-escalate when culture results allow\n",
-    "3. Prefer ACCESS category antibiotics when appropriate\n",
-    "4. Consider pharmacokinetic/pharmacodynamic (PK/PD) optimization\n",
-    "\n",
-    "OUTPUT FORMAT:\n",
-    "{\n",
-    "    \"primary_recommendation\": {\n",
-    "        \"antibiotic\": \"Drug name\",\n",
-    "        \"dose\": \"Amount and unit\",\n",
-    "        \"route\": \"IV|PO|IM\",\n",
-    "        \"frequency\": \"Dosing interval\",\n",
-    "        \"duration\": \"Treatment duration\",\n",
-    "        \"aware_category\": \"ACCESS|WATCH|RESERVE\"\n",
-    "    },\n",
-    "    \"alternative_recommendation\": {\n",
-    "        \"antibiotic\": \"Alternative drug\",\n",
-    "        \"indication\": \"When to use alternative\"\n",
-    "    },\n",
-    "    \"dose_adjustments\": {\n",
-    "        \"renal\": \"Adjustment details or None needed\"\n",
-    "    },\n",
-    "    \"safety_alerts\": [\n",
-    "        {\n",
-    "            \"level\": \"INFO|WARNING|CRITICAL\",\n",
-    "            \"message\": \"Alert message\"\n",
-    "        }\n",
-    "    ],\n",
-    "    \"monitoring_parameters\": [\"Labs/vitals to monitor\"],\n",
-    "    \"rationale\": \"Clinical reasoning\",\n",
-    "    \"guideline_references\": [\"Supporting guidelines\"]\n",
-    "}\n",
-    "\"\"\"\n",
-    "\n",
-    "CLINICAL_PHARMACOLOGIST_PROMPT = \"\"\"Synthesize all clinical data and provide a final antibiotic recommendation.\n",
-    "\n",
-    "PATIENT SUMMARY:\n",
-    "{intake_summary}\n",
-    "\n",
-    "LAB RESULTS:\n",
-    "{lab_results}\n",
-    "\n",
-    "MIC TREND ANALYSIS:\n",
-    "{trend_analysis}\n",
-    "\n",
-    "PATIENT PARAMETERS:\n",
-    "- Age: {age} years\n",
-    "- Weight: {weight} kg\n",
-    "- CrCl: {crcl} mL/min\n",
-    "- Allergies: {allergies}\n",
-    "- Current medications: {current_medications}\n",
-    "\n",
-    "INFECTION CONTEXT:\n",
-    "- Site: {infection_site}\n",
-    "- Severity: {severity}\n",
-    "\n",
-    "Provide your final recommendation following the system instructions.\"\"\""
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 7. Agent Implementation"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# State type definition\n",
-    "from typing import TypedDict, NotRequired\n",
-    "\n",
-    "class InfectionState(TypedDict, total=False):\n",
-    "    \"\"\"Global state for the Med-I-C pipeline.\"\"\"\n",
-    "    # Patient data\n",
-    "    patient_id: Optional[str]\n",
-    "    age_years: Optional[float]\n",
-    "    sex: Optional[Literal[\"male\", \"female\"]]\n",
-    "    weight_kg: Optional[float]\n",
-    "    height_cm: Optional[float]\n",
-    "    \n",
-    "    # Clinical context\n",
-    "    suspected_source: Optional[str]\n",
-    "    comorbidities: List[str]\n",
-    "    medications: List[str]\n",
-    "    allergies: List[str]\n",
-    "    infection_site: Optional[str]\n",
-    "    \n",
-    "    # Renal function\n",
-    "    serum_creatinine_mg_dl: Optional[float]\n",
-    "    creatinine_clearance_ml_min: Optional[float]\n",
-    "    \n",
-    "    # Lab data\n",
-    "    labs_raw_text: Optional[str]\n",
-    "    mic_data: List[Dict[str, Any]]\n",
-    "    \n",
-    "    # Stage routing\n",
-    "    stage: Literal[\"empirical\", \"targeted\"]\n",
-    "    route_to_vision: bool\n",
-    "    route_to_trend_analyst: bool\n",
-    "    \n",
-    "    # Agent outputs\n",
-    "    intake_notes: Optional[str]\n",
-    "    vision_notes: Optional[str]\n",
-    "    trend_notes: Optional[str]\n",
-    "    pharmacology_notes: Optional[str]\n",
-    "    recommendation: Optional[Dict[str, Any]]\n",
-    "    \n",
-    "    # Safety\n",
-    "    safety_warnings: List[str]\n",
-    "    errors: List[str]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def run_intake_historian(state: InfectionState) -> InfectionState:\n",
-    "    \"\"\"\n",
-    "    Agent 1: Parse patient data, calculate CrCl, identify risk factors.\n",
-    "    \"\"\"\n",
-    "    print(\"\\n\" + \"=\"*60)\n",
-    "    print(\"AGENT 1: INTAKE HISTORIAN\")\n",
-    "    print(\"=\"*60)\n",
-    "    \n",
-    "    # Calculate CrCl if we have required data\n",
-    "    crcl = None\n",
-    "    if all([state.get(\"age_years\"), state.get(\"weight_kg\"), \n",
-    "            state.get(\"serum_creatinine_mg_dl\"), state.get(\"sex\")]):\n",
-    "        crcl = calculate_crcl(\n",
-    "            age_years=state[\"age_years\"],\n",
-    "            weight_kg=state[\"weight_kg\"],\n",
-    "            serum_creatinine_mg_dl=state[\"serum_creatinine_mg_dl\"],\n",
-    "            sex=state[\"sex\"],\n",
-    "        )\n",
-    "        state[\"creatinine_clearance_ml_min\"] = crcl\n",
-    "        print(f\"Calculated CrCl: {crcl} mL/min ({get_renal_dose_category(crcl)})\")\n",
-    "    \n",
-    "    # Build patient data string\n",
-    "    patient_data = f\"\"\"\n",
-    "Age: {state.get('age_years', 'Unknown')} years\n",
-    "Sex: {state.get('sex', 'Unknown')}\n",
-    "Weight: {state.get('weight_kg', 'Unknown')} kg\n",
-    "Serum Creatinine: {state.get('serum_creatinine_mg_dl', 'Unknown')} mg/dL\n",
-    "CrCl: {crcl or 'Not calculated'} mL/min\n",
-    "Comorbidities: {', '.join(state.get('comorbidities', [])) or 'None reported'}\n",
-    "\"\"\"\n",
-    "    \n",
-    "    # Build prompt\n",
-    "    prompt = f\"{INTAKE_HISTORIAN_SYSTEM}\\n\\n{INTAKE_HISTORIAN_PROMPT.format(\n",
-    "        patient_data=patient_data,\n",
-    "        medications=', '.join(state.get('medications', [])) or 'None reported',\n",
-    "        allergies=', '.join(state.get('allergies', [])) or 'No known allergies',\n",
-    "        infection_site=state.get('infection_site', 'Unknown'),\n",
-    "        suspected_source=state.get('suspected_source', 'Unknown'),\n",
-    "    )}\"\"\"\n",
-    "    \n",
-    "    # Run inference\n",
-    "    print(\"Running MedGemma inference...\")\n",
-    "    response = run_inference(prompt, model_name=\"medgemma_4b\", max_new_tokens=1024)\n",
-    "    \n",
-    "    # Parse response\n",
-    "    parsed = safe_json_parse(response)\n",
-    "    if parsed:\n",
-    "        state[\"intake_notes\"] = json.dumps(parsed, indent=2)\n",
-    "        state[\"stage\"] = parsed.get(\"recommended_stage\", \"empirical\")\n",
-    "        print(f\"\\nIntake Assessment:\")\n",
-    "        print(json.dumps(parsed, indent=2))\n",
-    "    else:\n",
-    "        state[\"intake_notes\"] = response\n",
-    "        state[\"stage\"] = \"empirical\"\n",
-    "        print(f\"\\nRaw response: {response[:500]}...\")\n",
-    "    \n",
-    "    # Determine routing\n",
-    "    state[\"route_to_vision\"] = bool(state.get(\"labs_raw_text\"))\n",
-    "    print(f\"\\nStage: {state['stage']}\")\n",
-    "    print(f\"Route to Vision Specialist: {state['route_to_vision']}\")\n",
-    "    \n",
-    "    return state"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def run_vision_specialist(state: InfectionState) -> InfectionState:\n",
-    "    \"\"\"\n",
-    "    Agent 2: Extract structured data from lab reports.\n",
-    "    \"\"\"\n",
-    "    print(\"\\n\" + \"=\"*60)\n",
-    "    print(\"AGENT 2: VISION SPECIALIST\")\n",
-    "    print(\"=\"*60)\n",
-    "    \n",
-    "    labs_raw = state.get(\"labs_raw_text\", \"\")\n",
-    "    if not labs_raw:\n",
-    "        print(\"No lab data to process, skipping.\")\n",
-    "        state[\"vision_notes\"] = \"No lab data provided\"\n",
-    "        state[\"route_to_trend_analyst\"] = False\n",
-    "        return state\n",
-    "    \n",
-    "    # Build prompt\n",
-    "    prompt = f\"{VISION_SPECIALIST_SYSTEM}\\n\\n{VISION_SPECIALIST_PROMPT.format(\n",
-    "        report_content=labs_raw,\n",
-    "    )}\"\n",
-    "    \n",
-    "    # Run inference\n",
-    "    print(\"Running MedGemma inference on lab report...\")\n",
-    "    response = run_inference(prompt, model_name=\"medgemma_4b\", max_new_tokens=2048)\n",
-    "    \n",
-    "    # Parse response\n",
-    "    parsed = safe_json_parse(response)\n",
-    "    if parsed:\n",
-    "        state[\"vision_notes\"] = json.dumps(parsed, indent=2)\n",
-    "        \n",
-    "        # Extract MIC data\n",
-    "        susceptibility = parsed.get(\"susceptibility_results\", [])\n",
-    "        state[\"mic_data\"] = susceptibility\n",
-    "        state[\"route_to_trend_analyst\"] = len(susceptibility) > 0\n",
-    "        \n",
-    "        print(f\"\\nExtracted Lab Data:\")\n",
-    "        print(json.dumps(parsed, indent=2))\n",
-    "        \n",
-    "        # Check for critical findings\n",
-    "        critical = parsed.get(\"critical_findings\", [])\n",
-    "        if critical:\n",
-    "            print(f\"\\n⚠️ CRITICAL FINDINGS: {critical}\")\n",
-    "            state.setdefault(\"safety_warnings\", []).extend(critical)\n",
-    "    else:\n",
-    "        state[\"vision_notes\"] = response\n",
-    "        state[\"route_to_trend_analyst\"] = False\n",
-    "        print(f\"\\nRaw response: {response[:500]}...\")\n",
-    "    \n",
-    "    print(f\"\\nMIC data points: {len(state.get('mic_data', []))}\")\n",
-    "    print(f\"Route to Trend Analyst: {state.get('route_to_trend_analyst', False)}\")\n",
-    "    \n",
-    "    return state"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def run_trend_analyst(state: InfectionState) -> InfectionState:\n",
-    "    \"\"\"\n",
-    "    Agent 3: Analyze MIC trends and detect resistance velocity.\n",
-    "    \"\"\"\n",
-    "    print(\"\\n\" + \"=\"*60)\n",
-    "    print(\"AGENT 3: TREND ANALYST\")\n",
-    "    print(\"=\"*60)\n",
-    "    \n",
-    "    mic_data = state.get(\"mic_data\", [])\n",
-    "    if not mic_data:\n",
-    "        print(\"No MIC data to analyze, skipping.\")\n",
-    "        state[\"trend_notes\"] = \"No MIC data available\"\n",
-    "        return state\n",
-    "    \n",
-    "    trend_results = []\n",
-    "    \n",
-    "    for mic in mic_data:\n",
-    "        organism = mic.get(\"organism\", \"Unknown\")\n",
-    "        antibiotic = mic.get(\"antibiotic\", \"Unknown\")\n",
-    "        mic_value = mic.get(\"mic_value\")\n",
-    "        \n",
-    "        if mic_value is None:\n",
-    "            continue\n",
-    "        \n",
-    "        # For demo, create synthetic history showing increasing trend\n",
-    "        mic_history = json.dumps([\n",
-    "            {\"date\": \"2024-01-01\", \"mic_value\": float(mic_value) / 2},\n",
-    "            {\"date\": \"2024-06-01\", \"mic_value\": float(mic_value) / 1.5},\n",
-    "            {\"date\": \"2025-01-01\", \"mic_value\": float(mic_value)},\n",
-    "        ], indent=2)\n",
-    "        \n",
-    "        # Use standard EUCAST breakpoint (simplified)\n",
-    "        breakpoint = 2.0  # Default S <= 2 mg/L\n",
-    "        \n",
-    "        prompt = f\"{TREND_ANALYST_SYSTEM}\\n\\n{TREND_ANALYST_PROMPT.format(\n",
-    "            organism=organism,\n",
-    "            antibiotic=antibiotic,\n",
-    "            mic_history=mic_history,\n",
-    "            breakpoint=breakpoint,\n",
-    "        )}\"\n",
-    "        \n",
-    "        print(f\"\\nAnalyzing: {organism} / {antibiotic}...\")\n",
-    "        response = run_inference(prompt, model_name=\"medgemma_4b\", max_new_tokens=1024)\n",
-    "        \n",
-    "        parsed = safe_json_parse(response)\n",
-    "        if parsed:\n",
-    "            trend_results.append(parsed)\n",
-    "            risk_level = parsed.get(\"risk_level\", \"UNKNOWN\")\n",
-    "            print(f\"  Risk Level: {risk_level}\")\n",
-    "            \n",
-    "            if risk_level in [\"HIGH\", \"CRITICAL\"]:\n",
-    "                warning = f\"MIC trend alert for {organism}/{antibiotic}: {parsed.get('recommendation', 'Review needed')}\"\n",
-    "                state.setdefault(\"safety_warnings\", []).append(warning)\n",
-    "        else:\n",
-    "            trend_results.append({\"organism\": organism, \"antibiotic\": antibiotic, \"raw\": response[:200]})\n",
-    "    \n",
-    "    state[\"trend_notes\"] = json.dumps(trend_results, indent=2)\n",
-    "    print(f\"\\nTrend Analysis Complete:\")\n",
-    "    print(json.dumps(trend_results, indent=2))\n",
-    "    \n",
-    "    return state"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def run_clinical_pharmacologist(state: InfectionState) -> InfectionState:\n",
-    "    \"\"\"\n",
-    "    Agent 4: Generate final antibiotic recommendation with safety checks.\n",
-    "    \"\"\"\n",
-    "    print(\"\\n\" + \"=\"*60)\n",
-    "    print(\"AGENT 4: CLINICAL PHARMACOLOGIST\")\n",
-    "    print(\"=\"*60)\n",
-    "    \n",
-    "    # Gather previous agent outputs\n",
-    "    intake_summary = state.get(\"intake_notes\", \"No intake data\")\n",
-    "    lab_results = state.get(\"vision_notes\", \"No lab data\")\n",
-    "    trend_analysis = state.get(\"trend_notes\", \"No trend data\")\n",
-    "    \n",
-    "    prompt = f\"{CLINICAL_PHARMACOLOGIST_SYSTEM}\\n\\n{CLINICAL_PHARMACOLOGIST_PROMPT.format(\n",
-    "        intake_summary=intake_summary,\n",
-    "        lab_results=lab_results,\n",
-    "        trend_analysis=trend_analysis,\n",
-    "        age=state.get('age_years', 'Unknown'),\n",
-    "        weight=state.get('weight_kg', 'Unknown'),\n",
-    "        crcl=state.get('creatinine_clearance_ml_min', 'Unknown'),\n",
-    "        allergies=', '.join(state.get('allergies', [])) or 'No known allergies',\n",
-    "        current_medications=', '.join(state.get('medications', [])) or 'None',\n",
-    "        infection_site=state.get('infection_site', 'Unknown'),\n",
-    "        severity='moderate',\n",
-    "    )}\"\n",
-    "    \n",
-    "    print(\"Running MedGemma inference for final recommendation...\")\n",
-    "    response = run_inference(prompt, model_name=\"medgemma_4b\", max_new_tokens=2048)\n",
-    "    \n",
-    "    parsed = safe_json_parse(response)\n",
-    "    if parsed:\n",
-    "        state[\"pharmacology_notes\"] = json.dumps(parsed, indent=2)\n",
-    "        \n",
-    "        # Build recommendation\n",
-    "        primary = parsed.get(\"primary_recommendation\", {})\n",
-    "        recommendation = {\n",
-    "            \"primary_antibiotic\": primary.get(\"antibiotic\"),\n",
-    "            \"dose\": primary.get(\"dose\"),\n",
-    "            \"route\": primary.get(\"route\"),\n",
-    "            \"frequency\": primary.get(\"frequency\"),\n",
-    "            \"duration\": primary.get(\"duration\"),\n",
-    "            \"rationale\": parsed.get(\"rationale\"),\n",
-    "            \"references\": parsed.get(\"guideline_references\", []),\n",
-    "            \"safety_alerts\": [a.get(\"message\") for a in parsed.get(\"safety_alerts\", [])],\n",
-    "        }\n",
-    "        \n",
-    "        alt = parsed.get(\"alternative_recommendation\", {})\n",
-    "        if alt.get(\"antibiotic\"):\n",
-    "            recommendation[\"backup_antibiotic\"] = alt.get(\"antibiotic\")\n",
-    "        \n",
-    "        state[\"recommendation\"] = recommendation\n",
-    "        \n",
-    "        print(f\"\\n\" + \"=\"*60)\n",
-    "        print(\"FINAL RECOMMENDATION\")\n",
-    "        print(\"=\"*60)\n",
-    "        print(json.dumps(recommendation, indent=2))\n",
-    "        \n",
-    "        # Add safety alerts\n",
-    "        for alert in parsed.get(\"safety_alerts\", []):\n",
-    "            if alert.get(\"level\") in [\"WARNING\", \"CRITICAL\"]:\n",
-    "                state.setdefault(\"safety_warnings\", []).append(alert.get(\"message\"))\n",
-    "    else:\n",
-    "        state[\"pharmacology_notes\"] = response\n",
-    "        state[\"recommendation\"] = {\"rationale\": response}\n",
-    "        print(f\"\\nRaw response: {response[:500]}...\")\n",
-    "    \n",
-    "    return state"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 8. Pipeline Orchestration with LangGraph"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from langgraph.graph import StateGraph, END\n",
-    "\n",
-    "def build_infection_graph():\n",
-    "    \"\"\"\n",
-    "    Build the LangGraph StateGraph for the infection lifecycle workflow.\n",
-    "    \n",
-    "    Stage 1 (Empirical): Intake Historian -> Clinical Pharmacologist\n",
-    "    Stage 2 (Targeted): Intake Historian -> Vision Specialist -> Trend Analyst -> Clinical Pharmacologist\n",
-    "    \"\"\"\n",
-    "    graph = StateGraph(InfectionState)\n",
-    "    \n",
-    "    # Add nodes\n",
-    "    graph.add_node(\"intake_historian\", run_intake_historian)\n",
-    "    graph.add_node(\"vision_specialist\", run_vision_specialist)\n",
-    "    graph.add_node(\"trend_analyst\", run_trend_analyst)\n",
-    "    graph.add_node(\"clinical_pharmacologist\", run_clinical_pharmacologist)\n",
-    "    \n",
-    "    # Set entry point\n",
-    "    graph.set_entry_point(\"intake_historian\")\n",
-    "    \n",
-    "    # Conditional routing after intake\n",
-    "    def route_after_intake(state: InfectionState):\n",
-    "        if state.get(\"stage\") == \"targeted\" and state.get(\"route_to_vision\"):\n",
-    "            return \"vision_specialist\"\n",
-    "        return \"clinical_pharmacologist\"\n",
-    "    \n",
-    "    graph.add_conditional_edges(\n",
-    "        \"intake_historian\",\n",
-    "        route_after_intake,\n",
-    "        {\n",
-    "            \"vision_specialist\": \"vision_specialist\",\n",
-    "            \"clinical_pharmacologist\": \"clinical_pharmacologist\",\n",
-    "        }\n",
-    "    )\n",
-    "    \n",
-    "    # Conditional routing after vision\n",
-    "    def route_after_vision(state: InfectionState):\n",
-    "        if state.get(\"route_to_trend_analyst\"):\n",
-    "            return \"trend_analyst\"\n",
-    "        return \"clinical_pharmacologist\"\n",
-    "    \n",
-    "    graph.add_conditional_edges(\n",
-    "        \"vision_specialist\",\n",
-    "        route_after_vision,\n",
-    "        {\n",
-    "            \"trend_analyst\": \"trend_analyst\",\n",
-    "            \"clinical_pharmacologist\": \"clinical_pharmacologist\",\n",
-    "        }\n",
-    "    )\n",
-    "    \n",
-    "    # Edges to final node\n",
-    "    graph.add_edge(\"trend_analyst\", \"clinical_pharmacologist\")\n",
-    "    graph.add_edge(\"clinical_pharmacologist\", END)\n",
-    "    \n",
-    "    return graph\n",
-    "\n",
-    "\n",
-    "def run_pipeline(patient_data: dict, labs_raw_text: Optional[str] = None) -> InfectionState:\n",
-    "    \"\"\"\n",
-    "    Run the full infection lifecycle pipeline.\n",
-    "    \n",
-    "    Args:\n",
-    "        patient_data: Patient information dict\n",
-    "        labs_raw_text: Optional lab report text (triggers Stage 2)\n",
-    "    \n",
-    "    Returns:\n",
-    "        Final InfectionState with recommendation\n",
-    "    \"\"\"\n",
-    "    # Build initial state\n",
-    "    initial_state: InfectionState = {\n",
-    "        \"age_years\": patient_data.get(\"age_years\"),\n",
-    "        \"weight_kg\": patient_data.get(\"weight_kg\"),\n",
-    "        \"height_cm\": patient_data.get(\"height_cm\"),\n",
-    "        \"sex\": patient_data.get(\"sex\"),\n",
-    "        \"serum_creatinine_mg_dl\": patient_data.get(\"serum_creatinine_mg_dl\"),\n",
-    "        \"medications\": patient_data.get(\"medications\", []),\n",
-    "        \"allergies\": patient_data.get(\"allergies\", []),\n",
-    "        \"comorbidities\": patient_data.get(\"comorbidities\", []),\n",
-    "        \"infection_site\": patient_data.get(\"infection_site\"),\n",
-    "        \"suspected_source\": patient_data.get(\"suspected_source\"),\n",
-    "        \"safety_warnings\": [],\n",
-    "        \"errors\": [],\n",
-    "    }\n",
-    "    \n",
-    "    # Add lab data if provided\n",
-    "    if labs_raw_text:\n",
-    "        initial_state[\"labs_raw_text\"] = labs_raw_text\n",
-    "        initial_state[\"stage\"] = \"targeted\"\n",
-    "    else:\n",
-    "        initial_state[\"stage\"] = \"empirical\"\n",
-    "    \n",
-    "    # Build and run graph\n",
-    "    print(\"\\n\" + \"#\"*70)\n",
-    "    print(f\"# STARTING MED-I-C PIPELINE (Stage: {initial_state['stage'].upper()})\")\n",
-    "    print(\"#\"*70)\n",
-    "    \n",
-    "    graph = build_infection_graph()\n",
-    "    compiled = graph.compile()\n",
-    "    final_state = compiled.invoke(initial_state)\n",
-    "    \n",
-    "    print(\"\\n\" + \"#\"*70)\n",
-    "    print(\"# PIPELINE COMPLETE\")\n",
-    "    print(\"#\"*70)\n",
-    "    \n",
-    "    return final_state"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 9. Test Cases"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Test Case 1: Stage 1 (Empirical) - Community UTI"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Test Case 1: Stage 1 Empirical - Community UTI\n",
-    "patient_data_uti = {\n",
-    "    \"age_years\": 65,\n",
-    "    \"weight_kg\": 70,\n",
-    "    \"height_cm\": 170,\n",
-    "    \"sex\": \"male\",\n",
-    "    \"serum_creatinine_mg_dl\": 1.2,\n",
-    "    \"medications\": [\"metformin\", \"lisinopril\", \"aspirin\"],\n",
-    "    \"allergies\": [\"penicillin\"],\n",
-    "    \"comorbidities\": [\"diabetes\", \"hypertension\"],\n",
-    "    \"infection_site\": \"urinary\",\n",
-    "    \"suspected_source\": \"community-acquired UTI\",\n",
-    "}\n",
-    "\n",
-    "result_uti = run_pipeline(patient_data_uti)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Display results\n",
-    "print(\"\\n\" + \"=\"*70)\n",
-    "print(\"TEST CASE 1: COMMUNITY UTI (EMPIRICAL)\")\n",
-    "print(\"=\"*70)\n",
-    "\n",
-    "print(f\"\\nCrCl: {result_uti.get('creatinine_clearance_ml_min')} mL/min\")\n",
-    "print(f\"Stage: {result_uti.get('stage')}\")\n",
-    "\n",
-    "rec = result_uti.get('recommendation', {})\n",
-    "if rec:\n",
-    "    print(f\"\\nRecommendation:\")\n",
-    "    print(f\"  Drug: {rec.get('primary_antibiotic')}\")\n",
-    "    print(f\"  Dose: {rec.get('dose')}\")\n",
-    "    print(f\"  Route: {rec.get('route')}\")\n",
-    "    print(f\"  Frequency: {rec.get('frequency')}\")\n",
-    "    print(f\"  Duration: {rec.get('duration')}\")\n",
-    "    print(f\"  Rationale: {rec.get('rationale')}\")\n",
-    "\n",
-    "warnings = result_uti.get('safety_warnings', [])\n",
-    "if warnings:\n",
-    "    print(f\"\\nSafety Warnings:\")\n",
-    "    for w in warnings:\n",
-    "        print(f\"  ⚠️ {w}\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Test Case 2: Stage 2 (Targeted) - With Lab Results"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Test Case 2: Stage 2 Targeted - UTI with Lab Results\n",
-    "patient_data_targeted = {\n",
-    "    \"age_years\": 72,\n",
-    "    \"weight_kg\": 65,\n",
-    "    \"height_cm\": 165,\n",
-    "    \"sex\": \"female\",\n",
-    "    \"serum_creatinine_mg_dl\": 1.5,\n",
-    "    \"medications\": [\"warfarin\", \"amlodipine\"],\n",
-    "    \"allergies\": [],\n",
-    "    \"comorbidities\": [\"atrial fibrillation\", \"hypertension\", \"CKD stage 3\"],\n",
-    "    \"infection_site\": \"urinary\",\n",
-    "    \"suspected_source\": \"complicated UTI with pyelonephritis\",\n",
-    "}\n",
-    "\n",
-    "lab_report = \"\"\"\n",
-    "URINE CULTURE REPORT\n",
-    "Patient ID: 12345\n",
-    "Collection Date: 2025-02-15\n",
-    "\n",
-    "Specimen: Midstream urine\n",
-    "Colony Count: >100,000 CFU/mL\n",
-    "\n",
-    "ORGANISM ISOLATED:\n",
-    "Escherichia coli\n",
-    "\n",
-    "ANTIMICROBIAL SUSCEPTIBILITY:\n",
-    "-----------------------------------\n",
-    "Antibiotic          MIC (mg/L)   Interpretation\n",
-    "-----------------------------------\n",
-    "Ampicillin          >32          R\n",
-    "Amoxicillin-Clav    16           I\n",
-    "Ceftriaxone         0.25         S\n",
-    "Cefepime            0.5          S\n",
-    "Ciprofloxacin       0.5          S\n",
-    "Levofloxacin        1            S\n",
-    "Nitrofurantoin      32           S\n",
-    "TMP-SMX             >4           R\n",
-    "Gentamicin          2            S\n",
-    "Meropenem           0.06         S\n",
-    "\n",
-    "NOTES:\n",
-    "- ESBL screening negative\n",
-    "- No carbapenemase detected\n",
-    "\"\"\"\n",
-    "\n",
-    "result_targeted = run_pipeline(patient_data_targeted, labs_raw_text=lab_report)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Display results\n",
-    "print(\"\\n\" + \"=\"*70)\n",
-    "print(\"TEST CASE 2: COMPLICATED UTI WITH LAB RESULTS (TARGETED)\")\n",
-    "print(\"=\"*70)\n",
-    "\n",
-    "print(f\"\\nCrCl: {result_targeted.get('creatinine_clearance_ml_min')} mL/min\")\n",
-    "print(f\"Stage: {result_targeted.get('stage')}\")\n",
-    "\n",
-    "print(f\"\\nExtracted MIC Data:\")\n",
-    "for mic in result_targeted.get('mic_data', []):\n",
-    "    print(f\"  - {mic.get('organism')} / {mic.get('antibiotic')}: MIC {mic.get('mic_value')} ({mic.get('interpretation')})\")\n",
-    "\n",
-    "rec = result_targeted.get('recommendation', {})\n",
-    "if rec:\n",
-    "    print(f\"\\nFinal Recommendation:\")\n",
-    "    print(f\"  Primary: {rec.get('primary_antibiotic')}\")\n",
-    "    print(f\"  Dose: {rec.get('dose')}\")\n",
-    "    print(f\"  Route: {rec.get('route')}\")\n",
-    "    print(f\"  Frequency: {rec.get('frequency')}\")\n",
-    "    print(f\"  Duration: {rec.get('duration')}\")\n",
-    "    if rec.get('backup_antibiotic'):\n",
-    "        print(f\"  Alternative: {rec.get('backup_antibiotic')}\")\n",
-    "    print(f\"  Rationale: {rec.get('rationale')}\")\n",
     "\n",
-    "warnings = result_targeted.get('safety_warnings', [])\n",
-    "if warnings:\n",
-    "    print(f\"\\n⚠️ Safety Warnings:\")\n",
-    "    for w in warnings:\n",
-    "        print(f\"  - {w}\")"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "### Test Case 3: ESBL-producing Organism (High-Risk)"
    ]
   },
   {
@@ -1281,55 +201,8 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "# Test Case 3: ESBL E. coli\n",
-    "patient_esbl = {\n",
-    "    \"age_years\": 58,\n",
-    "    \"weight_kg\": 85,\n",
-    "    \"height_cm\": 175,\n",
-    "    \"sex\": \"male\",\n",
-    "    \"serum_creatinine_mg_dl\": 1.0,\n",
-    "    \"medications\": [\"metformin\", \"atorvastatin\"],\n",
-    "    \"allergies\": [],\n",
-    "    \"comorbidities\": [\"diabetes\", \"recent hospitalization\"],\n",
-    "    \"infection_site\": \"bloodstream\",\n",
-    "    \"suspected_source\": \"healthcare-associated bacteremia\",\n",
-    "}\n",
-    "\n",
-    "lab_esbl = \"\"\"\n",
-    "BLOOD CULTURE REPORT\n",
-    "Collection Date: 2025-02-18\n",
-    "\n",
-    "POSITIVE: Gram-negative bacilli\n",
-    "\n",
-    "FINAL IDENTIFICATION:\n",
-    "Escherichia coli (ESBL-producing)\n",
-    "\n",
-    "ANTIMICROBIAL SUSCEPTIBILITY:\n",
-    "-----------------------------------\n",
-    "Antibiotic          MIC (mg/L)   Interpretation\n",
-    "-----------------------------------\n",
-    "Ampicillin          >32          R\n",
-    "Ampicillin-Sulbact  >32          R\n",
-    "Ceftriaxone         >32          R\n",
-    "Cefepime            >32          R\n",
-    "Ceftazidime         >32          R\n",
-    "Ciprofloxacin       >4           R\n",
-    "Levofloxacin        >8           R\n",
-    "TMP-SMX             >4           R\n",
-    "Gentamicin          8            I\n",
-    "Amikacin            4            S\n",
-    "Ertapenem           0.25         S\n",
-    "Meropenem           0.06         S\n",
-    "Imipenem            0.5          S\n",
-    "Tigecycline         0.5          S\n",
-    "\n",
-    "ESBL CONFIRMATION: POSITIVE\n",
-    "Carbapenemase: NOT DETECTED\n",
-    "\n",
-    "CRITICAL ALERT: ESBL-producing organism in bloodstream\n",
-    "\"\"\"\n",
-    "\n",
-    "result_esbl = run_pipeline(patient_esbl, labs_raw_text=lab_esbl)"
    ]
   },
   {
@@ -1338,37 +211,28 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "# Display ESBL results\n",
-    "print(\"\\n\" + \"=\"*70)\n",
-    "print(\"TEST CASE 3: ESBL E. coli BACTEREMIA (HIGH-RISK)\")\n",
-    "print(\"=\"*70)\n",
     "\n",
-    "rec = result_esbl.get('recommendation', {})\n",
-    "if rec:\n",
-    "    print(f\"\\nRecommendation:\")\n",
-    "    print(f\"  Primary: {rec.get('primary_antibiotic')}\")\n",
-    "    print(f\"  Dose: {rec.get('dose')}\")\n",
-    "    print(f\"  Route: {rec.get('route')}\")\n",
-    "    print(f\"  Rationale: {rec.get('rationale')}\")\n",
-    "\n",
-    "warnings = result_esbl.get('safety_warnings', [])\n",
-    "if warnings:\n",
-    "    print(f\"\\n🚨 SAFETY ALERTS:\")\n",
-    "    for w in warnings:\n",
-    "        print(f\"  - {w}\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 10. Streamlit App (Optional - for local testing)\n",
-    "\n",
-    "Note: Streamlit doesn't run directly in Kaggle notebooks. To test the Streamlit app:\n",
-    "1. Download this notebook and the source files\n",
-    "2. Run locally with `streamlit run app.py`\n",
     "\n",
-    "Alternatively, you can use `ngrok` or `localtunnel` to expose the Streamlit app."
    ]
   },
   {
@@ -1377,103 +241,21 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "# Optional: Install and run Streamlit with localtunnel\n",
-    "# Uncomment to use\n",
-    "\n",
-    "# !pip install -q streamlit localtunnel\n",
-    "\n",
-    "# # Write the app file\n",
-    "# app_code = '''\n",
-    "# import streamlit as st\n",
-    "# import json\n",
-    "\n",
-    "# st.set_page_config(page_title=\"Med-I-C: AMR-Guard\", page_icon=\"🦠\", layout=\"wide\")\n",
-    "\n",
-    "# st.title(\"🦠 Med-I-C: AMR-Guard\")\n",
-    "# st.subheader(\"Infection Lifecycle Orchestrator - Multi-Agent System\")\n",
-    "\n",
-    "# st.markdown(\"\"\"\n",
-    "# This demo showcases the Med-I-C multi-agent system powered by MedGemma.\n",
-    "\n",
-    "# **Note:** Running in demo mode. For full functionality, deploy with GPU support.\n",
-    "# \"\"\")\n",
-    "\n",
-    "# # Patient form\n",
-    "# with st.form(\"patient_form\"):\n",
-    "#     col1, col2 = st.columns(2)\n",
-    "#     with col1:\n",
-    "#         age = st.number_input(\"Age\", 0, 120, 65)\n",
-    "#         weight = st.number_input(\"Weight (kg)\", 1.0, 300.0, 70.0)\n",
-    "#         sex = st.selectbox(\"Sex\", [\"male\", \"female\"])\n",
-    "#     with col2:\n",
-    "#         creatinine = st.number_input(\"Creatinine (mg/dL)\", 0.1, 20.0, 1.2)\n",
-    "#         infection_site = st.selectbox(\"Infection Site\", [\"urinary\", \"respiratory\", \"bloodstream\"])\n",
-    "#     \n",
-    "#     submitted = st.form_submit_button(\"Get Recommendation\")\n",
-    "\n",
-    "# if submitted:\n",
-    "#     st.success(\"Demo mode: Showing simulated recommendation\")\n",
-    "#     st.json({\n",
-    "#         \"primary_antibiotic\": \"Ciprofloxacin\",\n",
-    "#         \"dose\": \"500mg\",\n",
-    "#         \"route\": \"PO\",\n",
-    "#         \"frequency\": \"Every 12 hours\",\n",
-    "#         \"duration\": \"7 days\"\n",
-    "#     })\n",
-    "# '''\n",
-    "\n",
-    "# with open('streamlit_app.py', 'w') as f:\n",
-    "#     f.write(app_code)\n",
-    "\n",
-    "# # Run with localtunnel\n",
-    "# !streamlit run streamlit_app.py &>/dev/null &\n",
-    "# !npx localtunnel --port 8501"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 11. Summary & Conclusions\n",
-    "\n",
-    "This notebook demonstrates the **Med-I-C** multi-agent system for antimicrobial stewardship:\n",
-    "\n",
-    "### Key Features:\n",
-    "1. **4 Specialized Agents** powered by MedGemma 4B IT\n",
-    "2. **Conditional Routing** via LangGraph for Stage 1 (Empirical) vs Stage 2 (Targeted)\n",
-    "3. **CrCl Calculation** using Cockcroft-Gault equation\n",
-    "4. **MIC Trend Analysis** for resistance detection\n",
-    "5. **Safety Checks** including drug interactions and allergy alerts\n",
-    "\n",
-    "### Models Used:\n",
-    "- **MedGemma 4B IT** - Primary model for all agents (4-bit quantized)\n",
-    "- **TxGemma 2B** - Optional safety validation (not demonstrated in this notebook)\n",
-    "\n",
-    "### Future Enhancements:\n",
-    "- Integration with RAG (ChromaDB) for guideline retrieval\n",
-    "- MedGemma 27B for complex trend analysis\n",
-    "- Vision capabilities for image-based lab report extraction\n",
-    "- Regional resistance pattern analysis\n",
-    "\n",
-    "---\n",
     "\n",
-    "**Competition:** MedGemma Impact Challenge  \n",
-    "**Category:** Agentic Workflow  \n",
-    "**Deadline:** February 24, 2026"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Final memory cleanup\n",
-    "import gc\n",
-    "gc.collect()\n",
-    "if torch.cuda.is_available():\n",
-    "    torch.cuda.empty_cache()\n",
-    "    print(f\"GPU Memory after cleanup: {torch.cuda.memory_allocated() / 1e9:.2f} GB\")"
    ]
   }
  ],
@@ -1484,18 +266,10 @@
    "name": "python3"
   },
   "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
    "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
    "version": "3.10.0"
   }
  },
  "nbformat": 4,
- "nbformat_minor": 4
 }

    "cell_type": "markdown",
    "metadata": {},
    "source": [
+    "# Med-I-C · AMR-Guard\n",
+    "### Infection Lifecycle Orchestrator — Kaggle Demo\n",
     "\n",
+    "**Steps**\n",
+    "1. Clone repo & install packages\n",
+    "2. Authenticate with Hugging Face\n",
+    "3. Download models\n",
+    "4. Initialise the knowledge base\n",
+    "5. Launch the Streamlit app"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
+    "## 1 · Environment"
    ]
   },
   {
    "metadata": {},
    "outputs": [],
    "source": [
+    "import subprocess, torch\n",
+    "\n",
+    "# GPU check\n",
+    "print(subprocess.run(['nvidia-smi', '--query-gpu=name,memory.total', '--format=csv,noheader'],\n",
+    "                     capture_output=True, text=True).stdout.strip())\n",
+    "print(f\"PyTorch {torch.__version__} · CUDA {torch.cuda.is_available()}\")"
    ]
   },
   {
    "metadata": {},
    "outputs": [],
    "source": [
+    "%%bash\n",
+    "# Clone the repo (skip if already present)\n",
+    "if [ ! -d /kaggle/working/Med-I-C ]; then\n",
+    "    git clone https://github.com/benghita/Med-I-C.git /kaggle/working/Med-I-C\n",
+    "else\n",
+    "    echo \"Repo already cloned — pulling latest changes\"\n",
+    "    git -C /kaggle/working/Med-I-C pull\n",
+    "fi"
    ]
   },
   {
    "metadata": {},
    "outputs": [],
    "source": [
+    "%%capture\n",
+    "# Install packages from pyproject.toml dependencies\n",
+    "!pip install -q \\\n",
+    "    \"langgraph>=0.0.15\" \"langchain>=0.3.0\" langchain-text-splitters langchain-community \\\n",
+    "    \"chromadb>=0.4.0\" sentence-transformers \\\n",
+    "    \"transformers>=4.50.0\" accelerate bitsandbytes \\\n",
+    "    streamlit huggingface_hub \\\n",
+    "    \"pydantic>=2.0\" python-dotenv openpyxl pypdf \"pandas>=2.0\" jq"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
+    "## 2 · Hugging Face Authentication\n",
     "\n",
+    "Add your token to **Kaggle → Add-ons → Secrets** as `HF_TOKEN`.\n",
     "\n",
+    "Accept model licences before running:\n",
+    "- https://huggingface.co/google/gemma-2-2b-it"
    ]
   },
   {
    "metadata": {},
    "outputs": [],
    "source": [
+    "import os\n",
     "from huggingface_hub import login\n",
     "\n",
     "try:\n",
     "    from kaggle_secrets import UserSecretsClient\n",
+    "    hf_token = UserSecretsClient().get_secret(\"HF_TOKEN\")\n",
+    "    print(\"Token loaded from Kaggle secrets\")\n",
+    "except Exception:\n",
+    "    hf_token = os.getenv(\"HF_TOKEN\", \"\")\n",
+    "    print(\"Token loaded from environment\" if hf_token else \"WARNING: No HF_TOKEN found\")\n",
     "\n",
+    "if hf_token:\n",
+    "    login(token=hf_token, add_to_git_credential=False)"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
+    "## 3 · Download Models"
    ]
   },
   {
    "metadata": {},
    "outputs": [],
    "source": [
+    "from huggingface_hub import snapshot_download\n",
     "\n",
+    "# Single model used for all agents in the demo\n",
+    "MODEL_ID = \"google/gemma-2-2b-it\"\n",
     "\n",
+    "print(f\"Downloading {MODEL_ID} …\")\n",
+    "snapshot_download(\n",
+    "    repo_id=MODEL_ID,\n",
+    "    ignore_patterns=[\"*.gguf\", \"*.ot\"],   # skip quantised formats we don't need\n",
     ")\n",
+    "print(\"Download complete\")"
    ]
   },
   {
    "metadata": {},
    "outputs": [],
    "source": [
+    "# Embedding model for RAG (small, fast)\n",
+    "from sentence_transformers import SentenceTransformer\n",
+    "SentenceTransformer(\"sentence-transformers/all-MiniLM-L6-v2\")\n",
+    "print(\"Embedding model ready\")"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
+    "## 4 · Configure & Initialise"
    ]
   },
   {
    "metadata": {},
    "outputs": [],
    "source": [
+    "# Write .env for the Kaggle environment\n",
+    "env_content = f\"\"\"\n",
+    "MEDIC_ENV=kaggle\n",
+    "MEDIC_DEFAULT_BACKEND=local\n",
+    "MEDIC_USE_VERTEX=false\n",
+    "MEDIC_QUANTIZATION=4bit\n",
     "\n",
+    "MEDIC_LOCAL_MEDGEMMA_4B_MODEL={MODEL_ID}\n",
+    "MEDIC_LOCAL_MEDGEMMA_27B_MODEL={MODEL_ID}\n",
+    "MEDIC_LOCAL_TXGEMMA_9B_MODEL={MODEL_ID}\n",
+    "MEDIC_LOCAL_TXGEMMA_2B_MODEL={MODEL_ID}\n",
     "\n",
+    "MEDIC_EMBEDDING_MODEL=sentence-transformers/all-MiniLM-L6-v2\n",
+    "MEDIC_DATA_DIR=/kaggle/working/Med-I-C/data\n",
+    "MEDIC_CHROMA_DB_DIR=/kaggle/working/Med-I-C/data/chroma_db\n",
+    "\"\"\".strip()\n",
     "\n",
+    "with open(\"/kaggle/working/Med-I-C/.env\", \"w\") as f:\n",
+    "    f.write(env_content)\n",
     "\n",
+    "print(\".env written\")"
    ]
   },
   {
    "metadata": {},
    "outputs": [],
    "source": [
+    "import sys\n",
+    "sys.path.insert(0, \"/kaggle/working/Med-I-C\")\n",
     "\n",
+    "# Initialise SQLite + ChromaDB knowledge base\n",
+    "!python /kaggle/working/Med-I-C/setup_demo.py"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
+    "## 5 · Launch the App"
    ]
   },
   {
    "metadata": {},
    "outputs": [],
    "source": [
+    "%%capture\n",
+    "!pip install -q localtunnel"
    ]
   },
   {
    "metadata": {},
    "outputs": [],
    "source": [
+    "import subprocess, threading, time, requests\n",
     "\n",
+    "# Start Streamlit in the background\n",
+    "streamlit_proc = subprocess.Popen(\n",
+    "    [\"streamlit\", \"run\", \"/kaggle/working/Med-I-C/app.py\",\n",
+    "     \"--server.port\", \"8501\",\n",
+    "     \"--server.headless\", \"true\",\n",
+    "     \"--server.enableCORS\", \"false\"],\n",
+    "    stdout=subprocess.DEVNULL,\n",
+    "    stderr=subprocess.DEVNULL,\n",
+    ")\n",
     "\n",
+    "# Wait for Streamlit to be ready\n",
+    "for _ in range(15):\n",
+    "    try:\n",
+    "        if requests.get(\"http://localhost:8501\", timeout=2).status_code == 200:\n",
+    "            print(\"Streamlit is running on port 8501\")\n",
+    "            break\n",
+    "    except Exception:\n",
+    "        time.sleep(2)\n",
+    "else:\n",
+    "    print(\"Streamlit may still be starting…\")"
    ]
   },
   {
    "metadata": {},
    "outputs": [],
    "source": [
+    "# Expose via localtunnel — the public URL will appear below\n",
+    "tunnel_proc = subprocess.Popen(\n",
+    "    [\"npx\", \"localtunnel\", \"--port\", \"8501\"],\n",
+    "    stdout=subprocess.PIPE,\n",
+    "    stderr=subprocess.DEVNULL,\n",
+    "    text=True,\n",
+    ")\n",
     "\n",
+    "# Print the public URL\n",
+    "for line in tunnel_proc.stdout:\n",
+    "    if \"https://\" in line:\n",
+    "        print(\"\\n\" + \"=\"*50)\n",
+    "        print(f\"  App URL: {line.strip()}\")\n",
+    "        print(\"=\"*50)\n",
+    "        break"
    ]
   }
  ],
    "name": "python3"
   },
   "language_info": {
    "name": "python",
    "version": "3.10.0"
   }
  },
  "nbformat": 4,
+ "nbformat_minor": 5
 }

pyproject.toml CHANGED Viewed

@@ -8,8 +8,6 @@ dependencies = [
     "langgraph>=0.0.15",
     "langchain>=0.3.0",
     "langchain-text-splitters",
-    "langchain-google-vertexai",
-    "google-cloud-aiplatform",
     "chromadb>=0.4.0",
     "sentence-transformers",
     "transformers>=4.50.0",
@@ -26,4 +24,5 @@ dependencies = [
     "langchain-community>=0.4.1",
     "jq>=1.11.0",
     "pandas>=2.0.0",
 ]

     "langgraph>=0.0.15",
     "langchain>=0.3.0",
     "langchain-text-splitters",
     "chromadb>=0.4.0",
     "sentence-transformers",
     "transformers>=4.50.0",
     "langchain-community>=0.4.1",
     "jq>=1.11.0",
     "pandas>=2.0.0",
+    "huggingface-hub",
 ]

uv.lock CHANGED Viewed

The diff for this file is too large to render. See raw diff