MCPDischarge — Cross-Department MCP Interoperability

EHR × Pharmacy × Billing | RBAC | PHI Boundary | FastMCP

CitiusTech Gen AI & Agentic AI Training — Project 5

The Problem Traditional APIs Cannot Solve

A patient is ready for discharge. Data must flow across three departments that have never shared a common protocol:

Traditional workflow (45 minutes, 15 manual handoffs):
  Ward nurse    → prints discharge note
  Ward nurse    → phones pharmacy to check drug availability
  Pharmacy      → calls back 2 hours later (drug out of stock)
  Nurse         → calls doctor to re-prescribe
  Doctor        → updates chart
  Nurse         → re-contacts pharmacy
  Pharmacy      → dispenses (brand name ≠ generic name — wrong drug dispensed?)
  Nurse         → separately calls billing department
  Billing clerk → manually re-enters ICD-10 codes from printed note
  Billing clerk → can see full medication list including controlled substances (HIPAA risk)
  Patient       → waits, often 4–6 hours post-clinical-readiness

MCP (Model Context Protocol) solves this with a standardised, typed, RBAC-enforced tool call layer:

MCP workflow (< 1 second, automated):
  DischargeAgent.EHR.get_discharge_medications()           ← structured, not free text
  DischargeAgent.Pharmacy.check_stock()                    ← semantic name matching
  DischargeAgent.Pharmacy.get_alternative()                ← out-of-stock resolution
  DischargeAgent.EHR.get_billing_safe_summary()            ← PHI stripped at source
  DischargeAgent.Billing.generate_invoice()                ← billing never sees clinical notes

Architecture

┌────────────────────────────────────────────────────────────────┐
│                 Discharge Coordination Agent                    │
│                   (MCP Client — role: discharge_coordinator)   │
└────────┬───────────────────┬───────────────────┬──────────────┘
         │ MCP calls         │ MCP calls          │ MCP calls
         ▼                   ▼                    ▼
┌─────────────────┐ ┌─────────────────┐ ┌─────────────────┐
│  EHR MCP Server │ │ Pharmacy Server  │ │ Billing Server   │
│  (port 8001)    │ │ (port 8002)      │ │ (port 8003)      │
│                 │ │                  │ │                  │
│ Tools:          │ │ Tools:           │ │ Tools:           │
│ • discharge_meds│ │ • check_stock    │ │ • get_charges    │
│ • diagnosis_cod │ │ • get_alternative│ │ • get_insurance  │
│ • billing_safe  │ │ • get_price      │ │ • gen_invoice    │
│   _summary      │ │ • dispense_req   │ │                  │
│ [RBAC enforced] │ │ [RBAC enforced]  │ │ [RBAC enforced]  │
└─────────────────┘ └─────────────────┘ └─────────────────┘

PHI Boundary:
  EHR → Billing path uses get_billing_safe_summary()
  PHI fields blocked: name, DOB, MRN, discharge_note, attending_physician
  Billing receives: ICD-10 codes, LOS, ward — non-PHI operational data only

RBAC Policy Matrix

Every tool call validates the caller's role before returning data. Unauthorised calls raise RBACError and are logged to the telemetry feed.

Quick Start

Step 1: Install Dependencies

pip install fastmcp jsonschema numpy pandas matplotlib
# Optional for LLM integration:
pip install langchain-openai azure-ai-projects azure-identity

Step 2: Generate Data

cd data/
python generate_dataset.py

Step 3: Run the Servers

Option A: FastMCP HTTP servers (production-style)

pip install fastmcp

# Terminal 1:
python src/servers/mcp_servers.py --server ehr

# Terminal 2:
python src/servers/mcp_servers.py --server pharmacy

# Terminal 3:
python src/servers/mcp_servers.py --server billing

Option B: Direct Python (no HTTP, for training)

from src.servers.mcp_servers import EHRServer, PharmacyServer, BillingServer

ehr = EHRServer()
meds = ehr.get_discharge_medications("PAT-001", caller_role="discharge_coordinator")

Step 4: Run Discharge Agent

cd src/agents/
python discharge_agent.py PAT-001
python discharge_agent.py PAT-003    # biosimilar substitution
python discharge_agent.py PAT-006    # RBAC scope violation demo

Step 5: Full Demo

cd demo/
python demo.py                    # All 4 scenarios + 2 limitations
python demo.py --scenario 3       # RBAC demo only
python demo.py --limitations      # Limitations only

Step 6: Evaluation

cd evaluation/
python eval_dashboard.py

Project Structure

