Initial commit

app.py

@@ -0,0 +1,641 @@
+import gradio as gr
+from typing import Dict, Any
+
+from brand_to_generic import brand_lookup
+from dbi_mcp import dbi_mcp
+from clinical_calculators import (
+    cockcroft_gault_creatinine_clearance,
+    ckd_epi_egfr,
+    child_pugh_score,
+    bmi_calculator,
+    ideal_body_weight,
+    dosing_weight_recommendation,
+    creatinine_conversion,
+)
+from caching import with_caching
+from utils import with_error_handling, standardize_response, format_json_output
+from drug_data_endpoints import (
+    search_adverse_events,
+    fetch_event_details,
+    drug_label_warnings,
+    drug_recalls,
+    drug_pregnancy_lactation,
+    drug_dose_adjustments,
+    drug_livertox_summary,
+)
+import logging
+
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+    handlers=[logging.FileHandler("mcp_server.log"), logging.StreamHandler()],
+)
+logger = logging.getLogger(__name__)
+
+
+@with_error_handling
+def _brand_lookup_gradio(brand_name: str, prefer_countries_str: str = ""):
+    """Brand to generic lookup for single input."""
+    prefer_countries_list = (
+        [c.strip().upper() for c in prefer_countries_str.split(",") if c.strip()]
+        if prefer_countries_str
+        else None
+    )
+    result = brand_lookup(brand_name, prefer_countries=prefer_countries_list)
+    return standardize_response(result, "brand_to_generic")
+
+
+@with_error_handling
+def _dbi_mcp_gradio(text_block: str, route: str = "oral"):
+    result = dbi_mcp(text_block, route=route, ref_csv="dbi_reference_by_route.csv")
+    return standardize_response(result, "dbi_calculator")
+
+
+@with_error_handling
+def _cockcroft_gault_gradio(
+    age: int, weight_kg: float, serum_creatinine: float, is_female: bool
+):
+    result = cockcroft_gault_creatinine_clearance(
+        age, weight_kg, serum_creatinine, is_female
+    )
+    return standardize_response(result, "cockcroft_gault_calculator")
+
+
+@with_error_handling
+def _ckd_epi_gradio(age: int, serum_creatinine: float, is_female: bool, is_black: bool):
+    result = ckd_epi_egfr(age, serum_creatinine, is_female, is_black)
+    return standardize_response(result, "ckd_epi_calculator")
+
+
+@with_error_handling
+def _child_pugh_gradio(
+    bilirubin: float, albumin: float, inr: float, ascites: str, encephalopathy: str
+):
+    result = child_pugh_score(bilirubin, albumin, inr, ascites, encephalopathy)
+    return standardize_response(result, "child_pugh_calculator")
+
+
+@with_error_handling
+def _bmi_gradio(weight_kg: float, height_cm: float):
+    result = bmi_calculator(weight_kg, height_cm)
+    return standardize_response(result, "bmi_calculator")
+
+
+@with_error_handling
+def _ideal_body_weight_gradio(height_cm: float, is_male: bool):
+    result = ideal_body_weight(height_cm, is_male)
+    return standardize_response(result, "ideal_body_weight_calculator")
+
+
+@with_error_handling
+def _dosing_weight_gradio(actual_weight: float, height_cm: float, is_male: bool):
+    result = dosing_weight_recommendation(actual_weight, height_cm, is_male)
+    return standardize_response(result, "dosing_weight_calculator")
+
+
+@with_error_handling
+def _creatinine_conversion_gradio(value: float, from_unit: str, to_unit: str):
+    result = creatinine_conversion(value, from_unit, to_unit)
+    return standardize_response(result, "creatinine_conversion")
+
+
+@with_error_handling
+@with_caching(ttl=1800)
+def search_adverse_events_mcp(drug_name: str, limit: str = "5") -> str:
+    """
+    Search FAERS for adverse events related to a drug and return brief summaries.
+
+    Args:
+        drug_name (str): Generic or brand name to search (case-insensitive)
+        limit (str): Maximum number of FAERS safety reports to return (default: "5")
+
+    Returns:
+        str: JSON string with adverse event contexts and metadata
+    """
+    limit_int = int(limit) if limit.isdigit() else 5
+    result = search_adverse_events(drug_name, limit_int)
+    return format_json_output(result)
+
+
+@with_error_handling
+@with_caching(ttl=3600)
+def fetch_event_details_mcp(event_id: str) -> str:
+    """
+    Fetch full FAERS case details by safety-report ID.
+
+    Args:
+        event_id (str): Numeric FAERS safetyreportid string
+
+    Returns:
+        str: JSON string with structured case data including drugs, reactions, and full record
+    """
+    result = fetch_event_details(event_id)
+    return format_json_output(result)
+
+
+@with_error_handling
+@with_caching(ttl=7200)
+def drug_label_warnings_mcp(drug_name: str) -> str:
+    """
+    Get FDA label warnings including boxed warnings, contraindications, and drug interactions.
+
+    Args:
+        drug_name (str): Generic drug name preferred
+
+    Returns:
+        str: JSON string with boxed warnings, contraindications, and interaction data
+    """
+    result = drug_label_warnings(drug_name)
+    return format_json_output(result)
+
+
+@with_error_handling
+@with_caching(ttl=3600)
+def drug_recalls_mcp(drug_name: str, limit: str = "5") -> str:
+    """
+    Find recent FDA recall events for a drug.
+
+    Args:
+        drug_name (str): Free-text search string for the drug
+        limit (str): Maximum number of recall notices to return (default: "5")
+
+    Returns:
+        str: JSON string with recall notices including recall number, status, and reason
+    """
+    limit_int = int(limit) if limit.isdigit() else 5
+    result = drug_recalls(drug_name, limit_int)
+    return format_json_output(result)
+
+
+@with_error_handling
+@with_caching(ttl=7200)
+def drug_pregnancy_lactation_mcp(drug_name: str) -> str:
+    """
+    Get pregnancy and lactation information from FDA drug labels.
+
+    Args:
+        drug_name (str): Generic drug name preferred
+
+    Returns:
+        str: JSON string with pregnancy text, lactation text, and reproductive potential information
+    """
+    result = drug_pregnancy_lactation(drug_name)
+    return format_json_output(result)
+
+
+@with_error_handling
+@with_caching(ttl=7200)  # 2 hours cache
+def drug_dose_adjustments_mcp(drug_name: str) -> str:
+    """
+    Get renal and hepatic dose adjustment information from FDA labels.
+
+    Args:
+        drug_name (str): Generic drug name
+
+    Returns:
+        str: JSON string with renal and hepatic dosing excerpts
+    """
+    result = drug_dose_adjustments(drug_name)
+    return format_json_output(result)
+
+
+@with_error_handling
+@with_caching(ttl=1800)  # 30 minutes cache
+def drug_livertox_summary_mcp(drug_name: str) -> str:
+    """
+    Get hepatotoxicity information from the LiverTox database.
+
+    Args:
+        drug_name (str): Drug name to search for (case-insensitive)
+
+    Returns:
+        str: JSON string with hepatotoxicity data, mechanism of injury, and management information
+    """
+    result = drug_livertox_summary(drug_name)
+    return format_json_output(result)
+
+
+@with_error_handling
+def brand_to_generic_lookup_mcp(brand_name: str, prefer_countries: str = "US") -> str:
+    """
+    Look up generic drug information from brand names.
+
+    Args:
+        brand_name (str): Brand name to look up
+        prefer_countries (str): Comma-separated ISO country codes (e.g., "US,CA")
+
+    Returns:
+        str: JSON string with generic drug information and country-specific data
+    """
+    result = _brand_lookup_gradio(brand_name, prefer_countries)
+    return format_json_output(result)
+
+
+@with_error_handling
+def calculate_drug_burden_index_mcp(drug_list: str, route: str = "oral") -> str:
+    """
+    Calculate Drug Burden Index (DBI) from a list of medications.
+
+    Args:
+        drug_list (str): Drug list (one per line, include dose and frequency)
+        route (str): Route of administration (default: "oral")
+
+    Returns:
+        str: JSON string with DBI calculation results and individual drug contributions
+    """
+    result = _dbi_mcp_gradio(drug_list, route)
+    return format_json_output(result)
+
+
+@with_error_handling
+def calculate_creatinine_clearance_mcp(
+    age: str, weight_kg: str, serum_creatinine: str, is_female: str
+) -> str:
+    """
+    Calculate creatinine clearance using Cockcroft-Gault equation.
+
+    Args:
+        age (str): Patient's age in years
+        weight_kg (str): Patient's weight in kilograms
+        serum_creatinine (str): Patient's serum creatinine in mg/dL
+        is_female (str): "true" if patient is female, "false" if male
+
+    Returns:
+        str: JSON string with creatinine clearance calculation and interpretation
+    """
+    age_int = int(age)
+    weight_float = float(weight_kg)
+    creat_float = float(serum_creatinine)
+    is_female_bool = is_female.lower() == "true"
+
+    result = _cockcroft_gault_gradio(
+        age_int, weight_float, creat_float, is_female_bool
+    )
+    return format_json_output(result)
+
+
+@with_error_handling
+def calculate_egfr_mcp(
+    age: str, serum_creatinine: str, is_female: str, is_black: str
+) -> str:
+    """
+    Calculate estimated glomerular filtration rate using CKD-EPI equation.
+
+    Args:
+        age (str): Patient's age in years
+        serum_creatinine (str): Patient's serum creatinine in mg/dL
+        is_female (str): "true" if patient is female, "false" if male
+        is_black (str): "true" if patient is Black, "false" otherwise
+
+    Returns:
+        str: JSON string with eGFR calculation and CKD stage interpretation
+    """
+    age_int = int(age)
+    creat_float = float(serum_creatinine)
+    is_female_bool = is_female.lower() == "true"
+    is_black_bool = is_black.lower() == "true"
+
+    result = _ckd_epi_gradio(age_int, creat_float, is_female_bool, is_black_bool)
+    return format_json_output(result)
+
+
+@with_error_handling
+def calculate_child_pugh_score_mcp(
+    bilirubin: str, albumin: str, inr: str, ascites: str, encephalopathy: str
+) -> str:
+    """
+    Calculate Child-Pugh score for liver function assessment.
+
+    Args:
+        bilirubin (str): Total bilirubin in mg/dL
+        albumin (str): Serum albumin in g/dL
+        inr (str): INR value
+        ascites (str): Ascites level ("none", "mild", "moderate-severe")
+        encephalopathy (str): Encephalopathy grade ("none", "grade-1-2", "grade-3-4")
+
+    Returns:
+        str: JSON string with Child-Pugh score, class, and prognosis information
+    """
+    bilirubin_float = float(bilirubin)
+    albumin_float = float(albumin)
+    inr_float = float(inr)
+
+    result = _child_pugh_gradio(
+        bilirubin_float, albumin_float, inr_float, ascites, encephalopathy
+    )
+    return format_json_output(result)
+
+
+@with_error_handling
+def calculate_bmi_mcp(weight_kg: str, height_cm: str) -> str:
+    """
+    Calculate Body Mass Index (BMI) and weight category.
+
+    Args:
+        weight_kg (str): Weight in kilograms
+        height_cm (str): Height in centimeters
+
+    Returns:
+        str: JSON string with BMI calculation and weight category classification
+    """
+    weight_float = float(weight_kg)
+    height_float = float(height_cm)
+
+    result = _bmi_gradio(weight_float, height_float)
+    return format_json_output(result)
+
+
+@with_error_handling
+def calculate_ideal_body_weight_mcp(height_cm: str, is_male: str) -> str:
+    """
+    Calculate Ideal Body Weight (IBW) using the Devine formula.
+
+    Args:
+        height_cm (str): Patient's height in cm
+        is_male (str): "true" if patient is male, "false" if female
+
+    Returns:
+        str: JSON string with IBW calculation.
+    """
+    height_float = float(height_cm)
+    is_male_bool = is_male.lower() == "true"
+
+    result = _ideal_body_weight_gradio(height_float, is_male_bool)
+    return format_json_output(result)
+
+
+@with_error_handling
+def recommend_dosing_weight_mcp(
+    actual_weight: str, height_cm: str, is_male: str
+) -> str:
+    """
+    Recommend appropriate weight for medication dosing calculations.
+
+    Args:
+        actual_weight (str): Patient's actual weight in kg
+        height_cm (str): Patient's height in cm
+        is_male (str): "true" if patient is male, "false" if female
+
+    Returns:
+        str: JSON string with dosing weight recommendation and rationale
+    """
+    weight_float = float(actual_weight)
+    height_float = float(height_cm)
+    is_male_bool = is_male.lower() == "true"
+
+    result = _dosing_weight_gradio(weight_float, height_float, is_male_bool)
+    return format_json_output(result)
+
+
+@with_error_handling
+def convert_creatinine_units_mcp(value: str, from_unit: str, to_unit: str) -> str:
+    """
+    Convert creatinine values between mg/dL and μmol/L units.
+
+    Args:
+        value (str): The creatinine value to convert
+        from_unit (str): The original unit ("mg_dl" or "umol_l")
+        to_unit (str): The target unit ("mg_dl" or "umol_l")
+
+    Returns:
+        str: JSON string with converted creatinine value and conversion factor
+    """
+    value_float = float(value)
+
+    result = _creatinine_conversion_gradio(value_float, from_unit, to_unit)
+    return format_json_output(result)
+
+
+ae_search_ui = gr.Interface(
+    fn=search_adverse_events_mcp,
+    inputs=[gr.Text(label="Drug Name"), gr.Text(label="Limit", value="5")],
+    outputs=gr.JSON(label="Output"),
+    title="AE Search",
+    api_name="ae_search",
+    description="Search FAERS for adverse events.",
+)
+
+ae_details_ui = gr.Interface(
+    fn=fetch_event_details_mcp,
+    inputs=gr.Text(label="FAERS Event ID"),
+    outputs=gr.JSON(label="Output"),
+    title="AE Details",
+    api_name="ae_details",
+    description="Fetch a full FAERS case by safety-report ID.",
+)
+
+warnings_ui = gr.Interface(
+    fn=drug_label_warnings_mcp,
+    inputs=gr.Text(label="Drug Name"),
+    outputs=gr.JSON(label="Output"),
+    title="Label Warnings",
+    api_name="label_warnings",
+    description="Get FDA label warnings.",
+)
+
+recalls_ui = gr.Interface(
+    fn=drug_recalls_mcp,
+    inputs=[gr.Text(label="Drug"), gr.Text(label="Limit", value="5")],
+    outputs=gr.JSON(label="Output"),
+    title="Drug Recalls",
+    api_name="drug_recalls",
+    description="Return recent FDA recall events for a drug.",
+)
+
+pregnancy_ui = gr.Interface(
+    fn=drug_pregnancy_lactation_mcp,
+    inputs=gr.Text(label="Drug"),
+    outputs=gr.JSON(label="Output"),
+    title="Pregnancy & Lactation",
+    api_name="pregnancy_lactation",
+    description="Return Pregnancy & Lactation text from FDA label.",
+)
+
+adjustments_ui = gr.Interface(
+    fn=drug_dose_adjustments_mcp,
+    inputs=gr.Text(label="Drug"),
+    outputs=gr.JSON(label="Output"),
+    title="Dose Adjustments",
+    api_name="dose_adjustments",
+    description="Return renal & hepatic dosing excerpts from FDA label.",
+)
+
+livertox_ui = gr.Interface(
+    fn=drug_livertox_summary_mcp,
+    inputs=gr.Text(label="Drug Name"),
+    outputs=gr.JSON(label="Output"),
+    title="LiverTox Summary",
+    api_name="livertox_summary",
+    description="Get hepatotoxicity information.",
+)
+
+brand_generic_ui = gr.Interface(
+    fn=brand_to_generic_lookup_mcp,
+    inputs=[
+        gr.Text(label="Brand Name"),
+        gr.Text(
+            label="Preferred Countries (comma-separated ISO codes, e.g., US,CA)",
+            value="US",
+        ),
+    ],
+    outputs=gr.JSON(label="Output"),
+    title="Brand to Generic",
+    api_name="brand_to_generic",
+    description="Look up generic drug information.",
+)
+
+dbi_calculator_ui = gr.Interface(
+    fn=calculate_drug_burden_index_mcp,
+    inputs=[
+        gr.Textbox(
+            label="Drug List (one per line, include dose and frequency)",
+            lines=10,
+            placeholder="e.g., Aspirin 100mg daily\nFurosemide 40mg PRN",
+        ),
+        gr.Text(label="Route of Administration", value="oral"),
+    ],
+    outputs=gr.JSON(label="DBI Calculation"),
+    title="DBI Calculator",
+    api_name="dbi_calculator",
+    description="Calculate Drug Burden Index (DBI) from a list of medications. Supports PRN and various dose formats.",
+)
+
+cockcroft_gault_ui = gr.Interface(
+    fn=calculate_creatinine_clearance_mcp,
+    inputs=[
+        gr.Text(label="Age (years)", value="65"),
+        gr.Text(label="Weight (kg)", value="70"),
+        gr.Text(label="Serum Creatinine (mg/dL)", value="1.2"),
+        gr.Text(label="Is Female (true/false)", value="false"),
+    ],
+    outputs=gr.JSON(label="Creatinine Clearance"),
+    title="Cockcroft-Gault Calculator",
+    api_name="cockcroft_gault",
+    description="Calculate creatinine clearance using Cockcroft-Gault equation for dose adjustments.",
+)
+
+ckd_epi_ui = gr.Interface(
+    fn=calculate_egfr_mcp,
+    inputs=[
+        gr.Text(label="Age (years)", value="65"),
+        gr.Text(label="Serum Creatinine (mg/dL)", value="1.2"),
+        gr.Text(label="Is Female (true/false)", value="false"),
+        gr.Text(label="Is Black (true/false)", value="false"),
+    ],
+    outputs=gr.JSON(label="eGFR"),
+    title="CKD-EPI eGFR Calculator",
+    api_name="ckd_epi",
+    description="Calculate estimated glomerular filtration rate using CKD-EPI equation.",
+)
+
+child_pugh_ui = gr.Interface(
+    fn=calculate_child_pugh_score_mcp,
+    inputs=[
+        gr.Text(label="Total Bilirubin (mg/dL)", value="1.5"),
+        gr.Text(label="Serum Albumin (g/dL)", value="3.5"),
+        gr.Text(label="INR", value="1.3"),
+        gr.Dropdown(["none", "mild", "moderate-severe"], value="none", label="Ascites"),
+        gr.Dropdown(
+            ["none", "grade-1-2", "grade-3-4"], value="none", label="Encephalopathy"
+        ),
+    ],
+    outputs=gr.JSON(label="Child-Pugh Score"),
+    title="Child-Pugh Score Calculator",
+    api_name="child_pugh",
+    description="Calculate Child-Pugh score for liver function assessment and dose adjustments.",
+)
+
+bmi_ui = gr.Interface(
+    fn=calculate_bmi_mcp,
+    inputs=[
+        gr.Text(label="Weight (kg)", value="70"),
+        gr.Text(label="Height (cm)", value="170"),
+    ],
+    outputs=gr.JSON(label="BMI Calculation"),
+    title="BMI Calculator",
+    api_name="bmi_calculator",
+    description="Calculate Body Mass Index and weight category assessment.",
+)
+
+ideal_body_weight_ui = gr.Interface(
+    fn=calculate_ideal_body_weight_mcp,
+    inputs=[
+        gr.Text(label="Height (cm)", value="170"),
+        gr.Text(label="Is Male (true/false)", value="true"),
+    ],
+    outputs=gr.JSON(label="Ideal Body Weight Calculation"),
+    title="Ideal Body Weight (IBW) Calculator",
+    api_name="ideal_body_weight",
+    description="Calculate Ideal Body Weight using the Devine formula.",
+)
+
+dosing_weight_ui = gr.Interface(
+    fn=recommend_dosing_weight_mcp,
+    inputs=[
+        gr.Text(label="Actual Weight (kg)", value="85"),
+        gr.Text(label="Height (cm)", value="170"),
+        gr.Text(label="Is Male (true/false)", value="true"),
+    ],
+    outputs=gr.JSON(label="Dosing Weight Recommendation"),
+    title="Dosing Weight Calculator",
+    api_name="dosing_weight",
+    description="Recommend appropriate weight for medication dosing calculations.",
+)
+
+creatinine_convert_ui = gr.Interface(
+    fn=convert_creatinine_units_mcp,
+    inputs=[
+        gr.Text(label="Creatinine Value", value="1.2"),
+        gr.Dropdown(["mg_dl", "umol_l"], value="mg_dl", label="From Unit"),
+        gr.Dropdown(["mg_dl", "umol_l"], value="umol_l", label="To Unit"),
+    ],
+    outputs=gr.JSON(label="Converted Value"),
+    title="Creatinine Unit Converter",
+    api_name="creatinine_converter",
+    description="Convert creatinine values between mg/dL and μmol/L.",
+)
+
+demo = gr.TabbedInterface(
+    [
+        ae_search_ui,
+        ae_details_ui,
+        warnings_ui,
+        recalls_ui,
+        pregnancy_ui,
+        adjustments_ui,
+        livertox_ui,
+        brand_generic_ui,
+        dbi_calculator_ui,
+        cockcroft_gault_ui,
+        ckd_epi_ui,
+        child_pugh_ui,
+        bmi_ui,
+        ideal_body_weight_ui,
+        dosing_weight_ui,
+        creatinine_convert_ui,
+    ],
+    [
+        "AE Search",
+        "AE Details",
+        "Label Warnings",
+        "Recalls",
+        "Pregnancy",
+        "Dose Adjustments",
+        "LiverTox",
+        "Brand to Generic",
+        "DBI Calculator",
+        "Creatinine CL",
+        "eGFR",
+        "Child-Pugh",
+        "BMI",
+        "IBW",
+        "Dosing Weight",
+        "Unit Converter",
+    ],
+)
+
+if __name__ == "__main__":
+    logger.info("Starting Pharmacist MCP Server v1.1.0")
+    demo.launch(mcp_server=True, show_error=True)

