┌─────────────────────────────────────────────────────────────────────────────┐
│                CLINICAL DECISION SUPPORT ARCHITECTURE                       │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  ┌─────────────────────────────────────────────────────────────────────┐   │
│  │ CLINICAL INPUT                                                      │   │
│  │   Symptoms ──── Vitals ──── Medications ──── History               │   │
│  └──────────────────────────────┬──────────────────────────────────────┘   │
│                                 │                                          │
│                                 ▼                                          │
│  ┌─────────────────────────────────────────────────────────────────────┐   │
│  │ SAFETY LAYER (Pre-Processing)                                       │   │
│  │   Emergency Red Flags ──► Immediate Alert (bypass workflow)         │   │
│  └──────────────────────────────┬──────────────────────────────────────┘   │
│                                 │                                          │
│                                 ▼                                          │
│  ┌─────────────────────────────────────────────────────────────────────┐   │
│  │ AGENT CORE (LangGraph + ReAct)                                      │   │
│  │                                                                     │   │
│  │   ┌──────────────┐  ┌──────────────┐  ┌──────────────┐             │   │
│  │   │   Symptom    │  │ Differential │  │    Drug      │             │   │
│  │   │  Analyzer    │──►│  Generator   │──►│  Checker     │             │   │
│  │   └──────────────┘  └──────────────┘  └──────────────┘             │   │
│  │          │                  │                  │                     │   │
│  │          ▼                  ▼                  ▼                     │   │
│  │   ┌──────────────┐  ┌──────────────┐  ┌──────────────┐             │   │
│  │   │  Guideline   │  │     Lab      │  │   Output     │             │   │
│  │   │  Retriever   │  │  Suggestions │  │  Formatter   │             │   │
│  │   └──────────────┘  └──────────────┘  └──────────────┘             │   │
│  └──────────────────────────────┬──────────────────────────────────────┘   │
│                                 │                                          │
│                                 ▼                                          │
│  ┌─────────────────────────────────────────────────────────────────────┐   │
│  │ SAFETY LAYER (Post-Processing)                                      │   │
│  │   Language Sanitization ──► Disclaimer Injection ──► Audit Log      │   │
│  └─────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

clinical-decision-support/
├── src/
│   ├── __init__.py
│   ├── config.py
│   ├── clinical/
│   │   ├── __init__.py
│   │   ├── models.py            # Clinical data models
│   │   ├── state.py             # LangGraph state definition
│   │   ├── symptom_analyzer.py  # Symptom processing
│   │   └── differential.py     # Differential diagnosis generator
│   ├── tools/
│   │   ├── __init__.py
│   │   ├── openfda.py           # OpenFDA drug interaction API
│   │   ├── guidelines.py       # Clinical guideline retrieval
│   │   └── lab_suggestions.py  # Lab test recommendations
│   ├── safety/
│   │   ├── __init__.py
│   │   ├── red_flags.py         # Emergency detection
│   │   ├── sanitizer.py        # Language sanitization
│   │   └── audit.py            # Audit logging
│   ├── agent/
│   │   ├── __init__.py
│   │   └── workflow.py          # LangGraph workflow
│   └── api/
│       ├── __init__.py
│       └── main.py              # FastAPI endpoints
├── data/
│   └── guidelines/              # Clinical guideline documents
├── tests/
├── docker-compose.yml
└── requirements.txt

# src/config.py
from pydantic_settings import BaseSettings
from typing import Optional

class Settings(BaseSettings):
    # LLM Settings
    openai_api_key: str
    openai_model: str = "gpt-4o"
    temperature: float = 0.1  # Low temperature for clinical accuracy

    # OpenFDA API (free, no key required - but key increases rate limits)
    openfda_base_url: str = "https://api.fda.gov"
    openfda_api_key: Optional[str] = None  # Optional: increases rate limit
    openfda_drug_label_endpoint: str = "/drug/label.json"
    openfda_adverse_event_endpoint: str = "/drug/event.json"

    # Vector Store
    chroma_persist_dir: str = "./data/chroma"
    guidelines_collection: str = "clinical_guidelines"

    # Safety Settings
    enable_safety_guardrails: bool = True
    enable_audit_logging: bool = True
    max_differential_count: int = 5
    emergency_bypass: bool = True  # Skip workflow for emergencies

    # Clinical Settings
    supported_specialties: list = [
        "internal_medicine",
        "emergency_medicine",
        "cardiology",
        "pulmonology",
        "neurology"
    ]

    class Config:
        env_file = ".env"

settings = Settings()

┌─────────────────────────────────────────────────────────────────────┐
│ WHY THESE DEFAULTS                                                    │
├─────────────────────────────────────────────────────────────────────┤
│                                                                     │
│  temperature: 0.1                                                   │
│  └── Clinical reasoning needs consistency, not creativity           │
│      Higher temperatures → different answers for same symptoms      │
│      Lower temperatures → reproducible, auditable reasoning         │
│                                                                     │
│  OpenFDA API                                                        │
│  └── Free public API, no key required for basic access              │
│      • /drug/label.json → Drug labels, warnings, interactions       │
│      • /drug/event.json → Adverse event reports (FAERS database)    │
│      • Rate limit: 40/min without key, 240/min with key             │
│                                                                     │
│  emergency_bypass: True                                             │
│  └── Red flag symptoms (chest pain + SOB + diaphoresis) skip        │
│      the full workflow and immediately alert the clinician           │
│                                                                     │
└─────────────────────────────────────────────────────────────────────┘

# src/clinical/models.py
from pydantic import BaseModel, Field
from typing import List, Optional, Dict
from enum import Enum
from datetime import datetime

class Severity(str, Enum):
    MILD = "mild"
    MODERATE = "moderate"
    SEVERE = "severe"
    CRITICAL = "critical"

class Symptom(BaseModel):
    """A single clinical symptom."""
    name: str = Field(description="Symptom name (e.g., 'chest pain')")
    duration: Optional[str] = Field(None, description="Duration (e.g., '2 hours')")
    severity: Severity = Field(Severity.MODERATE, description="Symptom severity")
    onset: Optional[str] = Field(None, description="Onset type (e.g., 'sudden', 'gradual')")
    character: Optional[str] = Field(None, description="Quality (e.g., 'sharp', 'dull', 'burning')")
    associated_factors: List[str] = Field(default_factory=list)

class PatientContext(BaseModel):
    """Patient demographics and history."""
    age: int = Field(ge=0, le=150, description="Patient age in years")
    sex: str = Field(description="Patient sex: 'M' or 'F'")
    chief_complaint: str = Field(description="Primary reason for visit")
    symptoms: List[Symptom] = Field(default_factory=list)
    vital_signs: Dict[str, str] = Field(
        default_factory=dict,
        description="e.g., {'BP': '140/90', 'HR': '98', 'SpO2': '95%'}"
    )
    current_medications: List[str] = Field(default_factory=list)
    allergies: List[str] = Field(default_factory=list)
    past_medical_history: List[str] = Field(default_factory=list)
    family_history: List[str] = Field(default_factory=list)
    social_history: Optional[str] = None

