NSAID-AKI: Transparent NSAID-Associated Acute Kidney Injury Risk-Context Stratification Before or During Therapy

Authors: Dr. Erick Zamora-Tehozol, DNAI, RheumaAI
ORCID: 0000-0002-7888-3961

Abstract

Nonsteroidal anti-inflammatory drugs (NSAIDs) remain common analgesic and anti-inflammatory agents across rheumatology and general medicine, but acute kidney injury (AKI) risk rises sharply in older adults, chronic kidney disease (CKD), heart failure, cirrhosis, volume depletion, and the classic ACE inhibitor or angiotensin receptor blocker plus diuretic setting. The bedside problem is practical: clinicians need a transparent way to decide when baseline renal vulnerability and evolving hemodynamic or laboratory signals should make NSAID use unsafe. We present NSAID-AKI, an executable Python skill for transparent NSAID-associated AKI risk-context stratification. The model combines current or planned NSAID exposure, high-dose or multiple-NSAID use, therapy duration, eGFR below 60 or below 30 mL/min/1.73 m², prior NSAID-associated AKI, heart failure or cirrhosis, volume depletion or sepsis, ACEi/ARB use, diuretic use, diabetes, albuminuria/proteinuric CKD, and active injury signals including rising creatinine, oliguria or hypotension, and hyperkalemia. Outputs include visible component scores, categorical risk classes, recommended actions, alerts, and explicit limitations. In demonstration scenarios, a short-course low-risk musculoskeletal pain case is LOW risk, an older CKD patient on ACEi and diuretic therapy starting high-dose NSAID is VERY HIGH risk, and a dehydrated heart-failure patient with rising creatinine during NSAID exposure is CONTRAINDICATED / CRITICAL. NSAID-AKI is designed as an auditable prescribing and triage aid rather than a validated probability calculator.

Keywords: NSAID, acute kidney injury, CKD, heart failure, cirrhosis, triple whammy, nephrotoxicity, clinical decision support, RheumaAI, DeSci

1. Clinical problem

NSAID nephrotoxicity is well known in principle and still missed in practice. The reason is not lack of awareness that NSAIDs can reduce renal perfusion. The operational problem is that risk becomes highest when several individually familiar features coexist: older age, reduced eGFR, diuretic use, renin-angiotensin system blockade, heart failure, cirrhosis, intercurrent dehydration, or early biochemical evidence of kidney injury. In busy clinical settings, those elements are often reviewed separately rather than synthesized into one explicit risk frame.

The result is preventable harm. Some patients receive avoidable NSAID exposure in high-risk states. Others already show rising creatinine or oliguria, but the medication context is not escalated urgently enough. A transparent executable tool can help standardize that reasoning.

2. Methodology

2.1 Design principles

NSAID-AKI follows five bedside principles:

1. Exposure still matters. High-dose or multiple NSAIDs and longer duration increase concern.
2. Baseline renal vulnerability matters. CKD, albuminuria, diabetes, prior NSAID-AKI, and advanced age narrow safety margins.
3. Hemodynamic stress matters. Heart failure, cirrhosis, dehydration, sepsis, ACEi/ARB therapy, and diuretics materially raise risk.
4. Active injury signals matter. Rising creatinine, oliguria, hypotension, and hyperkalemia should shift reasoning from prevention to urgent evaluation.
5. Transparency matters. The user should see why the tool escalated concern.

2.2 Model structure

The executable implementation computes four visible components:

• Exposure burden — NSAID exposure, high-dose or multiple-NSAID use, and duration
• Renal vulnerability — eGFR below 60, eGFR below 30, proteinuric CKD, prior NSAID-AKI, diabetes, and age
• Hemodynamic stress — heart failure/cirrhosis, volume depletion or sepsis, ACEi/ARB use, and diuretic use
• Injury signal — rising creatinine, oliguria or hypotension, and hyperkalemia

Interaction terms increase concern in the classic ACEi/ARB-plus-diuretic-plus-NSAID setting, in advanced CKD with higher NSAID intensity, in volume-depleted patients receiving NSAIDs, and when rising creatinine coexists with oliguria or hypotension. A small downward adjustment is allowed only for very short-course, low-risk use without CKD, dehydration, or triple-whammy context.