brand_to_generic.py

@@ -0,0 +1,365 @@
+from __future__ import annotations
+
+import os
+import re
+import time
+import functools
+import logging
+from typing import Dict, List, Optional
+import requests
+import csv
+from io import StringIO
+
+logger = logging.getLogger(__name__)
+
+_session = requests.Session()
+
+
+class _Throttle:
+    """Simple host-level throttle (~1 rps)."""
+
+    _stamp: Dict[str, float] = {}
+
+    @classmethod
+    def wait(cls, host: str, gap: float = 1.0):
+        last = cls._stamp.get(host, 0.0)
+        now = time.time()
+        delta = now - last
+        if delta < gap:
+            time.sleep(gap - delta)
+        cls._stamp[host] = time.time()
+
+
+def _get(url: str, **kw):
+    host = requests.utils.urlparse(url).netloc
+    _Throttle.wait(host)
+    try:
+        requests_kwargs = {"timeout": 10}
+        if host in ("dmd.nhs.uk", "www.nhsbsa.nhs.uk"):
+            requests_kwargs["verify"] = False
+            logger.warning("Disabling SSL certificate verification for host: %s", host)
+
+        r = _session.get(url, **requests_kwargs, **kw)
+        r.raise_for_status()
+        return r
+    except Exception as exc:
+        logger.warning("%s → %s", url, exc)
+        return None
+
+
+_RX_RE_FMT = (
+    "https://rxnav.nlm.nih.gov/REST/rxcui/{rxcui}/related.json?rela=tradename_of"
+)
+
+
+@functools.lru_cache(maxsize=512)
+def _rxnorm_lookup(brand: str):
+    r = _get("https://rxnav.nlm.nih.gov/REST/rxcui.json", params={"name": brand})
+    if not r or not r.json().get("idGroup", {}).get("rxnormId"):
+        return []
+    rxcui = r.json()["idGroup"]["rxnormId"][0]
+    rel = _get(_RX_RE_FMT.format(rxcui=rxcui))
+    out = []
+    if rel:
+        for grp in rel.json().get("relatedGroup", {}).get("conceptGroup", []):
+            for c in grp.get("conceptProperties", []):
+                out.append(
+                    {
+                        "generic_name": c["name"],
+                        "strength": c.get("strength"),
+                        "dosage_form": c.get(
+                            "tty"
+                        ),  # SCDS/SCD etc. not ideal but indicative
+                        "route": None,
+                        "country": "US",
+                        "source": "RxNorm",
+                        "ids": {"rxcui": c["rxcui"]},
+                        "source_url": _RX_RE_FMT.format(rxcui=rxcui),
+                    }
+                )
+    return out
+
+
+_OPENFDA_NDC = "https://api.fda.gov/drug/ndc.json"
+
+
+@functools.lru_cache(maxsize=512)
+def _openfda_ndc(brand: str):
+    r = _get(_OPENFDA_NDC, params={"search": f'brand_name:"{brand}"', "limit": 20})
+    if not r:
+        return []
+    out: List[dict] = []
+    for prod in r.json().get("results", []):
+        api_gn = prod.get("generic_name")
+        display_gn: str
+        if isinstance(api_gn, str):
+            display_gn = api_gn  # Use the string directly
+        elif isinstance(api_gn, list):
+            display_gn = ", ".join(
+                str(g) for g in api_gn
+            )  # Join list elements, ensuring they are strings
+        else:
+            display_gn = ""  # Default for None or other unexpected types
+
+        out.append(
+            {
+                "generic_name": display_gn,
+                "strength": prod.get("active_ingredients", [{}])[0].get("strength"),
+                "dosage_form": prod.get("dosage_form"),
+                "route": prod.get("route"),
+                "country": "US",
+                "source": "openFDA-NDC",
+                "ids": {"ndc": prod.get("product_ndc"), "spl_id": prod.get("spl_id")},
+                "source_url": _OPENFDA_NDC,
+            }
+        )
+    return out
+
+
+_DPD = "https://health-products.canada.ca/api/drug/drugproduct/"
+
+
+@functools.lru_cache(maxsize=512)
+def _dpd_lookup(brand: str):
+    r = _get(_DPD, params={"brandname": brand, "lang": "en", "type": "json"})
+    if not r:
+        return []
+    out = []
+    for prod in r.json():
+        for ai in prod.get("active_ingredient", []):
+            out.append(
+                {
+                    "generic_name": ai.get("ingredient_name"),
+                    "strength": ai.get("strength"),
+                    "dosage_form": prod.get("dosage_form"),
+                    "route": prod.get("route_of_administration"),
+                    "country": "CA",
+                    "source": "Health Canada DPD",
+                    "ids": {"din": prod.get("drug_identification_number")},
+                    "source_url": _DPD,
+                }
+            )
+    return out
+
+
+_PBS_V3_BASE_URL = "https://data-api.health.gov.au/pbs/api/v3"
+_PBS_SUBSCRIPTION_KEY = os.getenv(
+    "PBS_API_SUBSCRIPTION_KEY", "2384af7c667342ceb5a736fe29f1dc6b"
+)
+
+
+def _pbs_v3_get(
+    endpoint: str, params: Optional[Dict] = None, accept_type: str = "application/json"
+):
+    """Helper to make GET requests to PBS API v3 with auth and throttling."""
+    url = f"{_PBS_V3_BASE_URL}/{endpoint}"
+    headers = {"subscription-key": _PBS_SUBSCRIPTION_KEY, "Accept": accept_type}
+    host = requests.utils.urlparse(url).netloc
+    _Throttle.wait(host, gap=5.0)  # PBS API specific throttle (1 req per 5 sec)
+    try:
+        r = _session.get(url, headers=headers, params=params, timeout=20)
+        r.raise_for_status()
+        return r
+    except Exception as exc:
+        logger.warning(
+            "PBS API v3 request failed for %s (params: %s): %s", url, params, exc
+        )
+        return None
+
+
+def _parse_li_form(li_form_str: Optional[str]) -> Dict[str, Optional[str]]:
+    """Parses strength and dosage form from an li_form string."""
+    if not li_form_str:
+        return {"strength": None, "dosage_form": None}
+
+    strength_regex = r"(\\d[\\d.,\\s]*(?:mg|mcg|g|mL|L|microlitres|nanograms|IU|%|mmol)(?:[\\s\\/][\\d.,\\s]*(?:mg|mcg|g|mL|L|microlitres|dose(?:s)?))?(?:\\s*\\(.*?\\))?(?:\\s+in\\s+[\\d.,\\s]*(?:mL|L|g|mg))?)"
+
+    strength_match = re.search(strength_regex, li_form_str, re.IGNORECASE)
+
+    extracted_strength = None
+    extracted_form = None
+
+    if strength_match:
+        extracted_strength = strength_match.group(0).strip()
+        form_before = li_form_str[: strength_match.start()].strip().rstrip(",").strip()
+        form_after = li_form_str[strength_match.end() :].strip().lstrip(",").strip()
+
+        if form_before and form_after:
+            extracted_form = f"{form_before} {form_after}".strip()
+        elif form_before:
+            extracted_form = form_before
+        elif form_after:
+            extracted_form = form_after
+
+    if not extracted_form and not extracted_strength:
+        if not re.search(r"\\d", li_form_str):
+            extracted_form = li_form_str.strip()
+        else:
+            extracted_form = li_form_str.strip()
+
+    return {
+        "strength": extracted_strength or None,
+        "dosage_form": extracted_form or None,
+    }
+
+
+@functools.lru_cache(maxsize=512)
+def _pbs_lookup(brand: str):
+    schedules_resp = _pbs_v3_get("schedules", params={"limit": 1})
+    if not schedules_resp:
+        return []
+    try:
+        schedules_data = schedules_resp.json()
+        if not schedules_data.get("data") or not schedules_data["data"][0].get(
+            "schedule_code"
+        ):
+            logger.warning(
+                "PBS API v3: Could not get schedule code from response: %s",
+                schedules_data,
+            )
+            return []
+        schedule_code = schedules_data["data"][0]["schedule_code"]
+    except (ValueError, IndexError, KeyError) as e:
+        logger.warning("PBS API v3: Error parsing schedules response: %s", e)
+        return []
+
+    items_resp = _pbs_v3_get(
+        "items",
+        params={"schedule_code": schedule_code, "brand_name": brand, "limit": 20},
+        accept_type="text/csv",
+    )
+    if not items_resp:
+        return []
+
+    out = []
+    try:
+        csv_text = items_resp.text
+        if not csv_text.strip():
+            logger.info(
+                "PBS API v3: Received empty CSV for brand '%s' with schedule '%s'",
+                brand,
+                schedule_code,
+            )
+            return []
+
+        csvfile = StringIO(csv_text)
+        reader = csv.DictReader(csvfile)
+        for row in reader:
+            li_form = row.get("li_form")
+            parsed_form_strength = _parse_li_form(li_form)
+
+            generic_name = row.get("drug_name", "").strip() or None
+
+            query_params = {
+                "schedule_code": schedule_code,
+                "brand_name": requests.utils.quote(brand),
+            }
+            source_url_params = "&".join([f"{k}={v}" for k, v in query_params.items()])
+            source_url = f"{_PBS_V3_BASE_URL}/items?{source_url_params}"
+
+            out.append(
+                {
+                    "generic_name": generic_name,
+                    "strength": parsed_form_strength["strength"],
+                    "dosage_form": parsed_form_strength["dosage_form"],
+                    "route": row.get("manner_of_administration", "").strip() or None,
+                    "country": "AU",
+                    "source": "PBS API v3",
+                    "ids": {"pbs_item_code": row.get("pbs_code", "").strip()},
+                    "source_url": source_url,
+                }
+            )
+    except csv.Error as e:
+        logger.warning(
+            "PBS API v3: CSV parsing error for brand '%s': %s. CSV content: %s",
+            brand,
+            e,
+            csv_text[:500],
+        )
+        return []
+    except Exception as e:
+        logger.exception(
+            "PBS API v3: Unexpected error processing items for brand '%s': %s", brand, e
+        )
+        return []
+
+    return out
+
+
+@functools.lru_cache(maxsize=512)
+def _pubchem_synonym_lookup(brand: str):
+    url = f"https://pubchem.ncbi.nlm.nih.gov/rest/pug/compound/name/{requests.utils.quote(brand)}/synonyms/JSON"
+    r = _get(url)
+    if not r:
+        return []
+    syns = (
+        r.json()
+        .get("InformationList", {})
+        .get("Information", [{}])[0]
+        .get("Synonym", [])
+    )
+    generic = syns[0]
+    if not generic:
+        return []
+    return [
+        {
+            "generic_name": generic,
+            "strength": None,
+            "dosage_form": None,
+            "route": None,
+            "country": None,
+            "source": "PubChem",
+            "ids": {},
+            "source_url": url,
+        }
+    ]
+
+
+def brand_lookup(
+    brand_name: str, *, prefer_countries: Optional[List[str]] = None
+) -> dict:
+    """Resolve *brand_name* to generic + strength/form using multiple datasets.
+
+    If a data source returns results, those results are processed and returned immediately.
+    Subsequent data sources are not queried.
+
+    ``prefer_countries`` (ISO alpha-2 list) controls result ordering for the successful source.
+    """
+    brand = brand_name.strip()
+
+    for fn in (
+        _pbs_lookup,
+        _rxnorm_lookup,
+        _openfda_ndc,
+        _dpd_lookup,
+        _pubchem_synonym_lookup,
+    ):
+        try:
+            current_results: List[dict] = fn(brand)
+            if current_results:
+                uniq = {}
+                for rec in current_results:
+                    key = (rec["generic_name"], rec.get("strength"), rec.get("country"))
+                    uniq[key] = rec
+
+                processed_results = list(uniq.values())
+
+                if prefer_countries:
+                    processed_results.sort(
+                        key=lambda r: (
+                            0 if r["country"] in prefer_countries else 1,
+                            r["country"] or "",
+                        )
+                    )
+
+                return {"brand_searched": brand, "results": processed_results}
+        except Exception as exc:
+            logger.exception("%s failed", fn.__name__)
+
+    return {"brand_searched": brand, "results": []}
+
+
+if __name__ == "__main__":
+    import sys, pprint
+
+    pprint.pp(brand_lookup(sys.argv[1] if len(sys.argv) > 1 else "Panadol Rapid"))