class DifferentialItem(BaseModel):
    """A single differential diagnosis."""
    diagnosis: str = Field(description="Diagnosis name")
    icd10_code: Optional[str] = Field(None, description="ICD-10 code")
    probability: str = Field(description="Likelihood: high, moderate, low")
    supporting_evidence: List[str] = Field(
        description="Findings that support this diagnosis"
    )
    contradicting_evidence: List[str] = Field(
        default_factory=list,
        description="Findings that argue against this diagnosis"
    )
    recommended_workup: List[str] = Field(
        default_factory=list,
        description="Tests to confirm or rule out"
    )

class DifferentialDiagnosis(BaseModel):
    """Complete differential diagnosis output."""
    differentials: List[DifferentialItem] = Field(
        description="Ranked differential diagnoses"
    )
    critical_considerations: List[str] = Field(
        default_factory=list,
        description="Life-threatening diagnoses to rule out first"
    )
    reasoning_summary: str = Field(
        description="Brief explanation of the clinical reasoning"
    )

class DrugInteraction(BaseModel):
    """Drug interaction finding."""
    drug_a: str
    drug_b: str
    severity: str  # mild, moderate, severe, contraindicated
    description: str
    source: str = "OpenFDA"
    adverse_events: List[str] = Field(default_factory=list)

class ClinicalOutput(BaseModel):
    """Final clinical decision support output."""
    patient_summary: str
    differential: DifferentialDiagnosis
    drug_interactions: List[DrugInteraction]
    guideline_recommendations: List[str]
    suggested_labs: List[str]
    red_flags_detected: List[str]
    disclaimer: str
    timestamp: datetime = Field(default_factory=datetime.utcnow)

# src/clinical/state.py
from typing import TypedDict, List, Optional, Annotated
from enum import Enum
import operator
from .models import (
    PatientContext, DifferentialDiagnosis,
    DrugInteraction, ClinicalOutput
)

class ClinicalPhase(str, Enum):
    INTAKE = "intake"
    RED_FLAG_CHECK = "red_flag_check"
    ANALYSIS = "analysis"
    DIFFERENTIAL = "differential"
    DRUG_CHECK = "drug_check"
    GUIDELINES = "guidelines"
    OUTPUT = "output"
    EMERGENCY = "emergency"

class ClinicalState(TypedDict):
    """State for the clinical decision support workflow."""
    # Input
    patient: PatientContext
    raw_input: str

    # Processing
    current_phase: ClinicalPhase
    symptom_analysis: str
    differential: Optional[DifferentialDiagnosis]
    drug_interactions: Annotated[List[DrugInteraction], operator.add]
    guideline_matches: List[str]
    suggested_labs: List[str]

    # Safety
    red_flags: List[str]
    is_emergency: bool
    audit_trail: Annotated[List[str], operator.add]

    # Output
    clinical_output: Optional[ClinicalOutput]
    errors: List[str]

┌─────────────────────────────────────────────────────────────────────┐
│ CLINICAL PHASE PROGRESSION                                            │
├─────────────────────────────────────────────────────────────────────┤
│                                                                     │
│  INTAKE ──► RED_FLAG_CHECK ──┬──► ANALYSIS ──► DIFFERENTIAL         │
│                              │         │                            │
│                              │         ▼                            │
│                        (if emergency)  DRUG_CHECK ──► GUIDELINES    │
│                              │                            │         │
│                              ▼                            ▼         │
│                          EMERGENCY                     OUTPUT       │
│                              │                            │         │
│                              └────────────────────────────┘         │
│                                                                     │
│  Key Design: Emergency path bypasses analysis entirely              │
│  • Chest pain + SOB + diaphoresis → immediate EMERGENCY             │
│  • No time wasted on differential for acute emergencies             │
│                                                                     │
└─────────────────────────────────────────────────────────────────────┘

# src/clinical/symptom_analyzer.py
from typing import List, Dict
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
from pydantic import BaseModel, Field
from .models import PatientContext, Symptom, Severity
from ..config import settings

class SymptomAnalysis(BaseModel):
    """Structured symptom analysis output."""
    organized_symptoms: List[Dict[str, str]] = Field(
        description="Symptoms organized by system (cardiac, pulmonary, etc.)"
    )
    key_positives: List[str] = Field(
        description="Clinically significant positive findings"
    )
    key_negatives: List[str] = Field(
        description="Important negative findings (pertinent negatives)"
    )
    clinical_pattern: str = Field(
        description="Overall clinical pattern recognition"
    )
    acuity_assessment: str = Field(
        description="Urgency level: emergent, urgent, semi-urgent, routine"
    )

class SymptomAnalyzer:
    """Analyzes and organizes clinical symptoms."""

    def __init__(self):
        self.llm = ChatOpenAI(
            model=settings.openai_model,
            api_key=settings.openai_api_key,
            temperature=settings.temperature
        ).with_structured_output(SymptomAnalysis)

        self.prompt = ChatPromptTemplate.from_messages([
            ("system", """You are a clinical decision support system assisting
licensed physicians. Analyze the patient presentation and organize findings.

IMPORTANT: You are a support tool, not a diagnostician. Frame all output
as considerations for the treating physician to evaluate.

Organize symptoms by organ system. Identify pertinent positives AND
pertinent negatives (what the patient does NOT have is often as important
as what they do have).

Assess acuity:
- Emergent: Immediate threat to life or limb
- Urgent: Needs evaluation within hours
- Semi-urgent: Needs evaluation within days
- Routine: Can be scheduled"""),
            ("human", """Patient: {age}yo {sex}
Chief Complaint: {chief_complaint}

Symptoms:
{symptoms}

Vital Signs: {vitals}

Current Medications: {medications}
Past Medical History: {pmh}

Analyze this clinical presentation.""")
        ])

    async def analyze(self, patient: PatientContext) -> SymptomAnalysis:
        """Analyze patient symptoms."""
        symptoms_text = "\n".join([
            f"- {s.name}: severity={s.severity.value}, "
            f"onset={s.onset or 'not specified'}, "
            f"duration={s.duration or 'not specified'}, "
            f"character={s.character or 'not specified'}"
            for s in patient.symptoms
        ])

        vitals_text = ", ".join([
            f"{k}: {v}" for k, v in patient.vital_signs.items()
        ]) or "Not provided"

        chain = self.prompt | self.llm
        result = await chain.ainvoke({
            "age": patient.age,
            "sex": patient.sex,
            "chief_complaint": patient.chief_complaint,
            "symptoms": symptoms_text or "See chief complaint",
            "vitals": vitals_text,
            "medications": ", ".join(patient.current_medications) or "None reported",
            "pmh": ", ".join(patient.past_medical_history) or "None reported"
        })
        return result

