RAKSHA AI

Smarter Disaster Response. Safer Communities.

Comment

Inspiration Disasters can change a situation within minutes, but emergency response often depends on fragmented information, delayed updates, and manual coordination. We wanted to build a system that could bring risk intelligence, environmental information, incident management, resource coordination, and emergency response into one place. That idea became RAKSHA AI — a disaster intelligence and response platform designed to help teams understand what is happening, identify risk, and coordinate action faster. What it does RAKSHA AI provides a unified command center for disaster response. It combines:

  • AI-powered risk intelligence for disaster impact screening and decision support
  • Real-time incident management for creating, tracking, and updating incidents
  • Environmental intelligence using weather and earthquake context
  • Risk maps and geospatial visualization
  • Resource management and deployment tracking
  • Real-time alerts and notifications
  • Emergency SOS workflows
  • Live responder/location tracking
  • Reports and audit logs
  • Role-based access for Admin, Dispatcher, and Responder users
  • Real-time communication through WebSockets The goal is simple: turn scattered disaster information into actionable intelligence. How we built it We built RAKSHA AI as a full-stack application with a separate frontend, backend, and machine-learning layer. Technology Stack
  • Frontend: React + Vite
  • Backend: Python + FastAPI
  • Database: PostgreSQL
  • AI/ML: Python, Pandas, NumPy, Scikit-learn, Joblib
  • Maps: React Leaflet
  • Real-time: WebSockets
  • Authentication: Token-based authentication with role-based access control
  • Deployment: Vercel for the frontend and Render for the backend/database The backend exposes REST APIs for authentication, incidents, resources, alerts, environmental intelligence, risk analysis, reports, and emergency workflows. For AI/ML, we developed a risk-impact prediction pipeline and integrated the production model into the FastAPI backend. The model is used as decision-support intelligence rather than a calibrated probability, with validation metrics and model-status information exposed to the application. We also implemented secure password hashing, session invalidation, protected APIs, CORS configuration, security headers, and audit logging. Challenges we ran into One of the biggest challenges was bringing many different components together without making the system fragile. The application needed to handle authentication, real-time updates, geospatial data, environmental feeds, ML inference, and emergency workflows while keeping a consistent user experience. We also faced practical deployment challenges. Our machine-learning workspace contained very large raw and processed datasets that exceeded GitHub's file-size limits. We solved this by separating source/deployment artifacts from large training datasets using .gitignore. Another challenge was connecting the deployed React frontend with the FastAPI backend. The first live login attempt produced a CORS preflight error. We traced the request using browser developer tools, identified the exact Vercel origin, and configured the backend to allow that production origin. Finally, we had to make sure the ML component was not presented as more certain than it actually is. We treated the model as a screening and decision-support component and documented its validation limitations. Accomplishments that we're proud of We are proud to have built a complete working disaster-response platform rather than only a prototype screen. The system now has:
  • A complete Admin / Dispatcher / Responder authentication flow
  • Admin-controlled user management
  • Integrated AI/ML risk intelligence
  • Real-time incident and resource management
  • Environmental and hazard intelligence
  • Interactive risk visualization
  • Emergency SOS capabilities
  • Live tracking and WebSocket communication
  • Reports, audit logs, and security controls
  • A production-style deployment pipeline with GitHub → Render → Vercel
  • A persistent PostgreSQL-backed deployment Most importantly, the project evolved from individual features into a single operational workflow designed around the needs of emergency response teams. What we learned Building RAKSHA AI taught us that developing a real-world system is much more than writing frontend and backend code. We learned how important it is to: design the architecture before scaling features, validate machine-learning systems carefully, secure authentication and APIs, handle real-time data, debug browser/network issues, manage deployment environments, and separate development data from production artifacts. We also learned that a good AI system should support human decision-makers rather than pretend to replace them. Reliable disaster response requires combining machine intelligence with real operational context. What's next for RAKSHA AI RAKSHA AI is designed to keep growing. Our next priorities are:
  • Stronger and more geographically representative ML training data
  • Better validation of high-risk events
  • More reliable real-time disaster-data ingestion
  • Advanced forecasting and anomaly detection
  • Improved responder route and resource optimization
  • More robust notification and communication workflows
  • Production monitoring, backups, and observability
  • Further scaling of the backend and database infrastructure Our long-term vision is to make RAKSHA AI a scalable disaster intelligence and emergency coordination platform that helps response teams act earlier, coordinate better, and protect more people.

Built With

Share this project:

Updates

Submission history