2.3 Output logic

The skill returns:

• Total score
• Risk class: LOW, HIGH, VERY HIGH, or CONTRAINDICATED / CRITICAL
• Recommended actions
• Safety alerts
• Explicit limitations

3. Executable skill

3.1 Implementation

The implementation is standalone Python using only the standard library and is stored locally at:

skills/nsaid-aki/nsaid_aki.py

3.2 Demo output summary

Short-course low-risk musculoskeletal pain treatment -> LOW
Older CKD patient on ACEi and diuretic starting high-dose NSAID -> VERY HIGH
Dehydrated heart failure patient with rising creatinine during NSAID exposure -> CONTRAINDICATED / CRITICAL

Representative critical output:

total_score: 99.0
risk_class: CONTRAINDICATED / CRITICAL
alert: Oliguria or hypotension suggests active hemodynamic compromise and warrants urgent assessment.

4. Why this solves a real problem

Existing nephrology and pharmacoepidemiology literature clearly identify NSAID-related AKI risk factors, but bedside prescribing often remains diffuse. NSAID-AKI narrows that gap. It does not attempt to generate a perfect individualized probability. Instead, it solves the more immediate clinical problem of making a dangerous renal context legible: when to avoid NSAIDs entirely, when to reassess the dose and indication, and when evolving laboratory or urine-output changes require urgent action.

5. Limitations

1. This is an evidence-informed heuristic tool, not a validated probability calculator for NSAID-associated AKI.
2. Weights are derived from mechanistic, observational, and guideline literature rather than prospective multivariable calibration.
3. The tool cannot resolve all alternative causes of creatinine rise, including obstruction, glomerulonephritis, or contrast nephropathy.
4. Medication lists may miss over-the-counter NSAIDs or duplicate exposure, which can materially underestimate risk.
5. Use only as a transparent decision-support aid alongside clinician judgment, direct examination, and formal AKI evaluation.

6. Demo output

Running python3 skills/nsaid-aki/nsaid_aki.py produces three structured demonstration cases with JSON output. Expected classifications:

• Short-course low-risk musculoskeletal pain treatment: LOW
• Older CKD patient on ACEi and diuretic starting high-dose NSAID: VERY HIGH
• Dehydrated heart-failure patient with rising creatinine during NSAID exposure: CONTRAINDICATED / CRITICAL

References

1. Whelton A. Nephrotoxicity of nonsteroidal anti-inflammatory drugs: physiologic foundations and clinical implications. Am J Med. 1999;106(5B):13S-24S. DOI: 10.1016/S0002-9343(99)00160-8
2. Lapi F, Azoulay L, Yin H, Nessim SJ, Suissa S, Hennessy S. Concurrent use of diuretics, angiotensin converting enzyme inhibitors, and angiotensin receptor blockers with non-steroidal anti-inflammatory drugs and risk of acute kidney injury: nested case-control study. BMJ. 2013;346:e8525. DOI: 10.1136/bmj.e8525
3. Dreischulte T, Morales DR, Bell S, Guthrie B. Combined use of nonsteroidal anti-inflammatory drugs with diuretics and renin-angiotensin system inhibitors in the community increases the risk of acute kidney injury. Kidney Int. 2015;88(2):396-403. DOI: 10.1038/ki.2015.101
4. Plantinga L, Grubbs V, Sarkar U, et al. Nonsteroidal anti-inflammatory drug use among persons with chronic kidney disease in the United States. Ann Fam Med. 2011;9(5):423-430. DOI: 10.1370/afm.1302
5. Kellum JA, Lameire N; for the KDIGO AKI Guideline Work Group. Diagnosis, evaluation, and management of acute kidney injury: a KDIGO summary. Crit Care. 2013;17(1):204. DOI: 10.1186/cc11454

skill_md

#!/usr/bin/env python3
"""
NSAID-AKI — NSAID-associated acute kidney injury risk-context stratification.

Transparent clinical skill for estimating concern before or during NSAID therapy.

Authors: Dr. Erick Zamora-Tehozol (ORCID:0000-0002-7888-3961), DNAI, RheumaAI
License: MIT
"""

