Predictive Healthcare Analytics Platform

Clinical Requirements:
├─ Readmission Risk: Predict 30-day readmission with > 75% AUC
├─ Latency: Risk scores available within 2 hours of discharge
├─ Intervention: Automated care coordinator alerts for high-risk patients
└─ Explainability: Clinician-interpretable risk factors
 
Data Requirements:
├─ Volume: 500K+ clinical events/day across all facilities
├─ Integration: 50+ EHR systems with varying data formats (HL7, FHIR, custom)
├─ History: 5 years of historical data for model training
└─ Quality: Data validation and cleansing for clinical accuracy
 
Compliance Requirements:
├─ HIPAA: Full compliance with Privacy Rule, Security Rule
├─ BAA: Business Associate Agreements with all vendors
├─ Audit: Complete audit trail for all PHI access
├─ Encryption: AES-256 at rest, TLS 1.3 in transit
└─ Access Control: Role-based access with MFA
 
Operational Requirements:
├─ Availability: 99.99% uptime (healthcare-critical SLA)
├─ Disaster Recovery: RTO < 4 hours, RPO < 1 hour
├─ Scalability: Handle 10x volume during flu season
└─ Support: 24/7 on-call for critical issues

┌─────────────────────────────────────────────────────────────────────────────┐
│               HIPAA-COMPLIANT HEALTHCARE ANALYTICS PLATFORM                  │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  DATA SOURCES (50+ EHR Systems)                                            │
│  ┌─────────┐  ┌─────────┐  ┌─────────┐  ┌─────────┐  ┌─────────┐          │
│  │  Epic   │  │ Cerner  │  │Meditech │  │Allscripts│  │   Lab   │          │
│  │ (HL7v2) │  │ (FHIR)  │  │  (ADT)  │  │ (CCD)   │  │ Systems │          │
│  └────┬────┘  └────┬────┘  └────┬────┘  └────┬────┘  └────┬────┘          │
│       │           │           │           │           │                    │
│       └───────────┴───────────┴───────────┴───────────┘                    │
│                               │                                             │
│                               ▼                                             │
│  ┌──────────────────────────────────────────────────────────────────────┐  │
│  │              INTEGRATION LAYER (AWS HealthLake + Custom)              │  │
│  │                                                                       │  │
│  │  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐                   │  │
│  │  │  Mirth      │  │   FHIR      │  │    PHI      │                   │  │
│  │  │  Connect    │  │  Converter  │  │  De-ID      │                   │  │
│  │  │(HL7 Parser) │  │             │  │  Engine     │                   │  │
│  │  └─────────────┘  └─────────────┘  └─────────────┘                   │  │
│  │                                                                       │  │
│  │  Encryption: AES-256 | Transit: TLS 1.3 | VPC: Isolated              │  │
│  └──────────────────────────────────────────────────────────────────────┘  │
│                               │                                             │
│                               ▼                                             │
│  ┌──────────────────────────────────────────────────────────────────────┐  │
│  │                    STORAGE LAYER (HIPAA-Compliant)                    │  │
│  │                                                                       │  │
│  │  ┌─────────────────────┐  ┌─────────────────────┐                    │  │
│  │  │   Clinical Data     │  │   Analytics Data    │                    │  │
│  │  │   (RDS PostgreSQL)  │  │   (Redshift)        │                    │  │
│  │  │                     │  │                     │                    │  │
│  │  │ - Patient records   │  │ - Aggregated metrics │                   │  │
│  │  │ - Encounters        │  │ - Model features    │                    │  │
│  │  │ - Lab results       │  │ - Risk scores       │                    │  │
│  │  │ - Medications       │  │ - Operational KPIs  │                    │  │
│  │  └─────────────────────┘  └─────────────────────┘                    │  │
│  │                                                                       │  │
│  │  S3 (PHI): Encrypted, Versioned, Access-Logged | Glacier: 7yr retain │  │
│  └──────────────────────────────────────────────────────────────────────┘  │
│                               │                                             │
│                               ▼                                             │
│  ┌──────────────────────────────────────────────────────────────────────┐  │
│  │                    ANALYTICS & ML LAYER                               │  │
│  │                                                                       │  │
│  │  ┌───────────────────────────────────────────────────────────────┐   │  │
│  │  │                    dbt Transformation                          │   │  │
│  │  │  staging → intermediate → marts (clinical, operational, research)│  │  │
│  │  └───────────────────────────────────────────────────────────────┘   │  │
│  │                               │                                       │  │
│  │  ┌─────────────────────────────────────────────────────────────────┐ │  │
│  │  │                    ML Pipeline (SageMaker)                       │ │  │
│  │  │  ┌───────────┐  ┌───────────┐  ┌───────────┐  ┌───────────┐   │ │  │
│  │  │  │  Feature  │─▶│   Model   │─▶│  Model    │─▶│  Serving  │   │ │  │
│  │  │  │  Store    │  │  Training │  │  Registry │  │  Endpoint │   │ │  │
│  │  │  └───────────┘  └───────────┘  └───────────┘  └───────────┘   │ │  │
│  │  └─────────────────────────────────────────────────────────────────┘ │  │
│  │                                                                       │  │
│  │  Orchestration: Apache Airflow | Monitoring: CloudWatch + Datadog    │  │
│  └──────────────────────────────────────────────────────────────────────┘  │
│                               │                                             │
│                               ▼                                             │
│  ┌──────────────────────────────────────────────────────────────────────┐  │
│  │                    SERVING LAYER                                      │  │
│  │                                                                       │  │
│  │  ┌───────────┐  ┌───────────┐  ┌───────────┐  ┌───────────┐         │  │
│  │  │  EHR      │  │ Clinician │  │   Care    │  │  Admin    │         │  │
│  │  │Integration│  │ Dashboard │  │Coordinator│  │ Reports   │         │  │
│  │  │  (SMART)  │  │  (React)  │  │  Alerts   │  │           │         │  │
│  │  └───────────┘  └───────────┘  └───────────┘  └───────────┘         │  │
│  └──────────────────────────────────────────────────────────────────────┘  │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