caching.py

@@ -0,0 +1,70 @@
+import json
+import hashlib
+import logging
+from datetime import datetime, timedelta
+from functools import wraps
+from typing import Dict, Any, Optional
+
+logger = logging.getLogger(__name__)
+
+class SimpleCache:
+    def __init__(self, default_ttl: int = 3600):
+        self.cache: Dict[str, Dict[str, Any]] = {}
+        self.default_ttl = default_ttl
+    
+    def _is_expired(self, entry: Dict[str, Any]) -> bool:
+        return datetime.now() > entry['expires']
+    
+    def get(self, key: str) -> Optional[Any]:
+        if key in self.cache:
+            entry = self.cache[key]
+            if not self._is_expired(entry):
+                logger.debug(f"Cache hit for key: {key}")
+                return entry['data']
+            else:
+                del self.cache[key]
+                logger.debug(f"Cache expired for key: {key}")
+        return None
+    
+    def set(self, key: str, data: Any, ttl: Optional[int] = None) -> None:
+        ttl = ttl or self.default_ttl
+        self.cache[key] = {
+            'data': data,
+            'expires': datetime.now() + timedelta(seconds=ttl)
+        }
+        logger.debug(f"Cached data for key: {key}")
+
+api_cache = SimpleCache()
+
+def generate_cache_key(*args: Any, **kwargs: Any) -> str:
+    """Generate a cache key from function arguments."""
+    try:
+        # Convert args to strings to avoid serialization issues
+        safe_args = []
+        for arg in args:
+            if isinstance(arg, (str, int, float, bool, type(None))):
+                safe_args.append(arg)
+            else:
+                safe_args.append(str(arg))
+        
+        key_data = json.dumps([safe_args, sorted(kwargs.items())], sort_keys=True, default=str)
+        return hashlib.md5(key_data.encode()).hexdigest()
+    except Exception:
+        fallback_key = f"{args}_{kwargs}"
+        return hashlib.md5(fallback_key.encode()).hexdigest()
+
+def with_caching(ttl: int = 3600):
+    """Decorator to add caching to functions."""
+    def decorator(func):
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            cache_key = f"{func.__name__}:{generate_cache_key(*args, **kwargs)}"
+            cached_result = api_cache.get(cache_key)
+            if cached_result is not None:
+                return cached_result
+            
+            result = func(*args, **kwargs)
+            api_cache.set(cache_key, result, ttl)
+            return result
+        return wrapper
+    return decorator 

