Monday, 5 October 2026

AI Diabetes Prediction System using Machine Learning

Absolutely. I can structure this as a **complete final-year/engineering project documentation package** for: > **AI-Powered Diabetes Prediction & IoT Health Monitoring System using Machine Learning, ESP32, n8n Agentic Automation, Telegram Voice Alerts, Google Sheets, ThingSpeak, and a Web Dashboard** The system can combine **ML-based diabetes-risk prediction**, **ESP32 IoT sensing**, **cloud visualization**, and an **AI agent that automatically interprets readings and triggers Telegram voice/text alerts**. ## 1\. Project Title **AI-Powered Diabetes Prediction and IoT Health Monitoring System using ESP32, Machine Learning, n8n Agentic Automation, Telegram Voice Alerts, Google Sheets and ThingSpeak** ### Short title **Agentic IoT-Based AI Diabetes Prediction System** --- # 2\. Abstract This project proposes an intelligent healthcare monitoring system that combines **Artificial Intelligence, Machine Learning, Internet of Things (IoT), ESP32, cloud dashboards, and workflow automation** to assist with diabetes-risk monitoring. The ESP32 acts as the IoT controller and collects physiological/environmental information from connected sensors. The collected measurements are transmitted through Wi-Fi to an IoT/cloud platform such as ThingSpeak and can also be forwarded to an automation workflow implemented using n8n. A trained Machine Learning model analyzes relevant health parameters and estimates the user's diabetes-risk category. The n8n automation layer functions as an **agentic orchestration layer**, receiving sensor/prediction data, applying decision logic and optionally an AI model, storing records in Google Sheets, updating cloud services, and sending notifications through Telegram. When a potentially abnormal condition or high-risk prediction is detected, the system can automatically generate a Telegram notification and, where configured, a voice alert. The user can also interact with the system through Telegram. The proposed system therefore creates an end-to-end pipeline: **Sensors → ESP32 → Wi-Fi → Cloud/API → n8n → AI/ML Analysis → Decision → Google Sheets/ThingSpeak → Telegram Alert** > **Important:** A diabetes prediction model should be presented as a **screening/research tool, not a medical diagnostic device**. Actual diagnosis requires appropriate clinical testing and professional medical evaluation. --- # 3\. Main Objectives The project has several objectives: 1. Develop a Machine Learning model capable of estimating diabetes risk from health-related input parameters. 2. Build an ESP32-based IoT monitoring device. 3. Collect sensor/user health data automatically. 4. Send data to a cloud platform. 5. Develop a web-based monitoring dashboard. 6. Integrate n8n for workflow automation. 7. Introduce an AI-agent layer for interpreting incoming information. 8. Store historical measurements in Google Sheets. 9. Visualize time-series data using ThingSpeak. 10. Send Telegram notifications when configurable thresholds/risk conditions are reached. 11. Generate Telegram voice notifications where supported by the selected implementation. 12. Provide an extensible architecture for future healthcare/IoT applications. --- # 4\. Proposed System Architecture ``` ┌──────────────────────────┐ │ USER / PATIENT │ │ Age, BMI, Glucose, etc. │ └────────────┬─────────────┘ │ ▼ ┌──────────────────────────┐ │ ESP32 IoT DEVICE │ │ │ │ Sensors / Display / WiFi │ └────────────┬─────────────┘ │ Wi-Fi / HTTP │ ▼ ┌──────────────────────────┐ │ IoT CLOUD │ │ ThingSpeak │ └────────────┬─────────────┘ │ │ API / Webhook ▼ ┌──────────────────────────┐ │ n8n │ │ Automation Workflow │ └────────────┬─────────────┘ │ ┌──────────────┼──────────────┐ │ │ │ ▼ ▼ ▼ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │ ML Model │ │ AI Agent │ │ Validation │ │ Prediction │ │ Reasoning │ │ / Rules │ └──────┬──────┘ └──────┬──────┘ └──────┬──────┘ └───────────────┼───────────────┘ ▼ ┌──────────────────────────┐ │ DECISION ENGINE │ │ Normal / Warning / High │ └────────────┬─────────────┘ │ ┌──────────────────┼──────────────────┐ ▼ ▼ ▼ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐ │ Google Sheets│ │ ThingSpeak │ │ Telegram │ │ Data Storage │ │ Dashboard │ │ Notification │ └──────────────┘ └──────────────┘ └──────┬───────┘ │ ▼ ┌──────────────┐ │ Voice Alert │ └──────────────┘ ``` --- # 5\. Overall Data Flow The complete data flow is: ``` START │ ▼ Power ON ESP32 │ ▼ Initialize Sensors │ ▼ Connect to Wi-Fi │ ▼ Read Sensor/User Parameters │ ▼ Validate Data │ ├── Invalid ──► Reject / Retry │ ▼ Send Data │ ├──────────────► ThingSpeak │ └──────────────► n8n Webhook │ ▼ Preprocess Data │ ▼ ML Prediction │ ▼ Risk Classification │ ┌───────────┼───────────┐ ▼ ▼ ▼ LOW MODERATE HIGH │ │ │ ▼ ▼ ▼ Record Record Record │ │ │ └───────────┼───────────┘ ▼ AI Agent Analysis │ ▼ Generate Response │ ┌───────────┼────────────┐ ▼ ▼ ▼ Google Sheets ThingSpeak Telegram │ ▼ Voice Notification ``` --- # 6\. Hardware Requirements A practical prototype can contain: | Component | Purpose | | --- | --- | | ESP32 development board | Main IoT controller | | MAX30102 | Heart-rate / SpO₂ sensing\* | | DS18B20 | Temperature measurement | | OLED display | Local information display | | Push button | User interaction | | Buzzer | Local alarm | | LED | Status indication | | Wi-Fi | Internet communication | | 5 V USB supply | Power | \*Sensor measurements such as SpO₂ and heart rate should not automatically be treated as clinically accurate unless the hardware and measurement procedure have been properly validated. For a diabetes-prediction prototype, some model inputs may not actually be measurable by the ESP32. For example: - Age - BMI - Pregnancies - Blood glucose - Blood pressure - Insulin - Diabetes pedigree information can instead be entered through the web interface or Telegram. This gives the system two input paths: ``` ┌───────────────┐ │ ESP32 Sensors │ └───────┬───────┘ │ ▼ IoT Measurements │ │ ┌──────────────┐ │ │ Web Interface│─────┤ └──────────────┘ │ ▼ Combined Patient Data │ ▼ ML Model ``` --- # 7\. ESP32 Hardware Block Diagram ``` ┌─────────────┐ │ ESP32 │ │ │ │ GPIO/I2C │ └──────┬──────┘ │ ┌────────────────┼────────────────┐ │ │ │ ▼ ▼ ▼ ┌─────────┐ ┌─────────┐ ┌─────────┐ │ MAX30102│ │ DS18B20 │ │ OLED │ │ Sensor │ │ Temp. │ │ Display │ └─────────┘ └─────────┘ └─────────┘ │ │ ▼ Health Data ┌─────────────┐ │ Wi-Fi Router│ └──────┬──────┘ │ Internet │ ▼ Cloud / n8n ``` --- # 8\. Suggested ESP32 Pin Configuration Example configuration: ``` ESP32 │ ├── GPIO 21 → I2C SDA ├── GPIO 22 → I2C SCL │ ├── I2C → MAX30102 ├── I2C → OLED │ ├── GPIO 4 → DS18B20 DATA ├── GPIO 25 → Buzzer ├── GPIO 26 → Status LED └── GPIO 27 → Push Button ``` ### Important I²C devices can share SDA/SCL as long as their I²C addresses do not conflict. Also verify the voltage requirements of every module before connecting it to the ESP32. --- # 9\. Schematic-Level Connection ``` ESP32 ┌───────────────┐ │ │ │ GPIO21 ───────┼──── SDA ─────┐ │ GPIO22 ───────┼──── SCL ─────┤ │ │ │ │ 3V3 ──────────┼──────────────┼───┐ │ GND ──────────┼──────────────┼───┤ │ │ │ │ └───────────────┘ │ │ │ │ ┌────────▼───▼──────┐ │ MAX30102 │ │ │ │ SDA SCL VCC GND │ └───────────────────┘ GPIO4 ───────────── DATA 3V3 ────────────── VCC GND ────────────── GND ┌─────────┐ │ DS18B20 │ └─────────┘ GPIO21 ───────── SDA GPIO22 ───────── SCL 3V3 ──────────── VCC GND ──────────── GND ┌───────┐ │ OLED │ └───────┘ GPIO25 ───────── Buzzer GPIO26 ───────── LED GPIO27 ───────── Push Button ``` For a physical build, include appropriate resistors, decoupling, pull-ups and transistor/driver stages where required by the specific modules. --- # 10\. Software Architecture ``` ┌───────────────────────────────────────────────┐ │ USER INTERFACE │ │ HTML / CSS / JavaScript Web App │ └───────────────────────┬───────────────────────┘ │ ▼ ┌───────────────────────────────────────────────┐ │ API / BACKEND │ │ Python Flask / FastAPI / Node.js │ └───────────────────────┬───────────────────────┘ │ ┌──────────┴──────────┐ ▼ ▼ ┌──────────────┐ ┌──────────────┐ │ ML Prediction│ │ n8n Webhook │ └──────────────┘ └──────┬───────┘ │ ▼ ┌──────────────┐ │ AI Agent │ └──────┬───────┘ │ ┌────────────────┼───────────────┐ ▼ ▼ ▼ Google Sheets ThingSpeak Telegram ``` --- # 11\. Machine Learning Component A commonly used academic dataset for demonstrating diabetes prediction is the **Pima Indians Diabetes Database**. Typical features include: ``` Pregnancies Glucose BloodPressure SkinThickness Insulin BMI DiabetesPedigreeFunction Age ``` Target: ``` Outcome 0 = lower predicted diabetes-risk class 1 = higher predicted diabetes-risk class ``` For an academic project, compare several algorithms rather than assuming one is automatically best: - Logistic Regression - Decision Tree - Random Forest - Support Vector Machine - K-Nearest Neighbors - Gradient Boosting Useful evaluation metrics: ``` Accuracy Precision Recall F1-score ROC-AUC Confusion Matrix ``` For health-related screening, **recall/sensitivity and false-negative behavior are especially important**, so reporting only accuracy would be inadequate. --- # 12\. ML Training Code Example Python implementation: ``` import pandas as pd from sklearn.model_selection import train_test_split from sklearn.preprocessing import StandardScaler from sklearn.pipeline import Pipeline from sklearn.linear_model import LogisticRegression from sklearn.metrics import ( accuracy_score, precision_score, recall_score, f1_score, roc_auc_score, confusion_matrix ) # Load dataset df = pd.read_csv("diabetes.csv") # Input features X = df.drop("Outcome", axis=1) # Target y = df["Outcome"] # Train/test split X_train, X_test, y_train, y_test = train_test_split( X, y, test_size=0.20, random_state=42, stratify=y ) # Pipeline model = Pipeline([ ("scaler", StandardScaler()), ("classifier", LogisticRegression(max_iter=1000)) ]) # Train model.fit(X_train, y_train) # Prediction y_pred = model.predict(X_test) y_prob = model.predict_proba(X_test)[:, 1] # Metrics print("Accuracy:", accuracy_score(y_test, y_pred)) print("Precision:", precision_score(y_test, y_pred)) print("Recall:", recall_score(y_test, y_pred)) print("F1:", f1_score(y_test, y_pred)) print("ROC-AUC:", roc_auc_score(y_test, y_prob)) print("Confusion Matrix:") print(confusion_matrix(y_test, y_pred)) ``` --- # 13\. Saving the ML Model ``` import joblib joblib.dump(model, "diabetes_model.pkl") print("Model saved successfully.") ``` The resulting model: ``` diabetes_model.pkl ``` can be loaded by the backend. --- # 14\. Prediction API A simple FastAPI implementation: ``` from fastapi import FastAPI import joblib app = FastAPI() model = joblib.load("diabetes_model.pkl") @app.get("/") def home(): return { "status": "online", "service": "AI Diabetes Prediction API" } @app.post("/predict") def predict(data: dict): features = [[ data["Pregnancies"], data["Glucose"], data["BloodPressure"], data["SkinThickness"], data["Insulin"], data["BMI"], data["DiabetesPedigreeFunction"], data["Age"] ]] prediction = int(model.predict(features)[0]) probability = float( model.predict_proba(features)[0][1] ) if prediction == 1: risk = "HIGH" else: risk = "LOW" return { "prediction": prediction, "risk": risk, "probability": probability } ``` --- # 15\. Webpage The webpage can provide: ``` +--------------------------------------------------+ | AI DIABETES & IoT MONITORING SYSTEM | +--------------------------------------------------+ | | | Patient Information | | | | Age: [ 45 ] | | Glucose: [ 145 ] | | Blood Pressure: [ 85 ] | | BMI: [ 28.5 ] | | | | [ PREDICT DIABETES RISK ] | | | +--------------------------------------------------+ | LIVE IoT DATA | +--------------------------------------------------+ | Heart Rate: 78 BPM | | SpO2: 97 % | | Temperature: 36.7 °C | +--------------------------------------------------+ | AI RESULT | | | | Risk: MODERATE/HIGH | | Probability: XX % | | | +--------------------------------------------------+ | ThingSpeak Graph | | | | /\/\/\/\__/\/\/\/\ | | | +--------------------------------------------------+ ``` --- # 16\. Example HTML ``` AI Diabetes Monitoring

