Project Info

Winner

Fetch AI: Best Use of Fetch AI

AlphaRescue

This project did not submit a demo video on Devpost.

Inspiration

In moments of emergency, every second counts. We were inspired by the idea that AI should be the first to know and the fastest to act. From natural disasters to critical medical needs, we envisioned a system that could assist first responders with intelligent decision-making. Thus, AlphaRescue was born — a smart, responsive, and location-aware emergency dispatch assistant.

What it does

AlphaRescue is a fully autonomous, AI-powered first responder system that listens to live distress calls, understands the situation, and intelligently coordinates with emergency authorities to dispatch help. A distressed user initiates a call through VAPI, our voice-based AI assistant trained specifically to handle emergency situations and provide immediate, scenario-based guidance. The voice transcripts from VAPI are summarized in real time using Gemini, converting lengthy, unstructured conversations into concise, actionable incident briefs while also detecting potential false alarms. A network of specialized Fetch.ai uAgents then takes over, interacting with each other to evaluate the situation, assess real-time authority availability, and formulate a coordinated plan of action. Each agent is designed to reason, communicate, and make independent decisions — working together to ensure the most effective response is triggered. The agents use a Retrieval-Augmented Generation (RAG) pipeline with Gemini to identify and rank the nearest, most appropriate hospital based on the emergency type and geographic location. Supabase serves as our real-time backend, storing both vector embeddings and structured facility data to support fast, intelligent retrieval. Our specialized agents also use Groq’s ultra-fast LLM to classify the ambulance type required — BLS, ALS, or CCT — ensuring the right unit is dispatched to the scene. These fully autonomous AI agents, built using uAgents, manage the entire downstream flow: summarizing transcripts, selecting facilities, and using VAPI to notify the appropriate authorities — all in a seamless, hands-free manner. A live dashboard, built using Vercel's v0.dev and Mapbox, provides real-time visualization of incidents, responders, and dispatch outcomes. AlphaRescue transforms emergency calls into immediate, intelligent action — combining voice, geospatial reasoning, and autonomous agents to reduce response time and save lives faster.

How we built it

Agent-based architecture built with Fetch.ai uAgents leveraging AgentVerse platform to simulate communication between emergency dispatch agents. AI-powered classification using Groq's LLM to determine the type of ambulance needed (BLS, ALS, or CCT). AI based summaryLeveraged Gemini to summarize verbose VAPI voice call transcripts in real-time. These concise summaries were then fed directly to the uAgents to enhance decision making and reduce cognitive load on the system. Geolocation-based facility selection using geopy and Supabase, built a RAG to find the closest, most suitable facility. Supabase as a real-time backend for storing facility data. Asynchronous system using Python, pydantic, and modern microservice principles.

Challenges we ran into

Syncing communication between multiple agents in a multi-process async environment. Managing agent registration and compatibility with the Almanac contract. Identifying false spam calls with the help of Gemini and reacting based on it, ensuring genuine calls does not go unattended. Handling LLM classification edge cases and ensuring consistent ambulance type decisions. Real-time Supabase query performance and ENUM filtering.

Accomplishments we're proud of

Designed a seamless end-to-end emergency dispatch pipeline powered by AI agents and real-time data. Enabled real-time summarization of live voice calls using Gemini, dramatically reducing LLM input size and improving response latency. Successfully integrated Groq’s blazing-fast LLM to classify medical emergencies with high accuracy. Achieved fast and accurate ambulance dispatch using geospatial filtering and facility prioritization logic. Built a plug-and-play agent ecosystem that can be extended to police, fire, or disaster response domains. ##

What we learned

How to orchestrate autonomous agents in a distributed, real-time environment using uAgents. Real-world challenges in LLM usage like hallucination, consistency, and prompt design. Importance of summarization pipelines when dealing with long-form audio transcripts in high-pressure scenarios. How to build scalable geolocation-aware search using PostgREST and Supabase. The power of combining structured backend logic with reasoning-driven LLM decision-making.

What's next

Integrate a trust and reputation layer to evaluate and ignore prank/spam calls automatically. Add support for multi-modal inputs like images/videos from users to enhance context and classification accuracy. Extend to support fire and police emergencies with role-specific uAgents and classifiers. Deploy a mobile-first frontend for citizens and responders with real-time tracking and notifications. Train an internal model using fine-tuned incident data for higher accuracy and offline deployments.

AlphaRescue 🚨

"First to know, First to act!"

An AI-powered emergency dispatch system designed to rapidly respond to distress calls by intelligently coordinating with emergency authorities.

🏆 Winner: Fetch AI Best Use of Fetch AI - UC Berkeley AI Hackathon 2025

🌟 Overview

AlphaRescue revolutionizes emergency response by combining cutting-edge AI technologies with autonomous agent networks to create a faster, more intelligent dispatch system. Our platform processes emergency calls in real-time, automatically assesses situations, and coordinates with the appropriate emergency services.

✨ Key Features

🎙️ Voice-based AI Assistant: Powered by VAPI for natural emergency call handling
📝 Real-time Call Transcription: Automatic summarization using Gemini AI
🤖 Autonomous Agent Network: Intelligent situation assessment and resource allocation
🏥 Smart Facility Selection: Geolocation-based hospital and emergency service matching
📊 Real-time Dashboard: Live incident monitoring and tracking
🚑 Intelligent Ambulance Dispatch: Automated selection of appropriate ambulance types