# infrastructure/security/hipaa_controls.py
"""
HIPAA Security Rule implementation using AWS services.
Maps to HIPAA Administrative, Physical, and Technical Safeguards.
"""
 
from dataclasses import dataclass
from enum import Enum
from typing import List, Optional
import boto3
 
class HIPAASafeguard(Enum):
    ADMINISTRATIVE = "administrative"
    PHYSICAL = "physical"
    TECHNICAL = "technical"
 
@dataclass
class SecurityControl:
    safeguard: HIPAASafeguard
    requirement: str
    implementation: str
    aws_service: str
    verification: str
 
HIPAA_CONTROLS = [
    # Administrative Safeguards (164.308)
    SecurityControl(
        safeguard=HIPAASafeguard.ADMINISTRATIVE,
        requirement="164.308(a)(1) - Security Management Process",
        implementation="Risk analysis and management program",
        aws_service="AWS Config, Security Hub",
        verification="Quarterly risk assessments with documented remediation"
    ),
    SecurityControl(
        safeguard=HIPAASafeguard.ADMINISTRATIVE,
        requirement="164.308(a)(3) - Workforce Security",
        implementation="Role-based access control with least privilege",
        aws_service="IAM, AWS SSO",
        verification="Monthly access reviews, immediate termination procedures"
    ),
    SecurityControl(
        safeguard=HIPAASafeguard.ADMINISTRATIVE,
        requirement="164.308(a)(4) - Information Access Management",
        implementation="Access authorization policies and procedures",
        aws_service="IAM Policies, Resource Policies",
        verification="Automated policy validation via OPA"
    ),
 
    # Technical Safeguards (164.312)
    SecurityControl(
        safeguard=HIPAASafeguard.TECHNICAL,
        requirement="164.312(a)(1) - Access Control",
        implementation="Unique user identification and MFA",
        aws_service="Cognito, IAM Identity Center",
        verification="100% MFA enforcement, session timeout < 15 min"
    ),
    SecurityControl(
        safeguard=HIPAASafeguard.TECHNICAL,
        requirement="164.312(b) - Audit Controls",
        implementation="Comprehensive audit logging of all PHI access",
        aws_service="CloudTrail, VPC Flow Logs, S3 Access Logs",
        verification="Real-time alerting on suspicious access patterns"
    ),
    SecurityControl(
        safeguard=HIPAASafeguard.TECHNICAL,
        requirement="164.312(c)(1) - Integrity",
        implementation="Data integrity verification and tamper detection",
        aws_service="S3 Object Lock, RDS encryption",
        verification="Hash verification on all PHI transfers"
    ),
    SecurityControl(
        safeguard=HIPAASafeguard.TECHNICAL,
        requirement="164.312(d) - Person Authentication",
        implementation="Multi-factor authentication for all users",
        aws_service="Cognito MFA, FIDO2",
        verification="No single-factor access to PHI permitted"
    ),
    SecurityControl(
        safeguard=HIPAASafeguard.TECHNICAL,
        requirement="164.312(e)(1) - Transmission Security",
        implementation="TLS 1.3 for all data in transit",
        aws_service="ALB, CloudFront, API Gateway",
        verification="Certificate pinning, no deprecated protocols"
    ),
]
 