AI Diabetes Prediction



ESP32 Live Monitoring

Heart Rate: --

SpO2: --

Temperature: --

``` --- # 17\. ESP32 Firmware Arduino-style ESP32 example: ``` #include #include const char* ssid = "YOUR_WIFI"; const char* password = "YOUR_PASSWORD"; const char* serverURL = "https://YOUR_SERVER/api/iot"; void setup() { Serial.begin(115200); WiFi.begin(ssid, password); Serial.print("Connecting"); while (WiFi.status() != WL_CONNECTED) { delay(500); Serial.print("."); } Serial.println(); Serial.println("WiFi connected"); } void loop() { float heartRate = 78.0; float spo2 = 97.0; float temperature = 36.7; if (WiFi.status() == WL_CONNECTED) { HTTPClient http; http.begin(serverURL); http.addHeader( "Content-Type", "application/json" ); String json = "{"; json += "\"heartRate\":" + String(heartRate) + ","; json += "\"spo2\":" + String(spo2) + ","; json += "\"temperature\":" + String(temperature); json += "}"; int responseCode = http.POST(json); Serial.print("HTTP Response: "); Serial.println(responseCode); http.end(); } delay(30000); } ``` Replace the example sensor values with actual sensor-library readings after integrating the hardware. --- # 18\. ThingSpeak Integration A useful ThingSpeak channel structure could be: ``` Field 1 → Heart Rate Field 2 → SpO2 Field 3 → Temperature Field 4 → Glucose Field 5 → BMI Field 6 → ML Risk Probability Field 7 → Risk Class ``` Conceptually: ``` ESP32 │ ▼ ThingSpeak API │ ├── Field 1 ── Heart Rate ├── Field 2 ── SpO2 ├── Field 3 ── Temperature ├── Field 4 ── Glucose ├── Field 5 ── BMI ├── Field 6 ── ML Probability └── Field 7 ── Risk ``` The ThingSpeak graph then provides a historical view of measurements. --- # 19\. n8n Automation Architecture The n8n workflow is the central automation layer. ``` ┌─────────────────┐ │ Webhook Trigger │ └────────┬────────┘ │ ▼ ┌─────────────────┐ │ Validate Input │ └────────┬────────┘ │ ▼ ┌─────────────────┐ │ Data Processing │ └────────┬────────┘ │ ▼ ┌─────────────────┐ │ ML Prediction │ └────────┬────────┘ │ ▼ ┌─────────────────┐ │ AI Agent │ │ Interpretation │ └────────┬────────┘ │ ▼ ┌─────────────┐ │ IF / Switch │ └──────┬──────┘ │ ┌──────────┼───────────┐ ▼ ▼ ▼ NORMAL WARNING HIGH │ │ │ ▼ ▼ ▼ Store Store Store │ │ │ └──────────┼───────────┘ ▼ Google Sheets │ ▼ Telegram │ ▼ Voice Alert ``` --- # 20\. Example n8n Workflow Recommended nodes: ``` Webhook ↓ Set / Edit Fields ↓ Code ↓ HTTP Request ↓ AI Agent ↓ Switch ├── LOW ├── MODERATE └── HIGH ↓ Google Sheets ↓ Telegram ↓ Voice generation / audio delivery ``` ### Webhook JSON ESP32/backend can send: ``` { "device_id": "ESP32_001", "heart_rate": 82, "spo2": 97, "temperature": 36.8, "glucose": 142, "bmi": 28.4, "age": 45 } ``` --- # 21\. n8n Code Node Example: ``` const data = $json; const glucose = Number(data.glucose); const bmi = Number(data.bmi); const age = Number(data.age); let status = "NORMAL"; if (glucose >= 200) { status = "HIGH"; } else if (glucose >= 140) { status = "WARNING"; } return [{ json: { ...data, preliminary_status: status, timestamp: new Date().toISOString() } }]; ``` This should be treated as **workflow demonstration logic**, not as a clinical diagnostic threshold engine. --- # 22\. AI Agent Role The AI agent should **not replace the ML model**. Instead: ``` ML Model │ │ numerical prediction ▼ AI Agent │ ├── Interpret result ├── Generate explanation ├── Decide notification wording ├── Summarize recent readings └── Trigger appropriate workflow action ``` This separation is important. ### ML model Answers: > "What does the trained statistical model predict?" ### AI agent Answers: > "How should this information be interpreted and communicated within the automation workflow?" --- # 23\. Example AI Agent Prompt ``` You are an IoT health-monitoring workflow assistant. Your task is to interpret incoming device data and the output of a diabetes-risk machine-learning model. Do not diagnose disease. Do not invent medical measurements. Use only the information supplied by the workflow. Return: 1. Risk category 2. Short explanation 3. Whether a notification should be generated 4. Concise Telegram message If the data appears incomplete or invalid, report that instead of making assumptions. If the ML system reports elevated risk, advise the user to consider appropriate professional medical evaluation rather than claiming that the user has diabetes. ``` --- # 24\. Google Sheets Database Create columns such as: ``` Timestamp Device_ID Age Glucose BloodPressure BMI HeartRate SpO2 Temperature ML_Probability Risk_Class AI_Message Alert_Status ``` Example: | Timestamp | Glucose | BMI | HR | Temp | ML Probability | Risk | | --- | --- | --- | --- | --- | --- | --- | | 08:00 | 120 | 24.5 | 76 | 36.6 | 0.21 | LOW | | 09:00 | 145 | 28.1 | 81 | 36.8 | 0.58 | MODERATE | | 10:00 | 165 | 30.2 | 88 | 37.0 | 0.76 | HIGH | --- # 25\. Telegram Notification Example normal message: ``` 🟢 HEALTH MONITORING UPDATE Device: ESP32_001 Heart Rate: 76 BPM SpO2: 98% Temperature: 36.6°C ML Risk Probability: 21% Status: LOW No automated alert is required. ``` Warning: ``` 🟠 HEALTH MONITORING ALERT The latest measurements produced an elevated ML risk estimate. Please review the recorded measurements and consider appropriate medical follow-up. This system is a screening/monitoring aid and is not a medical diagnosis. ``` High-risk workflow: ``` 🔴 ATTENTION REQUIRED The latest data has produced a high-risk prediction from the configured ML model. Please review the measurements and seek appropriate professional medical advice. This automated message does not constitute a diagnosis. ``` --- # 26\. Telegram Voice Alert The workflow can be: ``` ML Prediction ↓ Risk = HIGH ↓ AI Agent creates message ↓ Text-to-Speech service ↓ Audio file ↓ Telegram Bot ↓ Voice message ``` Example: ``` "Attention. The latest health measurements have produced an elevated risk prediction. Please review your measurements and consider contacting a qualified healthcare professional." ``` The exact text-to-speech implementation can be selected according to the services available in your deployment. --- # 27\. Complete Agentic IoT Workflow ``` ┌──────────────┐ │ ESP32 │ └──────┬───────┘ │ Sensor Measurements │ ▼ ┌──────────────┐ │ Wi-Fi │ └──────┬───────┘ │ ▼ ┌──────────────┐ │ n8n │ │ Webhook │ └──────┬───────┘ │ ▼ ┌──────────────┐ │ Data Validate │ └──────┬───────┘ │ ▼ ┌──────────────┐ │ ML Prediction │ └──────┬───────┘ │ ▼ ┌──────────────┐ │ AI Agent │ └──────┬───────┘ │ ┌────────┴────────┐ │ │ ▼ ▼ Normal/Low Elevated │ │ ▼ ▼ Log Information Generate Alert │ ┌──────────┼──────────┐ ▼ ▼ ▼ Sheet Telegram Voice │ │ │ └──────────┴──────────┘ │ ▼ User Response ``` --- # 28\. Telegram Chat Interface The system can also accept commands: ``` USER /start BOT Welcome to AI Health Monitor. Commands: /status /latest /prediction /history /help ``` ### Example ``` USER: /status BOT: ESP32_001 Heart Rate: 78 BPM SpO2: 97% Temperature: 36.7°C Latest ML Risk: LOW Last update: 10:42 AM ``` Another example: ``` USER: /prediction BOT: Latest prediction: Risk probability: 0.32 Classification: LOW This is an automated ML screening result and is not a medical diagnosis. ``` --- # 29\. Bidirectional Agentic Architecture The more advanced version allows the user to communicate back to the system. ``` ┌──────────────┐ │ USER │ └──────┬───────┘ │ Telegram │ ▼ ┌──────────────┐ │ Telegram Bot │ └──────┬───────┘ │ ▼ ┌──────────────┐ │ n8n │ └──────┬───────┘ │ ▼ ┌───────────┐ │ AI Agent │ └─────┬─────┘ │ ┌──────────┼──────────┐ ▼ ▼ ▼ Status Prediction History │ │ │ └──────────┼──────────┘ ▼ Response │ ▼ Telegram ``` This is what makes the project more **agentic** rather than simply a sensor + alert system. --- # 30\. Data Security Because this involves health-related information, security should be included in the project. Recommended measures: - HTTPS for API communication. - Do not hard-code Telegram bot tokens into publicly shared code. - Store credentials in environment variables or n8n credentials. - Authenticate API requests. - Use device IDs and authentication tokens. - Avoid exposing Google Sheets publicly. - Restrict access to dashboards. - Do not transmit unnecessary personally identifiable information. - Keep logs protected. - Use encrypted communication wherever possible. Example: ``` ESP32 │ │ HTTPS ▼ Authenticated API │ ▼ n8n │ ├── secured credentials ├── ML service ├── Google Sheets └── Telegram ``` --- # 31\. Failure Handling A professional project should demonstrate what happens when something fails. ### Wi-Fi failure ``` ESP32 ↓ Wi-Fi disconnected ↓ Retry connection ↓ Store temporary reading ↓ Reconnect ↓ Upload buffered data ``` ### n8n failure ``` ESP32 ↓ API unavailable ↓ Retry ↓ Log error ↓ Continue local monitoring ``` ### Invalid sensor data ``` Sensor ↓ Invalid reading ↓ Validation ↓ Reject value ↓ Retry sensor ``` ### AI service unavailable ``` ML result available ↓ AI service unavailable ↓ Use predefined safe notification template ↓ Continue logging ``` This is particularly important because **an AI agent should not become a single point of failure**. --- # 32\. Complete Project Flowchart ``` START │ ▼ Initialize ESP32 │ ▼ Initialize Sensors │ ▼ Connect Wi-Fi │ ┌─────┴─────┐ │ Connected?│ └─────┬─────┘ No │ Yes │ │ └───┘ Retry │ ▼ Read Sensors │ ▼ Validate Values │ ┌──────┴──────┐ │ Valid Data? │ └──────┬───────┘ │ Yes │ No │ │ │ Retry ▼ Send IoT Data │ ▼ n8n Webhook │ ▼ Preprocess Data │ ▼ ML Prediction │ ▼ AI Agent │ ▼ Decision Engine │ ┌─────────┼─────────┐ ▼ ▼ ▼ LOW MODERATE HIGH │ │ │ └─────────┼─────────┘ ▼ Google Sheets │ ▼ ThingSpeak │ ▼ Telegram Alert │ ▼ Voice Notification │ ▼ Repeat ``` --- # 33. Recommended Project Folder Structure ``` AI-Diabetes-IoT/ │ ├── README.md │ ├── esp32/ │ ├── esp32_main.ino │ ├── sensors.h │ └── config.h │ ├── ml/ │ ├── diabetes.csv │ ├── train_model.py │ ├── evaluate_model.py │ └── diabetes_model.pkl │ ├── backend/ │ ├── main.py │ ├── requirements.txt │ └── models/ │ ├── web/ │ ├── index.html │ ├── style.css │ └── app.js │ ├── n8n/ │ └── diabetes_iot_workflow.json │ ├── telegram/ │ └── bot_logic.md │ ├── docs/ │ ├── architecture.md │ ├── hardware.md │ ├── software.md │ ├── testing.md │ └── project_report.md │ └── diagrams/ ├── system_architecture.png ├── flowchart.png └── circuit.png ``` --- # 34\. Testing Plan | Test | Input | Expected Result | | --- | --- | --- | | ESP32 boot | Power ON | Device starts | | Wi-Fi | Correct credentials | Connected | | Sensor | Valid measurement | Reading displayed | | API | Valid JSON | HTTP success | | ML | Valid features | Prediction generated | | Invalid input | Missing feature | Validation error | | n8n | Webhook data | Workflow executes | | Google Sheets | Valid record | Row inserted | | ThingSpeak | Valid fields | Graph updated | | Telegram | Alert condition | Message delivered | | Voice | High-risk workflow | Audio notification | | Network loss | Disconnect Wi-Fi | Retry/recovery | --- # 35\. Performance Metrics ### Machine Learning Report: ``` Accuracy Precision Recall F1-score ROC-AUC Confusion Matrix ``` ### IoT Measure: ``` Sensor sampling interval API latency n8n workflow execution time Telegram notification latency Packet loss Wi-Fi reconnection time ``` ### System Measure: ``` End-to-end latency Sensor reading ↓ Cloud ↓ n8n ↓ ML ↓ AI Agent ↓ Telegram Total response time = ______ seconds ``` --- # 36\. Advantages - Combines AI, ML and IoT. - ESP32 provides a low-cost IoT platform. - Automated workflow reduces manual monitoring. - Historical data can be stored automatically. - ThingSpeak provides visualization. - Google Sheets provides simple data analysis/export. - Telegram enables remote notifications. - Voice alerts improve accessibility. - AI-agent architecture allows natural-language interaction. - Modular design allows additional sensors and models. --- # 37\. Limitations A good academic report should explicitly acknowledge: 1. The system is not a medical diagnostic device. 2. ML performance depends heavily on the training dataset. 3. Dataset bias can affect predictions. 4. Consumer sensors may not provide clinically validated measurements. 5. Internet connectivity is required for cloud automation. 6. AI-generated explanations may be imperfect. 7. Threshold-based alerts are not equivalent to clinical decision-making. 8. Personal health data requires careful security and privacy management. --- # 38\. Future Enhancements The system can later be extended with: ``` Continuous glucose monitoring integration ↓ Mobile application ↓ Wearable device ↓ Federated learning ↓ Personalized ML models ↓ Anomaly detection ↓ Long-term trend analysis ↓ Voice-based AI assistant ↓ Multilingual Telegram assistant ↓ Doctor/caregiver dashboard ``` An advanced version could use: ``` ESP32 ↓ MQTT ↓ IoT Broker ↓ n8n ↓ AI Agent ↓ Tool Calling ├── ML prediction ├── Database ├── Google Sheets ├── ThingSpeak └── Telegram ``` --- # 39\. Final System Architecture The strongest version of the project can therefore be presented as: ``` ┌───────────────────┐ │ USER │ └─────────┬─────────┘ │ ┌─────────────┴─────────────┐ │ │ ▼ ▼ Web Dashboard Telegram │ │ │ │ └─────────────┬─────────────┘ ▼ ┌──────────────────┐ │ n8n │ │ Automation Layer │ └────────┬─────────┘ │ ┌─────────────┼──────────────┐ │ │ │ ▼ ▼ ▼ ESP32 IoT ML Model AI Agent │ │ │ │ └──────┬───────┘ │ │ ▼ ▼ Sensor Data Decision │ │ └──────────┬─────────┘ ▼ ┌──────────────┐ │ Cloud Storage│ └──────┬───────┘ │ ┌───────────┴───────────┐ ▼ ▼ Google Sheets ThingSpeak │ ▼ Cloud Dashboard AI Agent │ ┌────────────┴────────────┐ ▼ ▼ Telegram Text Voice Alert ``` ## 40\. Suggested Final Project Name For your **project report, PPT, GitHub repository and viva**, I recommend using one consistent title: > **“AI-Powered IoT-Based Diabetes Risk Prediction and Health Monitoring System Using ESP32, Machine Learning and n8n Agentic Automation with Telegram Voice Alerts”** This title captures the complete project without making the stronger—and medically inappropriate—claim that the system itself diagnoses diabetes. If you are building this as a **college/final-year project**, the documentation can be organized into **Chapter 1: Introduction, Chapter 2: Literature Survey, Chapter 3: Requirements, Chapter 4: System Design, Chapter 5: Hardware Design, Chapter 6: ML Model, Chapter 7: ESP32 Programming, Chapter 8: n8n/AI Agent, Chapter 9: Telegram/Cloud Integration, Chapter 10: Implementation, Chapter 11: Testing & Results, Chapter 12: Conclusion and Future Scope**, followed by references and appendices.