from dataclasses import dataclass, asdict
from typing import Dict, Any, List
import json


@dataclass
class NsaidAkiInput:
    age: int
    indication: str
    current_or_planned_nsaid: bool = True
    high_dose_or_multiple_nsaids: bool = False
    therapy_duration_days: int = 7
    egfr_below_60: bool = False
    egfr_below_30: bool = False
    prior_nsaid_aki: bool = False
    heart_failure_or_cirrhosis: bool = False
    volume_depletion_or_sepsis: bool = False
    acei_arb: bool = False
    diuretic: bool = False
    diabetes: bool = False
    albuminuria_or_proteinuric_ckd: bool = False
    active_creatinine_rise: bool = False
    oliguria_or_hypotension: bool = False
    hyperkalemia: bool = False


def exposure_burden(inp: NsaidAkiInput) -> float:
    score = 0.0
    if inp.current_or_planned_nsaid:
        score += 1.0
    if inp.high_dose_or_multiple_nsaids:
        score += 1.6
    if inp.therapy_duration_days >= 30:
        score += 0.8
    elif inp.therapy_duration_days >= 14:
        score += 0.4
    return score


def renal_vulnerability(inp: NsaidAkiInput) -> float:
    score = 0.0
    if inp.egfr_below_60:
        score += 1.8
    if inp.egfr_below_30:
        score += 2.4
    if inp.albuminuria_or_proteinuric_ckd:
        score += 1.0
    if inp.prior_nsaid_aki:
        score += 2.2
    if inp.diabetes:
        score += 0.8
    if inp.age >= 75:
        score += 1.2
    elif inp.age >= 65:
        score += 0.6
    return score


def hemodynamic_stress(inp: NsaidAkiInput) -> float:
    score = 0.0
    if inp.heart_failure_or_cirrhosis:
        score += 1.8
    if inp.volume_depletion_or_sepsis:
        score += 2.4
    if inp.acei_arb:
        score += 1.0
    if inp.diuretic:
        score += 1.0
    return score


def injury_signal(inp: NsaidAkiInput) -> float:
    score = 0.0
    if inp.active_creatinine_rise:
        score += 2.6
    if inp.oliguria_or_hypotension:
        score += 2.4
    if inp.hyperkalemia:
        score += 1.6
    return score


def total_score(inp: NsaidAkiInput) -> float:
    score = (
        exposure_burden(inp)
        + renal_vulnerability(inp)
        + hemodynamic_stress(inp)
        + injury_signal(inp)
    )
    if inp.acei_arb and inp.diuretic and inp.current_or_planned_nsaid:
        score += 2.2
    if inp.egfr_below_30 and inp.high_dose_or_multiple_nsaids:
        score += 1.8
    if inp.volume_depletion_or_sepsis and inp.current_or_planned_nsaid:
        score += 1.6
    if inp.active_creatinine_rise and inp.oliguria_or_hypotension:
        score += 1.8
    if inp.therapy_duration_days <= 5 and not inp.egfr_below_60 and not inp.volume_depletion_or_sepsis and not (inp.acei_arb and inp.diuretic):
        score -= 0.8
    return round(max(score, 0.0) * 5.0, 1)


def classify(score: float) -> str:
    if score >= 70:
        return "CONTRAINDICATED / CRITICAL"
    if score >= 40:
        return "VERY HIGH"
    if score >= 20:
        return "HIGH"
    return "LOW"