class HIPAAComplianceChecker:
    """Automated HIPAA compliance verification."""
 
    def __init__(self):
        self.config_client = boto3.client('config')
        self.securityhub_client = boto3.client('securityhub')
 
    def run_compliance_check(self) -> dict:
        """Run all HIPAA compliance checks and return report."""
 
        results = {
            'timestamp': datetime.utcnow().isoformat(),
            'overall_status': 'COMPLIANT',
            'controls': []
        }
 
        for control in HIPAA_CONTROLS:
            check_result = self._check_control(control)
            results['controls'].append(check_result)
 
            if check_result['status'] != 'COMPLIANT':
                results['overall_status'] = 'NON_COMPLIANT'
 
        return results
 
    def _check_control(self, control: SecurityControl) -> dict:
        """Check individual control compliance."""
 
        # AWS Config rules for HIPAA
        config_rules = self._get_config_rules(control.requirement)
 
        compliance_status = 'COMPLIANT'
        findings = []
 
        for rule in config_rules:
            rule_compliance = self.config_client.get_compliance_details_by_config_rule(
                ConfigRuleName=rule
            )
 
            for result in rule_compliance['EvaluationResults']:
                if result['ComplianceType'] != 'COMPLIANT':
                    compliance_status = 'NON_COMPLIANT'
                    findings.append({
                        'resource': result['EvaluationResultIdentifier']['EvaluationResultQualifier']['ResourceId'],
                        'rule': rule,
                        'status': result['ComplianceType']
                    })
 
        return {
            'requirement': control.requirement,
            'safeguard': control.safeguard.value,
            'status': compliance_status,
            'findings': findings
        }

# etl/ehr_integration.py
"""
EHR data integration pipeline using HL7 FHIR R4 as canonical format.
Supports Epic, Cerner, Meditech, Allscripts, and custom EHR systems.
"""
 
from abc import ABC, abstractmethod
from dataclasses import dataclass
from typing import Dict, List, Optional
import hl7
from fhirclient import client
from fhirclient.models import patient, encounter, observation
 
@dataclass
class ClinicalEvent:
    """Canonical clinical event format (FHIR-aligned)."""
    patient_id: str
    encounter_id: str
    event_type: str
    event_datetime: datetime
    facility_id: str
    provider_id: Optional[str]
    diagnosis_codes: List[str]  # ICD-10
    procedure_codes: List[str]  # CPT
    lab_results: List[Dict]
    medications: List[Dict]
    vitals: Dict
    source_system: str
    raw_data: Dict  # Preserve original for audit
 
class EHRAdapter(ABC):
    """Abstract base class for EHR system adapters."""
 
    @abstractmethod
    def connect(self) -> bool:
        pass
 
    @abstractmethod
    def extract_events(self, since: datetime) -> List[ClinicalEvent]:
        pass
 
    @abstractmethod
    def validate_event(self, event: ClinicalEvent) -> bool:
        pass
 