clinical_calculators.py

@@ -0,0 +1,436 @@
+"""
+Clinical Calculator Suite - Phase 1.2 MCP Development
+Implements common clinical calculations for pharmacist workflow
+"""
+
+import logging
+from typing import Dict, Any
+
+logger = logging.getLogger(__name__)
+
+def cockcroft_gault_creatinine_clearance(
+    age: int,
+    weight_kg: float,
+    serum_creatinine_mg_dl: float,
+    is_female: bool = False
+) -> Dict[str, Any]:
+    """
+    Calculate creatinine clearance using Cockcroft-Gault equation.
+    
+    Args:
+        age: Patient age in years
+        weight_kg: Weight in kilograms
+        serum_creatinine_mg_dl: Serum creatinine in mg/dL
+        is_female: True if patient is female
+    
+    Returns:
+        Dict with calculated creatinine clearance and interpretation
+    """
+    if age <= 0 or weight_kg <= 0 or serum_creatinine_mg_dl <= 0:
+        raise ValueError("All values must be positive")
+    
+    clearance = ((140 - age) * weight_kg) / (72 * serum_creatinine_mg_dl)
+    
+    if is_female:
+        clearance *= 0.85
+    
+    if clearance >= 90:
+        stage = "Normal or high"
+        category = "G1"
+    elif clearance >= 60:
+        stage = "Mildly decreased"
+        category = "G2"
+    elif clearance >= 45:
+        stage = "Mild to moderately decreased"
+        category = "G3a"
+    elif clearance >= 30:
+        stage = "Moderately to severely decreased"
+        category = "G3b"
+    elif clearance >= 15:
+        stage = "Severely decreased"
+        category = "G4"
+    else:
+        stage = "Kidney failure"
+        category = "G5"
+    
+    return {
+        "creatinine_clearance_ml_min": round(clearance, 1),
+        "kidney_function_stage": stage,
+        "gfr_category": category,
+        "formula_used": "Cockcroft-Gault",
+        "requires_dose_adjustment": clearance < 60,
+        "patient_info": {
+            "age": age,
+            "weight_kg": weight_kg,
+            "serum_creatinine_mg_dl": serum_creatinine_mg_dl,
+            "is_female": is_female
+        }
+    }
+
+def ckd_epi_egfr(
+    age: int,
+    serum_creatinine_mg_dl: float,
+    is_female: bool = False,
+    is_black: bool = False
+) -> Dict[str, Any]:
+    """
+    Calculate estimated GFR using CKD-EPI equation.
+    
+    Args:
+        age: Patient age in years
+        serum_creatinine_mg_dl: Serum creatinine in mg/dL
+        is_female: True if patient is female
+        is_black: True if patient is Black
+    
+    Returns:
+        Dict with calculated eGFR and interpretation
+    """
+    if age <= 0 or serum_creatinine_mg_dl <= 0:
+        raise ValueError("Age and creatinine must be positive")
+    
+    if is_female:
+        kappa = 0.7
+        alpha = -0.329
+        if serum_creatinine_mg_dl <= kappa:
+            alpha = -0.411
+    else:
+        kappa = 0.9
+        alpha = -0.411
+        if serum_creatinine_mg_dl <= kappa:
+            alpha = -0.302
+    
+    scr_kappa_ratio = serum_creatinine_mg_dl / kappa
+    if serum_creatinine_mg_dl <= kappa:
+        egfr = 141 * (scr_kappa_ratio ** alpha) * (0.993 ** age)
+    else:
+        egfr = 141 * (scr_kappa_ratio ** -1.209) * (0.993 ** age)
+    
+    if is_female:
+        egfr *= 1.018
+    
+    if is_black:
+        egfr *= 1.159
+    
+    if egfr >= 90:
+        stage = "Normal or high"
+        category = "G1"
+    elif egfr >= 60:
+        stage = "Mildly decreased"
+        category = "G2"
+    elif egfr >= 45:
+        stage = "Mild to moderately decreased"
+        category = "G3a"
+    elif egfr >= 30:
+        stage = "Moderately to severely decreased"
+        category = "G3b"
+    elif egfr >= 15:
+        stage = "Severely decreased"
+        category = "G4"
+    else:
+        stage = "Kidney failure"
+        category = "G5"
+    
+    return {
+        "egfr_ml_min_1_73m2": round(egfr, 1),
+        "kidney_function_stage": stage,
+        "gfr_category": category,
+        "formula_used": "CKD-EPI",
+        "requires_dose_adjustment": egfr < 60,
+        "patient_info": {
+            "age": age,
+            "serum_creatinine_mg_dl": serum_creatinine_mg_dl,
+            "is_female": is_female,
+            "is_black": is_black
+        }
+    }
+
+def child_pugh_score(
+    bilirubin_mg_dl: float,
+    albumin_g_dl: float,
+    inr: float,
+    ascites: str,
+    encephalopathy: str
+) -> Dict[str, Any]:
+    """
+    Calculate Child-Pugh score for liver function assessment.
+    
+    Args:
+        bilirubin_mg_dl: Total bilirubin in mg/dL
+        albumin_g_dl: Serum albumin in g/dL
+        inr: International Normalized Ratio
+        ascites: 'none', 'mild', or 'moderate-severe'
+        encephalopathy: 'none', 'grade-1-2', or 'grade-3-4'
+    
+    Returns:
+        Dict with Child-Pugh score, class, and interpretation
+    """
+    score = 0
+    
+    if bilirubin_mg_dl < 2:
+        score += 1
+    elif bilirubin_mg_dl <= 3:
+        score += 2
+    else:
+        score += 3
+    
+    if albumin_g_dl > 3.5:
+        score += 1
+    elif albumin_g_dl >= 2.8:
+        score += 2
+    else:
+        score += 3
+    
+    if inr < 1.7:
+        score += 1
+    elif inr <= 2.3:
+        score += 2
+    else:
+        score += 3
+    
+    ascites_lower = ascites.lower()
+    if 'none' in ascites_lower:
+        score += 1
+    elif 'mild' in ascites_lower:
+        score += 2
+    else:
+        score += 3
+    
+    encephalopathy_lower = encephalopathy.lower()
+    if 'none' in encephalopathy_lower:
+        score += 1
+    elif 'grade-1-2' in encephalopathy_lower or '1-2' in encephalopathy_lower:
+        score += 2
+    else:
+        score += 3
+    
+    if score <= 6:
+        child_class = "A"
+        mortality_1yr = "< 10%"
+        mortality_2yr = "< 15%"
+        perioperative_mortality = "10%"
+    elif score <= 9:
+        child_class = "B"
+        mortality_1yr = "10-20%"
+        mortality_2yr = "20-30%"
+        perioperative_mortality = "30%"
+    else:
+        child_class = "C"
+        mortality_1yr = "> 20%"
+        mortality_2yr = "> 35%"
+        perioperative_mortality = "50%"
+    
+    return {
+        "child_pugh_score": score,
+        "child_pugh_class": child_class,
+        "one_year_mortality": mortality_1yr,
+        "two_year_mortality": mortality_2yr,
+        "perioperative_mortality": perioperative_mortality,
+        "requires_dose_adjustment": child_class in ["B", "C"],
+        "severe_impairment": child_class == "C",
+        "components": {
+            "bilirubin_mg_dl": bilirubin_mg_dl,
+            "albumin_g_dl": albumin_g_dl,
+            "inr": inr,
+            "ascites": ascites,
+            "encephalopathy": encephalopathy
+        }
+    }
+
+def bmi_calculator(
+    weight_kg: float,
+    height_cm: float
+) -> Dict[str, Any]:
+    """
+    Calculate Body Mass Index and provide interpretation.
+    
+    Args:
+        weight_kg: Weight in kilograms
+        height_cm: Height in centimeters
+    
+    Returns:
+        Dict with BMI and weight category
+    """
+    if weight_kg <= 0 or height_cm <= 0:
+        raise ValueError("Weight and height must be positive")
+    
+    height_m = height_cm / 100
+    bmi = weight_kg / (height_m ** 2)
+    
+    if bmi < 18.5:
+        category = "Underweight"
+        risk = "Increased risk of malnutrition"
+    elif bmi < 25:
+        category = "Normal weight"
+        risk = "Low risk"
+    elif bmi < 30:
+        category = "Overweight"
+        risk = "Increased risk"
+    elif bmi < 35:
+        category = "Obesity Class I"
+        risk = "High risk"
+    elif bmi < 40:
+        category = "Obesity Class II"
+        risk = "Very high risk"
+    else:
+        category = "Obesity Class III"
+        risk = "Extremely high risk"
+    
+    return {
+        "bmi": round(bmi, 1),
+        "category": category,
+        "health_risk": risk,
+        "weight_kg": weight_kg,
+        "height_cm": height_cm
+    }
+
+def ideal_body_weight(
+    height_cm: float,
+    is_male: bool = True
+) -> Dict[str, Any]:
+    """
+    Calculate Ideal Body Weight using Devine formula.
+    
+    Args:
+        height_cm: Height in centimeters
+        is_male: True if patient is male
+    
+    Returns:
+        Dict with ideal body weight
+    """
+    if height_cm <= 0:
+        raise ValueError("Height must be positive")
+    
+    height_inches = height_cm / 2.54
+    
+    if is_male:
+        ibw_kg = 50 + 2.3 * (height_inches - 60)
+    else:
+        ibw_kg = 45.5 + 2.3 * (height_inches - 60)
+    
+    ibw_kg = max(ibw_kg, 30)
+    
+    return {
+        "ideal_body_weight_kg": round(ibw_kg, 1),
+        "height_cm": height_cm,
+        "is_male": is_male,
+        "formula_used": "Devine"
+    }
+
+def adjusted_body_weight(
+    actual_weight_kg: float,
+    ideal_weight_kg: float,
+    correction_factor: float = 0.4
+) -> Dict[str, Any]:
+    """
+    Calculate Adjusted Body Weight for obese patients.
+    
+    Args:
+        actual_weight_kg: Actual body weight in kg
+        ideal_weight_kg: Ideal body weight in kg
+        correction_factor: Correction factor (default 0.4)
+    
+    Returns:
+        Dict with adjusted body weight
+    """
+    if actual_weight_kg <= 0 or ideal_weight_kg <= 0:
+        raise ValueError("Weights must be positive")
+    
+    if actual_weight_kg <= ideal_weight_kg * 1.2:
+        adjusted_weight = actual_weight_kg
+        adjustment_needed = False
+    else:
+        adjusted_weight = ideal_weight_kg + correction_factor * (actual_weight_kg - ideal_weight_kg)
+        adjustment_needed = True
+    
+    return {
+        "adjusted_body_weight_kg": round(adjusted_weight, 1),
+        "actual_weight_kg": actual_weight_kg,
+        "ideal_weight_kg": ideal_weight_kg,
+        "correction_factor": correction_factor,
+        "adjustment_needed": adjustment_needed,
+        "percent_above_ideal": round(((actual_weight_kg / ideal_weight_kg) - 1) * 100, 1)
+    }
+
+def creatinine_conversion(
+    creatinine_value: float,
+    from_unit: str,
+    to_unit: str
+) -> Dict[str, Any]:
+    """
+    Convert creatinine between mg/dL and μmol/L.
+    
+    Args:
+        creatinine_value: Creatinine value to convert
+        from_unit: 'mg_dl' or 'umol_l'
+        to_unit: 'mg_dl' or 'umol_l'
+    
+    Returns:
+        Dict with converted value
+    """
+    if creatinine_value <= 0:
+        raise ValueError("Creatinine value must be positive")
+    
+    conversion_factor = 88.42
+    
+    if from_unit == to_unit:
+        converted_value = creatinine_value
+    elif from_unit == 'mg_dl' and to_unit == 'umol_l':
+        converted_value = creatinine_value * conversion_factor
+    elif from_unit == 'umol_l' and to_unit == 'mg_dl':
+        converted_value = creatinine_value / conversion_factor
+    else:
+        raise ValueError("Invalid units. Use 'mg_dl' or 'umol_l'")
+    
+    return {
+        "original_value": creatinine_value,
+        "original_unit": from_unit,
+        "converted_value": round(converted_value, 2),
+        "converted_unit": to_unit,
+        "conversion_factor": conversion_factor
+    }
+
+def dosing_weight_recommendation(
+    actual_weight_kg: float,
+    height_cm: float,
+    is_male: bool = True
+) -> Dict[str, Any]:
+    """
+    Recommend appropriate weight for dosing calculations.
+    
+    Args:
+        actual_weight_kg: Actual body weight in kg
+        height_cm: Height in centimeters
+        is_male: True if patient is male
+    
+    Returns:
+        Dict with dosing weight recommendation
+    """
+    ibw_result = ideal_body_weight(height_cm, is_male)
+    ibw = ibw_result["ideal_body_weight_kg"]
+    
+    bmi_result = bmi_calculator(actual_weight_kg, height_cm)
+    bmi = bmi_result["bmi"]
+    
+    if actual_weight_kg <= ibw * 1.2:
+        dosing_weight = actual_weight_kg
+        recommendation = "Use actual body weight"
+        rationale = "Patient weight is within 20% of ideal body weight"
+    elif bmi >= 30:
+        adj_weight_result = adjusted_body_weight(actual_weight_kg, ibw)
+        dosing_weight = adj_weight_result["adjusted_body_weight_kg"]
+        recommendation = "Use adjusted body weight"
+        rationale = "Patient is obese (BMI ≥ 30); adjusted weight recommended for most drugs"
+    else:
+        dosing_weight = actual_weight_kg
+        recommendation = "Use actual body weight (consider drug-specific guidelines)"
+        rationale = "Patient is overweight but not obese; actual weight typically appropriate"
+    
+    return {
+        "recommended_dosing_weight_kg": dosing_weight,
+        "recommendation": recommendation,
+        "rationale": rationale,
+        "actual_weight_kg": actual_weight_kg,
+        "ideal_weight_kg": ibw,
+        "bmi": bmi,
+        "bmi_category": bmi_result["category"]
+    } 