Project Summary

AI-Powered IoT-Based Diabetes Risk Prediction and Health Monitoring System combines Machine Learning, ESP32 IoT, n8n automation, an AI agent, Telegram alerts, Google Sheets, ThingSpeak, and a web dashboard into one automated healthcare-monitoring prototype.

Core workflow

ESP32 Sensors / Web Input
          ↓
       Wi-Fi
          ↓
    ThingSpeak / API
          ↓
        n8n
          ↓
   Data Validation
          ↓
   ML Diabetes-Risk Model
          ↓
       AI Agent
          ↓
   Decision / Risk Level
     ↙      ↓       ↘
  Normal  Warning    High
     ↓      ↓         ↓
     └──────┼─────────┘
            ↓
      Google Sheets
            +
       ThingSpeak
            +
        Telegram
            ↓
       Voice Alert

Main components

  • ESP32: collects IoT measurements and communicates over Wi-Fi.

  • Machine Learning: predicts diabetes risk from features such as glucose, BMI, age, blood pressure, etc.

  • Web application: allows users to enter patient/model inputs and view IoT data.

  • n8n: coordinates the complete automation workflow.

  • AI Agent: interprets ML results and generates appropriate responses/notifications.

  • ThingSpeak: provides cloud-based IoT visualization and historical graphs.

  • Google Sheets: maintains a simple historical database.

  • Telegram: delivers text and voice notifications.

  • Sensors: examples include MAX30102, DS18B20, OLED, buzzer and status LED.

ML component

A dataset such as the Pima Indians Diabetes Database can be used for academic model development. Candidate algorithms include:

  • Logistic Regression

  • Random Forest

  • Decision Tree

  • SVM

  • KNN

  • Gradient Boosting

Evaluate the model using accuracy, precision, recall, F1-score, ROC-AUC and a confusion matrix.

Important design principle

The ML model should make the statistical prediction, while the AI agent interprets and communicates the result. The AI agent should not independently diagnose diabetes.

Final project outcome

The completed system demonstrates an end-to-end Agentic IoT architecture:

Sense → Transmit → Predict → Reason → Automate → Store → Visualize → Alert

For an academic project, describe it as a diabetes-risk screening/monitoring prototype, not as a clinically validated diagnostic system.

 

No comments:

Post a Comment