CuraMind is an AI-assisted preventive healthcare platform designed to simplify the early cancer screening journey.
It collects relevant patient information—including demographics, lifestyle factors, family history, medical information, environmental factors, and symptoms—and processes the assessment through CuraCore™, our rule-based risk screening engine.
The system generates cancer-wise risk scores, explains contributing factors, and provides personalized screening-oriented recommendations.
⚕️ Important: CuraMind is a screening and clinical decision-support prototype. It does not diagnose or predict cancer and does not replace qualified medical professionals or clinical evaluation.
https://curamind-ai.netlify.app/
https://curamind-ai-mx76.onrender.com/
https://curamind-ai-mx76.onrender.com/health
The deployed prototype connects the React frontend to the FastAPI backend and runs the CuraCore risk-screening workflow end-to-end.
Cancer screening can be confusing and delayed because people may:
- Ignore early symptoms
- Be unaware of important risk factors
- Not know which screening pathway is appropriate
- Search for information across disconnected sources
- Reach healthcare providers later than ideal
Healthcare providers can also benefit from better-organized patient information and risk-screening support.
CuraMind aims to simplify this journey by bringing patient assessment, risk screening, explanations, and recommendations into one workflow.
CuraMind follows a patient-to-screening workflow:
👤 Patient
↓
📋 Health Assessment
↓
🧠 CuraCore™ Risk Engine
↓
🎯 Cancer-Wise Risk Results
↓
💡 Personalized Recommendations
↓
👨⚕️ Clinical Review
The current prototype focuses on the first five stages and provides a working end-to-end screening workflow.
CuraCore™ is the current intelligence layer of CuraMind.
The present prototype uses a transparent rule-based risk engine rather than a trained machine-learning model.
Patient Data
↓
Configured Risk Rules & Weights
↓
Cancer-Wise Risk Scores
↓
Risk Classification
↓
Explanation Engine
↓
Recommendation Engine
↓
Final Screening Report
The risk engine evaluates configured rules against patient information and symptom data to calculate cancer-wise scores.
The explanation engine identifies the matched risk factors and generates understandable reasons associated with the calculated scores.
The recommendation engine uses the resulting risk level and configured cancer-specific information to generate:
- Recommended actions
- Next steps
- Relevant specialists
- Lifestyle guidance
- Tests to discuss where applicable
The assessment workflow collects structured information across multiple areas:
- Personal information
- Medical information
- Lifestyle
- Family history
- Environmental factors
- Symptoms
- Relevant reports/information
CuraCore™ evaluates the submitted information using configured rules and risk weights.
The backend calculates scores for the supported cancer categories and classifies applicable results into risk levels.
The system provides the factors/rules that contributed to the calculated risk score.
Recommendations are generated according to the resulting risk level and cancer-specific configuration.
The frontend presents:
- Overall risk
- Cancer-wise scores
- Risk levels
- Contributing factors
- Recommended actions
- Suggested tests
- Lifestyle guidance
The frontend communicates with the FastAPI backend through REST API endpoints.
Begin the CuraMind cancer-risk screening journey by clicking "Start Screening" on the landing page.
Complete a guided 7-step assessment covering personal, lifestyle, family, medical, symptom, and environmental factors.
Optionally upload supporting medical reports before clicking "Run CuraCore™ Analysis" to begin the screening process.
The rule-based CuraCore™ engine evaluates submitted risk factors and generates screening results.
View overall risk, cancer-wise scores, priority areas, recommended specialists, and contributing risk factors.
Review, share, print, or download the generated CuraCore™ screening report.
Final CuraMind prediction flow
User completes CuraMind assessment
↓
Frontend sends all assessment data to backend
↓
Shared preprocessing layer
• age
• sex
• BMI
• smoking
• lifestyle
• medical history
↓
CuraMind model router
↓
┌──────────────────────────────┐
│ Lung Cancer Model → Risk score │
│ Breast Cancer Model → Risk score │
│ Oral Cancer Model → Risk score │
│ Colorectal Cancer Model → Risk score │
│ Cervical Cancer Model → Risk score │
│ Prostate Cancer Model → Risk score │
└──────────────────────────────┘
↓
Risk validation + normalization
↓
Risk factor breakdown dashboard
If a user submits their assessment, the frontend can display the model results as a cancer-wise breakdown:
Lung Cancer → 72
Breast Cancer → 14
Oral Cancer → 8
Colorectal Cancer → 31
Cervical Cancer → N/A
Prostate Cancer → N/A
The dashboard presents these scores visually alongside the contributing risk factors, explanations, and recommendations.
- React
- TypeScript
- Vite
- Tailwind CSS
- React Router
- Framer Motion
- Lucide React
- Three.js / Spline tooling
- Python
- FastAPI
- Uvicorn
- Pydantic
- CuraCore™ Rule-Based Risk Engine
- Risk Weight Configuration
- Explanation Engine
- Recommendation Engine
- JSON-based configuration
- Netlify — Frontend
- Render — Backend
CuraMind/
│
├── backend/
│ ├── api/
│ │ └── routes.py
│ │
│ ├── config/
│ │ ├── patient_schema.json
│ │ ├── recommendations.json
│ │ └── risk_weights.json
│ │
│ ├── exceptions/
│ │ └── handlers.py
│ │
│ ├── models/
│ │ ├── request_models.py
│ │ └── response_models.py
│ │
│ ├── services/
│ │ ├── risk_engine.py
│ │ ├── explanation_engine.py
│ │ └── recommendation_engine.py
│ │
│ ├── utils/
│ │ └── responses.py
│ │
│ ├── main.py
│ ├── requirements.txt
│ └── test_engine.py
│
├── frontend/
│ ├── public/
│ ├── src/
│ │ ├── api/
│ │ ├── assets/
│ │ ├── components/
│ │ ├── context/
│ │ ├── hooks/
│ │ ├── lib/
│ │ ├── pages/
│ │ ├── types/
│ │ ├── App.tsx
│ │ └── main.tsx
│ │
│ ├── package.json
│ ├── package-lock.json
│ ├── vite.config.ts
│ └── tsconfig.json
│
├── patient_schema.md
└── README.md
The backend currently exposes the following primary endpoints:
| Method | Endpoint | Purpose |
|---|---|---|
GET |
/ |
API information |
GET |
/health |
Health check |
POST |
/predict |
Process patient assessment and generate screening results |
{
"success": true,
"message": "API is healthy.",
"data": {
"status": "healthy"
}
}Follow the steps below in order to run CuraMind locally.
Before starting, make sure your computer has the following installed:
- Python 3.10 or newer
- Node.js 18 or newer
- Git
- VS Code (recommended)
Open a terminal in VS Code and run:
python --version
node --version
npm --version
git --versionIf any command says that it is not recognized, install the missing software first.
If winget is available, you can install the required tools with:
winget install Python.Python.3.10
winget install OpenJS.NodeJS.LTS
winget install Git.GitAfter installation, restart VS Code and check the versions again.
If you use Homebrew:
brew install python
brew install node
brew install gitThen verify:
python3 --version
node --version
npm --version
git --versionClone the CuraMind repository and open the project folder:
git clone https://github.com/javedarham2-coder/CuraMind-AI.git
cd CuraMind-AIMake sure you are now inside the main CuraMind-AI folder.
CuraMind-AI folder, NOT inside backend.
Run this while you are in the project root:
python -m venv .venvAfter this, your project should look like:
CuraMind-AI/
├── .venv/
├── backend/
├── frontend/
└── README.md
Run:
.\.venv\Scripts\Activate.ps1If PowerShell blocks the activation script, run:
Set-ExecutionPolicy -Scope Process -ExecutionPolicy BypassThen activate again:
.\.venv\Scripts\Activate.ps1You should see (.venv) at the beginning of your terminal.
Run:
source .venv/bin/activateNow enter the backend folder:
cd backendInstall the backend dependencies:
pip install -r requirements.txtStart the FastAPI backend:
uvicorn main:app --reloadThe backend will normally run at:
http://127.0.0.1:8000
Keep this terminal running.
Open a new terminal in VS Code.
Go back to the project root:
cd CuraMind-AIThen enter the frontend folder:
cd frontendInstall the frontend dependencies:
npm installBefore starting the frontend, you must create a .env file inside the frontend folder. This tells CuraMind where the local backend is running.
First, make sure you are inside the frontend folder:
cd frontendCreate a new file named exactly:
.env
Your folder should look like this:
CuraMind-AI/
├── backend/
└── frontend/
├── .env
├── package.json
└── ...
Open the .env file and paste exactly this line:
VITE_API_URL=http://127.0.0.1:8000Save the file.
⚠️ Important: The file must be named.env— not.env.txt, and it must be inside thefrontendfolder.
This connects the frontend to the local FastAPI backend.
Run:
npm run devVite will show a local URL in the terminal, usually:
http://localhost:5173
Open that URL in your browser.
You should now have:
Frontend → http://localhost:5173
↓
Backend → http://127.0.0.1:8000
Keep both terminals running while using CuraMind locally.
- Frontend changes are automatically refreshed by Vite.
- Backend changes are automatically reloaded by Uvicorn.
- If you pull new changes from GitHub, run:
git pullThen install any new dependencies if requirements.txt or package.json has changed:
pip install -r backend/requirements.txtand/or:
cd frontend
npm installThe current prototype uses:
GitHub
│
├── Frontend → Netlify
│
└── Backend → Render
The frontend communicates with the deployed backend through:
VITE_API_URL=https://curamind-ai-mx76.onrender.comEdit Code
↓
Test Locally
↓
Git Commit
↓
Git Push
↓
GitHub
├──────────────→ Netlify
│ Frontend Deployment
│
└──────────────→ Render
Backend Deployment
- Patient assessment
- Frontend/backend integration
- FastAPI API
- CuraCore rule-based risk engine
- Cancer-wise risk scoring
- Risk classification
- Explanation generation
- Personalized recommendations
- Results/report interface
- End-to-end deployed workflow
- Doctor/clinical dashboard
- Persistent patient database
- Production authentication
- Advanced hospital/doctor locator functionality
- Full production-grade healthcare infrastructure
- Curated cancer-risk datasets
- Unified machine-learning training dataset
- Machine-learning-based risk estimation
- Random Forest / Gradient Boosting model comparison
- SHAP-based explainability
- Medical report analysis
- Expanded clinical workflows
- Production-grade security and deployment
The current hackathon prototype intentionally uses a rule-based engine so that the screening logic remains transparent and explainable.
Patient registration and structured health assessment.
Rule-based cancer risk screening and risk stratification.
Screening-oriented recommendations and explainable results.
Doctor dashboard, patient prioritization, clinical validation, and follow-up planning.
Machine-learning models, SHAP explainability, medical report analysis, and broader deployment.
CuraMind is an AI-assisted screening and clinical decision-support prototype.
It does not diagnose cancer, confirm the presence of cancer, or replace professional medical evaluation.
The risk scores and recommendations generated by CuraCore™ are intended to support screening awareness and decision-making. Users should consult qualified healthcare professionals for appropriate medical assessment, testing, diagnosis, and treatment.
CuraMind — Earlier Screening. Better Decisions. Better Outcomes.
© 2026 CuraMind Team. All Rights Reserved.
CuraMind and CuraCore™ are proprietary project names and materials developed by the CuraMind Team.
This repository is publicly available for hackathon evaluation and demonstration. No license is granted for reuse, redistribution, commercialization, or derivative works except where explicitly stated in the repository.
The 3 Bytes
CuraMind — AI-Assisted Early Cancer Risk Screening & Clinical Decision Support
HealthTech & Social Impact
Mohammad Arham Javed
Role: Team Lead & Full-Stack Developer
Contact: +91 7905833216
| Name | Role | Contact |
|---|---|---|
| Mohammad Raiyan | Frontend Developer | +91 9336078040 |
| Avnee Shukla | Presentation & UI/UX Designer | +91 9651440786 |