mcpdischarge/
├── data/
│   ├── generate_dataset.py          ← Run this first
│   ├── ehr_patients.json            ← 6 patient records with discharge medications
│   ├── pharmacy_inventory.json      ← 17 drugs (4 out of stock, aliases table)
│   ├── billing_rate_cards.json      ← 15 charge codes
│   ├── insurance_contracts.json     ← 2 insurer contracts
│   ├── patient_insurance_map.json   ← Patient → insurer mappings
│   ├── icd10_billing_codes.json     ← ICD-10 → DRG billing mappings
│   └── rbac_policies.json           ← RBAC matrix (role → server → tools)
│
├── src/
│   ├── servers/
│   │   └── mcp_servers.py           ← EHRServer, PharmacyServer, BillingServer + FastMCP wrappers
│   └── agents/
│       └── discharge_agent.py       ← DischargeCoordinationAgent + WorkflowMetrics
│
├── evaluation/
│   ├── eval_dashboard.py
│   ├── 01_manual_vs_mcp.png
│   ├── 02_rbac_telemetry.png
│   └── 03_data_integrity.png
│
├── demo/
│   └── demo.py                      ← 4 scenarios + 2 limitations
│
├── configs/
│   ├── fastmcp_deployment.md        ← FastMCP HTTP server setup
│   ├── azure_foundry_mcp.md         ← Azure AI Foundry MCP integration
│   └── rbac_design.md               ← RBAC policy design guide
│
└── README.md

Injected Challenge Patterns

The Three MCP Servers (Detailed)

EHR Server

PHI-sensitive tools (clinical roles only):

get_patient_discharge_summary(patient_id, caller_role)  # full clinical note
get_discharge_medications(patient_id, caller_role)       # medication list

PHI-safe tools (all roles including billing):

get_diagnosis_codes(patient_id, caller_role)             # ICD-10 only
get_admission_info(patient_id, caller_role)              # LOS, ward, dates
get_billing_safe_summary(patient_id, caller_role)        # strips PHI fields

PHI stripping (what gets blocked for billing):

PHI_FIELDS = {"name", "dob", "mrn", "discharge_note", "attending_physician"}
# Billing receives: patient_id, ward, admission_date, discharge_date, los_days, diagnosis_icd10

Pharmacy Server

Semantic name resolution:

# EHR says "Dapagliflozin" → Pharmacy stores as "Farxiga"
# MCP alias table: {"farxiga": "PH-001", "dapa": "PH-001", "sglt2 inhibitor": "PH-001"}
drug = _find_drug_by_name("Dapagliflozin")  # → PH-001 (Dapagliflozin)
drug = _find_drug_by_name("Humira")          # → PH-008 (Adalimumab, branded)

Dose conflict detection:

# EHR prescribes Semaglutide 0.5mg, formulary standard is 0.25mg starter
if queried_dose not in formulary_dose:
    dose_conflict = True  # triggers clinical review alert

Semantic match score:

# score = word overlap / max(len(ehr_words), len(pharm_words))
# score < 0.85 → NAME_MISMATCH alert even if drug found
semantic_drug_match_score("Humira", "Adalimumab")  # → 0.0 (no word overlap)
semantic_drug_match_score("Furosemide", "Furosemide")  # → 1.0 (exact)

Billing Server

Invoice generation (PHI guard):

def generate_invoice(patient_id, billing_safe_ehr, drug_costs, ...):
    # Verify PHI is stripped
    for phi_field in PHI_FIELDS:
        if phi_field in billing_safe_ehr:
            raise PermissionError(f"PHI field '{phi_field}' in billing payload")
    # Process invoice using only: ICD-10 + LOS + ward + drug prices

MCP vs Traditional API Comparison

Evaluation Results (6 Patient Discharges)

Total: 72 MCP tool calls | 100% success | 15 manual handoffs replaced per discharge | ~45 minutes saved per case

FastMCP HTTP Deployment

See configs/fastmcp_deployment.md. Key pattern:

from fastmcp import FastMCP

ehr_mcp = FastMCP("EHR-Server")

@ehr_mcp.tool()
def get_discharge_medications(patient_id: str, caller_role: str) -> dict:
    """Get discharge medication list from EHR."""
    return EHRServer().get_discharge_medications(patient_id, caller_role)

# Run as HTTP SSE server
ehr_mcp.run(transport="sse", host="0.0.0.0", port=8001)

Agent connects as MCP client:

from mcp import ClientSession, StdioServerParameters
from mcp.client.sse import sse_client

