Your form. Analyzed. Corrected. In real time.
AI-powered fitness coaching from first impression to real-time workout analysis.
NeuroKinetIQ is a real-time AI fitness coaching platform that transforms an ordinary webcam into an intelligent workout assistant. Using computer vision, pose estimation, geometric movement analysis, AI-generated feedback, and voice synthesis, NeuroKinetIQ can understand exercise movements, count repetitions, evaluate posture, provide corrective coaching, and maintain workout history.
The project combines a polished Vercel-hosted product experience with a dedicated Streamlit-based real-time AI engine, creating a complete journey from product discovery and authentication to live exercise analysis and workout analytics.
Landing experience, sign-up flow, dashboard, pose tracking, workout intelligence, and AI feedback in one unified product journey.
NeuroKinetIQ is presented through two complementary layers that work together as one product.
| Layer | Purpose | Technology | Status |
|---|---|---|---|
| 🌐 Landing & Product Dashboard | Product presentation, user journey and application showcase | HTML5, CSS3, Vercel | 🟢 Live |
| 🤖 Real-Time AI Gym Coach | Webcam-based pose analysis, exercise tracking and AI coaching | Python, Streamlit, MediaPipe, OpenCV | 🟢 Live |
NeuroKinetIQ Landing Dashboard https://neurokinetiq-landing-dashboard.vercel.app/
A polished, responsive product experience designed to introduce NeuroKinetIQ, communicate its capabilities, showcase the application workflow, and provide access to the live AI coach.
NeuroKinetIQ AI Application https://neurokinetiq-ai-realtime-gym-coach.streamlit.app/
The actual real-time computer-vision application where webcam movement is analyzed, repetitions are counted, posture metrics are calculated, corrective feedback is generated, and workout data is recorded.
The following walkthrough demonstrates the complete NeuroKinetIQ experience — from entering the product to completing an AI-assisted workout session.
Click here to play or download the full walkthrough video
Discover → Sign Up → Dashboard → Select Exercise → Configure Workout → Start Camera → Analyze Movement → Receive Feedback → Complete Workout → Review History
NeuroKinetIQ is designed around a simple principle:
The user should focus on exercising. The system should focus on understanding the movement.
The following screens represent the complete product journey and the most important user-facing states.
Secure account creation and authentication provide the entry point into the personalized workout experience. |
The central dashboard provides access to workouts, progress, exercise information and historical performance. |
Workout information is organized into measurable metrics including exercises, repetitions, sets and historical activity. |
Users configure and begin their workout before entering the real-time computer-vision experience. |
This is the core of NeuroKinetIQ: body landmarks and movement metrics are continuously analyzed while the user performs an exercise. |
Once the target is reached, the session is finalized and workout metrics become part of the user's progress history. |
Historical sessions allow users to review completed workouts and the feedback associated with their training. |
The Vercel-hosted landing experience introduces the product and communicates the complete AI fitness proposition. |
The showcase experience provides a visual overview of the application. |
The product experience also provides an interactive demonstration of the real-time coaching workflow. |
The final product section provides a direct connection point for users, collaborators and opportunities. |
|
NeuroKinetIQ uses MediaPipe Pose Landmarker together with OpenCV to process webcam frames and identify important human body landmarks.
The system tracks movement around key regions including:
- Shoulders
- Elbows
- Wrists
- Hips
- Knees
- Ankles
- Torso
These landmarks form the foundation for downstream exercise analysis.
Rather than treating the video as a simple image stream, NeuroKinetIQ converts detected body landmarks into meaningful geometric measurements.
Joint angles and positional relationships can be used to determine movement characteristics such as:
- Squat depth
- Knee positioning
- Elbow alignment
- Arm extension
- Back positioning
- Exercise phase
This converts raw visual information into measurable movement data.
Exercise repetition counting is handled through movement-based state transitions.
Instead of simply detecting whether a person is visible, the system observes changes in relevant body measurements and determines when an exercise transitions through its required movement phases.
This helps prevent every detected frame from being incorrectly interpreted as a repetition.
Different exercises require different movement rules.
NeuroKinetIQ evaluates exercise-specific posture and movement conditions rather than applying one generic rule to every exercise.
Examples include:
- Squat depth and lower-body alignment
- Push-up elbow and body positioning
- Lunge movement
- Biceps curl arm movement
- Shoulder press movement
When posture or movement deviates from defined conditions, NeuroKinetIQ can generate corrective guidance.
The feedback pipeline combines:
Movement Metrics → AI Feedback Generation → Text → Speech → User
Groq-powered LLaMA models provide fast AI-generated coaching responses, while gTTS converts generated feedback into audible instructions.
The goal is to make the feedback feel immediate enough to be useful during an active workout.
NeuroKinetIQ estimates calories using exercise-specific metabolic assumptions.
Current per-repetition estimates include:
| Exercise | Estimated kcal / rep |
|---|---|
| Squats | 0.40 |
| Push-ups | 0.35 |
| Lunges | 0.25 |
| Dumbbell Biceps Curls | 0.15 |
| Shoulder Press | 0.30 |
These values are intended as estimated workout metrics, not medical-grade energy expenditure measurements.
Completed sessions are persisted so that users can review previous workout activity.
The system records relevant workout information such as:
- Exercise
- Repetitions
- Sets
- Calories
- Session history
- Feedback
User passwords are not stored as plain text.
NeuroKinetIQ uses:
PBKDF2-HMAC-SHA256 + random salt + 100,000 iterations
This provides a substantially safer authentication mechanism than storing raw passwords.
The AI application uses custom CSS to create a modern visual system featuring:
- Glassmorphic cards
- Translucent surfaces
- Blur effects
- Emerald highlights
- Responsive layouts
- Mobile-friendly tables
- Scrollable content areas
- Consistent visual hierarchy
At the center of the application is a real-time computer-vision pipeline.
flowchart LR
A[Webcam Frame] --> B[OpenCV]
B --> C[MediaPipe Pose Landmarker]
C --> D[Body Landmarks]
D --> E[Joint Angle Calculation]
E --> F[Exercise State Analysis]
F --> G[Rep Counter]
F --> H[Form Analysis]
H --> I[AI Feedback]
I --> J[gTTS]
J --> K[Voice Coaching]
G --> L[Workout Metrics]
L --> M[SQLite]
Camera
↓
Video Frame
↓
Pose Detection
↓
Body Landmarks
↓
Joint Angles / Position Metrics
↓
Exercise State
├── Rep Counter
└── Form Analyzer
↓
Corrective Feedback
↓
Groq LLaMA
↓
gTTS
↓
Voice Coaching
Workout Metrics
↓
SQLite
↓
History / Dashboard
A typical workout session follows this sequence:
The user's webcam provides a continuous video stream.
Frames are processed through the computer-vision pipeline.
MediaPipe identifies relevant body landmarks.
The system derives geometric information such as joint angles and positional relationships.
The relevant movement is interpreted according to the selected exercise's movement rules.
The state machine determines whether a complete repetition has occurred.
Relevant posture conditions are checked against exercise-specific thresholds.
When corrective feedback is required, the movement information is passed through the AI feedback layer.
Generated feedback can be converted into speech using gTTS.
Workout metrics are synchronized with SQLite for historical tracking.
NeuroKinetIQ consists of two primary product layers and a real-time AI processing layer.
graph TB
User[User]
subgraph Product["NeuroKinetIQ Product"]
Landing["Vercel Landing & Product Experience"]
AI["Streamlit AI Gym Coach"]
end
subgraph Vision["Real-Time Computer Vision"]
Camera["Webcam"]
OpenCV["OpenCV"]
Pose["MediaPipe Pose Landmarker"]
Landmarks["Body Landmarks"]
Geometry["Joint Angle / Position Analysis"]
State["Exercise State Machine"]
Reps["Repetition Counter"]
Form["Form Analyzer"]
end
subgraph Intelligence["AI Coaching"]
Groq["Groq API / LLaMA"]
TTS["gTTS"]
Voice["Voice Feedback"]
end
subgraph Persistence["Persistence"]
SQLite["SQLite Database"]
History["Workout History"]
end
User --> Landing
Landing --> AI
AI --> Camera
Camera --> OpenCV
OpenCV --> Pose
Pose --> Landmarks
Landmarks --> Geometry
Geometry --> State
State --> Reps
State --> Form
Form --> Groq
Groq --> TTS
TTS --> Voice
Reps --> SQLite
Form --> SQLite
SQLite --> History
History --> AI
The computer-vision layer receives webcam frames and extracts human pose landmarks.
The important abstraction is:
Image
↓
Pose Model
↓
Landmark Coordinates
↓
Geometric Measurements
↓
Exercise Logic
This allows the application to reason about movement, rather than simply recognizing the presence of a person.
Joint angles are useful for determining the phase and quality of many exercises.
For three points:
A -------- B -------- C
Joint
the angle at B can be calculated from the vectors:
BA = A - B
BC = C - B
and:
angle = arccos(
(BA · BC) / (|BA| × |BC|)
)
These measurements become useful signals for exercise-specific rules.
Repetition counting is based on movement transitions rather than individual frames.
Conceptually:
START
│
▼
Initial Position
│
▼
Movement Begins
│
▼
Target Position
│
▼
Return Movement
│
▼
REP + 1
│
└──────────────► Next Rep
This state-based approach helps reduce false repetition counts caused by small frame-to-frame movements.
NeuroKinetIQ uses SQLite for local persistence.
The database supports application requirements including:
- User authentication
- User records
- Workout sessions
- Exercise metrics
- Repetition data
- Set information
- Calorie estimates
- Workout history
SQLite can temporarily report database-locking errors when multiple operations attempt to access the database concurrently.
NeuroKinetIQ addresses this with a transaction wrapper and retry mechanism.
def execute_query(query_func):
for attempt in range(1, 6):
try:
with sqlite3.connect(_DB_PATH) as conn:
conn.row_factory = sqlite3.Row
return query_func(conn)
except (sqlite3.OperationalError, sqlite3.DatabaseError) as e:
if "locked" in str(e).lower() or "busy" in str(e).lower():
time.sleep(1.0)
else:
raise eDatabase Operation
↓
Try Transaction
↓
┌── Success ──► Return
│
└── Locked/Busy
↓
Wait 1 second
↓
Retry
↓
Maximum
5 Attempts
This makes persistence significantly more resilient during concurrent application activity.
Passwords are protected using salted PBKDF2-HMAC-SHA256 hashing.
def hash_password(password: str) -> str:
salt = secrets.token_hex(16)
pwd_hash = hashlib.pbkdf2_hmac(
"sha256",
password.encode("utf-8"),
salt.encode("utf-8"),
100000
).hex()
return f"{salt}:{pwd_hash}"- Random per-password salt
- SHA-256 based PBKDF2
- 100,000 derivation iterations
- No plain-text password storage
- Salt stored alongside the derived password hash
The salt prevents identical passwords from producing identical stored hashes.
Building a real-time AI fitness application involves more than simply connecting a pose model to a webcam.
Problem: Webcam processing must remain responsive while pose estimation and application logic execute continuously.
Solution: The application uses a dedicated video-processing pipeline built around OpenCV and MediaPipe, while keeping the surrounding Streamlit interface lightweight.
Problem: Counting every frame as movement would produce incorrect repetition totals.
Solution: Exercise-specific movement states and geometric thresholds are used to identify meaningful transitions and completed repetitions.
Problem:
Concurrent SQLite access can cause database is locked or database is busy errors.
Solution: A transactional wrapper retries locked operations up to five times with a one-second delay between attempts.
Problem: Storing passwords directly would expose user credentials.
Solution: PBKDF2-HMAC-SHA256 with random salts and 100,000 iterations is used before storing credentials.
Problem: Fitness feedback needs to be understandable and immediate rather than simply displaying raw mathematical values.
Solution: Movement metrics are transformed into human-readable corrective feedback, with Groq-powered LLaMA generation and optional gTTS voice output.
Problem: Workout metrics and tables can become difficult to use on narrow screens.
Solution: Custom responsive CSS, horizontal scrolling, flexible layouts and glassmorphic cards provide a consistent experience across viewport sizes.
| Category | Technology | Role |
|---|---|---|
| Language | Python 3.10+ | Core AI application |
| Web Application | Streamlit | Interactive AI application |
| Computer Vision | OpenCV | Video processing |
| Pose Estimation | MediaPipe Pose Landmarker | Human pose tracking |
| Generative AI | Groq / LLaMA | AI coaching feedback |
| Speech | gTTS | Text-to-speech feedback |
| Database | SQLite3 | Application persistence |
| Styling | Vanilla CSS | Glassmorphic responsive UI |
| Product Showcase | HTML5 / CSS3 | Landing experience |
| Deployment | Vercel | Landing application hosting |
| Deployment | Streamlit Community Cloud | AI application hosting |
NeuroKinetIQ/
│
├── .streamlit/
│ └── config.toml
│
├── services/
│ ├── auth/
│ │ └── login_wall.py
│ │
│ ├── config/
│ │ └── workout_config.py
│ │
│ ├── persistence/
│ │ └── exercise_repository.py
│ │
│ ├── tracking/
│ │ └── metrics.py
│ │
│ └── vision/
│ └── excercise_video_processor.py
│
├── static/
│ └── style.css
│
├── main.py
├── packages.txt
├── requirements.txt
└── LICENSE
| Module | Responsibility |
|---|---|
main.py |
Application routing and dashboard coordination |
login_wall.py |
Authentication and sign-in/sign-up flow |
workout_config.py |
Exercise configuration and workout constants |
exercise_repository.py |
SQLite persistence, authentication and retry handling |
metrics.py |
Workout metric synchronization |
excercise_video_processor.py |
OpenCV + MediaPipe real-time processing |
style.css |
Responsive glassmorphic interface |
The Vercel-hosted component provides the polished product-facing layer of NeuroKinetIQ.
LandingPage/
│
├── IMGS/
│ ├── 1_Sign_up.png
│ ├── 2_Home_Page.png
│ ├── 3_Exercise_Reps_Sets_History.png
│ ├── 4_Start_Progress.png
│ ├── 5_Pose_Metrics_Updation.png
│ ├── 6_Workout_Complete.png
│ ├── 7_Workout_History_Feedback.png
│ ├── 8_Landing_Page.png
│ ├── 9_Gallery_Section.png
│ ├── 10_Video_Demo_Section.png
│ └── 11_Contact_Connections.png
│
├── videos/
│ └── NeuroKinetIQVideo.mp4
│
├── fonts/
├── favicon.svg
├── index.html
├── style.css
├── NeuroKinetIQVideoGIF.gif
├── vercel.json
└── README.md
The landing experience focuses on:
- Product positioning
- Visual storytelling
- Feature communication
- Application showcase
- Demo presentation
- Connection / contact experience
- Access to the live AI application
Before running the AI application locally, ensure you have:
- Python 3.10, 3.11 or 3.12
- A working webcam
- Git
- A Groq API key
git clone https://github.com/mihirgupta665/NeuroKinetIQ.git
cd NeuroKinetIQpython -m venv .venv
.venv\Scripts\activatepython -m venv .venv
source .venv/bin/activatepip install -r requirements.txtCreate a .env file in the project root:
GROQ_API_KEY="your-groq-api-key-here"Never commit API keys or other secrets to Git.
streamlit run main.pyThen open:
http://localhost:8501
The product showcase is deployed through Vercel.
Deployment flow:
Landing Page Source
↓
GitHub
↓
Vercel
↓
Production Website
The real-time AI application is deployed through Streamlit Community Cloud.
Deployment flow:
Python Application
↓
GitHub
↓
Streamlit Community Cloud
↓
Live AI Gym Coach
Production deployment requires the Groq API key to be configured securely through the deployment platform's secrets/environment configuration.
The application also includes packages.txt for required Linux system dependencies.
Modern browsers require secure origins for webcam access. Production deployment therefore uses HTTPS.
The Groq API key should be supplied through environment variables or platform secrets rather than committed to source control.
SQLite provides lightweight persistence suitable for the current application architecture. A production-scale deployment with many concurrent users could migrate the persistence layer to a server-based relational database.
| Capability | Status |
|---|---|
| Real-time webcam processing | ✅ |
| Human pose estimation | ✅ |
| Joint-angle analysis | ✅ |
| Exercise-specific movement analysis | ✅ |
| Repetition counting | ✅ |
| Set tracking | ✅ |
| Form feedback | ✅ |
| AI-generated coaching | ✅ |
| Voice feedback | ✅ |
| Workout history | ✅ |
| Calorie estimation | ✅ |
| User authentication | ✅ |
| SQLite persistence | ✅ |
| Responsive UI | ✅ |
| Vercel deployment | ✅ |
| Streamlit deployment | ✅ |
NeuroKinetIQ is designed as a foundation that can be expanded into a more comprehensive AI fitness platform.
Add additional exercises and exercise-specific form rules.
Improve movement understanding using temporal models and richer motion representations.
Introduce long-term performance trends, progress graphs and personalized recommendations.
Generate workout plans based on user goals, performance and historical activity.
Adapt feedback intensity, exercise difficulty and recommendations to individual users.
Move from local SQLite persistence to a production database architecture for larger-scale multi-user deployments.
Extend the platform into a dedicated mobile application for training outside the desktop environment.
Traditional fitness applications often tell users what exercise to perform.
NeuroKinetIQ focuses on another question:
Are you performing it correctly?
By combining computer vision, geometric movement analysis and generative AI, the system attempts to close the gap between:
Workout Instructions
+
Human Movement
+
Real-Time Analysis
+
Corrective Coaching
=
Intelligent Fitness Assistance
The webcam becomes more than a camera.
It becomes the interface between the user and an AI coach.
A complete walkthrough is available in the repository through:
Play or download the full walkthrough video
The README also includes the optimized animated walkthrough:
Open the animated GIF walkthrough
B.Tech CSE — Artificial Intelligence & Machine Learning
NeuroKinetIQ was designed and developed as an end-to-end AI computer-vision project combining:
Software Engineering + Computer Vision + Generative AI + Real-Time Systems + Product Design
This project is licensed under the MIT License.
See LICENSE for details.
See the movement. Understand the form. Improve the workout.