class EpicHL7Adapter(EHRAdapter):
    """Epic EHR adapter using HL7v2 ADT messages."""
 
    def __init__(self, config: Dict):
        self.mirth_url = config['mirth_endpoint']
        self.facility_mapping = config['facility_mapping']
 
    def extract_events(self, since: datetime) -> List[ClinicalEvent]:
        """Extract ADT events from Epic via Mirth Connect."""
 
        events = []
        hl7_messages = self._fetch_hl7_messages(since)
 
        for msg in hl7_messages:
            parsed = hl7.parse(msg)
 
            # Extract patient info (PID segment)
            pid = parsed.segment('PID')
            patient_id = str(pid[3])  # Patient ID
 
            # Extract encounter info (PV1 segment)
            pv1 = parsed.segment('PV1')
            encounter_id = str(pv1[19]) if pv1[19] else None
 
            # Extract diagnoses (DG1 segments)
            diagnoses = []
            for dg1 in parsed.segments('DG1'):
                if dg1[3]:
                    diagnoses.append(str(dg1[3]))
 
            # Create canonical event
            event = ClinicalEvent(
                patient_id=self._hash_phi(patient_id),  # De-identify
                encounter_id=encounter_id,
                event_type=self._map_event_type(str(parsed.segment('MSH')[9])),
                event_datetime=self._parse_hl7_datetime(str(parsed.segment('MSH')[7])),
                facility_id=self.facility_mapping.get(str(parsed.segment('MSH')[4])),
                provider_id=str(pv1[7]) if pv1[7] else None,
                diagnosis_codes=diagnoses,
                procedure_codes=[],
                lab_results=[],
                medications=[],
                vitals={},
                source_system='epic_hl7v2',
                raw_data={'hl7_message': msg}  # Encrypted storage
            )
 
            if self.validate_event(event):
                events.append(event)
 
        return events
 
class CernerFHIRAdapter(EHRAdapter):
    """Cerner EHR adapter using FHIR R4 API."""
 
    def __init__(self, config: Dict):
        self.fhir_settings = {
            'app_id': config['client_id'],
            'app_secret': config['client_secret'],
            'api_base': config['fhir_endpoint']
        }
        self.smart = client.FHIRClient(settings=self.fhir_settings)
 
    def extract_events(self, since: datetime) -> List[ClinicalEvent]:
        """Extract encounters from Cerner via FHIR API."""
 
        events = []
 
        # Search for recent encounters
        search = encounter.Encounter.where(struct={
            'date': f'ge{since.isoformat()}',
            '_count': 1000
        })
 
        encounters = search.perform_resources(self.smart.server)
 
        for enc in encounters:
            # Fetch associated resources
            patient_ref = enc.subject.reference
            patient_resource = patient.Patient.read(patient_ref, self.smart.server)
 
            # Fetch observations (vitals, labs)
            obs_search = observation.Observation.where(struct={
                'encounter': enc.id
            })
            observations = obs_search.perform_resources(self.smart.server)
 
            event = ClinicalEvent(
                patient_id=self._hash_phi(patient_resource.id),
                encounter_id=enc.id,
                event_type=enc.class_fhir.code if enc.class_fhir else 'unknown',
                event_datetime=enc.period.start.date if enc.period else datetime.utcnow(),
                facility_id=self._extract_facility(enc),
                provider_id=self._extract_provider(enc),
                diagnosis_codes=self._extract_diagnoses(enc),
                procedure_codes=self._extract_procedures(enc),
                lab_results=self._extract_labs(observations),
                medications=self._extract_medications(enc),
                vitals=self._extract_vitals(observations),
                source_system='cerner_fhir_r4',
                raw_data={'fhir_resources': {
                    'encounter': enc.as_json(),
                    'patient': patient_resource.as_json()
                }}
            )
 
            if self.validate_event(event):
                events.append(event)
 
        return events

# ml/readmission_model.py
"""
30-day readmission prediction model.
Uses clinical features to predict risk of unplanned readmission.
"""
 
import xgboost as xgb
import shap
import pandas as pd
import numpy as np
from sklearn.model_selection import StratifiedKFold
from sklearn.metrics import roc_auc_score, precision_recall_curve
from typing import Dict, List, Tuple
 