🛠️ Technologies Used

Frontend

React.js with TypeScript
Tailwind CSS for styling
Mapbox GL for mapping
Lucide React for icons

Backend

Node.js with Express
Python for AI agents
Fetch.ai uAgents for autonomous agents
Supabase for database and real-time features

AI & ML

Gemini AI for transcription and summarization
Groq LLM for fast inference
OpenAI for additional AI capabilities

Infrastructure

Vercel for deployment
VAPI for voice integration

🚀 Getting Started

Prerequisites

Node.js (v16 or higher)
Python 3.8+
Supabase account
API keys for Gemini, Groq, and VAPI

Installation

Clone the repository

git clone https://github.com/yourusername/Alpha-Rescue.git
cd Alpha-Rescue

Setup Frontend Dashboard

cd Dashboard/dashboard-frontend
npm install
npm start

Setup Backend Dashboard

cd Dashboard/dashboard-backend
npm install
npm start

Setup Python Agents

cd fetch-agent-fire-responder
pip install -r requirements.txt
python Orchestrator.py

Environment Variables

Create .env files in the respective directories with:

# Supabase
SUPABASE_URL=your_supabase_url
SUPABASE_KEY=your_supabase_key

# AI Services
GEMINI_API_KEY=your_gemini_key
GROQ_API_KEY=your_groq_key
OPENAI_API_KEY=your_openai_key

# VAPI
VAPI_API_KEY=your_vapi_key

# Mapbox
MAPBOX_ACCESS_TOKEN=your_mapbox_token

📁 Project Structure

Alpha-Rescue/
├── Dashboard/
│   ├── dashboard-frontend/     # React frontend application
│   │   ├── src/
│   │   │   ├── components/     # React components
│   │   │   └── types.ts        # TypeScript definitions
│   │   └── package.json
│   └── dashboard-backend/      # Express.js backend
│       ├── server.js           # Main server file
│       └── package.json
└── fetch-agent-fire-responder/ # Python agents
    ├── Orchestrator.py         # Main orchestrator agent
    ├── paramedic/              # Paramedic agents
    │   ├── ambulance_agent.py  # Ambulance dispatch logic
    │   └── groq_classifier.py  # AI classification
    ├── hospital_agent.py       # Hospital matching agent
    ├── firestation_lookup_agent.py # Fire station agent
    ├── police_integration.py   # Police coordination
    └── requirements.txt        # Python dependencies

🎯 How It Works

Emergency Call Received: VAPI processes incoming voice calls
Real-time Transcription: Gemini AI transcribes and summarizes the call
Agent Network Activation: Fetch.ai agents assess the situation
Resource Allocation: System identifies optimal emergency services
Dispatch Coordination: Automated coordination with hospitals, fire stations, or police
Real-time Monitoring: Dashboard provides live updates on incident status

🏆 Achievements

UC Berkeley AI Hackathon 2025 Winner: Fetch AI Best Use of Fetch AI
Successfully demonstrated end-to-end emergency response automation
Integrated multiple AI technologies into a cohesive system
Built scalable microservice architecture

🚧 Challenges Overcome

Multi-agent Communication: Synchronized communication between distributed agents
Agent Registration Management: Efficient handling of agent lifecycle
Spam Call Detection: AI-powered filtering of non-emergency calls
LLM Edge Cases: Robust handling of AI classification uncertainties

🔮 What's Next

Trust & Reputation Layer: Add reliability scoring for emergency services
Multi-modal Support: Voice, text, and image-based emergency reporting
Extended Coverage: Support for fire department and police emergencies
Mobile-first Frontend: Dedicated mobile application
Custom Model Training: Train internal models with incident data
Real-world Deployment: Partner with emergency services for pilot programs

📄 License

This project is licensed under the MIT License - see the LICENSE file for details.

🤝 Contributing

We welcome contributions! Please feel free to submit a Pull Request.

📞 Contact

For questions or support, please reach out to the team through our GitHub repository.

AlphaRescue - Transforming emergency response through AI innovation. 🚑✨

Analysis

Compare with all teams

View

Metric

Figures cover GitHub contributors during the hackathon window. A co-authored commit counts in full for each author, so per-member totals add up to more than the whole-team figures.

Technology

Found in codeClaimed only

CSSIn code
ExpressIn code
JavaScriptIn code
OpenAIIn code
PythonIn code
ReactIn code
SupabaseIn code
Tailwind CSSIn code
TypeScriptIn code
Google GeminiClaimed
Node.jsClaimed
VercelClaimed

9 of 12 appear in the indexed code. 3 claimed on Devpost could not be matched to code, which may simply mean the tool leaves no trace in the repository.

AI coding agents

No AI coding agent signals were found in this repository.

Detected from committed agent config files and commit authorship. Absence of a signal is not proof an agent was unused.

Codebase size

Source size

121 KB

Source files

Counts recognized source files only; vendored directories, binaries and lockfiles are excluded, so this is smaller than the repository on disk.