┌─────────────────────────────────────────────────────────────────────┐
│ PERTINENT NEGATIVES IN CLINICAL REASONING                            │
├─────────────────────────────────────────────────────────────────────┤
│                                                                     │
│  Patient: 55yo M with chest pain                                    │
│                                                                     │
│  Pertinent Positives:          Pertinent Negatives:                 │
│  ┌─────────────────────┐      ┌─────────────────────┐              │
│  │ • Substernal chest  │      │ • NO radiation to   │              │
│  │   pain              │      │   arm or jaw         │              │
│  │ • Worse with        │      │ • NO diaphoresis     │              │
│  │   deep breath       │      │ • NO shortness of    │              │
│  │ • Reproducible on   │      │   breath             │              │
│  │   palpation         │      │ • NO nausea/vomiting │              │
│  └─────────────────────┘      └─────────────────────┘              │
│                                                                     │
│  The negatives SHIFT the differential:                              │
│  • With those negatives → more likely musculoskeletal/pleuritic    │
│  • Without those negatives → acute coronary syndrome stays high    │
│                                                                     │
│  THIS IS WHY the SymptomAnalyzer extracts both positives AND       │
│  negatives - they carry equal diagnostic weight.                    │
│                                                                     │
└─────────────────────────────────────────────────────────────────────┘

# src/tools/openfda.py
from typing import List, Dict, Optional
import httpx
from pydantic import BaseModel, Field
from langchain_core.tools import tool
from ..clinical.models import DrugInteraction
from ..config import settings

class OpenFDAClient:
    """Client for the OpenFDA Drug API.

    OpenFDA provides free access to FDA drug data:
    - Drug labels (prescribing info, warnings, interactions)
    - Adverse event reports (FAERS database)

    No API key required for basic access (40 requests/min).
    """

    def __init__(self):
        self.base_url = settings.openfda_base_url
        self.api_key = settings.openfda_api_key

    def _build_params(self, search: str, limit: int = 5) -> Dict:
        """Build query parameters."""
        params = {
            "search": search,
            "limit": limit
        }
        if self.api_key:
            params["api_key"] = self.api_key
        return params

    async def get_drug_label(self, drug_name: str) -> List[Dict]:
        """Get drug label information including warnings and interactions."""
        search = f'openfda.brand_name:"{drug_name}"+openfda.generic_name:"{drug_name}"'
        params = self._build_params(search, limit=3)

        try:
            async with httpx.AsyncClient() as client:
                response = await client.get(
                    f"{self.base_url}{settings.openfda_drug_label_endpoint}",
                    params=params,
                    timeout=15.0
                )
                response.raise_for_status()
                data = response.json()

            results = []
            for result in data.get("results", []):
                results.append({
                    "brand_name": result.get("openfda", {}).get(
                        "brand_name", ["Unknown"]
                    )[0],
                    "generic_name": result.get("openfda", {}).get(
                        "generic_name", ["Unknown"]
                    )[0],
                    "warnings": result.get("warnings", [""])[0][:500],
                    "drug_interactions": result.get(
                        "drug_interactions", [""]
                    )[0][:500],
                    "contraindications": result.get(
                        "contraindications", [""]
                    )[0][:500],
                    "adverse_reactions": result.get(
                        "adverse_reactions", [""]
                    )[0][:300]
                })
            return results
        except httpx.HTTPStatusError as e:
            if e.response.status_code == 404:
                return []  # Drug not found in OpenFDA
            raise
        except Exception:
            return []

    async def get_adverse_events(
        self,
        drug_name: str,
        limit: int = 5
    ) -> List[Dict]:
        """Get adverse event reports for a drug from FAERS database."""
        search = f'patient.drug.openfda.generic_name:"{drug_name}"'
        params = self._build_params(search, limit=limit)

        try:
            async with httpx.AsyncClient() as client:
                response = await client.get(
                    f"{self.base_url}{settings.openfda_adverse_event_endpoint}",
                    params=params,
                    timeout=15.0
                )
                response.raise_for_status()
                data = response.json()

            events = []
            for result in data.get("results", []):
                reactions = [
                    r.get("reactionmeddrapt", "")
                    for r in result.get("patient", {}).get("reaction", [])
                ]
                drugs_involved = [
                    d.get("medicinalproduct", "")
                    for d in result.get("patient", {}).get("drug", [])
                ]
                events.append({
                    "reactions": reactions[:5],
                    "drugs_involved": drugs_involved[:5],
                    "serious": result.get("serious", "0") == "1",
                    "outcome": result.get(
                        "patient", {}
                    ).get("patientonsetage", "unknown")
                })
            return events
        except Exception:
            return []

    async def check_interaction(
        self,
        drug_a: str,
        drug_b: str
    ) -> Optional[DrugInteraction]:
        """Check for interactions between two drugs."""
        # Get label info for drug_a (interactions section mentions drug_b)
        labels = await self.get_drug_label(drug_a)

        for label in labels:
            interaction_text = label.get("drug_interactions", "").lower()
            if drug_b.lower() in interaction_text:
                # Determine severity from language
                severity = "moderate"
                if any(w in interaction_text for w in [
                    "contraindicated", "do not", "never"
                ]):
                    severity = "contraindicated"
                elif any(w in interaction_text for w in [
                    "serious", "severe", "life-threatening"
                ]):
                    severity = "severe"
                elif any(w in interaction_text for w in [
                    "minor", "mild", "unlikely"
                ]):
                    severity = "mild"

                return DrugInteraction(
                    drug_a=drug_a,
                    drug_b=drug_b,
                    severity=severity,
                    description=label["drug_interactions"][:300],
                    source="OpenFDA Drug Label"
                )

        # Also check adverse events where both drugs are co-reported
        events = await self.get_adverse_events(drug_a)
        co_reported = []
        for event in events:
            if drug_b.lower() in [
                d.lower() for d in event.get("drugs_involved", [])
            ]:
                co_reported.extend(event.get("reactions", []))

        if co_reported:
            return DrugInteraction(
                drug_a=drug_a,
                drug_b=drug_b,
                severity="moderate",
                description=f"Co-reported in adverse events with reactions: "
                           f"{', '.join(set(co_reported[:5]))}",
                source="OpenFDA FAERS",
                adverse_events=list(set(co_reported[:10]))
            )

        return None


@tool
async def check_drug_interactions(
    medications: List[str]
) -> str:
    """Check for drug interactions between a list of medications using OpenFDA.

    Args:
        medications: List of medication names to check for interactions

    Returns:
        Formatted interaction report
    """
    client = OpenFDAClient()
    interactions = []

    # Check all pairs
    for i, drug_a in enumerate(medications):
        for drug_b in medications[i + 1:]:
            interaction = await client.check_interaction(drug_a, drug_b)
            if interaction:
                interactions.append(interaction)

    if not interactions:
        return "No known interactions found between the listed medications."

    report = "DRUG INTERACTION REPORT:\n\n"
    for ix in interactions:
        report += f"⚠ {ix.drug_a} + {ix.drug_b}\n"
        report += f"  Severity: {ix.severity.upper()}\n"
        report += f"  {ix.description}\n"
        report += f"  Source: {ix.source}\n\n"

    return report


@tool
async def get_drug_info(drug_name: str) -> str:
    """Get drug label information including warnings and adverse reactions.

    Args:
        drug_name: Name of the drug (brand or generic)

    Returns:
        Drug label information
    """
    client = OpenFDAClient()
    labels = await client.get_drug_label(drug_name)

    if not labels:
        return f"No drug label found for '{drug_name}' in OpenFDA."

    label = labels[0]
    return (
        f"Drug: {label['brand_name']} ({label['generic_name']})\n"
        f"Warnings: {label['warnings'][:300]}\n"
        f"Interactions: {label['drug_interactions'][:300]}\n"
        f"Contraindications: {label['contraindications'][:300]}\n"
    )