class ReadmissionPredictor:
    """
    XGBoost classifier for 30-day readmission prediction.
    Includes SHAP-based explanations for clinical interpretability.
    """
 
    def __init__(self, model_config: Dict):
        self.config = model_config
        self.model = None
        self.explainer = None
        self.feature_names = None
 
        # Clinical feature groups
        self.feature_groups = {
            'demographics': ['age', 'gender', 'insurance_type'],
            'clinical': [
                'charlson_comorbidity_index',
                'num_diagnoses',
                'num_procedures',
                'length_of_stay',
                'icu_admission',
                'num_prior_admissions_12mo'
            ],
            'lab_results': [
                'hemoglobin_last',
                'creatinine_last',
                'sodium_last',
                'bun_last',
                'glucose_last'
            ],
            'medications': [
                'num_medications_discharge',
                'high_risk_medications',
                'anticoagulant_prescribed'
            ],
            'social': [
                'lives_alone',
                'discharge_disposition',
                'pcp_followup_scheduled'
            ]
        }
 
    def train(self, X: pd.DataFrame, y: pd.Series,
              validation_data: Tuple[pd.DataFrame, pd.Series] = None) -> Dict:
        """
        Train the readmission model with cross-validation.
 
        Args:
            X: Feature matrix
            y: Target (1 = readmitted within 30 days)
            validation_data: Optional held-out validation set
 
        Returns:
            Training metrics and feature importances
        """
 
        self.feature_names = X.columns.tolist()
 
        # Handle class imbalance (readmissions ~15% of discharges)
        scale_pos_weight = (y == 0).sum() / (y == 1).sum()
 
        # XGBoost parameters tuned for clinical predictions
        params = {
            'objective': 'binary:logistic',
            'eval_metric': ['auc', 'logloss'],
            'max_depth': 6,
            'learning_rate': 0.05,
            'subsample': 0.8,
            'colsample_bytree': 0.8,
            'scale_pos_weight': scale_pos_weight,
            'min_child_weight': 5,
            'reg_alpha': 0.1,
            'reg_lambda': 1.0,
            'seed': 42
        }
 
        # Cross-validation for robust performance estimate
        cv_scores = []
        kfold = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)
 
        for fold, (train_idx, val_idx) in enumerate(kfold.split(X, y)):
            X_train, X_val = X.iloc[train_idx], X.iloc[val_idx]
            y_train, y_val = y.iloc[train_idx], y.iloc[val_idx]
 
            dtrain = xgb.DMatrix(X_train, label=y_train)
            dval = xgb.DMatrix(X_val, label=y_val)
 
            model = xgb.train(
                params,
                dtrain,
                num_boost_round=500,
                evals=[(dtrain, 'train'), (dval, 'val')],
                early_stopping_rounds=50,
                verbose_eval=False
            )
 
            val_pred = model.predict(dval)
            cv_scores.append(roc_auc_score(y_val, val_pred))
 
        # Train final model on full training data
        dtrain_full = xgb.DMatrix(X, label=y)
        self.model = xgb.train(
            params,
            dtrain_full,
            num_boost_round=500
        )
 
        # Initialize SHAP explainer
        self.explainer = shap.TreeExplainer(self.model)
 
        metrics = {
            'cv_auc_mean': np.mean(cv_scores),
            'cv_auc_std': np.std(cv_scores),
            'feature_importance': self._get_feature_importance()
        }
 
        # Validation set performance if provided
        if validation_data:
            X_test, y_test = validation_data
            dtest = xgb.DMatrix(X_test)
            test_pred = self.model.predict(dtest)
            metrics['test_auc'] = roc_auc_score(y_test, test_pred)
            metrics['test_metrics'] = self._calculate_clinical_metrics(y_test, test_pred)
 
        return metrics
 
    def predict(self, X: pd.DataFrame, explain: bool = True) -> Dict:
        """
        Generate predictions with optional explanations.
 
        Args:
            X: Feature matrix for prediction
            explain: Whether to generate SHAP explanations
 
        Returns:
            Dictionary with predictions and explanations
        """
 
        dmatrix = xgb.DMatrix(X)
        probabilities = self.model.predict(dmatrix)
 
        # Risk stratification
        risk_categories = np.select(
            [probabilities >= 0.7, probabilities >= 0.4, probabilities >= 0.2],
            ['high', 'medium', 'low'],
            default='very_low'
        )
 
        results = {
            'risk_probability': probabilities.tolist(),
            'risk_category': risk_categories.tolist()
        }
 
        if explain:
            shap_values = self.explainer.shap_values(X)
 
            # Top risk factors for each prediction
            explanations = []
            for i in range(len(X)):
                patient_shap = pd.Series(
                    shap_values[i],
                    index=self.feature_names
                ).sort_values(key=abs, ascending=False)
 
                # Top 5 contributing factors
                top_factors = []
                for feature, value in patient_shap.head(5).items():
                    direction = 'increases' if value > 0 else 'decreases'
                    feature_value = X.iloc[i][feature]
                    top_factors.append({
                        'feature': self._human_readable_feature(feature),
                        'value': feature_value,
                        'direction': direction,
                        'shap_value': float(value)
                    })
 
                explanations.append({
                    'top_risk_factors': top_factors,
                    'shap_values': shap_values[i].tolist()
                })
 
            results['explanations'] = explanations
 
        return results
 
    def _human_readable_feature(self, feature: str) -> str:
        """Convert feature name to clinician-friendly description."""
 
        mappings = {
            'charlson_comorbidity_index': 'Comorbidity burden',
            'num_prior_admissions_12mo': 'Prior hospitalizations (12 months)',
            'length_of_stay': 'Length of stay (days)',
            'num_medications_discharge': 'Discharge medications',
            'hemoglobin_last': 'Hemoglobin level',
            'creatinine_last': 'Creatinine (kidney function)',
            'lives_alone': 'Lives alone',
            'pcp_followup_scheduled': 'PCP follow-up scheduled',
            'icu_admission': 'ICU stay during admission',
            'high_risk_medications': 'High-risk medications prescribed'
        }
 
        return mappings.get(feature, feature.replace('_', ' ').title())
 
    def _calculate_clinical_metrics(self, y_true, y_pred) -> Dict:
        """Calculate clinically relevant metrics."""
 
        # Find optimal threshold for clinical use (balance sensitivity/PPV)
        precision, recall, thresholds = precision_recall_curve(y_true, y_pred)
 
        # F2 score (weighs recall higher - we want to catch readmissions)
        f2_scores = (5 * precision * recall) / (4 * precision + recall + 1e-10)
        optimal_idx = np.argmax(f2_scores)
        optimal_threshold = thresholds[optimal_idx]
 
        y_pred_binary = (y_pred >= optimal_threshold).astype(int)
 
        return {
            'optimal_threshold': float(optimal_threshold),
            'sensitivity': float(recall[optimal_idx]),
            'ppv': float(precision[optimal_idx]),
            'f2_score': float(f2_scores[optimal_idx]),
            'nnt_alert': int(1 / precision[optimal_idx])  # Number needed to alert to prevent 1 readmission
        }

