From 5e4da0f77f7f4277f9155b5a126d52ece1bc4047 Mon Sep 17 00:00:00 2001
From: Aditya8369 <mahajan2005aditya@gmail.com>
Date: Mon, 9 Feb 2026 23:47:40 +0530
Subject: [PATCH 1/2] feat: AI-Powered Financial Insights Dashboard

---
 package.json                    |   1 +
 public/ai-insights-dashboard.js |   0
 public/dashboard.html           | 150 +++++++++++++++++++++++---------
 services/aiInsightsService.js   |   1 +
 4 files changed, 111 insertions(+), 41 deletions(-)
 create mode 100644 public/ai-insights-dashboard.js

diff --git a/package.json b/package.json
index 1c9f6d27..ba18f90e 100644
--- a/package.json
+++ b/package.json
@@ -8,6 +8,7 @@
     "dev": "nodemon server.js"
   },
   "dependencies": {
+    "@tensorflow/tfjs-node": "^4.15.0",
     "axios": "^1.6.2",
     "bcryptjs": "^2.4.3",
     "cors": "^2.8.5",
diff --git a/public/ai-insights-dashboard.js b/public/ai-insights-dashboard.js
new file mode 100644
index 00000000..e69de29b
diff --git a/public/dashboard.html b/public/dashboard.html
index 16c5ba83..d8b6d54a 100644
--- a/public/dashboard.html
+++ b/public/dashboard.html
@@ -919,68 +919,136 @@ <h3 id="recurring-modal-title">Add Recurring Expense</h3>
         </div>
       </section>
 
-      <!-- Analytics Dashboard Section -->
-      <section id="analytics" class="analytics-section">
+      <!-- AI-Powered Financial Insights Dashboard -->
+      <section id="ai-insights" class="ai-insights-section">
         <div class="section-header">
-          <h3><i class="fas fa-chart-bar"></i> Financial Analytics & Forecasting</h3>
-          <div class="analytics-actions">
-            <select id="trends-period" class="period-select">
-              <option value="monthly">Monthly</option>
-              <option value="weekly">Weekly</option>
-              <option value="daily">Daily</option>
-            </select>
-            <button id="refresh-analytics" class="refresh-btn">
-              <i class="fas fa-sync-alt"></i> Refresh
+          <h3><i class="fas fa-brain"></i> AI-Powered Financial Insights</h3>
+          <div class="insights-actions">
+            <button id="refresh-insights" class="refresh-btn">
+              <i class="fas fa-sync-alt"></i> Refresh AI Insights
             </button>
+            <span class="ai-status">
+              <i class="fas fa-robot"></i> AI Active
+            </span>
           </div>
         </div>
 
-        <div id="analytics-dashboard" class="analytics-grid">
-          <!-- Top Row: Velocity and Forecast -->
-          <div class="analytics-row top-row">
-            <div id="velocity-widget" class="analytics-card velocity-card">
-              <div class="widget-loading">
+        <!-- Financial Health Score -->
+        <div class="health-score-card">
+          <div class="health-score-header">
+            <h4><i class="fas fa-heartbeat"></i> Financial Health Score</h4>
+            <div id="health-score-display" class="health-score-display">
+              <div class="score-loading">
                 <i class="fas fa-spinner fa-spin"></i>
-                <span>Calculating velocity...</span>
+                <span>Analyzing your finances...</span>
               </div>
             </div>
-            <div id="forecast-widget" class="analytics-card forecast-card">
-              <div class="widget-loading">
-                <i class="fas fa-spinner fa-spin"></i>
-                <span>Generating forecast...</span>
+          </div>
+          <div id="health-factors" class="health-factors">
+            <!-- Health factors will be loaded here -->
+          </div>
+        </div>
+
+        <!-- AI Insights Grid -->
+        <div id="ai-insights-dashboard" class="ai-insights-grid">
+          <!-- Top Row: Forecast and Anomalies -->
+          <div class="insights-row top-row">
+            <div id="ai-forecast-widget" class="insights-card forecast-card">
+              <div class="card-header">
+                <h4><i class="fas fa-chart-line"></i> AI Spending Forecast</h4>
+                <span class="ai-badge">ML-Powered</span>
+              </div>
+              <div class="card-content">
+                <div class="forecast-loading">
+                  <i class="fas fa-spinner fa-spin"></i>
+                  <span>Training AI model...</span>
+                </div>
+              </div>
+            </div>
+            <div id="ai-anomalies-widget" class="insights-card anomalies-card">
+              <div class="card-header">
+                <h4><i class="fas fa-exclamation-triangle"></i> Spending Anomalies</h4>
+                <span class="ai-badge">AI Detected</span>
+              </div>
+              <div class="card-content">
+                <div class="anomalies-loading">
+                  <i class="fas fa-spinner fa-spin"></i>
+                  <span>Scanning for anomalies...</span>
+                </div>
               </div>
             </div>
           </div>
 
-          <!-- Middle Row: Trends and Category Breakdown -->
-          <div class="analytics-row main-charts">
-            <div id="trends-chart" class="analytics-card trends-card">
-              <div class="widget-loading">
-                <i class="fas fa-spinner fa-spin"></i>
-                <span>Loading trends...</span>
+          <!-- Middle Row: Recommendations and Trends -->
+          <div class="insights-row main-row">
+            <div id="ai-recommendations-widget" class="insights-card recommendations-card">
+              <div class="card-header">
+                <h4><i class="fas fa-lightbulb"></i> Smart Recommendations</h4>
+                <span class="ai-badge">Personalized</span>
+              </div>
+              <div class="card-content">
+                <div class="recommendations-loading">
+                  <i class="fas fa-spinner fa-spin"></i>
+                  <span>Generating recommendations...</span>
+                </div>
               </div>
             </div>
-            <div id="category-chart" class="analytics-card category-card">
-              <div class="widget-loading">
-                <i class="fas fa-spinner fa-spin"></i>
-                <span>Loading distribution...</span>
+            <div id="ai-trends-widget" class="insights-card trends-card">
+              <div class="card-header">
+                <h4><i class="fas fa-chart-bar"></i> Spending Trends</h4>
+                <span class="ai-badge">Pattern Analysis</span>
+              </div>
+              <div class="card-content">
+                <div class="trends-loading">
+                  <i class="fas fa-spinner fa-spin"></i>
+                  <span>Analyzing trends...</span>
+                </div>
               </div>
             </div>
           </div>
 
-          <!-- Bottom Row: Insights and Predictions -->
-          <div class="analytics-row details-row">
-            <div id="insights-container" class="analytics-card insights-card">
-              <div class="widget-loading">
-                <i class="fas fa-spinner fa-spin"></i>
-                <span>Gathering insights...</span>
+          <!-- Bottom Row: Budget Optimization and Alerts -->
+          <div class="insights-row bottom-row">
+            <div id="ai-budget-widget" class="insights-card budget-card">
+              <div class="card-header">
+                <h4><i class="fas fa-piggy-bank"></i> Budget Optimization</h4>
+                <span class="ai-badge">Smart Allocation</span>
+              </div>
+              <div class="card-content">
+                <div class="budget-loading">
+                  <i class="fas fa-spinner fa-spin"></i>
+                  <span>Optimizing budgets...</span>
+                </div>
               </div>
             </div>
-            <div id="predictions-widget" class="analytics-card predictions-card">
-              <div class="widget-loading">
-                <i class="fas fa-spinner fa-spin"></i>
-                <span>Predicting spending...</span>
+            <div id="ai-alerts-widget" class="insights-card alerts-card">
+              <div class="card-header">
+                <h4><i class="fas fa-bell"></i> Smart Alerts</h4>
+                <span class="ai-badge">Proactive</span>
               </div>
+              <div class="card-content">
+                <div class="alerts-loading">
+                  <i class="fas fa-spinner fa-spin"></i>
+                  <span>Monitoring spending...</span>
+                </div>
+              </div>
+            </div>
+          </div>
+        </div>
+
+        <!-- AI Insights Summary -->
+        <div class="ai-summary-card">
+          <div class="summary-header">
+            <h4><i class="fas fa-robot"></i> AI Analysis Summary</h4>
+            <div id="ai-confidence" class="ai-confidence">
+              <span class="confidence-label">AI Confidence:</span>
+              <span class="confidence-score">--</span>
+            </div>
+          </div>
+          <div id="ai-summary-content" class="summary-content">
+            <div class="summary-loading">
+              <i class="fas fa-spinner fa-spin"></i>
+              <span>Generating AI summary...</span>
             </div>
           </div>
         </div>
diff --git a/services/aiInsightsService.js b/services/aiInsightsService.js
index 249e6e6c..88be46d6 100644
--- a/services/aiInsightsService.js
+++ b/services/aiInsightsService.js
@@ -6,6 +6,7 @@ const AnalyticsCache = require('../models/AnalyticsCache');
 const notificationService = require('./notificationService');
 const mongoose = require('mongoose');
 const crypto = require('crypto');
+const tf = require('@tensorflow/tfjs-node');
 
 /**
  * Smart Budget Forecasting & AI Financial Insights Service

From 2dde215ce5098785935e02712901a03308af28ce Mon Sep 17 00:00:00 2001
From: Aditya8369 <mahajan2005aditya@gmail.com>
Date: Tue, 10 Feb 2026 11:27:31 +0530
Subject: [PATCH 2/2] Automated Expense Categorization with Machine Learning

---
 models/CategoryAnalytics.js       | 228 ++++++++++++++++++++++++++++++
 models/CategoryModel.js           |  93 ++++++++++++
 routes/categorization.js          |  60 +++++++-
 services/categorizationService.js | 144 +++++++++++++------
 4 files changed, 484 insertions(+), 41 deletions(-)
 create mode 100644 models/CategoryAnalytics.js
 create mode 100644 models/CategoryModel.js

diff --git a/models/CategoryAnalytics.js b/models/CategoryAnalytics.js
new file mode 100644
index 00000000..59592b6d
--- /dev/null
+++ b/models/CategoryAnalytics.js
@@ -0,0 +1,228 @@
+const mongoose = require('mongoose');
+
+const categoryAnalyticsSchema = new mongoose.Schema({
+    user: {
+        type: mongoose.Schema.Types.ObjectId,
+        ref: 'User',
+        required: true
+    },
+    date: {
+        type: Date,
+        default: Date.now
+    },
+    totalPredictions: {
+        type: Number,
+        default: 0
+    },
+    correctPredictions: {
+        type: Number,
+        default: 0
+    },
+    accuracy: {
+        type: Number,
+        default: 0,
+        min: 0,
+        max: 1
+    },
+    methodBreakdown: {
+        tensorflow: {
+            predictions: { type: Number, default: 0 },
+            correct: { type: Number, default: 0 },
+            accuracy: { type: Number, default: 0 }
+        },
+        pattern: {
+            predictions: { type: Number, default: 0 },
+            correct: { type: Number, default: 0 },
+            accuracy: { type: Number, default: 0 }
+        },
+        'rule-based': {
+            predictions: { type: Number, default: 0 },
+            correct: { type: Number, default: 0 },
+            accuracy: { type: Number, default: 0 }
+        }
+    },
+    categoryBreakdown: {
+        food: {
+            predictions: { type: Number, default: 0 },
+            correct: { type: Number, default: 0 },
+            accuracy: { type: Number, default: 0 }
+        },
+        transport: {
+            predictions: { type: Number, default: 0 },
+            correct: { type: Number, default: 0 },
+            accuracy: { type: Number, default: 0 }
+        },
+        entertainment: {
+            predictions: { type: Number, default: 0 },
+            correct: { type: Number, default: 0 },
+            accuracy: { type: Number, default: 0 }
+        },
+        utilities: {
+            predictions: { type: Number, default: 0 },
+            correct: { type: Number, default: 0 },
+            accuracy: { type: Number, default: 0 }
+        },
+        healthcare: {
+            predictions: { type: Number, default: 0 },
+            correct: { type: Number, default: 0 },
+            accuracy: { type: Number, default: 0 }
+        },
+        shopping: {
+            predictions: { type: Number, default: 0 },
+            correct: { type: Number, default: 0 },
+            accuracy: { type: Number, default: 0 }
+        },
+        other: {
+            predictions: { type: Number, default: 0 },
+            correct: { type: Number, default: 0 },
+            accuracy: { type: Number, default: 0 }
+        }
+    },
+    averageConfidence: {
+        type: Number,
+        default: 0
+    },
+    trainingDataUsed: {
+        type: Number,
+        default: 0
+    }
+}, {
+    timestamps: true
+});
+
+// Indexes
+categoryAnalyticsSchema.index({ user: 1, date: -1 });
+categoryAnalyticsSchema.index({ user: 1, date: 1 });
+
+// Static method to record prediction
+categoryAnalyticsSchema.statics.recordPrediction = async function(userId, prediction, actualCategory, confidence) {
+    const today = new Date();
+    today.setHours(0, 0, 0, 0);
+
+    let analytics = await this.findOne({
+        user: userId,
+        date: today
+    });
+
+    if (!analytics) {
+        analytics = new this({
+            user: userId,
+            date: today
+        });
+    }
+
+    analytics.totalPredictions += 1;
+    const isCorrect = prediction.category === actualCategory;
+    if (isCorrect) {
+        analytics.correctPredictions += 1;
+    }
+
+    // Update method breakdown
+    if (analytics.methodBreakdown[prediction.method]) {
+        analytics.methodBreakdown[prediction.method].predictions += 1;
+        if (isCorrect) {
+            analytics.methodBreakdown[prediction.method].correct += 1;
+        }
+        analytics.methodBreakdown[prediction.method].accuracy =
+            analytics.methodBreakdown[prediction.method].correct /
+            analytics.methodBreakdown[prediction.method].predictions;
+    }
+
+    // Update category breakdown
+    if (analytics.categoryBreakdown[actualCategory]) {
+        analytics.categoryBreakdown[actualCategory].predictions += 1;
+        if (isCorrect) {
+            analytics.categoryBreakdown[actualCategory].correct += 1;
+        }
+        analytics.categoryBreakdown[actualCategory].accuracy =
+            analytics.categoryBreakdown[actualCategory].correct /
+            analytics.categoryBreakdown[actualCategory].predictions;
+    }
+
+    // Update overall accuracy
+    analytics.accuracy = analytics.correctPredictions / analytics.totalPredictions;
+
+    // Update average confidence
+    analytics.averageConfidence = (
+        (analytics.averageConfidence * (analytics.totalPredictions - 1)) + confidence
+    ) / analytics.totalPredictions;
+
+    return await analytics.save();
+};
+
+// Static method to get user analytics
+categoryAnalyticsSchema.statics.getUserAnalytics = async function(userId, days = 30) {
+    const startDate = new Date();
+    startDate.setDate(startDate.getDate() - days);
+
+    const analytics = await this.find({
+        user: userId,
+        date: { $gte: startDate }
+    }).sort({ date: -1 });
+
+    if (analytics.length === 0) {
+        return {
+            totalPredictions: 0,
+            overallAccuracy: 0,
+            averageConfidence: 0,
+            methodBreakdown: {},
+            categoryBreakdown: {},
+            dailyStats: []
+        };
+    }
+
+    // Aggregate stats
+    const totalPredictions = analytics.reduce((sum, day) => sum + day.totalPredictions, 0);
+    const totalCorrect = analytics.reduce((sum, day) => sum + day.correctPredictions, 0);
+    const overallAccuracy = totalCorrect / totalPredictions;
+
+    const averageConfidence = analytics.reduce((sum, day) => sum + day.averageConfidence, 0) / analytics.length;
+
+    // Aggregate method breakdown
+    const methodBreakdown = {};
+    analytics.forEach(day => {
+        Object.keys(day.methodBreakdown).forEach(method => {
+            if (!methodBreakdown[method]) {
+                methodBreakdown[method] = { predictions: 0, correct: 0 };
+            }
+            methodBreakdown[method].predictions += day.methodBreakdown[method].predictions;
+            methodBreakdown[method].correct += day.methodBreakdown[method].correct;
+        });
+    });
+
+    Object.keys(methodBreakdown).forEach(method => {
+        methodBreakdown[method].accuracy = methodBreakdown[method].correct / methodBreakdown[method].predictions;
+    });
+
+    // Aggregate category breakdown
+    const categoryBreakdown = {};
+    analytics.forEach(day => {
+        Object.keys(day.categoryBreakdown).forEach(category => {
+            if (!categoryBreakdown[category]) {
+                categoryBreakdown[category] = { predictions: 0, correct: 0 };
+            }
+            categoryBreakdown[category].predictions += day.categoryBreakdown[category].predictions;
+            categoryBreakdown[category].correct += day.categoryBreakdown[category].correct;
+        });
+    });
+
+    Object.keys(categoryBreakdown).forEach(category => {
+        categoryBreakdown[category].accuracy = categoryBreakdown[category].correct / categoryBreakdown[category].predictions;
+    });
+
+    return {
+        totalPredictions,
+        overallAccuracy,
+        averageConfidence,
+        methodBreakdown,
+        categoryBreakdown,
+        dailyStats: analytics.map(day => ({
+            date: day.date,
+            predictions: day.totalPredictions,
+            accuracy: day.accuracy,
+            confidence: day.averageConfidence
+        }))
+    };
+};
+
+module.exports = mongoose.model('CategoryAnalytics', categoryAnalyticsSchema);
diff --git a/models/CategoryModel.js b/models/CategoryModel.js
new file mode 100644
index 00000000..d03020de
--- /dev/null
+++ b/models/CategoryModel.js
@@ -0,0 +1,93 @@
+const mongoose = require('mongoose');
+
+const categoryModelSchema = new mongoose.Schema({
+    user: {
+        type: mongoose.Schema.Types.ObjectId,
+        ref: 'User',
+        required: true
+    },
+    modelData: {
+        type: Buffer,
+        required: true
+    },
+    modelType: {
+        type: String,
+        enum: ['tensorflow', 'brainjs'],
+        default: 'tensorflow'
+    },
+    version: {
+        type: Number,
+        default: 1
+    },
+    accuracy: {
+        type: Number,
+        default: 0,
+        min: 0,
+        max: 1
+    },
+    trainingSamples: {
+        type: Number,
+        default: 0
+    },
+    lastTrained: {
+        type: Date,
+        default: Date.now
+    },
+    isActive: {
+        type: Boolean,
+        default: true
+    },
+    metadata: {
+        layers: Number,
+        inputSize: Number,
+        outputSize: Number,
+        trainingTime: Number,
+        epochs: Number
+    }
+}, {
+    timestamps: true
+});
+
+// Indexes
+categoryModelSchema.index({ user: 1, isActive: 1 });
+categoryModelSchema.index({ user: 1, version: -1 });
+
+// Static method to get active model for user
+categoryModelSchema.statics.getActiveModel = async function(userId) {
+    return await this.findOne({
+        user: userId,
+        isActive: true
+    }).sort({ version: -1 });
+};
+
+// Static method to save model
+categoryModelSchema.statics.saveModel = async function(userId, modelData, metadata = {}) {
+    // Deactivate previous models
+    await this.updateMany(
+        { user: userId, isActive: true },
+        { $set: { isActive: false } }
+    );
+
+    // Get next version
+    const lastModel = await this.findOne({ user: userId }).sort({ version: -1 });
+    const nextVersion = lastModel ? lastModel.version + 1 : 1;
+
+    const newModel = new this({
+        user: userId,
+        modelData,
+        version: nextVersion,
+        metadata,
+        lastTrained: new Date()
+    });
+
+    return await newModel.save();
+};
+
+// Static method to get model history
+categoryModelSchema.statics.getModelHistory = async function(userId, limit = 10) {
+    return await this.find({ user: userId })
+        .sort({ version: -1 })
+        .limit(limit);
+};
+
+module.exports = mongoose.model('CategoryModel', categoryModelSchema);
diff --git a/routes/categorization.js b/routes/categorization.js
index 37b5571a..93dff00f 100644
--- a/routes/categorization.js
+++ b/routes/categorization.js
@@ -217,7 +217,7 @@ router.delete('/patterns', auth, async (req, res) => {
 router.get('/stats', auth, async (req, res) => {
     try {
         const stats = await categorizationService.getUserStats(req.user._id);
-        
+
         res.json({
             success: true,
             data: stats
@@ -232,4 +232,62 @@ router.get('/stats', auth, async (req, res) => {
     }
 });
 
+/**
+ * @route   GET /api/categorization/analytics
+ * @desc    Get user's categorization analytics
+ * @access  Private
+ */
+router.get('/analytics', auth, async (req, res) => {
+    try {
+        const { days = 30 } = req.query;
+        const CategoryAnalytics = require('../models/CategoryAnalytics');
+
+        const analytics = await CategoryAnalytics.getUserAnalytics(req.user._id, parseInt(days));
+
+        res.json({
+            success: true,
+            data: analytics
+        });
+    } catch (error) {
+        console.error('Get analytics error:', error);
+        res.status(500).json({
+            success: false,
+            message: 'Error fetching analytics',
+            error: error.message
+        });
+    }
+});
+
+/**
+ * @route   POST /api/categorization/record-prediction
+ * @desc    Record a prediction result for analytics
+ * @access  Private
+ */
+router.post('/record-prediction', auth, async (req, res) => {
+    try {
+        const { prediction, actualCategory, confidence } = req.body;
+        const CategoryAnalytics = require('../models/CategoryAnalytics');
+
+        const analytics = await CategoryAnalytics.recordPrediction(
+            req.user._id,
+            prediction,
+            actualCategory,
+            confidence
+        );
+
+        res.json({
+            success: true,
+            message: 'Prediction recorded',
+            data: analytics
+        });
+    } catch (error) {
+        console.error('Record prediction error:', error);
+        res.status(500).json({
+            success: false,
+            message: 'Error recording prediction',
+            error: error.message
+        });
+    }
+});
+
 module.exports = router;
diff --git a/services/categorizationService.js b/services/categorizationService.js
index 39fd2775..72cb878f 100644
--- a/services/categorizationService.js
+++ b/services/categorizationService.js
@@ -1,17 +1,11 @@
-let brain;
-try {
-  brain = require('brain.js');
-} catch (error) {
-  console.log('Brain.js not available, using enhanced rule-based categorization');
-  brain = null;
-}
-
+const tf = require('@tensorflow/tfjs');
 const CategoryPattern = require('../models/CategoryPattern');
 const CategoryTraining = require('../models/CategoryTraining');
+const CategoryModel = require('../models/CategoryModel');
 
 class CategorizationService {
   constructor() {
-    this.networks = new Map(); // Store trained networks per user
+    this.models = new Map(); // Store trained TensorFlow models per user
     this.categories = ['food', 'transport', 'entertainment', 'utilities', 'healthcare', 'shopping', 'other'];
     this.categoryMap = {
       0: 'food',
@@ -22,7 +16,6 @@ class CategorizationService {
       5: 'shopping',
       6: 'other'
     };
-    this.brainAvailable = brain !== null;
   }
 
   // Legacy method for backward compatibility
@@ -79,9 +72,11 @@ class CategorizationService {
     return features;
   }
 
-  // Train ML model for a user
+  // Train TensorFlow ML model for a user
   async trainModel(userId) {
     try {
+      const startTime = Date.now();
+
       // Get training data
       const trainingData = await CategoryTraining.getTrainingData(userId, 5000);
 
@@ -90,53 +85,116 @@ class CategorizationService {
         return false;
       }
 
-      // Prepare training set
-      const trainingSet = trainingData.map(item => {
-        const input = this.textToFeatures(item.description, item.amount);
+      console.log(`Training TensorFlow model for user ${userId} with ${trainingData.length} samples`);
+
+      // Prepare training data
+      const inputs = [];
+      const labels = [];
+
+      trainingData.forEach(item => {
+        const features = this.textToFeatures(item.description, item.amount);
+        inputs.push(features);
+
         const output = new Array(7).fill(0);
         const categoryIndex = this.categories.indexOf(item.category);
         if (categoryIndex >= 0) {
           output[categoryIndex] = 1;
         }
-        return { input, output };
+        labels.push(output);
       });
 
-      // Create and train network
-      const net = new brain.NeuralNetwork({
-        hiddenLayers: [20, 10],
-        activation: 'sigmoid'
+      // Convert to tensors
+      const xs = tf.tensor2d(inputs);
+      const ys = tf.tensor2d(labels);
+
+      // Create model
+      const model = tf.sequential();
+      model.add(tf.layers.dense({ inputShape: [50], units: 64, activation: 'relu' }));
+      model.add(tf.layers.dropout({ rate: 0.2 }));
+      model.add(tf.layers.dense({ units: 32, activation: 'relu' }));
+      model.add(tf.layers.dropout({ rate: 0.2 }));
+      model.add(tf.layers.dense({ units: 7, activation: 'softmax' }));
+
+      // Compile model
+      model.compile({
+        optimizer: tf.train.adam(0.001),
+        loss: 'categoricalCrossentropy',
+        metrics: ['accuracy']
       });
 
-      console.log(`Training ML model for user ${userId} with ${trainingSet.length} samples`);
-      net.train(trainingSet, {
-        iterations: 2000,
-        errorThresh: 0.005,
-        log: false
+      // Train model
+      const history = await model.fit(xs, ys, {
+        epochs: 50,
+        batchSize: 32,
+        validationSplit: 0.2,
+        callbacks: {
+          onEpochEnd: (epoch, logs) => {
+            if (epoch % 10 === 0) {
+              console.log(`Epoch ${epoch}: loss = ${logs.loss.toFixed(4)}, accuracy = ${logs.acc.toFixed(4)}`);
+            }
+          }
+        }
       });
 
-      // Store trained network
-      this.networks.set(userId.toString(), net);
+      // Calculate accuracy
+      const finalAccuracy = history.history.acc[history.history.acc.length - 1];
+
+      // Save model to database
+      const modelData = await model.save(tf.io.withSaveHandler(async (artifacts) => {
+        return Buffer.from(JSON.stringify(artifacts));
+      }));
+
+      await CategoryModel.saveModel(userId, modelData, {
+        layers: 3,
+        inputSize: 50,
+        outputSize: 7,
+        trainingTime: Date.now() - startTime,
+        epochs: 50,
+        accuracy: finalAccuracy
+      });
+
+      // Store in memory for quick access
+      this.models.set(userId.toString(), model);
+
+      // Clean up tensors
+      xs.dispose();
+      ys.dispose();
 
-      console.log(`ML model trained successfully for user ${userId}`);
+      console.log(`TensorFlow model trained successfully for user ${userId} with ${finalAccuracy.toFixed(4)} accuracy`);
       return true;
     } catch (error) {
-      console.error('Error training ML model:', error);
+      console.error('Error training TensorFlow model:', error);
       return false;
     }
   }
 
-  // Predict category using ML model
+  // Predict category using TensorFlow ML model
   async predictCategory(userId, description, amount = 0) {
     const userKey = userId.toString();
 
-    // Check if we have a trained model
-    if (!this.networks.has(userKey)) {
-      // Try to load or train model
-      await this.trainModel(userId);
+    // Check if we have a trained model in memory
+    if (!this.models.has(userKey)) {
+      // Try to load from database first
+      const savedModel = await CategoryModel.getActiveModel(userId);
+      if (savedModel) {
+        try {
+          // Load model from saved data
+          const modelArtifacts = JSON.parse(savedModel.modelData.toString());
+          const model = await tf.loadLayersModel(tf.io.fromMemory(modelArtifacts));
+          this.models.set(userKey, model);
+        } catch (error) {
+          console.error('Error loading saved model:', error);
+          // Fall back to training new model
+          await this.trainModel(userId);
+        }
+      } else {
+        // Train new model
+        await this.trainModel(userId);
+      }
     }
 
-    const net = this.networks.get(userKey);
-    if (!net) {
+    const model = this.models.get(userKey);
+    if (!model) {
       // Fallback to rule-based categorization
       return {
         category: this.categorize(description),
@@ -146,27 +204,33 @@ class CategorizationService {
     }
 
     try {
-      const input = this.textToFeatures(description, amount);
-      const output = net.run(input);
+      const inputFeatures = this.textToFeatures(description, amount);
+      const inputTensor = tf.tensor2d([inputFeatures]);
+      const prediction = model.predict(inputTensor);
+      const probabilities = await prediction.data();
 
       // Find the category with highest probability
       let maxProb = 0;
       let predictedIndex = 6; // default to 'other'
 
-      output.forEach((prob, index) => {
+      probabilities.forEach((prob, index) => {
         if (prob > maxProb) {
           maxProb = prob;
           predictedIndex = index;
         }
       });
 
+      // Clean up tensors
+      inputTensor.dispose();
+      prediction.dispose();
+
       return {
         category: this.categoryMap[predictedIndex],
         confidence: maxProb,
-        method: 'ml'
+        method: 'tensorflow'
       };
     } catch (error) {
-      console.error('Error predicting category:', error);
+      console.error('Error predicting category with TensorFlow:', error);
       return {
         category: this.categorize(description),
         confidence: 0.5,