Cyrex — AI-Powered Disaster Response Coordination System

IBM SkillsBuild AICTE Internship 2026 — Team Cyrex (Rechana R S — Lead, Sajeed Ahsan, Reva R Thaara Mitra)

Cyrex automates emergency request intake during disasters (floods, cyclones, landslides, fires) by classifying the disaster type, scoring urgency, and recommending the right rescue team — through a multi-agent workflow.

Architecture

Citizen submits request (Streamlit form)
        │
        ▼
   ┌─────────────┐
   │   INTAKE    │  validates/normalizes the request
   └──────┬──────┘
          ▼
   ┌─────────────┐
   │ CLASSIFY    │  LLM (Groq) or rule-based fallback → disaster type
   └──────┬──────┘
          ▼
   ┌─────────────┐
   │  URGENCY    │  applies scoring rules (e.g. group size) → urgency level
   └──────┬──────┘
          ▼
   ┌─────────────┐
   │  ALLOCATE   │  matches disaster type + urgency → best available team
   └──────┬──────┘
          ▼
     SQLite (cyrex.db) → Authority Dashboard (prioritized queue, status tracking)

The agent graph is built with LangGraph (workflow.py), where each stage is an independent node operating on a shared state object — making it easy to add new agents (e.g. a dedicated notification agent, a geolocation-based routing agent) later without restructuring the pipeline.

Tech Stack

• Python — core logic
• LangGraph — multi-agent orchestration
• Groq LLM (via langchain-groq/groq SDK) — disaster classification & urgency reasoning
• Streamlit — web interface (citizen intake form + authority dashboard)
• SQLite — request persistence and status tracking

Offline-safe by design

If no GROQ_API_KEY is set (or the API call fails), Cyrex automatically falls back to a transparent rule-based classifier (llm_client.py) using keyword and severity-signal matching. This means:

• The prototype is fully demoable without any API key or internet access.
• A real deployment never "goes dark" during an actual disaster if the LLM provider is unreachable.

Setup

cd cyrex
pip install -r requirements.txt

# Optional — enables live LLM classification instead of the rule-based fallback
cp .env.example .env
# edit .env and add your Groq API key, then:
export $(cat .env | xargs)

streamlit run app.py

The app opens at http://localhost:8501.

Using the app

1. Submit Emergency Request — citizens describe their situation; Cyrex classifies it and assigns a team automatically.
2. Authority Dashboard — view all requests sorted by urgency, filter by status, update status as teams are dispatched/resolve cases, view rescue team availability, and export the request log as CSV.

Project structure

cyrex/
├── app.py           # Streamlit UI (citizen form + dashboard)
├── workflow.py       # LangGraph multi-agent pipeline
├── llm_client.py      # Groq LLM wrapper + rule-based fallback classifier
├── resources.py        # Rescue team reference data & allocation logic
├── database.py           # SQLite persistence layer
├── requirements.txt
├── .env.example
└── cyrex.db          # created automatically on first run

Notes for extending this prototype

• Resource data (resources.py) is currently static/mock — in a real deployment this would sync with live rescue-team GPS/availability data.
• Urgency rules in workflow.py's urgency_agent can be extended with more business logic (e.g. proximity to known flood zones, time-of-day).
• Swap SQLite for PostgreSQL by replacing database.py's connection logic if moving beyond a single-instance prototype.

SDG Alignment

Primary: SDG 11 — Sustainable Cities and Communities Secondary: SDG 13 — Climate Action