dbi_mcp.py

@@ -0,0 +1,293 @@
+from __future__ import annotations
+
+import math
+import re
+import logging
+import functools
+from pathlib import Path
+from typing import Dict, List, Tuple, Optional, Union, Mapping, Sequence
+
+from brand_to_generic import brand_lookup
+
+import csv
+
+try:
+    import pandas as pd
+except ImportError:
+    pd = None 
+
+__all__ = [
+    "load_reference",
+    "load_patient_meds",
+    "calculate_dbi",
+    "print_report",
+]
+
+PatientInput = Union[
+    Path,
+    Sequence[Tuple[str, float]],
+    Mapping[str, float],
+]
+
+
+def _normalise_name(name: str) -> str:
+    """Strip/-lower a drug name for key matching."""
+    return name.strip().lower()
+
+
+def load_reference(
+    ref_path: Path,
+    *,
+    route: str = "oral",
+    use_pandas: bool | None = None,
+) -> Dict[str, Tuple[float, str]]:
+    """Return mapping **generic → (δ<sub>route</sub>, drug_class)**.
+
+    If a drug lacks the requested route it is silently skipped.  Callers may
+    retry with ``route=None`` to get the *first* available dose instead.
+    """
+    if use_pandas is None:
+        use_pandas = pd is not None
+
+    ref: Dict[str, Tuple[float, str]] = {}
+
+    if use_pandas:
+        df = pd.read_csv(ref_path)
+        df = df[df["route"].str.lower() == route.lower()]
+        for _, row in df.iterrows():
+            ref[_normalise_name(row["generic_name"])] = (
+                float(row["min_daily_dose_mg"]),
+                row["drug_class"].strip().lower(),
+            )
+    else:
+        with ref_path.open(newline="") as f:
+            rdr = csv.DictReader(f)
+            for row in rdr:
+                if row["route"].strip().lower() != route.lower():
+                    continue
+                ref[_normalise_name(row["generic_name"])] = (
+                    float(row["min_daily_dose_mg"]),
+                    row["drug_class"].strip().lower(),
+                )
+
+    return ref
+
+def calculate_dbi(
+    patient_meds: Mapping[str, float],
+    reference: Mapping[str, Tuple[float, str]],
+) -> Tuple[float, List[Tuple[str, float, float, float]]]:
+    """Return ``(total, details)`` where *details* is a list of
+    ``(generic_name, dose_mg, δ_mg, DBI_i)``.
+    """
+    details: List[Tuple[str, float, float, float]] = []
+    total = 0.0
+
+    for drug, dose in patient_meds.items():
+        ref = reference.get(drug)
+        if not ref:
+            continue  # unknown or route-mismatch
+        delta, drug_class = ref
+        if drug_class not in {"anticholinergic", "sedative", "both"}:
+            continue
+        dbi_i = dose / (delta + dose)
+        details.append((drug, dose, delta, dbi_i))
+        total += dbi_i
+
+    return total, details
+
+
+logger = logging.getLogger(__name__)
+
+UNIT_PAT = re.compile(r"(?P<val>\d+(?:[.,]\d+)?)(?:\s*)(?P<unit>mcg|μg|mg|g)\b", re.I)
+
+PATCH_PAT = re.compile(r"(?P<val>\d+(?:[.,]\d+)?)(?:\s*)(mcg|μg)\s*/\s*hr", re.I)
+
+CONC_PAT = re.compile(r"(?P<drug_val>\d+(?:[.,]\d+)?)(?:\s*)(?P<drug_unit>mcg|μg|mg|g)\s*/\s*(?P<vol_val>\d+(?:[.,]\d+)?)(?:\s*)m ?l", re.I)
+
+VOL_PAT = re.compile(r"(?P<voldose>\d+(?:[.,]\d+)?)(?:\s*)m ?l", re.I)
+
+QTY_PAT = re.compile(r"(?<!\d)(?P<qty>\d+)\s*(?:tab|caps?|puff|spray|patch|patches)s?\b", re.I)
+
+FREQ_PAT = re.compile(r"\b(q\d{1,2}h|qd|od|daily|once daily|bid|bd|twice daily|tid|tds|three times daily|qid|four times daily|nocte|mane|am|pm)\b", re.I)
+EVERY_HOURS_PAT = re.compile(r"q(\d{1,2})h", re.I)
+
+_FREQ_MAP = {
+    "qd": 1, "od": 1, "daily": 1, "once daily": 1,
+    "bid": 2, "bd": 2, "twice daily": 2,
+    "tid": 3, "tds": 3, "three times daily": 3,
+    "qid": 4, "four times daily": 4,
+    "nocte": 1, "pm": 1,
+    "mane": 1, "am": 1,
+}
+
+def _unit_to_mg(val: float, unit: str) -> float:
+    unit = unit.lower()
+    if unit == "mg":
+        return val
+    if unit in {"g"}:
+        return val * 1_000
+    if unit in {"mcg", "μg"}:
+        return val / 1_000
+    return math.nan
+
+
+def _freq_to_per_day(token: str) -> float:
+    token = token.lower()
+    if token in _FREQ_MAP:
+        return _FREQ_MAP[token]
+    m = EVERY_HOURS_PAT.fullmatch(token)
+    if m:
+        hrs = int(m.group(1))
+        return 24 / hrs if hrs else 1
+    return 1
+
+Parsed = Tuple[str, float, bool]
+
+@functools.lru_cache(maxsize=2048)
+def _parse_line(line: str) -> Optional[Parsed]:
+    original = line.strip()
+    if not original:
+        return None
+
+    is_prn = "prn" in original.lower()
+
+    m_patch = PATCH_PAT.search(original)
+    if m_patch:
+        mcg_hr = float(m_patch.group("val").replace(",", "."))
+        mg_day = (mcg_hr * 24) / 1_000  # µg/hr → mg/day
+        name_part = PATCH_PAT.sub("", original).split()[0]
+        return (name_part, mg_day, is_prn)
+
+    m_conc = CONC_PAT.search(original)
+    m_vol  = VOL_PAT.search(original)
+    if m_conc and m_vol:
+        drug_val = _unit_to_mg(float(m_conc.group("drug_val").replace(",", ".")), m_conc.group("drug_unit"))
+        vol_val  = float(m_conc.group("vol_val").replace(",", "."))
+        voldose  = float(m_vol.group("voldose").replace(",", "."))
+        if vol_val == 0:
+            logger.warning("volume 0 in concentration parse – %s", original)
+            return None
+        mg_per_dose = drug_val * (voldose / vol_val)
+        qty = 1
+        freq = 1.0
+        m_freq = FREQ_PAT.search(original)
+        if m_freq:
+            freq = _freq_to_per_day(m_freq.group(0))
+        mg_day = mg_per_dose * freq
+        name_part = CONC_PAT.split(original)[0].strip()
+        return (name_part, mg_day, is_prn)
+
+    m = UNIT_PAT.search(original)
+    if m:
+        strength_mg = _unit_to_mg(float(m.group("val").replace(",", ".")), m.group("unit"))
+        qty = 1
+        m_qty = QTY_PAT.search(original)
+        if m_qty:
+            qty = int(m_qty.group("qty"))
+        freq = 1.0
+        m_freq = FREQ_PAT.search(original)
+        if m_freq:
+            freq = _freq_to_per_day(m_freq.group(0))
+        mg_day = strength_mg * qty * freq
+        name_part = original[:m.start()].strip()
+        name_part = re.sub(r"[^A-Za-z0-9\s]", " ", name_part)
+        name_part = re.sub(r"\s+", " ", name_part).strip()
+        return (name_part, mg_day, is_prn)
+
+    logger.debug("unhandled line: %s", original)
+    return None
+
+def _smart_drug_lookup(raw_name: str, reference_data: dict) -> str:
+    """
+    Smart drug name resolution that avoids unnecessary API calls.
+    
+    1. First checks if the name (or close variant) exists in reference data
+    2. Only calls brand_lookup API if not found in reference
+    3. Returns the best generic name match
+    """
+    clean_name = raw_name.strip().lower()
+    
+    if clean_name in reference_data:
+        logger.debug(f"Direct match found for '{raw_name}' in reference data")
+        return clean_name
+    
+    for ref_name in reference_data.keys():
+        if len(clean_name) >= 4 and len(ref_name) >= 4:
+            if clean_name in ref_name or ref_name in clean_name:
+                logger.debug(f"Partial match found: '{raw_name}' -> '{ref_name}' in reference data")
+                return ref_name
+    
+    common_variations = {
+        'acetaminophen': 'paracetamol',
+        'paracetamol': 'acetaminophen',
+        'hydrochlorothiazide': 'hctz',
+        'hctz': 'hydrochlorothiazide',
+        'furosemide': 'frusemide',
+        'frusemide': 'furosemide',
+    }
+    
+    if clean_name in common_variations:
+        alt_name = common_variations[clean_name]
+        if alt_name in reference_data:
+            logger.debug(f"Found common variation: '{raw_name}' -> '{alt_name}' in reference data")
+            return alt_name
+    
+    logger.debug(f"'{raw_name}' not found in reference data, trying brand lookup API")
+    try:
+        lookup = brand_lookup(raw_name)
+        if lookup["results"]:
+            generic_name = lookup["results"][0]["generic_name"].lower().strip()
+            logger.debug(f"Brand lookup successful: '{raw_name}' -> '{generic_name}'")
+            return generic_name
+        else:
+            logger.debug(f"Brand lookup returned no results for '{raw_name}'")
+            return clean_name
+    except Exception as e:
+        logger.warning(f"Brand lookup failed for '{raw_name}': {e}")
+        return clean_name
+
+
+def dbi_mcp(text_block: str, *, ref_csv: Union[str, Path] = "dbi_reference_by_route.csv", route: str = "oral") -> dict:
+    """End-to-end DBI calculator with dual PRN handling and smart drug name resolution."""
+    ref = load_reference(Path(ref_csv), route=route)
+    
+    parsed: List[Parsed] = []
+    unmatched: List[str] = []
+    for ln in text_block.splitlines():
+        res = _parse_line(ln)
+        if res:
+            parsed.append(res)
+        else:
+            unmatched.append(ln)
+
+    meds_with: Dict[str, float] = {}
+    meds_without: Dict[str, float] = {}
+
+    for raw_name, mg_day, is_prn in parsed:
+        generic = _smart_drug_lookup(raw_name, ref)
+        
+        meds_with[generic] = meds_with.get(generic, 0.0) + mg_day
+        if not is_prn:
+            meds_without[generic] = meds_without.get(generic, 0.0) + mg_day
+
+    total_no, details_no = calculate_dbi(meds_without, ref)
+    total_with, details_with = calculate_dbi(meds_with, ref)
+
+    def _details_to_list(details):
+        return [dict(generic_name=g, dose_mg_day=d, delta_mg=delta, dbi_component=dbi) for g, d, delta, dbi in details]
+
+    return {
+        "route": route,
+        "dbi_without_prn": round(total_no, 2),
+        "dbi_with_prn": round(total_with, 2),
+        "details_without_prn": _details_to_list(details_no),
+        "details_with_prn": _details_to_list(details_with),
+        "unmatched_input": unmatched,
+    }
+
+
+if __name__ == "__main__":
+    import sys
+    import pprint
+    text = sys.stdin.read() if not sys.stdin.isatty() else "\n".join(sys.argv[1:])
+    pprint.pp(dbi_mcp(text))

