AI-Powered Clinical Decision Support, ICU Monitoring, Clinical Copilot, and Hospital Intelligence Platform
An enterprise-grade healthcare AI platform designed to support clinicians with intelligent patient monitoring, real-time telemetry, AI-assisted clinical decision support, and hospital management capabilities.
The IntelliICU platform is deployed on Railway with separate frontend and backend services.
User / Browser
│
▼
React + Vite Frontend
Nginx • Railway
│
│ HTTPS REST API
│ Secure WebSocket
▼
FastAPI Backend
Railway
│
▼
PostgreSQL Database
IntelliICU is an Enterprise AI Clinical Decision Support System (CDSS) designed to demonstrate how Artificial Intelligence, Machine Learning, real-time patient monitoring, and modern full-stack technologies can be integrated into a unified healthcare platform.
The system provides dedicated interfaces for administrators and healthcare professionals while supporting AI-assisted clinical workflows, live ICU monitoring, telemetry visualization, clinical copilot functionality, and hospital management.
IntelliICU is designed as a portfolio-quality enterprise healthcare application with a scalable architecture, separated frontend and backend services, REST APIs, authentication, database integration, containerization, and cloud deployment capabilities.
The long-term vision of IntelliICU is to build a comprehensive AI-powered healthcare intelligence platform inspired by modern enterprise healthcare ecosystems.
Important: IntelliICU is an educational and research-oriented project. It is not intended to replace professional medical judgment or be used as a certified medical device.
- Secure user authentication
- JWT-based authentication
- Password hashing
- Role-Based Access Control (RBAC)
- Protected API endpoints
- Token validation
- Role-specific application access
A dedicated dashboard for healthcare professionals providing access to clinical information and AI-assisted workflows.
Features include:
- Clinical overview
- Patient information
- ICU monitoring
- Clinical decision support
- AI-powered clinical tools
- Hospital workflow access
- Real-time patient information
Centralized administrative dashboard for managing the IntelliICU platform.
Features include:
- Platform overview
- User management
- Hospital management
- System statistics
- Administrative controls
- Role management
- Operational monitoring
The Clinical Copilot provides an AI-assisted interface designed to support healthcare professionals during clinical workflows.
Potential capabilities include:
- Clinical information assistance
- Patient context analysis
- Decision-support insights
- Risk interpretation
- Clinical recommendations
- Medical knowledge assistance
- Context-aware AI interactions
The Clinical Copilot is designed as a decision-support tool and does not replace professional medical judgment.
AI-powered hospital assistance functionality designed to support hospital operations and healthcare workflows.
Features may include:
- Hospital information assistance
- Clinical workflow support
- Healthcare-related queries
- Operational assistance
- AI-powered interaction
- Context-aware responses
The Live Monitoring module provides real-time visualization of patient and ICU information.
Capabilities include:
- Live patient monitoring
- Vital-sign visualization
- Patient status tracking
- Clinical alerts
- Real-time dashboard updates
- ICU patient overview
The Telemetry Monitor provides continuous visualization of patient physiological data.
Designed to support monitoring of information such as:
- Heart rate
- Blood pressure
- Oxygen saturation
- Respiratory rate
- Temperature
- Other clinical telemetry signals
The telemetry interface demonstrates how real-time patient information can be integrated into an AI-powered clinical platform.
Administrative user management functionality for controlling access to the platform.
Features include:
- View users
- Manage user accounts
- Role assignment
- User status management
- Access control
- Administrative actions
The IntelliICU authentication interface provides secure access to the platform.
The Admin Dashboard provides centralized control and visibility across the IntelliICU platform.
The Doctor Dashboard provides healthcare professionals with access to clinical workflows, monitoring tools, and patient information.
The AI-powered Clinical Copilot assists healthcare professionals with clinical information and decision-support workflows.
The Hospital Assistant provides an AI-powered interface for healthcare and hospital-related assistance.
The Live Monitoring dashboard provides real-time visibility into patient and ICU information.
The Telemetry Monitor provides visualization of real-time physiological and clinical telemetry data.
The User Management interface allows administrators to manage platform users, roles, and access.
IntelliICU follows a modular full-stack architecture designed for scalability, maintainability, and future healthcare AI integrations.
┌─────────────────────┐
│ Users │
│ │
│ Admins / Doctors │
└──────────┬──────────┘
│
▼
┌─────────────────────┐
│ React Frontend │
│ │
│ Dashboards & UI │
└──────────┬──────────┘
│
REST API
│
▼
┌───────────────────────────┐
│ FastAPI Backend │
└─────────────┬─────────────┘
│
┌─────────────────────┼─────────────────────┐
│ │ │
▼ ▼ ▼
┌────────────────┐ ┌────────────────┐ ┌────────────────┐
│ Authentication │ │ Clinical / AI │ │ Hospital APIs │
│ & RBAC │ │ Services │ │ & Management │
└───────┬────────┘ └───────┬────────┘ └───────┬────────┘
│ │ │
└─────────────────────┼─────────────────────┘
│
▼
┌─────────────────────┐
│ Database Layer │
│ │
│ SQLAlchemy / │
│ PostgreSQL │
└─────────────────────┘
INTELLIICU/
│
├── .github/
│ ├── ISSUE_TEMPLATE/
│ ├── workflows/
│ └── pull_request_template.md
│
├── assets/
│ └── Project assets and static resources
│
├── backend/
│ └── FastAPI backend application
│
├── config/
│ └── Application configuration
│
├── docker/
│ └── Docker configuration files
│
├── docs/
│ └── Project documentation
│
├── frontend/
│ └── React + Vite frontend application
│
├── infra/
│ └── Infrastructure configuration
│
├── screenshots/
│ ├── admin-dashboard.png
│ ├── clinical-copilot.png
│ ├── doctor-dashboard.png
│ ├── hospital-assistant.png
│ ├── live-monitoring.png
│ ├── login.png
│ ├── telemetry-monitor.png
│ └── user-management.png
│
├── scripts/
│ └── Development and deployment scripts
│
├── src/
│ └── Supporting source code
│
├── tests/
│ └── Automated tests
│
├── .env.example
├── .gitignore
├── CONTRIBUTING.md
├── docker-compose.yml
├── LICENSE
└── README.md
Local development directories such as
.venv/,node_modules/, and generated build artifacts are excluded from version control and are not part of the repository structure.
- React
- Vite
- JavaScript
- Modern Component-Based UI
- REST API Integration
- WebSocket Integration
- Responsive Dashboard Design
- Nginx Production Server
- Python
- FastAPI
- REST API Architecture
- Pydantic
- SQLAlchemy
- Uvicorn
- PostgreSQL
- SQLAlchemy ORM
- Python
- Scikit-learn
- Pandas
- NumPy
- Machine Learning Models
- Retrieval-Augmented Generation (RAG)
- AI Clinical Decision Support
- Clinical Copilot
- LLM Provider Architecture
- JWT Authentication
- Password Hashing
- Role-Based Access Control (RBAC)
- Protected API Routes
- CORS Configuration
- Environment-Based Secrets
- WebSockets
- Live ICU Telemetry
- Real-Time Dashboard Updates
- Patient Monitoring Streams
- Docker
- Docker Compose
- GitHub
- GitHub Actions
- Railway
- Nginx
- CI/CD Pipeline
- Cloud Deployment Architecture
Before running IntelliICU locally, make sure you have installed:
- Python 3.10+
- Node.js 20+
- npm
- Git
- Docker (optional)
- PostgreSQL (if running the database locally)
git clone https://github.com/Sumeet2005/IntelliICU.git
cd IntelliICUCreate your local environment file using the provided example:
cp .env.example .envOn Windows PowerShell:
Copy-Item .env.example .envConfigure the required environment variables inside .env.
Never commit your actual
.envfile, production credentials, database passwords, JWT secrets, or API keys to GitHub.
Navigate to the backend directory:
cd backendCreate a virtual environment:
python -m venv .venvActivate the virtual environment.
.venv\Scripts\Activate.ps1source .venv/bin/activateInstall backend dependencies:
pip install -r requirements.txtStart the FastAPI development server:
uvicorn app.main:app --reloadThe backend will typically be available at:
http://localhost:8000
Interactive Swagger API documentation:
http://localhost:8000/docs
Alternative ReDoc documentation:
http://localhost:8000/redoc
Open a new terminal and navigate to the frontend directory:
cd frontendInstall dependencies:
npm installStart the development server:
npm run devThe frontend will typically be available at:
http://localhost:5173
To create a production build:
npm run buildThe application can be started using Docker Compose:
docker compose up --buildTo stop the containers:
docker compose downTo rebuild the application:
docker compose up --build --force-recreateThe project uses environment variables for application configuration, database connectivity, authentication, AI providers, and deployment settings.
Refer to:
.env.example
for the available environment configuration template.
Important configuration categories include:
- Project metadata
- PostgreSQL database configuration
- JWT authentication settings
- Clinical LLM provider configuration
- OpenAI configuration
- Google Gemini configuration
- Ollama configuration
- LM Studio configuration
- Deployment settings
Production secrets should be configured directly through the deployment platform and must never be committed to source control.
Once the backend is running, FastAPI automatically provides interactive API documentation.
http://localhost:8000/docs
http://localhost:8000/redoc
The documentation allows developers to:
- Explore available API endpoints
- View request and response schemas
- Test API requests
- Review authentication requirements
- Understand API models
For the deployed application, use the live Swagger documentation linked at the top of this README.
| Module | Description |
|---|---|
| 🔐 Authentication | Secure authentication and authorization |
| 👨⚕️ Doctor Dashboard | Clinical dashboard for healthcare professionals |
| 🛡️ Admin Dashboard | Administrative platform management |
| 🤖 Clinical Copilot | AI-assisted clinical decision support |
| 🏥 Hospital Assistant | AI-powered hospital assistance |
| 📡 Live Monitoring | Real-time patient and ICU monitoring |
| 📈 Telemetry Monitor | Patient physiological telemetry visualization |
| 👥 User Management | User and role administration |
| 🔒 RBAC | Role-Based Access Control |
| 🔌 REST API | Frontend-backend application communication |
| ⚡ WebSockets | Real-time telemetry and dashboard communication |
| 🗄️ PostgreSQL | Persistent relational data storage |
IntelliICU uses GitHub Actions for continuous integration.
The CI pipeline validates important parts of the application, including:
- Backend dependency installation
- Python application compile checks
- Frontend dependency installation
- Vite production build validation
This helps identify integration and build problems before changes are deployed.
The production architecture separates the application into independent services.
Internet
│
├──► React + Vite Frontend
│ │
│ └── Nginx
│ │
│ ▼
│ Railway
│
└──► FastAPI Backend
│
▼
Railway
│
▼
PostgreSQL
The frontend communicates with the backend through HTTPS REST APIs and secure WebSocket connections.
Production environment variables are managed through the deployment platform.
The project includes a dedicated testing directory:
tests/
Backend tests can be executed using:
pytestTesting is an important part of the IntelliICU architecture to ensure:
- API reliability
- Authentication correctness
- Data validation
- Clinical service reliability
- Regression prevention
Planned future improvements include:
- Advanced AI Clinical Decision Support
- Multi-Hospital Architecture
- Multi-Tenant Support
- Real-Time ICU Event Streaming
- Advanced Patient Telemetry
- Early Warning Systems
- Sepsis Risk Prediction
- Cardiac Risk Prediction
- Clinical Deterioration Prediction
- Explainable AI (XAI)
- AI Model Monitoring
- Model Versioning
- Clinical Audit Logging
- Notification and Alert System
- FHIR Integration
- HL7 Integration
- Electronic Health Record (EHR) Integration
- Medical Imaging Integration
- Wearable Device Integration
- Advanced Role-Based Access Control
- Kubernetes Deployment
- Advanced CI/CD
- Cloud-Native Infrastructure
- Observability and Monitoring
The primary goals of IntelliICU are to demonstrate practical experience in:
- Enterprise Software Architecture
- Healthcare Software Engineering
- Artificial Intelligence
- Machine Learning Integration
- Clinical Decision Support Systems
- Full-Stack Development
- REST API Design
- Authentication and Authorization
- Role-Based Access Control
- Real-Time Monitoring Systems
- WebSocket Communication
- Database Architecture
- Docker Containerization
- Cloud Deployment
- CI/CD
- Scalable System Design
- Production-Oriented Software Development
IntelliICU is developed for educational, research, demonstration, and portfolio purposes.
The platform:
- Is not a certified medical device.
- Is not intended for direct clinical diagnosis.
- Is not intended to replace qualified healthcare professionals.
- Should not be used as the sole basis for medical decisions.
- Does not provide professional medical advice.
Any AI-generated predictions, recommendations, alerts, or clinical information produced by the system should be treated as decision-support information only.
Clinical decisions must always be made by qualified healthcare professionals using appropriate clinical judgment.
Contributions, suggestions, and improvements are welcome.
Please refer to:
CONTRIBUTING.md
for contribution guidelines.
General contribution workflow:
git checkout -b feature/your-feature-name
git add .
git commit -m "feat: add your feature"
git push origin feature/your-feature-nameThen create a Pull Request.
Healthcare applications require strong security practices.
When contributing to or deploying IntelliICU:
- Never commit
.envfiles. - Never expose database credentials.
- Never commit API keys.
- Never store plaintext passwords.
- Use secure JWT secrets.
- Apply proper authentication and authorization.
- Validate all incoming data.
- Follow the principle of least privilege.
For production healthcare use, additional regulatory, security, privacy, compliance, validation, and clinical governance requirements would be necessary.
This project is licensed under the terms specified in the:
LICENSE
file included in this repository.
Sumeet Sonar
B.E. Information Technology — 2026
AI, Data Science & Full-Stack Development
Interested in building enterprise AI systems, healthcare technology, and intelligent software platforms.
If you find IntelliICU interesting or useful, consider giving the repository a ⭐ Star.
It helps support the project and its continued development.
IntelliICU
Building the future of AI-powered Clinical Decision Support and Intelligent Healthcare Systems.