async with sse_client("http://localhost:8001/sse") as (read, write):
    async with ClientSession(read, write) as session:
        result = await session.call_tool(
            "get_discharge_medications",
            {"patient_id": "PAT-001", "caller_role": "discharge_coordinator"}
        )

Azure AI Foundry Integration

See configs/azure_foundry_mcp.md. MCP servers register as Foundry tools:

from azure.ai.projects.models import McpToolDefinition

mcp_tools = [
    McpToolDefinition(server_url="http://ehr-server:8001/sse", name="ehr-server"),
    McpToolDefinition(server_url="http://pharmacy-server:8002/sse", name="pharmacy-server"),
    McpToolDefinition(server_url="http://billing-server:8003/sse", name="billing-server"),
]

agent = client.agents.create_agent(
    model="gpt-4o",
    name="DischargeCoordinationAgent",
    instructions=DISCHARGE_AGENT_SYSTEM_PROMPT,
    tools=[t.as_tool_definition() for t in mcp_tools],
)

CitiusTech Gen AI & Agentic AI Training Program — Project 5 of 5

1. Product Vision (What your UI should feel like)

Think of it like:

👉 “Stripe Dashboard + AI Agent + Hospital System”

When a user opens your portal:

They don’t just click discharge They see the system thinking, deciding, and acting in real-time 🧩 2. Core UI Experience (Step-by-Step) 🏁 Landing Page (Portal Entry) What user sees: Patient search / select “Start Discharge” button Recent discharges (history) ⚡ After Clicking “Start Discharge”

👉 Transition into a Live Execution Dashboard

🧠 3. THE MAIN SCREEN (This is your WOW factor) 🔥 A. Live Agent Trace Panel (MOST IMPORTANT)

Like a debug console + timeline

UI: [10:21:01] 🔄 Calling EHR.get_patient() [10:21:02] ✅ Patient data retrieved

[10:21:03] 🔄 Calling Pharmacy.check_stock(Metformin) [10:21:03] ✅ In stock

[10:21:04] 🔄 Calling Pharmacy.check_stock(Atorvastatin) [10:21:04] ❌ Out of stock

[10:21:05] 🤖 AI Suggestion: "Atorvastatin is unavailable. Suggested alternative: Rosuvastatin (similar statin, higher potency)."

[10:21:06] 🔄 Calling Billing.generate_invoice() [10:21:07] ✅ Invoice generated 🎨 How to implement: Left panel → trace logs Each step: loading animation success (green) failure (red) AI reasoning (purple) 💡 B. Smart Error + Suggestion Cards

When something fails:

Example UI Card: ⚠ Drug Out of Stock

Original: Atorvastatin
Suggested: Rosuvastatin

Reason:

• Same drug class (statin)
• Better LDL reduction
• Available in inventory

[ Accept Suggestion ] [ Override ]

👉 This is your AI reasoning visibility → HUGE differentiator

📊 C. Right Panel → Structured Output Sections: 🧾 Final Medications 💰 Invoice Breakdown 📋 Summary 🎥 D. Animated Flow (WOW Factor #2)

Show flow like:

EHR → Pharmacy → Billing

With animated arrows:

glowing when active dim when idle

👉 Users SEE orchestration

🔍 E. Tool Call Inspector (WOW Factor #3)

Click any step → show:

Request: { "drug": "Atorvastatin" }

Response: { "stock": 0 }

👉 This is developer-grade transparency

🧪 4. Failure Scenarios UI (CRITICAL) Case 1: Drug Out of Stock Show suggestion (already covered) Case 2: No Alternative Found ❌ No substitute available

Suggested Actions:

• Notify doctor
• Delay discharge Case 3: Billing Failure ⚠ Insurance validation failed

Reason: Policy expired

[ Continue with self-pay ] 🎨 5. UI Stack (Recommended) Frontend: React Tailwind CSS Framer Motion (animations) Backend: FastAPI WebSockets (for live trace updates) ⚙️ 6. How Data Flows (Important) Use WebSockets:

Backend sends:

{ "step": "pharmacy_check", "status": "failed", "message": "Out of stock", "suggestion": "Use Rosuvastatin" }

Frontend:

updates UI in real-time 🧠 7. AI Layer (Upgrade your WOW factor)

Use:

LangChain

For:

generating explanations: “why this drug?” “why substitution?” 💎 8. Extra WOW Features (Highly Recommended) 🔥 1. “Explain This Decision” Button

User clicks → AI explains reasoning

🔥 2. Confidence Score Substitution Confidence: 92% 🔥 3. Replay Mode Re-run past discharge Step-by-step playback