dbi_reference_by_route.csv

@@ -0,0 +1,119 @@
+generic_name,route,min_daily_dose_mg,drug_class
+alimemazine,oral,10,both
+amitriptyline,oral,10,both
+aripiprazole,oral,10,sedative
+aripiprazole,parenteral,10,sedative
+atropine,oral,0.6,anticholinergic
+atropine,parenteral,0.3,anticholinergic
+baclofen,oral,30,sedative
+baclofen,parenteral,30,sedative
+benzatropine,oral,0.5,anticholinergic
+benzatropine,parenteral,0.5,anticholinergic
+biperiden,oral,1,both
+brompheniramine,oral,16,both
+buclizine,oral,12.5,both
+buprenorphine,oral,0.12,sedative
+buprenorphine,parenteral,0.4,sedative
+buprenorphine,sublingual_buccal,0.12,sedative
+carbamazepine,oral,400,both
+carbamazepine,parenteral,500,both
+chlorphenamine,oral,8,both
+chlorphenamine,parenteral,3,both
+chlorpromazine,oral,30,both
+chlorpromazine,parenteral,6,both
+cinnarizine,oral,60,both
+clemastine,oral,2,both
+clomipramine,oral,30,both
+clonazepam,oral,0.5,sedative
+clonazepam,parenteral,0.5,sedative
+clozapine,oral,25,both
+cyclizine,oral,50,both
+cyclizine,parenteral,50,both
+cyproheptadine,oral,4,both
+dexchlorpheniramine,oral,8,both
+diazepam,oral,1,sedative
+diazepam,parenteral,1,sedative
+diazepam,sublingual_buccal,1,sedative
+dimenhydrinate,oral,150,both
+diphenhydramine,oral,50,both
+disopyramide,oral,300,anticholinergic
+disopyramide,parenteral,300,anticholinergic
+dosulepin,oral,50,both
+doxepin,oral,25,both
+doxylamine,oral,25,both
+fentanyl,oral,0.3,sedative
+fentanyl,parenteral,0.6,sedative
+fentanyl,sublingual_buccal,0.3,sedative
+flavoxate,oral,600,both
+flupentixol,oral,0.5,both
+flupentixol,parenteral,0.3,both
+fluphenazine,oral,0.36,both
+glycopyrronium,oral,2,both
+glycopyrronium,parenteral,0.2,both
+haloperidol,oral,0.5,sedative
+haloperidol,parenteral,0.25,sedative
+hydromorphone,oral,7.8,sedative
+hydromorphone,parenteral,2.6,sedative
+hydroxyzine,oral,25,both
+hyoscine base,oral,0.5,both
+hyoscine butylbromide,oral,30,anticholinergic
+hyoscine butylbromide,parenteral,30,anticholinergic
+hyoscine hydrobromide,oral,0.9,both
+hyoscine hydrobromide,parenteral,0.5,both
+imipramine,oral,30,both
+levomepromazine,oral,37.5,both
+levomepromazine,parenteral,37.5,both
+lofepramine,oral,140,both
+lorazepam,oral,0.5,sedative
+lorazepam,parenteral,0.5,sedative
+loxapine,oral,4.5,both
+meclozine,oral,25,both
+methocarbamol,oral,2.25e+03,both
+metoclopramide,oral,15,sedative
+metoclopramide,parenteral,15,sedative
+morphine,oral,20,sedative
+morphine,parenteral,6.7,sedative
+nefopam,oral,90,both
+nortriptyline,oral,30,both
+olanzapine,oral,5,both
+olanzapine,parenteral,5,both
+oxybutynin,oral,5,both
+oxybutynin,parenteral,1.95,both
+oxycodone,oral,20,sedative
+oxycodone,parenteral,10,sedative
+oxycodone,sublingual_buccal,20,sedative
+paliperidone,oral,3,sedative
+paliperidone,parenteral,0.89,sedative
+paroxetine,oral,20,both
+pentazocine,oral,300,sedative
+pentazocine,parenteral,180,sedative
+pericyazine,oral,5,both
+perphenazine,oral,3,both
+pethidine,oral,300,sedative
+pethidine,parenteral,150,sedative
+phenobarbital,oral,60,sedative
+phenobarbital,parenteral,60,sedative
+phenytoin,oral,200,sedative
+phenytoin,parenteral,200,sedative
+pimozide,oral,2,both
+pizotifen,oral,1.5,both
+prochlorperazine,oral,10,both
+prochlorperazine,parenteral,1.25,both
+prochlorperazine,sublingual_buccal,4,both
+promazine,oral,100,both
+promethazine,oral,20,both
+promethazine,parenteral,5,both
+propiverine,oral,15,both
+quetiapine,oral,50,both
+risperidone,oral,1,sedative
+risperidone,parenteral,0.7,sedative
+sulpiride,oral,400,both
+tizanidine,oral,6,both
+tolterodine,oral,2,both
+tramadol,oral,200,sedative
+tramadol,parenteral,200,sedative
+trifluoperazine,oral,2,both
+trimipramine,oral,37.5,both
+triprolidine,oral,10,both
+zuclopenthixol,oral,20,both
+zuclopenthixol,parenteral,11.4,both