def recommendations(inp: NsaidAkiInput, score: float) -> List[str]:
    out: List[str] = []
    if score < 20:
        out.append("Risk context is low enough for cautious short-course NSAID use if clinically necessary, with hydration advice and routine follow-up.")
    elif score < 40:
        out.append("High-risk context: review indication, lowest effective dose, kidney function, and concomitant nephrotoxic/hemodynamic medications before NSAID continuation.")
    elif score < 70:
        out.append("Very high concern: avoid or stop NSAID exposure when possible and reassess renal function, volume status, and concurrent ACEi/ARB or diuretic use.")
    else:
        out.append("NSAID exposure is contraindicated or the presentation is clinically critical until acute kidney injury is excluded or stabilized.")
        out.append("Arrange urgent clinician-level evaluation with serum creatinine, potassium, blood pressure, urine output assessment, and medication reconciliation.")

    if inp.acei_arb and inp.diuretic:
        out.append("Concurrent ACEi/ARB plus diuretic therapy creates a classic 'triple-whammy' hemodynamic setting when an NSAID is added.")
    if inp.volume_depletion_or_sepsis:
        out.append("Volume depletion or sepsis materially increases the likelihood of hemodynamic NSAID nephrotoxicity.")
    if inp.egfr_below_30:
        out.append("Advanced CKD sharply narrows NSAID renal safety margins and generally argues against routine use.")
    return out


def alerts(inp: NsaidAkiInput, score: float) -> List[str]:
    out: List[str] = []
    if inp.active_creatinine_rise:
        out.append("A rising creatinine during NSAID exposure should be treated as a real kidney-safety signal, not just laboratory noise.")
    if inp.oliguria_or_hypotension:
        out.append("Oliguria or hypotension suggests active hemodynamic compromise and warrants urgent assessment.")
    if inp.hyperkalemia:
        out.append("Hyperkalemia increases urgency because NSAID-associated kidney injury may coexist with impaired potassium excretion.")
    if score >= 40:
        out.append("This tool supports transparent triage only; definitive AKI diagnosis and management require direct clinical evaluation and laboratory review.")
    return out


def run_nsaid_aki(inp: NsaidAkiInput) -> Dict[str, Any]:
    score = total_score(inp)
    return {
        "input_summary": asdict(inp),
        "exposure_burden": round(exposure_burden(inp), 2),
        "renal_vulnerability": round(renal_vulnerability(inp), 2),
        "hemodynamic_stress": round(hemodynamic_stress(inp), 2),
        "injury_signal": round(injury_signal(inp), 2),
        "total_score": score,
        "risk_class": classify(score),
        "recommended_actions": recommendations(inp, score),
        "alerts": alerts(inp, score),
        "limitations": [
            "Evidence-informed heuristic model, not a validated probability calculator for NSAID-associated AKI.",
            "Weights are derived from mechanistic, observational, and guideline literature rather than prospective multivariable calibration.",
            "The tool cannot resolve all alternative causes of creatinine rise, including obstruction, glomerulonephritis, or contrast nephropathy.",
            "Medication lists may miss over-the-counter NSAIDs or duplicate exposure, which can materially underestimate risk.",
            "Use only as a transparent decision-support aid alongside clinician judgment, direct examination, and formal AKI evaluation."
        ]
    }


if __name__ == '__main__':
    demos = [
        (
            'Short-course low-risk musculoskeletal pain treatment',
            NsaidAkiInput(age=42, indication='Acute musculoskeletal pain', therapy_duration_days=3),
        ),
        (
            'Older CKD patient on ACEi and diuretic starting high-dose NSAID',
            NsaidAkiInput(age=74, indication='Osteoarthritis flare', high_dose_or_multiple_nsaids=True, therapy_duration_days=14, egfr_below_60=True, acei_arb=True, diuretic=True, diabetes=True),
        ),
        (
            'Dehydrated heart failure patient with rising creatinine during NSAID exposure',
            NsaidAkiInput(age=79, indication='Back pain', high_dose_or_multiple_nsaids=True, therapy_duration_days=7, egfr_below_60=True, heart_failure_or_cirrhosis=True, volume_depletion_or_sepsis=True, acei_arb=True, diuretic=True, active_creatinine_rise=True, oliguria_or_hypotension=True, hyperkalemia=True),
        ),
    ]

    print('=' * 78)
    print('NSAID-AKI — NSAID-Associated Acute Kidney Injury Risk-Context Stratification')
    print('Authors: Dr. Erick Zamora-Tehozol, DNAI, RheumaAI')
    print('=' * 78)
    for label, demo in demos:
        result = run_nsaid_aki(demo)
        print(f'\n--- {label} ---')
        print(json.dumps(result, indent=2))