Forem: devin nicholson

VitalSense: Real-Time Patient Triage on Redis (Streams • Search • JSON • TimeSeries)

devin nicholson — Mon, 11 Aug 2025 05:18:30 +0000

This is a submission for the Redis AI Challenge: Beyond the Cache.

What I Built

A real-time patient triage dashboard that uses Redis 8 as the primary data platform. It ingests vitals (HR/SpO₂/BP) via Redis Streams, persists the latest state per patient in Hashes, indexes snapshots with RediSearch for instant querying, publishes alerts with Pub/Sub, stores adjustable alert thresholds in RedisJSON, and renders 24-hour trends from RedisTimeSeries. The React/Next.js UI is real-time (WebSocket), offline-first (IndexedDB hydration), supports threshold configuration (persisted in Redis), and provides a drill-down panel with a per-patient sparkline (via TS.RANGE).

Key properties:

Primary DB: No external database; Redis is the system of record for runtime state + settings.
Search & Rules: RediSearch powers numeric queries for “critical” patients (low SpO₂ / high HR), pulled by a watcher that publishes alerts.
Streams + Pub/Sub: Streams for ingestion/fan-out; Pub/Sub for real-time alert fan-out to the browser.
Time series: Per-patient SpO₂ time series with 24h retention for drill-down trends.
UX: Progressive skeletons, dark mode, drill-down, offline cache, threshold modal (live-reconfigures the watcher).

Demo

Github:

devinnicholson / vitalsense

VitalSense Hackathon Project

A real-time health data pipeline using Redis Streams, RedisJSON, RediSearch Pub/Sub, and a beautiful Tailwind/Next.js dashboard.

Prerequisites

Node.js v16+
Redis 8 instance with modules:
- RedisJSON
- Redis Streams
- RediSearch
- (Optional) RedisAI

Environment variable

export REDIS_URL="redis://default:<PASSWORD>@<HOST>:<PORT>"

1. Vitals Generator

Emits synthetic patient vitals into patients:stream.

cd vital-sense-generator
npm install
npm start

You’ll see logs like:

Emitted <streamId> { patientId: 'P01', hr: 82, spo2: 95, sys: 120, dia: 80 }

2. Stream Consumer

Reads from patients:stream, writes snapshots to patient:<ID>:snapshot, and acknowledges.

cd vital-sense-consumer
npm install
npm start

You’ll see:

✔ Consumer group "consumer-group" created on "patients:stream"
▶ Listening for new entries…
🗂 Got 1 msg(s) from stream "patients:stream"
✅ Processed <streamId> → patient:P01:snapshot { hr: '82', spo2: '95', sys: '120', dia: '80' }

3. Index Creation (RediSearch)

Drop & recreate the snapshots index to cover all patient:*:snapshot keys.

# in vital-sense-consumer/
npm run

…

View on GitHub

Demo:

vitalsense.mov - Google Drive

drive.google.com

How I Used Redis 8

Data ingestion (Streams)

XADD patients:stream * id P01 heart_rate 82 spo2 95 bp_systolic 120 bp_diastolic 80
Consumer group (XGROUP CREATE / XREADGROUP) provides reliable processing and back-pressure.

Primary state (Hashes)

Latest snapshot per patient in Hash:
HSET patient:P01:snapshot hr 82 spo2 95 sys 120 dia 80 timestamp <iso>

No external DB; Redis holds the live source of truth.

Indexed queries (RediSearch)

FT.CREATE idx:snapshots ON HASH PREFIX 1 "patient:" SCHEMA hr NUMERIC SORTABLE spo2 NUMERIC SORTABLE sys NUMERIC dia NUMERIC timestamp TAG
Query examples used by the watcher/UI:
Low oxygen: @spo2:[-inf 92]
High HR: @hr:[120 +inf]
Combined: (@spo2:[-inf 92]) | (@hr:[120 +inf])
Event fan-out (Pub/Sub)
Watcher runs a periodic RediSearch query, publishes critical hits to alerts:critical.
A Node WS proxy subscribes and forwards JSON to browser WebSockets.

Time series analytics (RedisTimeSeries)

Per-patient SpO₂:

TS.CREATE ts:patient:Pxx:spo2 RETENTION 86400000 LABELS patient Pxx
TS.ADD ts:patient:Pxx:spo2 <ts> <spo2>
Drill-down: TS.RANGE ts:patient:Pxx:spo2 <now-24h> <now>
Dynamic configuration (RedisJSON)

Alert thresholds live in JSON:

JSON.SET settings:thresholds . '{"spo2":92,"hr":100}'
Next API GET/PATCH /api/settings/thresholds reads/writes this key.
Watcher reloads thresholds each loop → instant effect.

Team Submissions:
Devin Nicholson

EmberAI: Algolia MCP Server Challenge

devin nicholson — Mon, 28 Jul 2025 06:50:39 +0000

This is a submission for the Algolia MCP Server Challenge

What I Built

An open‑source, AI‑powered mapping dashboard for tracking wildfires and shelter locations in real time.

EmberAI combines lightning‑fast search with meaningful AI insights to equip communities, first responders, and volunteers with the information they need to act quickly during fire emergencies.

🚀 Key Features
Geo‑Aware Search with Algolia MCP

Unified proxy for multiple indices (fires, shelters, aqi).
Instant insideBoundingBox filtering for map viewport queries.
High‑performance faceting (e.g. severity:4+, state:CA).
AI Enrichment via n8n Workflows

Fire Severity Classification: Automated LLM calls convert raw satellite data into a 1–5 urgency score and one‑sentence summary.
Shelter Capacity Forecasting: Time‑series API + LLM or ARIMA predicts near‑future capacity risks (boolean flag).
Modular workflows in n8n, no additional server code required.
Real‑Time Data Ingestion

MODIS / VIIRS fire data from NASA FIRMS (7‑day CSV feeds).
FEMA shelter locations via open data API.
Optional Air Quality Index (AQI) from AirNow.
Secure, batch indexing into Algolia with a Python pipeline (update_indices.py).
Interactive Map UI

React + Leaflet front‑end with colored circle markers: scale up severity from green→purple.
Popups display date, confidence, AI summary, and capacity forecasts.
Search bar for date, confidence, and full‑text queries.
Responsive design for desktop and tablet use.

Demo

devinnicholson / emberAI

EmberAI

An open‑source, AI‑powered mapping dashboard for tracking wildfires and shelter locations in real time.

EmberAI combines lightning‑fast search with meaningful AI insights to equip communities, first responders, and volunteers with the information they need to act quickly during fire emergencies.

🚀 Key Features

Geo‑Aware Search with Algolia MCP
- Unified proxy for multiple indices (fires, shelters, aqi).
- Instant insideBoundingBox filtering for map viewport queries.
- High‑performance faceting (e.g. severity:4+, state:CA).
AI Enrichment via n8n Workflows
- Fire Severity Classification: Automated LLM calls convert raw satellite data into a 1–5 urgency score and one‑sentence summary.
- Shelter Capacity Forecasting: Time‑series API + LLM or ARIMA predicts near‑future capacity risks (boolean flag).
- Modular workflows in n8n, no additional server code required.
Real‑Time Data Ingestion
- MODIS / VIIRS fire data from NASA FIRMS (7‑day CSV feeds).
- FEMA shelter locations via open data API.
- Optional Air Quality Index (AQI)…

View on GitHub

https://drive.google.com/file/d/15_zrdsIvDyFeaNjLbLJrZVluVqevZm6C/view?usp=sharing

How I Utilized the Algolia MCP Server

Unified proxy for multiple indices (fires, shelters, aqi).
Instant insideBoundingBox filtering for map viewport queries.
High‑performance faceting (e.g. severity:4+, state:CA).

Key Takeaways

Over the past few weeks I built EmberAI end‑to‑end. I started with a Python pipeline to pull in 7‑day fire data from NASA FIRMS and shelter locations from FEMA, then batch‑indexing everything into Algolia through the MCP proxy. I ran into CORS and scaling issues when trying to serve search requests directly, so I introduced Algolia’s MCP Server to unify multiple indices and handle geo‑filtered queries in under 100 ms.

Including AI enrichment in n8n was both powerful and tricky. I had to batch millions of fire records into a single webhook call to avoid hours‑long loops, and design LLM prompts that reliably output a 1–5 severity score plus a concise human summary. Integrating these Webhook→HTTP Request→partialUpdateObject steps taught me how to version workflows as code and keep everything reproducible.

On the UI side, I used React and Leaflet to visualize severity colored markers alongside shelter capacity forecasts, and refined the UX. I had fun UI issues where I needed to keep moving the search bar out of the way of map controls. Also spent time ensuring every marker displays fallback values if AI enrichment isn’t yet available. Throughout the project I learned the importance of batching over per‑record requests, the flexibility of n8n for no server AI workflows, and how Algolia MCP can turn large, fast‑moving datasets into a truly interactive, life‑saving search experience.

Team Submissions: Devin Nicholson