drug_data_endpoints.py

@@ -0,0 +1,358 @@
+import requests
+import re
+import bs4
+from datasets import load_dataset
+import pandas as pd
+import logging
+
+from caching import with_caching
+from utils import with_error_handling, make_api_request
+
+logger = logging.getLogger(__name__)
+
+try:
+    livertox_dataset = load_dataset("cmcmaster/livertox", split="train")
+    livertox_df = livertox_dataset.to_pandas()
+    logger.info(f"Loaded LiverTox dataset with {len(livertox_df)} drugs")
+except Exception as e:
+    logger.error(f"Could not load LiverTox dataset: {e}")
+    livertox_df = None
+
+
+@with_error_handling
+@with_caching(ttl=1800)
+def search_adverse_events(drug_name: str, limit: int = 5):
+    """
+    Search FAERS for a drug and return brief summaries.
+
+    Args:
+        drug_name: Generic or brand name to search (case-insensitive).
+        limit: Maximum number of FAERS safety reports to return.
+
+    Returns:
+        Dict with a ``contexts`` key - list of objects ``{id, text}`` suitable
+        for an LLM to inject as context.
+    """
+    base_url = "https://api.fda.gov/drug/event.json"
+    query_params = {
+        "search": f'patient.drug.medicinalproduct:"{drug_name}"',
+        "limit": min(limit, 100)
+    }
+    
+    response = make_api_request(base_url, query_params)
+    
+    if response.status_code != 200:
+        raise requests.exceptions.RequestException(f"FAERS search failed: {response.status_code}")
+    
+    data = response.json()
+    ctx = []
+    for rec in data.get("results", []):
+        rid = rec.get("safetyreportid")
+        terms = [rx.get("reactionmeddrapt", "") for rx in rec.get("patient", {}).get("reaction", [])[:3]]
+        ctx.append({"id": str(rid), "text": "; ".join(terms)})
+    
+    return {
+        "contexts": ctx,
+        "total_found": data.get("meta", {}).get("results", {}).get("total", 0),
+        "query": drug_name
+    }
+
+@with_error_handling
+@with_caching(ttl=3600)
+def fetch_event_details(event_id: str):
+    """
+    Fetch a full FAERS case by safety-report ID.
+
+    Args:
+        event_id: Numeric FAERS ``safetyreportid`` string.
+
+    Returns:
+        Structured JSON with patient drugs, reactions, seriousness flag and the
+        full raw record (under ``full_record``).
+    """
+    base_url = "https://api.fda.gov/drug/event.json"
+    query_params = {
+        "search": f'safetyreportid:"{event_id}"'
+    }
+    
+    response = make_api_request(base_url, query_params)
+    
+    if response.status_code != 200:
+        raise requests.exceptions.RequestException(f"Event fetch failed: {response.status_code}")
+    
+    data = response.json()
+    if not data.get("results"):
+        raise ValueError("Record not found")
+    
+    rec = data["results"][0]
+    patient = rec.get("patient", {})
+    
+    return {
+        "event_id": event_id,
+        "drugs": [d.get("medicinalproduct") for d in patient.get("drug", [])],
+        "reactions": [rx.get("reactionmeddrapt") for rx in patient.get("reaction", [])],
+        "serious": bool(int(rec.get("serious", "0"))),
+        "full_record": rec
+    }
+
+@with_error_handling
+@with_caching(ttl=7200)
+def drug_label_warnings(drug_name: str):
+    """
+    Return boxed warning, contraindications, interactions text and parsed interaction table.
+
+    Args:
+        drug_name: Generic name preferred.
+
+    Returns:
+        Dict with ``boxed_warning``, ``contraindications``, 
+        ``drug_interactions_section`` (strings) and ``drug_interactions_table`` (parsed list).
+    """
+    base_url = "https://api.fda.gov/drug/label.json"
+    query_params = {
+        "search": f'openfda.generic_name:"{drug_name}"',
+        "limit": 1
+    }
+    
+    response = make_api_request(base_url, query_params)
+    
+    if response.status_code != 200:
+        raise requests.exceptions.RequestException(f"Label search failed: {response.status_code}")
+    
+    data = response.json()
+    if not data.get("results"):
+        raise ValueError("Label not found")
+    
+    lab = data["results"][0]
+
+    parsed_interactions_table = []
+    interactions_table_html_list = lab.get("drug_interactions_table", [])
+    if interactions_table_html_list:
+        interactions_table_html = interactions_table_html_list[0]
+        if interactions_table_html and isinstance(interactions_table_html, str) and "<table" in interactions_table_html:
+            soup = bs4.BeautifulSoup(interactions_table_html, "html.parser")
+            table = soup.find("table")
+            if table:
+                rows = table.find_all("tr")
+                for row in rows:
+                    cols = row.find_all("td")
+                    if len(cols) >= 2:
+                        col1_items = [item.get_text(strip=True) for item in cols[0].find_all("item")]
+                        col1_text = "; ".join(col1_items) if col1_items else cols[0].get_text(strip=True)
+                        
+                        col2_items = [item.get_text(strip=True) for item in cols[1].find_all("item")]
+                        col2_text = "; ".join(col2_items) if col2_items else cols[1].get_text(strip=True)
+                        
+                        if col1_text or col2_text:
+                            parsed_interactions_table.append({
+                                "drug_or_category1": col1_text,
+                                "drug_or_category2": col2_text
+                            })
+            else:
+                parsed_interactions_table.append({
+                    "raw_html_content": interactions_table_html, 
+                    "parsing_error": "No <table> tag found."
+                })
+
+    return {
+        "boxed_warning": lab.get("boxed_warning", [""])[0],
+        "contraindications": lab.get("contraindications", [""])[0],
+        "drug_interactions_section": lab.get("drug_interactions", [""])[0],
+        "drug_interactions_table": parsed_interactions_table if parsed_interactions_table else "Not found or not applicable.",
+        "drug_name": drug_name
+    }
+
+@with_error_handling
+@with_caching(ttl=3600)
+def drug_recalls(drug_name: str, limit: int = 5):
+    """
+    Return recent FDA recall events for a drug.
+
+    Args:
+        drug_name: Free-text search string.
+        limit: Max rows.
+
+    Returns:
+        List of recall notices with recall_number, status, classification, reason.
+    """
+    base_url = "https://api.fda.gov/drug/enforcement.json"
+    query_params = {
+        "search": f'product_description:"{drug_name}"',
+        "limit": min(limit, 50)
+    }
+    
+    response = make_api_request(base_url, query_params)
+    
+    if response.status_code != 200:
+        raise requests.exceptions.RequestException(f"Recall search failed: {response.status_code}")
+    
+    data = response.json()
+    events = []
+    for e in data.get("results", []):
+        events.append({
+            "recall_number": e.get("recall_number"),
+            "status": e.get("status"),
+            "classification": e.get("classification"),
+            "reason": e.get("reason_for_recall", "")[:120] + ("…" if len(e.get("reason_for_recall", "")) > 120 else "")
+        })
+    
+    return {
+        "recalls": events,
+        "total_found": data.get("meta", {}).get("results", {}).get("total", 0),
+        "query": drug_name
+    }
+
+
+LACTATION_PAT = re.compile(r"(?:8\.2\s*Lactation|Lactation\s*Risk\s*Summary)\s*(.*?)(?:\n\s*8\.\d|\n\s*[A-Z][a-z]+ and [A-Z][a-z]+ of Reproductive Potential|$)", re.I | re.S)
+REPRODUCTIVE_POTENTIAL_PAT = re.compile(r"(?:8\.3\s*(?:Females\s+and\s+Males\s+of\s+Reproductive\s+Potential|Reproductive\s+Potential))\s*(.*?)(?:\n\s*8\.\d|\n\s*[A-Z][a-z]+ Use|$)", re.I | re.S)
+
+@with_error_handling
+@with_caching(ttl=7200)
+def drug_pregnancy_lactation(drug_name: str):
+    """
+    Return Pregnancy & Lactation text from FDA label.
+
+    Args:
+        drug_name: Generic name preferred.
+
+    Returns:
+        Dict with pregnancy_text, pregnancy_registry, lactation_text, and reproductive_potential_text.
+    """
+    base_url = "https://api.fda.gov/drug/label.json"
+    query_params = {
+        "search": f'openfda.generic_name:"{drug_name}"',
+        "limit": 1
+    }
+    
+    response = make_api_request(base_url, query_params)
+    
+    if response.status_code != 200:
+        raise requests.exceptions.RequestException(f"Label search failed: {response.status_code}")
+    
+    data = response.json()
+    if not data.get("results"):
+        raise ValueError("Label not found")
+    
+    lab = data["results"][0]
+    
+    use_in_specific_populations_text = "\n".join(lab.get("use_in_specific_populations", []))
+
+    lactation_match = LACTATION_PAT.search(use_in_specific_populations_text)
+    lactation_text = lactation_match.group(1).strip() if lactation_match else lab.get("lactation", [""])[0]
+    if not lactation_text and lactation_match:
+        lactation_text = lactation_match.group(1).strip()
+    elif not lactation_text and not lab.get("lactation", [""])[0]:
+        lactation_text = "Not found or not specified in the label."
+
+    reproductive_potential_match = REPRODUCTIVE_POTENTIAL_PAT.search(use_in_specific_populations_text)
+    reproductive_potential_text = reproductive_potential_match.group(1).strip() if reproductive_potential_match else "Not found or not specified in the label."
+
+    return {
+        "pregnancy_text": lab.get("pregnancy", [""])[0] or "Not found or not specified in the label.",
+        "pregnancy_registry": lab.get("pregnancy_exposure_registry", [""])[0] or "Not specified.",
+        "lactation_text": lactation_text,
+        "reproductive_potential_text": reproductive_potential_text,
+        "drug_name": drug_name
+    }
+
+RENAL_PAT = re.compile(r"\brenal\b.*?\b(impairment|dysfunction|failure)\b", re.I | re.S)
+HEP_PAT   = re.compile(r"\bhepatic\b.*?\b(impairment|dysfunction|child(?:--|\s|-)?pugh)\b", re.I | re.S)
+
+@with_error_handling
+@with_caching(ttl=7200)
+def drug_dose_adjustments(drug_name: str):
+    """
+    Return renal & hepatic dosing excerpts from FDA label.
+
+    Args:
+        drug_name: Generic name.
+
+    Returns:
+        Dict with renal_excerpt and hepatic_excerpt strings (<=1000 chars each).
+    """
+    base_url = "https://api.fda.gov/drug/label.json"
+    query_params = {
+        "search": f'openfda.generic_name:"{drug_name}"',
+        "limit": 1
+    }
+    
+    response = make_api_request(base_url, query_params)
+    
+    if response.status_code != 200:
+        raise requests.exceptions.RequestException(f"Label search failed: {response.status_code}")
+    
+    data = response.json()
+    if not data.get("results"):
+        raise ValueError("Label not found")
+    
+    label = data["results"][0]
+    sections = "\n".join(label.get(k, [""])[0] for k in ("dosage_and_administration", "use_in_specific_populations"))
+    
+    renal = RENAL_PAT.search(sections)
+    hepatic = HEP_PAT.search(sections)
+    
+    return {
+        "renal_excerpt": renal.group(0)[:1000] if renal else "Not found",
+        "hepatic_excerpt": hepatic.group(0)[:1000] if hepatic else "Not found",
+        "drug_name": drug_name
+    }
+
+@with_error_handling
+@with_caching(ttl=1800)
+def drug_livertox_summary(drug_name: str):
+    """
+    Return hepatotoxicity summary from LiverTox dataset.
+
+    Args:
+        drug_name: Drug name to search for (case-insensitive).
+
+    Returns:
+        Dict with drug info including hepatotoxicity, management, trade names, etc.
+    """
+    if livertox_df is None:
+        raise ValueError("LiverTox dataset not available")
+    
+    drug_name_clean = drug_name.strip().lower()
+    
+    mask = livertox_df['drug_name'].str.lower() == drug_name_clean
+    matches = livertox_df[mask]
+    
+    if matches.empty:
+        mask = livertox_df['drug_name'].str.lower().str.contains(drug_name_clean, na=False)
+        matches = livertox_df[mask]
+    
+    if matches.empty:
+        mask = livertox_df['trade_names'].str.lower().str.contains(drug_name_clean, na=False)
+        matches = livertox_df[mask]
+    
+    if matches.empty:
+        raise ValueError(f"Drug '{drug_name}' not found in LiverTox dataset")
+    
+    drug_info = matches.iloc[0]
+    
+    response = {
+        "drug_name": drug_info.get('drug_name', 'N/A'),
+        "trade_names": drug_info.get('trade_names', 'N/A'),
+        "drug_class": drug_info.get('drug_class', 'N/A'),
+        "last_updated": drug_info.get('last_updated', 'N/A'),
+        "hepatotoxicity": drug_info.get('hepatotoxicity', 'N/A'),
+        "mechanism_of_injury": drug_info.get('mechanism_of_injury', 'N/A'),
+        "outcome_and_management": drug_info.get('outcome_and_management', 'N/A'),
+        "introduction": drug_info.get('introduction', 'N/A'),
+        "background": drug_info.get('background', 'N/A'),
+        "source": "LiverTox Dataset (cmcmaster/livertox)",
+        "total_matches": len(matches),
+        "query": drug_name
+    }
+    
+    if pd.notna(drug_info.get('components')):
+        try:
+            components = drug_info.get('components')
+            if isinstance(components, str) and components.startswith('['):
+                import ast
+                components = ast.literal_eval(components)
+            response["components"] = components
+        except:
+            response["components"] = drug_info.get('components')
+    
+    return response 

