ModelForge AI is an end-to-end, full-stack Machine Learning platform that simplifies the complete ML workflow—from dataset upload and preprocessing to model training, evaluation, explainability, reporting, and deployment.
It is designed to provide a structured, user-friendly environment where users can perform Machine Learning operations without having to build every workflow manually.
Machine Learning projects often require developers and data scientists to work with multiple tools for:
- Dataset management
- Data validation and cleaning
- Exploratory Data Analysis (EDA)
- Feature engineering
- Model training
- Model comparison
- Model evaluation
- Explainable AI
- Report generation
- Model deployment
- Prediction APIs
- Monitoring
ModelForge AI brings these capabilities together into a single platform.
Register / Login
↓
Create Workspace
↓
Create Project
↓
Upload Dataset
↓
Dataset Validation
↓
Data Cleaning
↓
Exploratory Data Analysis
↓
Feature Engineering
↓
Model Training
↓
Model Comparison
↓
Model Explainability
↓
Experiment & Report
↓
Model Deployment
↓
Prediction API
↓
Monitoring
- User registration and login
- Password hashing
- JWT-based authentication
- Protected API routes
- Email-based functionality
- Create workspaces
- Create and manage ML projects
- Organize datasets and experiments by project
- Project-level ML workflow
Supported dataset formats:
.csv
.xlsx
.xls
.json
Features include:
- Dataset upload
- Dataset validation
- Dataset profiling
- Dataset versioning
- Dataset metadata
- Original, cleaned, and feature-engineered datasets
- Soft deletion
- Duplicate dataset-name validation
ModelForge AI provides preprocessing capabilities for:
- Missing-value handling
- Duplicate detection
- Data validation
- Data-type analysis
- Cleaning previews
- Cleaned dataset generation
The EDA module provides:
- Dataset statistics
- Column information
- Missing-value analysis
- Correlation analysis
- Distribution analysis
- Categorical analysis
- Visualization-ready results
- Automated dataset insights
Feature engineering capabilities include:
- One-Hot Encoding
- Label Encoding
- Ordinal Encoding
ModelForge AI supports multiple Machine Learning problem types:
- Classification
- Regression
- Clustering
- Time Series
- Anomaly Detection
The training pipeline includes:
Training Validation
↓
Target Leakage Detection
↓
Dataset Splitting
↓
Model Creation
↓
Model Training
↓
Cross Validation
↓
Prediction
↓
Evaluation
↓
Model Saving
Models can be evaluated using appropriate metrics based on the problem type.
The platform also supports:
- Train/test splitting
- Cross-validation
- Predictions
- Evaluation results
- Experiment tracking
The platform provides report-generation capabilities for ML workflows, including:
- Dataset information
- Trained Model information
- Evaluation metrics
- Visualizations
- Training results
Trained models can be prepared for deployment through REST APIs.
The deployment workflow is designed to provide:
Trained Model
↓
Model Saving
↓
Model Deployment
↓
Prediction API
↓
Client/Application
ModelForge AI uses a three-layer backend architecture.
┌───────────────────┐
│ React Frontend │
│ :5173 │
└─────────┬─────────┘
│
│ REST API
▼
┌───────────────────┐
│ Node.js API │
│ Express :5000 │
│ │
│ CRUD + Business │
│ Logic + Auth │
└───────┬───────────┘
│
┌──────────┴──────────┐
│ │
▼ ▼
┌──────────────────┐ ┌──────────────────┐
│ MongoDB │ │ Django ML Engine │
│ │ │ :8000 │
│ Users │ │ │
│ Projects │ │ Data Processing │
│ Datasets │ │ EDA │
│ Experiments │ │ Feature Engineer │
│ Deployments │ │ Training │
└──────────────────┘ │ Explainability │
│ Reporting │
└──────────────────┘
| Component | Responsibility |
|---|---|
| React | User interface and interaction |
| Node.js + Express | Authentication, CRUD, API orchestration |
| Django | Machine Learning and data-processing engine |
| MongoDB | Application data and metadata |
| Django Media | Dataset, model, report and temporary file storage |
The frontend communicates with the Node.js backend.
The frontend does not directly communicate with the Django ML engine for the main application workflow.
React → Node.js → Django
- React
- Vite
- JavaScript
- React Router
- Axios
- React Hook Form
- Recharts
- Framer Motion
- Lucide React
- TanStack React Table
- Node.js
- Express.js
- MongoDB
- Mongoose
- JWT
- bcrypt
- Nodemailer
- Multer
- Express Validator
- Axios
- Python
- Django
- Django REST Framework
- NumPy
- Pandas
- SciPy
- Scikit-learn
- XGBoost
- LightGBM
- CatBoost
- Joblib
- Cloudpickle
- Matplotlib
- Seaborn
- Plotly
- ReportLab
- Docker
- Docker Compose
- MongoDB
- Git
- GitHub
ModelForge-AI/
│
├── frontend/
│ ├── src/
│ ├── public/
│ ├── package.json
│ ├── Dockerfile
│ └── .env.example
│
├── node_backend/
│ ├── src/
│ │ ├── config/
│ │ ├── controllers/
│ │ ├── services/
│ │ ├── repositories/
│ │ ├── routes/
│ │ ├── middleware/
│ │ ├── validators/
│ │ └── models/
│ │
│ ├── package.json
│ ├── Dockerfile
│ └── .env.example
│
├── django_backend/
│ ├── config/
│ ├── ml_engine/
│ ├── report_engine/
│ ├── ai_chat/
│ ├── api/
│ ├── media/
│ ├── requirements.txt
│ ├── Dockerfile
│ └── .env.example
│
├── docker-compose.yml
└── README.md
ModelForge AI uses MongoDB for application data.
Major collections include:
users
auth
projects
datasets
dataset_versions
experiments
reports
deployments
notifications
comments
Dataset files and generated ML artifacts are stored separately from MongoDB.
For example:
django_backend/
└── media/
├── datasets/
│ └── <dataset_id>/
│ └── v1/
│ ├── original.csv
│ ├── cleaned.csv
│ ├── feature_engineered.csv
│ └── feature_metadata.json
│
├── models/
├── reports/
└── temp/
MongoDB stores the metadata and file paths rather than storing the complete dataset files directly.
ModelForge AI can be run using Docker Compose.
The Docker environment contains:
┌───────────────────────────────┐
│ Docker │
│ │
│ ┌───────────┐ │
│ │ Frontend │ :5173 │
│ └───────────┘ │
│ │
│ ┌───────────┐ │
│ │ Node.js │ :5000 │
│ └───────────┘ │
│ │
│ ┌───────────┐ │
│ │ Django │ :8000 │
│ └───────────┘ │
└───────────────────────────────┘
MongoDB
localhost:27017
(Host Machine)
This allows the application services to be started together instead of manually running separate terminals.
Make sure the following are installed:
- Node.js
- npm
- Python
- MongoDB
- Docker Desktop
- Git
git clone <YOUR_GITHUB_REPOSITORY_URL>
cd ModelForge-AICreate the required .env files using the provided examples:
node_backend/.env.example
frontend/.env.example
django_backend/.env.example
Rename/copy them to:
node_backend/.env
frontend/.env
django_backend/.env
Update the values according to your local environment.
Never commit
.envfiles containing passwords, API keys, JWT secrets, SMTP credentials, or other sensitive information.
Make sure Docker Desktop is running.
From the project root:
docker compose up --buildAfter the containers start:
http://localhost:5173
http://localhost:5000
http://localhost:8000
To run the containers in the background:
docker compose up -d --buildTo stop them:
docker compose downTo check running services:
docker compose psTo view logs:
docker compose logs -fFor a specific service:
docker compose logs -f node
docker compose logs -f django
docker compose logs -f frontendModelForge AI includes several security-oriented practices:
- Password hashing with bcrypt
- JWT authentication
- Protected API routes
- Request validation
- File-type validation
- File-size validation
- Environment-based secrets
- CORS configuration
- Soft deletion for application records
For production deployment, additional infrastructure and security hardening should be configured before exposing the application publicly.
| Stage | Purpose |
|---|---|
| Validation | Check dataset quality and training requirements |
| Cleaning | Handle data-quality problems |
| EDA | Understand dataset patterns |
| Feature Engineering | Transform and generate useful features |
| Training | Train Machine Learning algorithms |
| Cross Validation | Estimate model generalization |
| Evaluation | Measure model performance |
| Comparison | Compare different experiments/models |
| Reporting | Generate ML reports |
| Deployment | Expose trained models |
| Monitoring | Track deployed model performance |
ModelForge AI is being developed as a modular end-to-end Machine Learning platform.
- Authentication
- Project management
- Dataset management
- Dataset validation
- Data cleaning
- EDA
- Feature engineering
- Model training
- Model evaluation
- Experiment management
- Model comparison
- Report generation
- Model deployment
- Dataset AI assistant
If you find ModelForge AI useful, consider giving the repository a ⭐ on GitHub.
For bugs, feature requests, or improvements, open an issue or submit a pull request.
Build. Train. Explain. Deploy.
A unified platform for turning datasets into deployable Machine Learning models.