// frontend/src/components/RiskAlert.tsx
/**
 * Real-time readmission risk alert component.
 * Integrated into Epic via SMART on FHIR.
 */
 
import React, { useEffect, useState } from 'react';
import { Card, Badge, List, Typography, Button, Spin } from 'antd';
import { AlertOutlined, PhoneOutlined, CalendarOutlined } from '@ant-design/icons';
import { usePatientContext } from '../hooks/usePatientContext';
import { fetchRiskPrediction, RiskPrediction } from '../api/predictions';
 
const { Title, Text } = Typography;
 
interface RiskAlertProps {
  encounterId: string;
}
 
export const RiskAlert: React.FC<RiskAlertProps> = ({ encounterId }) => {
  const [prediction, setPrediction] = useState<RiskPrediction | null>(null);
  const [loading, setLoading] = useState(true);
  const { patientId, facilityId } = usePatientContext();
 
  useEffect(() => {
    const loadPrediction = async () => {
      try {
        const result = await fetchRiskPrediction(patientId, encounterId);
        setPrediction(result);
      } catch (error) {
        console.error('Failed to fetch risk prediction:', error);
      } finally {
        setLoading(false);
      }
    };
 
    loadPrediction();
  }, [patientId, encounterId]);
 
  if (loading) {
    return <Spin tip="Calculating readmission risk..." />;
  }
 
  if (!prediction) {
    return null;
  }
 
  const getRiskColor = (category: string) => {
    switch (category) {
      case 'high': return '#f5222d';
      case 'medium': return '#fa8c16';
      case 'low': return '#52c41a';
      default: return '#1890ff';
    }
  };
 
  const getRiskBadge = (category: string) => {
    switch (category) {
      case 'high': return <Badge status="error" text="High Risk" />;
      case 'medium': return <Badge status="warning" text="Medium Risk" />;
      case 'low': return <Badge status="success" text="Low Risk" />;
      default: return <Badge status="default" text="Very Low Risk" />;
    }
  };
 
  return (
    <Card
      title={
        <span>
          <AlertOutlined style={{ marginRight: 8 }} />
          30-Day Readmission Risk
        </span>
      }
      extra={getRiskBadge(prediction.risk_category)}
      style={{ borderLeft: `4px solid ${getRiskColor(prediction.risk_category)}` }}
    >
      {/* Risk Score */}
      <div style={{ textAlign: 'center', marginBottom: 16 }}>
        <Title level={2} style={{ color: getRiskColor(prediction.risk_category), margin: 0 }}>
          {Math.round(prediction.risk_probability * 100)}%
        </Title>
        <Text type="secondary">Predicted readmission probability</Text>
      </div>
 
      {/* Risk Factors */}
      <Title level={5}>Top Contributing Factors</Title>
      <List
        size="small"
        dataSource={prediction.explanations.top_risk_factors.slice(0, 5)}
        renderItem={(factor) => (
          <List.Item>
            <Text>
              {factor.feature}:{' '}
              <Text strong>{factor.value}</Text>
              <Text
                type={factor.direction === 'increases' ? 'danger' : 'success'}
                style={{ marginLeft: 8 }}
              >
                ({factor.direction} risk)
              </Text>
            </Text>
          </List.Item>
        )}
      />
 
      {/* Recommended Actions for High Risk */}
      {prediction.risk_category === 'high' && (
        <>
          <Title level={5} style={{ marginTop: 16 }}>Recommended Actions</Title>
          <div style={{ display: 'flex', gap: 8, flexWrap: 'wrap' }}>
            <Button
              icon={<PhoneOutlined />}
              onClick={() => window.open(`tel:${prediction.care_coordinator_phone}`)}
            >
              Contact Care Coordinator
            </Button>
            <Button
              icon={<CalendarOutlined />}
              onClick={() => {/* Schedule follow-up logic */}}
            >
              Schedule 48hr Follow-up
            </Button>
          </div>
        </>
      )}
 
      {/* Audit footer */}
      <div style={{ marginTop: 16, borderTop: '1px solid #f0f0f0', paddingTop: 8 }}>
        <Text type="secondary" style={{ fontSize: 10 }}>
          Model v{prediction.model_version} | Prediction ID: {prediction.prediction_id}
          <br />
          Generated: {new Date(prediction.timestamp).toLocaleString()}
        </Text>
      </div>
    </Card>
  );
};

                       OPERATIONAL IMPACT
 