┌─────────────────────────────────────────────────────────────────────┐
│ OPENFDA API ARCHITECTURE                                              │
├─────────────────────────────────────────────────────────────────────┤
│                                                                     │
│  Two data sources, different information:                           │
│                                                                     │
│  /drug/label.json (Drug Labels)                                     │
│  ┌─────────────────────────────────────────────────────┐            │
│  │ • Official prescribing information                   │            │
│  │ • Warnings, contraindications, interactions          │            │
│  │ • Written by manufacturer, reviewed by FDA           │            │
│  │ • Best for: known drug-drug interaction checks       │            │
│  └─────────────────────────────────────────────────────┘            │
│                                                                     │
│  /drug/event.json (FAERS - Adverse Events)                          │
│  ┌─────────────────────────────────────────────────────┐            │
│  │ • Post-market safety reports                         │            │
│  │ • Real-world adverse reaction data                   │            │
│  │ • Reports from healthcare providers and patients     │            │
│  │ • Best for: detecting co-reported drug combinations  │            │
│  └─────────────────────────────────────────────────────┘            │
│                                                                     │
│  Interaction check strategy:                                        │
│  1. First check drug labels (authoritative)                         │
│  2. Then check FAERS co-reports (signal detection)                  │
│  3. Combine findings with severity assessment                       │
│                                                                     │
└─────────────────────────────────────────────────────────────────────┘

# src/clinical/differential.py
from typing import List
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
from .models import (
    PatientContext, DifferentialDiagnosis,
    DifferentialItem
)
from ..config import settings

class DifferentialGenerator:
    """Generates ranked differential diagnoses with structured output."""

    def __init__(self):
        self.llm = ChatOpenAI(
            model=settings.openai_model,
            api_key=settings.openai_api_key,
            temperature=settings.temperature
        ).with_structured_output(DifferentialDiagnosis)

        self.prompt = ChatPromptTemplate.from_messages([
            ("system", """You are a clinical decision support system generating
differential diagnoses for licensed physicians to evaluate.

RULES:
1. List up to {max_count} diagnoses ranked by clinical probability
2. Always include dangerous "can't-miss" diagnoses even if less likely
3. For each diagnosis provide:
   - ICD-10 code when known
   - Supporting evidence from the presentation
   - Contradicting evidence from the presentation
   - Recommended workup to confirm or rule out
4. Frame everything as "considerations" not "diagnoses"
5. Include critical considerations that must be ruled out first

NEVER use definitive diagnostic language like "the patient has X".
Instead use: "X should be considered", "findings are consistent with X"."""),
            ("human", """Patient: {age}yo {sex}
Chief Complaint: {chief_complaint}

Symptom Analysis:
{symptom_analysis}

Vital Signs: {vitals}
Current Medications: {medications}
Past Medical History: {pmh}
Family History: {family_history}

Generate differential diagnosis considerations for this presentation.""")
        ])

    async def generate(
        self,
        patient: PatientContext,
        symptom_analysis: str
    ) -> DifferentialDiagnosis:
        """Generate differential diagnosis."""
        vitals_text = ", ".join([
            f"{k}: {v}" for k, v in patient.vital_signs.items()
        ]) or "Not provided"

        chain = self.prompt | self.llm
        result = await chain.ainvoke({
            "max_count": settings.max_differential_count,
            "age": patient.age,
            "sex": patient.sex,
            "chief_complaint": patient.chief_complaint,
            "symptom_analysis": symptom_analysis,
            "vitals": vitals_text,
            "medications": ", ".join(patient.current_medications) or "None",
            "pmh": ", ".join(patient.past_medical_history) or "None",
            "family_history": ", ".join(patient.family_history) or "None"
        })
        return result

┌─────────────────────────────────────────────────────────────────────┐
│ EXAMPLE DIFFERENTIAL OUTPUT                                           │
├─────────────────────────────────────────────────────────────────────┤
│                                                                     │
│  Patient: 62yo M, chest pain, HTN, diabetes                        │
│                                                                     │
│  ┌─── CRITICAL CONSIDERATIONS (rule out first) ─────────────────┐  │
│  │ • Acute Coronary Syndrome (I21.9)                             │  │
│  │ • Pulmonary Embolism (I26.99)                                 │  │
│  │ • Aortic Dissection (I71.00)                                  │  │
│  └───────────────────────────────────────────────────────────────┘  │
│                                                                     │
│  1. Acute Coronary Syndrome (HIGH)                                  │
│     ┌ Supporting: age, sex, HTN, DM, chest pain                    │
│     ├ Contradicting: pain reproducible on palpation                │
│     └ Workup: ECG, troponin, CXR                                  │
│                                                                     │
│  2. Musculoskeletal Chest Pain (MODERATE)                           │
│     ┌ Supporting: reproducible on palpation                        │
│     ├ Contradicting: cardiac risk factors present                  │
│     └ Workup: clinical diagnosis after ruling out cardiac          │
│                                                                     │
│  NOTE: "Can't-miss" diagnoses always included even if low          │
│  probability - missing them could be fatal                          │
│                                                                     │
└─────────────────────────────────────────────────────────────────────┘

# src/safety/red_flags.py
from typing import List, Tuple
from dataclasses import dataclass
from ..clinical.models import PatientContext, Severity

@dataclass
class RedFlag:
    """A clinical red flag finding."""
    name: str
    description: str
    urgency: str  # immediate, urgent, semi-urgent
    recommended_action: str

# Red flag patterns - RULE-BASED, not LLM-dependent
# These are hardcoded because they are life-critical
RED_FLAG_PATTERNS = {
    "acute_coronary_syndrome": {
        "symptoms": ["chest pain", "chest tightness", "chest pressure"],
        "associated": ["shortness of breath", "diaphoresis", "nausea",
                       "jaw pain", "left arm pain", "arm pain"],
        "min_associated": 1,
        "urgency": "immediate",
        "action": "IMMEDIATE: 12-lead ECG, troponin, cardiology consult"
    },
    "stroke": {
        "symptoms": ["facial droop", "face droop", "arm weakness",
                     "speech difficulty", "slurred speech", "aphasia",
                     "sudden weakness", "sudden numbness"],
        "associated": ["headache", "vision changes", "confusion",
                       "dizziness", "loss of balance"],
        "min_associated": 0,
        "urgency": "immediate",
        "action": "IMMEDIATE: FAST assessment, CT head, neurology consult, "
                  "check last known well time"
    },
    "anaphylaxis": {
        "symptoms": ["difficulty breathing", "throat swelling",
                     "tongue swelling", "wheezing", "stridor"],
        "associated": ["hives", "urticaria", "hypotension", "rash",
                       "itching", "abdominal pain"],
        "min_associated": 1,
        "urgency": "immediate",
        "action": "IMMEDIATE: Epinephrine IM, IV access, airway management"
    },
    "respiratory_distress": {
        "symptoms": ["severe shortness of breath", "respiratory distress",
                     "cannot breathe", "gasping"],
        "associated": ["cyanosis", "accessory muscle use", "altered mental status"],
        "min_associated": 0,
        "urgency": "immediate",
        "action": "IMMEDIATE: Oxygen, ABG, CXR, prepare for intubation if needed"
    },
    "sepsis": {
        "symptoms": ["fever", "high fever"],
        "associated": ["confusion", "altered mental status", "hypotension",
                       "tachycardia", "rapid breathing", "tachypnea"],
        "min_associated": 2,
        "urgency": "immediate",
        "action": "IMMEDIATE: Blood cultures, lactate, broad-spectrum antibiotics, "
                  "IV fluids"
    }
}


