Building CareGraph AI: Autonomous Multilingual Voice & Knowledge Graph Healthcare Triage with FalkorDB

Can a graph database save lives during medical emergencies? Here is how we replaced hallucinating LLMs with a 0.31ms 5-hop FalkorDB traversal to connect voice symptoms directly to verified ICU beds and doctors across India.

🚨 The Emergency Triage Crisis in India

In acute medical crises — myocardial infarctions (heart attacks), hypoxic pneumonia, acute stroke — every second counts. In India, emergency medical triage currently suffers from two fatal bottlenecks:

1. Passive, Hallucinating Chatbots: Traditional LLM chatbots guess medical advice probabilistically. In an emergency, a hallucinated drug recommendation or delayed triage is catastrophic.
2. Disconnected Hospital Resources: A patient or paramedic spends precious minutes making frantic phone calls to check which hospital has an ICU oxygen bed and an attending specialist on duty.

We asked: What if an autonomous voice assistant could listen to patient symptoms in pure Hindi or English, and instantly traverse a deterministic clinical knowledge graph to identify life-threatening conditions, check drug contraindications, allocate live ICU beds, and auto-dispatch ambulance CAD alerts in under a second?

Enter CareGraph AI.

🏗️ System Architecture

CareGraph AI unites FalkorDB, LiveKit WebRTC, Murf Falcon TTS, and Twilio PSTN into a closed-loop emergency triage system:

Patient Speaks (Hindi/English)
          │
          ▼
Live Voice Intake (Deepgram Nova-2 + Murf Falcon <250ms)
          │  writes session + detected symptoms live
          ▼
┌────────────────────────────────────────────────────────┐
│            FalkorDB Graph Memory Engine                │
│                                                        │
│  (:Patient)-[:HAD_SESSION]->(:AgentSession)            │
│  (:Patient)-[:EXHIBITS]->(:Symptom)                    │
│  (:Symptom)-[:INDICATES]->(:Condition)                 │
│  (:Patient)-[:ALLERGIC_TO]->(:Drug)                    │
│  (:Condition)-[:CONTRAINDICATES]->(:Drug)              │
│  (:Hospital)-[:EMPLOYS]->(:Doctor)                     │
│  (:Hospital)-[:HAS_BED]->(:Bed)                        │
└────────────────────────────────────────────────────────┘
          │                                  │
          │ High-Risk Event                  │ 24 Hours Later
          ▼                                  ▼
Emergency CAD Dispatcher (Twilio)     Recovery Follow-up Engine
Automated PSTN call to Hospital       Outbound Adherence Call
Graph Mutation: SET bed.is_available=false

🕸️ The Graph Data Model in FalkorDB

We structured healthcare as a connected property graph in FalkorDB:

Nodes:

• (:Patient {id, name, age, phone, blood_group})
• (:Symptom {id, name, severity, name_hi})
• (:Condition {id, name, risk_level, required_specialty})
• (:Drug {id, name})
• (:Hospital {id, name, phone, city, lat, long})
• (:Doctor {id, name, specialty, available})
• (:Bed {id, type, is_available})
• (:AgentSession {id, timestamp, status})

Relationships:

• (:Patient)-[:EXHIBITS {since_days}]->(:Symptom)
• (:Symptom)-[:INDICATES {probability}]->(:Condition)
• (:Patient)-[:ALLERGIC_TO]->(:Drug)
• (:Condition)-[:CONTRAINDICATES]->(:Drug)
• (:Hospital)-[:EMPLOYS]->(:Doctor)
• (:Hospital)-[:HAS_BED]->(:Bed)
• (:Patient)-[:HAD_SESSION]->(:AgentSession)-[:DETECTED]->(:Symptom)

⚡ The Core Decision Engine: 5-Hop Cypher Traversal

Instead of asking an LLM to guess which hospital has a bed, CareGraph AI executes this exact 5-hop Cypher traversal in FalkorDB:

MATCH (p:Patient {id: $patient_id})-[e:EXHIBITS]->(s:Symptom)-[i:INDICATES]->(c:Condition)
WHERE c.risk_level IN ['High', 'Critical']
OPTIONAL MATCH (p)-[:ALLERGIC_TO]->(d:Drug)<-[:CONTRAINDICATES]-(c)
MATCH (h:Hospital)-[:EMPLOYS]->(doc:Doctor {specialty: c.required_specialty, available: true}),
      (h)-[:HAS_BED]->(b:Bed {type: 'ICU_Oxygen', is_available: true})
RETURN p.name AS PatientName, 
       c.name AS SuspectedCondition, 
       c.risk_level AS RiskLevel,
       collect(DISTINCT d.name) AS KnownAllergiesToAvoid,
       h.name AS TargetHospital, 
       h.phone AS HospitalContact,
       doc.name AS AssignedDoctor, 
       count(b) AS AvailableBeds
ORDER BY AvailableBeds DESC
LIMIT 1;

Why This Is Revolutionary:

• Zero Hallucination: The diagnosis and hospital recommendation are backed by verified graph edges, not probabilistic next-token predictions.
• Sub-Millisecond Execution: On FalkorDB, this 5-hop multi-hospital traversal benchmarked at 0.31 ms!
• Patient Safety Check: OPTIONAL MATCH (p)-[:ALLERGIC_TO]->(d)<-[:CONTRAINDICATES]-(c) automatically checks if the patient has known drug allergies (e.g., Penicillin) before emergency drugs are administered.

🚑 Automated Hospital CAD Dispatch & Real-Time Bed Locking

When a critical condition (like STEMI heart attack or stroke) is verified, the system triggers the Emergency Dispatch CAD:

1. Auto-dials the hospital emergency desk via Twilio PSTN: > "Emergency Alert from CareGraph AI: Patient Rajesh Kumar (52, Acute Coronary Syndrome) is en route. Reserve ICU_Oxygen bed for Dr. Ananya Sharma."
2. Mutates the FalkorDB state live:

   MATCH (b:Bed {id: $bed_id})
   SET b.is_available = false;
   CREATE (b)-[:RESERVED_FOR {timestamp: timestamp()}]->(p);

1. The right-hand visualizer reflects the reserved bed with a red lock badge in real time.

⏱️ 24-Hour Autonomous Recovery Follow-Up

Patient care does not end at hospital admission. CareGraph AI runs a scheduled Cypher query:

MATCH (p:Patient)-[:HAD_SESSION]->(s:AgentSession)
WHERE s.timestamp < timestamp() - 86400 AND s.followup_status IS NULL
RETURN p.name, p.phone, s.id, s.timestamp;

It automatically dials the patient for a post-discharge adherence check-in, asking in Hindi/English about symptom recurrence, and stores the recovery status (RECOVERING / STABLE) back into FalkorDB.

📊 Performance Benchmarks

🔗 Try It Live

• 🌐 Live Website: https://caregraph-ai.vercel.app
• 💻 GitHub Repository: https://github.com/roshni09mishra-0/CareGraph-AI

💡 What We Learned & Why FalkorDB Won

Building CareGraph AI proved that Graph Databases are the missing link in Healthcare AI. While LLMs are great for conversational interfaces, clinical decisions require the mathematical certainty of graph traversals. FalkorDB’s raw speed and intuitive Cypher syntax made sub-second healthcare triage a reality.

Built for the FalkorDB Hackathon on WeMakeDevs.