┌────────────────────────────────────────────────────────────────┐
│                                                                │
│  RESOURCE UTILIZATION                  DATA PROCESSING         │
│  ────────────────────                  ────────────────         │
│  ┌──────────────────┐                 ┌──────────────────┐    │
│  │ Bed Occupancy:   │                 │ Event Processing:│    │
│  │ +25% utilization │                 │ 500K+/day        │    │
│  │                  │                 │                  │    │
│  │ Staff Scheduling:│                 │ Analytics Latency│    │
│  │ 15% overtime     │                 │ < 2 hours        │    │
│  │ reduction        │                 │ (was 3-5 days)   │    │
│  └──────────────────┘                 └──────────────────┘    │
│                                                                │
│  COMPLIANCE                            COST SAVINGS            │
│  ──────────                            ────────────            │
│  ┌──────────────────┐                 ┌──────────────────┐    │
│  │ HIPAA Audits:    │                 │ Total Annual:    │    │
│  │ 100% pass rate   │                 │ $8.2M            │    │
│  │                  │                 │                  │    │
│  │ Security         │                 │ - Penalties: $3.6M│   │
│  │ Incidents: 0     │                 │ - Operations:$2.4M│   │
│  │                  │                 │ - LOS Reduction: │    │
│  │                  │                 │   $2.2M          │    │
│  └──────────────────┘                 └──────────────────┘    │
│                                                                │
└────────────────────────────────────────────────────────────────┘