class RedFlagDetector:
    """Detects clinical red flags using rule-based logic.

    CRITICAL: Red flag detection is NEVER delegated to an LLM.
    These are hardcoded rules because:
    1. LLMs can hallucinate or miss critical findings
    2. Response time matters - no API latency
    3. Rules are deterministic and auditable
    4. Patient safety cannot depend on probabilistic outputs
    """

    def detect(self, patient: PatientContext) -> List[RedFlag]:
        """Detect red flags from patient presentation."""
        detected = []

        # Collect all symptom text for matching
        all_symptoms = set()
        all_symptoms.add(patient.chief_complaint.lower())
        for symptom in patient.symptoms:
            all_symptoms.add(symptom.name.lower())
            for factor in symptom.associated_factors:
                all_symptoms.add(factor.lower())

        # Check vital sign red flags
        vitals_flags = self._check_vitals(patient.vital_signs)
        detected.extend(vitals_flags)

        # Check symptom pattern red flags
        for pattern_name, pattern in RED_FLAG_PATTERNS.items():
            # Check if any primary symptom matches
            primary_match = any(
                s in " ".join(all_symptoms)
                for s in pattern["symptoms"]
            )

            if primary_match:
                # Count associated findings
                associated_count = sum(
                    1 for s in pattern["associated"]
                    if s in " ".join(all_symptoms)
                )

                if associated_count >= pattern["min_associated"]:
                    detected.append(RedFlag(
                        name=pattern_name.replace("_", " ").title(),
                        description=f"Pattern matched: primary symptom with "
                                   f"{associated_count} associated findings",
                        urgency=pattern["urgency"],
                        recommended_action=pattern["action"]
                    ))

        return detected

    def _check_vitals(self, vitals: dict) -> List[RedFlag]:
        """Check vital signs for red flags."""
        flags = []

        # SpO2 check
        spo2_str = vitals.get("SpO2", vitals.get("spo2", ""))
        if spo2_str:
            try:
                spo2 = int(spo2_str.replace("%", "").strip())
                if spo2 < 90:
                    flags.append(RedFlag(
                        name="Hypoxemia",
                        description=f"SpO2 {spo2}% (critical: below 90%)",
                        urgency="immediate",
                        recommended_action="Supplemental O2, ABG, "
                                          "identify cause of hypoxemia"
                    ))
                elif spo2 < 94:
                    flags.append(RedFlag(
                        name="Low Oxygen Saturation",
                        description=f"SpO2 {spo2}% (concerning: below 94%)",
                        urgency="urgent",
                        recommended_action="Supplemental O2, monitor, "
                                          "evaluate respiratory status"
                    ))
            except ValueError:
                pass

        # Heart rate check
        hr_str = vitals.get("HR", vitals.get("heart_rate", ""))
        if hr_str:
            try:
                hr = int(hr_str.replace("bpm", "").strip())
                if hr > 150:
                    flags.append(RedFlag(
                        name="Severe Tachycardia",
                        description=f"HR {hr} bpm (critical: above 150)",
                        urgency="immediate",
                        recommended_action="12-lead ECG, IV access, "
                                          "evaluate for unstable arrhythmia"
                    ))
                elif hr < 40:
                    flags.append(RedFlag(
                        name="Severe Bradycardia",
                        description=f"HR {hr} bpm (critical: below 40)",
                        urgency="immediate",
                        recommended_action="12-lead ECG, atropine at bedside, "
                                          "transcutaneous pacer ready"
                    ))
            except ValueError:
                pass

        # Blood pressure check
        bp_str = vitals.get("BP", vitals.get("blood_pressure", ""))
        if bp_str and "/" in bp_str:
            try:
                parts = bp_str.replace("mmHg", "").strip().split("/")
                systolic = int(parts[0])
                diastolic = int(parts[1])
                if systolic < 90:
                    flags.append(RedFlag(
                        name="Hypotension",
                        description=f"BP {bp_str} (critical: SBP below 90)",
                        urgency="immediate",
                        recommended_action="IV fluids, vasopressors if needed, "
                                          "identify cause (sepsis, hemorrhage, cardiac)"
                    ))
                elif systolic > 180 or diastolic > 120:
                    flags.append(RedFlag(
                        name="Hypertensive Emergency",
                        description=f"BP {bp_str} (critical: above 180/120)",
                        urgency="immediate",
                        recommended_action="IV antihypertensives, "
                                          "evaluate for end-organ damage"
                    ))
            except (ValueError, IndexError):
                pass

        return flags

    def is_emergency(self, red_flags: List[RedFlag]) -> bool:
        """Determine if any red flag requires immediate action."""
        return any(rf.urgency == "immediate" for rf in red_flags)

# src/safety/sanitizer.py
from typing import List, Tuple
import re

class LanguageSanitizer:
    """Sanitizes clinical output language to prevent misinterpretation.

    Ensures the system never appears to make definitive diagnoses
    or replace clinical judgment. All output is framed as
    decision support for the treating physician.
    """

    # Phrases that imply definitive diagnosis
    BLOCKED_PHRASES = [
        (r'\byou have\b', 'findings are consistent with'),
        (r'\byou are diagnosed with\b', 'the presentation suggests'),
        (r'\bthe diagnosis is\b', 'the leading consideration is'),
        (r'\bthis is definitely\b', 'this is most consistent with'),
        (r'\byou need to take\b', 'the treating physician may consider'),
        (r'\btake this medication\b', 'medication options include'),
        (r'\byou should stop\b', 'discuss with your physician whether to adjust'),
        (r'\byou will\b', 'the clinical trajectory may include'),
        (r'\bI diagnose\b', 'the assessment suggests'),
        (r'\bI prescribe\b', 'the physician may consider prescribing'),
    ]

    MANDATORY_DISCLAIMER = (
        "\n\n---\n"
        "**Clinical Decision Support Notice**: This analysis is generated by an "
        "AI system designed to assist licensed healthcare professionals. It does "
        "not constitute a medical diagnosis, treatment recommendation, or "
        "substitute for clinical judgment. All findings must be independently "
        "verified by the treating physician. Patient care decisions should be "
        "based on the full clinical picture, including factors not captured "
        "in this analysis."
    )

    def sanitize(self, text: str) -> str:
        """Remove or replace inappropriate clinical language."""
        sanitized = text
        for pattern, replacement in self.BLOCKED_PHRASES:
            sanitized = re.sub(pattern, replacement, sanitized, flags=re.IGNORECASE)
        return sanitized

    def add_disclaimer(self, text: str) -> str:
        """Add mandatory clinical disclaimer."""
        return text + self.MANDATORY_DISCLAIMER

    def process(self, text: str) -> str:
        """Full sanitization pipeline."""
        sanitized = self.sanitize(text)
        with_disclaimer = self.add_disclaimer(sanitized)
        return with_disclaimer

    def validate(self, text: str) -> List[Tuple[str, str]]:
        """Check text for blocked phrases (for testing/auditing)."""
        violations = []
        for pattern, replacement in self.BLOCKED_PHRASES:
            matches = re.findall(pattern, text, flags=re.IGNORECASE)
            for match in matches:
                violations.append((match, replacement))
        return violations