requirements.txt

@@ -0,0 +1,5 @@
+gradio
+requests
+datasets
+beautifulsoup4
+pandas

utils.py

@@ -0,0 +1,104 @@
+import time
+import json
+import logging
+import requests
+from datetime import datetime
+from functools import wraps
+from typing import Dict, Any
+
+logger = logging.getLogger(__name__)
+
+def with_error_handling(func):
+    """Decorator to add comprehensive error handling."""
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        start_time = time.time()
+        try:
+            safe_args = []
+            for i, arg in enumerate(args[:2]):
+                if isinstance(arg, (str, int, float, bool)):
+                    safe_args.append(str(arg))
+                else:
+                    safe_args.append(f"<{type(arg).__name__}>")
+            logger.info(f"Starting {func.__name__} with args: {safe_args}")
+            
+            result = func(*args, **kwargs)
+            
+            if isinstance(result, dict) and 'error' not in result:
+                result = standardize_response(result, func.__name__)
+            
+            execution_time = time.time() - start_time
+            logger.info(f"Completed {func.__name__} in {execution_time:.2f}s")
+            return result
+            
+        except requests.exceptions.Timeout:
+            logger.error(f"Timeout in {func.__name__}")
+            return create_error_response("Request timeout", func.__name__)
+        except requests.exceptions.ConnectionError:
+            logger.error(f"Connection error in {func.__name__}")
+            return create_error_response("Connection failed", func.__name__)
+        except requests.exceptions.RequestException as e:
+            logger.error(f"Request error in {func.__name__}: {e}")
+            return create_error_response(f"Request failed: {str(e)}", func.__name__)
+        except Exception as e:
+            logger.error(f"Unexpected error in {func.__name__}: {e}")
+            return create_error_response(f"Unexpected error: {str(e)}", func.__name__)
+    
+    return wrapper
+
+def standardize_response(data: Dict[str, Any], source: str) -> Dict[str, Any]:
+    """Standardize API response format with metadata."""
+    return {
+        "data": data,
+        "metadata": {
+            "source": source,
+            "timestamp": datetime.now().isoformat(),
+            "version": "1.1.0",
+            "cached": False
+        },
+        "status": "success"
+    }
+
+def create_error_response(error_msg: str, source: str) -> Dict[str, Any]:
+    """Create standardized error response."""
+    return {
+        "data": None,
+        "metadata": {
+            "source": source,
+            "timestamp": datetime.now().isoformat(),
+            "version": "1.1.0"
+        },
+        "status": "error",
+        "error": error_msg
+    }
+
+def make_api_request(url: str, params: Dict[str, Any], timeout: int = 15, max_retries: int = 3) -> requests.Response:
+    """Make API request with retry logic and rate limiting."""
+    for attempt in range(max_retries):
+        try:
+            time.sleep(0.1 * attempt)
+            response = requests.get(url, params=params, timeout=timeout)
+            if response.status_code == 429:
+                wait_time = 2 ** attempt
+                logger.warning(f"Rate limited, waiting {wait_time}s before retry {attempt + 1}")
+                time.sleep(wait_time)
+                continue
+            return response
+        except requests.exceptions.RequestException as e:
+            if attempt == max_retries - 1:
+                raise
+            logger.warning(f"Request attempt {attempt + 1} failed: {e}")
+    
+    raise requests.exceptions.RequestException("Max retries exceeded")
+
+def format_json_output(obj: Any) -> str:
+    """
+    Formats a Python object as a pretty-printed JSON string.
+
+    Args:
+        obj: The Python object to format.
+
+    Returns:
+        A JSON string with an indent of 2 and UTF-8 characters preserved.
+    """
+    return json.dumps(obj, indent=2, ensure_ascii=False)