# src/safety/audit.py
from typing import Dict, Any
from datetime import datetime
import json
import logging
from pathlib import Path
from ..config import settings

class AuditLogger:
    """Logs all clinical interactions for compliance and review."""

    def __init__(self, log_dir: str = "./logs/audit"):
        self.log_dir = Path(log_dir)
        self.log_dir.mkdir(parents=True, exist_ok=True)
        self.logger = logging.getLogger("clinical_audit")
        self.logger.setLevel(logging.INFO)

        # File handler
        handler = logging.FileHandler(
            self.log_dir / f"audit_{datetime.now():%Y%m%d}.jsonl"
        )
        handler.setFormatter(logging.Formatter('%(message)s'))
        self.logger.addHandler(handler)

    def log_event(
        self,
        event_type: str,
        data: Dict[str, Any],
        phase: str = ""
    ):
        """Log a clinical audit event."""
        if not settings.enable_audit_logging:
            return

        event = {
            "timestamp": datetime.utcnow().isoformat(),
            "event_type": event_type,
            "phase": phase,
            "data": data
        }
        self.logger.info(json.dumps(event))

    def log_red_flag(self, red_flag_name: str, urgency: str, action: str):
        """Log a red flag detection."""
        self.log_event("RED_FLAG_DETECTED", {
            "red_flag": red_flag_name,
            "urgency": urgency,
            "recommended_action": action
        }, phase="red_flag_check")

    def log_drug_interaction(
        self,
        drug_a: str,
        drug_b: str,
        severity: str
    ):
        """Log a drug interaction finding."""
        self.log_event("DRUG_INTERACTION", {
            "drug_a": drug_a,
            "drug_b": drug_b,
            "severity": severity
        }, phase="drug_check")

    def log_sanitization(self, original: str, sanitized: str):
        """Log when language sanitization modifies output."""
        self.log_event("LANGUAGE_SANITIZED", {
            "modifications_made": original != sanitized
        }, phase="output")

┌─────────────────────────────────────────────────────────────────────┐
│ THREE LAYERS OF SAFETY                                                │
├─────────────────────────────────────────────────────────────────────┤
│                                                                     │
│  Layer 1: RED FLAG DETECTION (Pre-Processing)                       │
│  ┌─────────────────────────────────────────────────────────────┐   │
│  │ • Rule-based ONLY (no LLM involvement)                      │   │
│  │ • Hardcoded patterns for life-threatening conditions         │   │
│  │ • Vital sign thresholds (SpO2 < 90%, SBP < 90, etc.) │   │
│  │ • Triggers EMERGENCY bypass of entire workflow               │   │
│  │ • WHY: Patient safety cannot depend on LLM reliability      │   │
│  └─────────────────────────────────────────────────────────────┘   │
│                                                                     │
│  Layer 2: LANGUAGE SANITIZATION (Post-Processing)                   │
│  ┌─────────────────────────────────────────────────────────────┐   │
│  │ • Regex replacement of definitive diagnostic language        │   │
│  │ • "you have X" → "findings consistent with X"               │   │
│  │ • "I diagnose" → "the assessment suggests"                  │   │
│  │ • WHY: Prevents patients/clinicians from over-relying       │   │
│  └─────────────────────────────────────────────────────────────┘   │
│                                                                     │
│  Layer 3: AUDIT LOGGING (Continuous)                                │
│  ┌─────────────────────────────────────────────────────────────┐   │
│  │ • JSONL structured logs for every interaction                │   │
│  │ • Red flags, drug interactions, sanitization events          │   │
│  │ • WHY: Regulatory compliance, quality review, liability      │   │
│  └─────────────────────────────────────────────────────────────┘   │
│                                                                     │
└─────────────────────────────────────────────────────────────────────┘

# src/agent/workflow.py
from typing import Literal
from langgraph.graph import StateGraph, END
from langchain_openai import ChatOpenAI
from langchain_openai import OpenAIEmbeddings
from langchain_chroma import Chroma

from ..clinical.state import ClinicalState, ClinicalPhase
from ..clinical.models import PatientContext, ClinicalOutput, DifferentialDiagnosis
from ..clinical.symptom_analyzer import SymptomAnalyzer
from ..clinical.differential import DifferentialGenerator
from ..tools.openfda import OpenFDAClient
from ..safety.red_flags import RedFlagDetector
from ..safety.sanitizer import LanguageSanitizer
from ..safety.audit import AuditLogger
from ..config import settings

# Initialize components
symptom_analyzer = SymptomAnalyzer()
differential_generator = DifferentialGenerator()
openfda_client = OpenFDAClient()
red_flag_detector = RedFlagDetector()
sanitizer = LanguageSanitizer()
audit = AuditLogger()


async def intake_node(state: ClinicalState) -> ClinicalState:
    """Parse and validate clinical input."""
    audit.log_event("INTAKE", {
        "chief_complaint": state["patient"].chief_complaint,
        "medication_count": len(state["patient"].current_medications)
    }, phase="intake")

    return {
        **state,
        "current_phase": ClinicalPhase.RED_FLAG_CHECK,
        "audit_trail": [f"Intake: {state['patient'].chief_complaint}"]
    }


async def red_flag_node(state: ClinicalState) -> ClinicalState:
    """Check for emergency red flags (rule-based)."""
    red_flags = red_flag_detector.detect(state["patient"])

    is_emergency = red_flag_detector.is_emergency(red_flags)

    # Log each red flag
    for rf in red_flags:
        audit.log_red_flag(rf.name, rf.urgency, rf.recommended_action)

    flag_names = [rf.name for rf in red_flags]
    flag_actions = [rf.recommended_action for rf in red_flags]

    next_phase = (
        ClinicalPhase.EMERGENCY if is_emergency
        else ClinicalPhase.ANALYSIS
    )

    return {
        **state,
        "red_flags": flag_names,
        "is_emergency": is_emergency,
        "current_phase": next_phase,
        "audit_trail": [
            f"Red flag check: {len(red_flags)} found, "
            f"emergency={is_emergency}"
        ]
    }


async def emergency_node(state: ClinicalState) -> ClinicalState:
    """Handle emergency - bypass full analysis, provide immediate guidance."""
    red_flags = red_flag_detector.detect(state["patient"])

    emergency_output = ClinicalOutput(
        patient_summary=(
            f"{state['patient'].age}yo {state['patient'].sex} presenting with "
            f"{state['patient'].chief_complaint}"
        ),
        differential=DifferentialDiagnosis(
            differentials=[],
            critical_considerations=[rf.name for rf in red_flags],
            reasoning_summary="EMERGENCY: Red flags detected. "
                            "Full differential deferred pending stabilization."
        ),
        drug_interactions=[],
        guideline_recommendations=[
            rf.recommended_action for rf in red_flags
        ],
        suggested_labs=[
            "STAT: CBC, BMP, Troponin, Lactate, Type & Screen"
        ],
        red_flags_detected=[rf.name for rf in red_flags],
        disclaimer=sanitizer.MANDATORY_DISCLAIMER
    )

    return {
        **state,
        "clinical_output": emergency_output,
        "current_phase": ClinicalPhase.OUTPUT,
        "audit_trail": [
            "EMERGENCY pathway activated - immediate action required"
        ]
    }


async def analysis_node(state: ClinicalState) -> ClinicalState:
    """Deep symptom analysis using LLM."""
    analysis = await symptom_analyzer.analyze(state["patient"])

    analysis_text = (
        f"Clinical Pattern: {analysis.clinical_pattern}\n"
        f"Acuity: {analysis.acuity_assessment}\n\n"
        f"Key Positives: {', '.join(analysis.key_positives)}\n"
        f"Key Negatives: {', '.join(analysis.key_negatives)}"
    )

    return {
        **state,
        "symptom_analysis": analysis_text,
        "current_phase": ClinicalPhase.DIFFERENTIAL,
        "audit_trail": [f"Analysis complete: acuity={analysis.acuity_assessment}"]
    }


async def differential_node(state: ClinicalState) -> ClinicalState:
    """Generate differential diagnosis."""
    differential = await differential_generator.generate(
        state["patient"],
        state["symptom_analysis"]
    )

    return {
        **state,
        "differential": differential,
        "current_phase": ClinicalPhase.DRUG_CHECK,
        "audit_trail": [
            f"Differential: {len(differential.differentials)} considerations"
        ]
    }


async def drug_check_node(state: ClinicalState) -> ClinicalState:
    """Check drug interactions via OpenFDA."""
    medications = state["patient"].current_medications
    interactions = []

    if len(medications) >= 2:
        for i, drug_a in enumerate(medications):
            for drug_b in medications[i + 1:]:
                interaction = await openfda_client.check_interaction(
                    drug_a, drug_b
                )
                if interaction:
                    interactions.append(interaction)
                    audit.log_drug_interaction(
                        drug_a, drug_b, interaction.severity
                    )

    # Also check interactions with commonly prescribed drugs
    # for the top differential diagnosis
    if state["differential"] and state["differential"].differentials:
        top_dx = state["differential"].differentials[0].diagnosis
        audit.log_event("DRUG_CHECK", {
            "medications_checked": len(medications),
            "interactions_found": len(interactions),
            "top_differential": top_dx
        }, phase="drug_check")

    return {
        **state,
        "drug_interactions": interactions,
        "current_phase": ClinicalPhase.GUIDELINES,
        "audit_trail": [
            f"Drug check: {len(interactions)} interactions found"
        ]
    }


async def guidelines_node(state: ClinicalState) -> ClinicalState:
    """Retrieve relevant clinical guidelines from knowledge base."""
    guidelines = []
    suggested_labs = []

    if state["differential"] and state["differential"].differentials:
        # Search guidelines for top differentials
        try:
            embeddings = OpenAIEmbeddings(
                api_key=settings.openai_api_key
            )
            vectorstore = Chroma(
                persist_directory=settings.chroma_persist_dir,
                embedding_function=embeddings,
                collection_name=settings.guidelines_collection
            )

            for dx in state["differential"].differentials[:3]:
                results = vectorstore.similarity_search(
                    f"{dx.diagnosis} clinical guidelines management",
                    k=2
                )
                for doc in results:
                    guidelines.append(
                        f"[{dx.diagnosis}] {doc.page_content[:300]}"
                    )

                # Collect lab suggestions from differential
                suggested_labs.extend(dx.recommended_workup)

        except Exception:
            # Guidelines DB may not be populated yet
            guidelines.append(
                "Guidelines database not configured. "
                "Consult institutional protocols."
            )

    # Deduplicate labs
    suggested_labs = list(dict.fromkeys(suggested_labs))

    return {
        **state,
        "guideline_matches": guidelines,
        "suggested_labs": suggested_labs,
        "current_phase": ClinicalPhase.OUTPUT,
        "audit_trail": [
            f"Guidelines: {len(guidelines)} matches, "
            f"{len(suggested_labs)} labs suggested"
        ]
    }


async def output_node(state: ClinicalState) -> ClinicalState:
    """Assemble final output with safety processing."""
    patient = state["patient"]

    # Build patient summary
    summary = (
        f"{patient.age}yo {patient.sex} presenting with "
        f"{patient.chief_complaint}. "
    )
    if patient.past_medical_history:
        summary += f"PMH: {', '.join(patient.past_medical_history)}. "
    if patient.current_medications:
        summary += f"Medications: {', '.join(patient.current_medications)}."

    # Sanitize all text outputs
    summary = sanitizer.sanitize(summary)
    guidelines = [
        sanitizer.sanitize(g) for g in state.get("guideline_matches", [])
    ]

    output = ClinicalOutput(
        patient_summary=summary,
        differential=state.get("differential", DifferentialDiagnosis(
            differentials=[],
            critical_considerations=[],
            reasoning_summary="Analysis not completed"
        )),
        drug_interactions=state.get("drug_interactions", []),
        guideline_recommendations=guidelines,
        suggested_labs=state.get("suggested_labs", []),
        red_flags_detected=state.get("red_flags", []),
        disclaimer=sanitizer.MANDATORY_DISCLAIMER
    )

    # Log sanitization
    audit.log_event("OUTPUT_GENERATED", {
        "differential_count": len(output.differential.differentials),
        "interaction_count": len(output.drug_interactions),
        "red_flags": output.red_flags_detected,
        "labs_suggested": len(output.suggested_labs)
    }, phase="output")

    return {
        **state,
        "clinical_output": output,
        "audit_trail": ["Output assembled and sanitized"]
    }


def route_after_red_flag(
    state: ClinicalState
) -> Literal["emergency", "analysis"]:
    """Route based on red flag detection."""
    if state.get("is_emergency", False) and settings.emergency_bypass:
        return "emergency"
    return "analysis"


# Build the LangGraph workflow
def create_clinical_workflow() -> StateGraph:
    """Create the clinical decision support workflow."""
    workflow = StateGraph(ClinicalState)

    # Add nodes
    workflow.add_node("intake", intake_node)
    workflow.add_node("red_flag_check", red_flag_node)
    workflow.add_node("emergency", emergency_node)
    workflow.add_node("analysis", analysis_node)
    workflow.add_node("differential", differential_node)
    workflow.add_node("drug_check", drug_check_node)
    workflow.add_node("guidelines", guidelines_node)
    workflow.add_node("output", output_node)

    # Set entry point
    workflow.set_entry_point("intake")

    # Add edges
    workflow.add_edge("intake", "red_flag_check")

    # Conditional: emergency bypass or continue analysis
    workflow.add_conditional_edges(
        "red_flag_check",
        route_after_red_flag,
        {
            "emergency": "emergency",
            "analysis": "analysis"
        }
    )

    workflow.add_edge("emergency", END)
    workflow.add_edge("analysis", "differential")
    workflow.add_edge("differential", "drug_check")
    workflow.add_edge("drug_check", "guidelines")
    workflow.add_edge("guidelines", "output")
    workflow.add_edge("output", END)

    return workflow.compile()


# Create the agent
clinical_agent = create_clinical_workflow()

┌─────────────────────────────────────────────────────────────────────┐
│ CLINICAL DECISION SUPPORT STATE MACHINE                               │
├─────────────────────────────────────────────────────────────────────┤
│                                                                     │
│  Entry Point                                                        │
│       │                                                             │
│       ▼                                                             │
│  ┌──────────────────┐                                               │
│  │     INTAKE       │  • Validate patient data                      │
│  │                  │  • Log interaction start                      │
│  └────────┬─────────┘                                               │
│           │                                                         │
│           ▼                                                         │
│  ┌──────────────────┐                                               │
│  │  RED FLAG CHECK  │  • Rule-based emergency detection             │
│  │  (Rules Only!)   │  • Vital sign thresholds                     │
│  └────────┬─────────┘                                               │
│           │                                                         │
│     ┌─────┴──────┐                                                  │
│     │            │                                                  │
│  (emergency)  (normal)                                              │
│     │            │                                                  │
│     ▼            ▼                                                  │
│  ┌────────┐  ┌──────────────────┐                                   │
│  │EMERGENCY│  │    ANALYSIS      │  • Symptom organization          │
│  │ (fast   │  │                  │  • Pertinent pos/neg             │
│  │  exit)  │  └────────┬─────────┘                                   │
│  └────┬───┘           │                                             │
│       │               ▼                                             │
│       │      ┌──────────────────┐                                   │
│       │      │  DIFFERENTIAL    │  • Ranked diagnoses               │
│       │      │                  │  • ICD-10 codes                   │
│       │      └────────┬─────────┘                                   │
│       │               │                                             │
│       │               ▼                                             │
│       │      ┌──────────────────┐                                   │
│       │      │   DRUG CHECK     │  • OpenFDA API queries            │
│       │      │                  │  • Interaction detection          │
│       │      └────────┬─────────┘                                   │
│       │               │                                             │
│       │               ▼                                             │
│       │      ┌──────────────────┐                                   │
│       │      │   GUIDELINES     │  • ChromaDB retrieval             │
│       │      │                  │  • Lab suggestions                │
│       │      └────────┬─────────┘                                   │
│       │               │                                             │
│       │               ▼                                             │
│       │      ┌──────────────────┐                                   │
│       │      │     OUTPUT       │  • Sanitize language              │
│       │      │                  │  • Add disclaimer                 │
│       │      └────────┬─────────┘                                   │
│       │               │                                             │
│       └───────────────┘                                             │
│               │                                                     │
│               ▼                                                     │
│             END                                                     │
│                                                                     │
└─────────────────────────────────────────────────────────────────────┘

# src/api/main.py
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from typing import List, Optional, Dict
import json

from ..agent.workflow import clinical_agent
from ..clinical.state import ClinicalState, ClinicalPhase
from ..clinical.models import (
    PatientContext, Symptom, Severity,
    ClinicalOutput, DrugInteraction
)
from ..tools.openfda import OpenFDAClient

app = FastAPI(
    title="Clinical Decision Support API",
    description="AI-powered clinical reasoning for healthcare professionals",
    version="1.0.0"
)

class ClinicalRequest(BaseModel):
    """Clinical analysis request."""
    patient: PatientContext

class DrugCheckRequest(BaseModel):
    """Drug interaction check request."""
    medications: List[str]

class ClinicalResponse(BaseModel):
    """Clinical analysis response."""
    patient_summary: str
    differentials: List[dict]
    critical_considerations: List[str]
    drug_interactions: List[dict]
    guideline_recommendations: List[str]
    suggested_labs: List[str]
    red_flags: List[str]
    is_emergency: bool
    disclaimer: str

@app.post("/clinical/analyze", response_model=ClinicalResponse)
async def analyze_clinical(request: ClinicalRequest):
    """Analyze a clinical presentation.

    Provides differential diagnosis, drug interaction checking,
    guideline retrieval, and safety guardrails.
    """
    initial_state: ClinicalState = {
        "patient": request.patient,
        "raw_input": json.dumps(request.patient.model_dump(), default=str),
        "current_phase": ClinicalPhase.INTAKE,
        "symptom_analysis": "",
        "differential": None,
        "drug_interactions": [],
        "guideline_matches": [],
        "suggested_labs": [],
        "red_flags": [],
        "is_emergency": False,
        "audit_trail": [],
        "clinical_output": None,
        "errors": []
    }

    try:
        result = await clinical_agent.ainvoke(initial_state)
        output = result.get("clinical_output")

        if not output:
            raise HTTPException(
                status_code=500,
                detail="Clinical analysis did not produce output"
            )

        return ClinicalResponse(
            patient_summary=output.patient_summary,
            differentials=[
                d.model_dump() for d in output.differential.differentials
            ],
            critical_considerations=output.differential.critical_considerations,
            drug_interactions=[
                d.model_dump() for d in output.drug_interactions
            ],
            guideline_recommendations=output.guideline_recommendations,
            suggested_labs=output.suggested_labs,
            red_flags=output.red_flags_detected,
            is_emergency=result.get("is_emergency", False),
            disclaimer=output.disclaimer
        )
    except Exception as e:
        raise HTTPException(
            status_code=500,
            detail=f"Clinical analysis failed: {str(e)}"
        )

@app.post("/clinical/drug-check")
async def check_drugs(request: DrugCheckRequest):
    """Check interactions between medications using OpenFDA."""
    client = OpenFDAClient()
    interactions = []

    for i, drug_a in enumerate(request.medications):
        for drug_b in request.medications[i + 1:]:
            interaction = await client.check_interaction(drug_a, drug_b)
            if interaction:
                interactions.append(interaction.model_dump())

    return {
        "medications": request.medications,
        "interactions": interactions,
        "interaction_count": len(interactions)
    }

@app.get("/health")
async def health():
    return {"status": "healthy", "service": "clinical-decision-support"}

# docker-compose.yml
version: '3.8'

services:
  clinical-api:
    build: .
    ports:
      - "8000:8000"
    environment:
      - OPENAI_API_KEY=${OPENAI_API_KEY}
      - OPENFDA_API_KEY=${OPENFDA_API_KEY:-}
    volumes:
      - ./data:/app/data
      - ./logs:/app/logs
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8000/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  chromadb:
    image: chromadb/chroma:latest
    ports:
      - "8001:8000"
    volumes:
      - chroma_data:/chroma/chroma

volumes:
  chroma_data:

FROM python:3.11-slim

WORKDIR /app

COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

COPY src/ ./src/
COPY data/ ./data/

RUN mkdir -p /app/logs/audit

EXPOSE 8000

CMD ["uvicorn", "src.api.main:app", "--host", "0.0.0.0", "--port", "8000"]

# requirements.txt
langgraph>=0.2.0
langchain>=0.3.0
langchain-openai>=0.2.0
langchain-chroma>=0.1.0
chromadb>=0.5.0
openai>=1.40.0
httpx>=0.27.0
fastapi>=0.115.0
uvicorn>=0.30.0
pydantic>=2.9.0
pydantic-settings>=2.5.0
scispacy>=0.5.0