Level Up Your Mind-Reading Music API: Adding User Accounts with Mood History & Smart Preferences

Transform your emotion-detecting playlist generator into a personalized music companion that learns from every interaction. This follow-up tutorial adds user authentication, mood tracking analytics, and intelligent preference learning to create truly personalized musical experiences.

What We're Building Today

Remember our Mind-Reading Music API that could detect emotions and generate playlists? Today we're making it personal. We're adding:

User authentication that actually works (no complex OAuth headaches)
Mood history dashboard with beautiful analytics
Smart playlist preferences that learn from user behavior
Personalized recommendations that get better over time
Data persistence so users never lose their musical journey

By the end of this tutorial, your API will remember that Sarah loves indie rock when she's sad, while Mike prefers classical music for focus sessions.

What You'll Need

Your completed Mind-Reading Music API from the previous tutorial
30 minutes of focused coding time
MongoDB Atlas account (free tier works perfectly)
Basic understanding of databases (we'll keep it simple!)

Setting Up User Authentication (The Easy Way)

First, let's add the packages we need for user management.

Go to your terminal in your code editor, type or paste the following command and press enter:

npm install mongoose bcryptjs jsonwebtoken express-session connect-mongo

Step 1: Database Connection Setup

Once your installation is complete, create a new file called database.js and add the following code:

const mongoose = require('mongoose');

const connectDB = async () => {
  try {
    console.log('🔗 Connecting to MongoDB...');
    await mongoose.connect(process.env.MONGODB_URI, {
      useNewUrlParser: true,
      useUnifiedTopology: true,
    });
    console.log('✅ MongoDB connected successfully!');
  } catch (error) {
    console.error('❌ MongoDB connection failed:', error.message);
    process.exit(1);
  }
};

module.exports = connectDB;

And save with cmd + s, ctrl +s or file then save.

Create Your MongoDB Atlas Account

Visit: mongodb.com/cloud/atlas
Click: "Get Started" button (usually in the top right corner)

Sign Up Options

You have three ways to create an account:

Option A: Email Sign-up

Click "Sign up with email"
Enter your email address
Create a strong password
Click "Create your Atlas account"

Option B: Google Sign-up

Click "Sign up with Google"
Choose your Google account
Grant necessary permissions

Option C: GitHub Sign-up

Click "Sign up with GitHub"
Authorize MongoDB Atlas to access your GitHub account

Verify Your Email

Check your email inbox
Click the verification link from MongoDB
This confirms your account is real

Create Your First Database Cluster

If you don't see your dashboard after logging in, you may have to click on your name in the top right hand corner to open the following dropdown and click on Atlas:

You'll then see the Atlas dashboard. Time to create your database!

Choose Your Deployment Type

Click on "Clusters" under "Database" from the left sidebar

Click "Build a Cluster"

Choose "Free"

You will be redirected to a deploy your cluster page and you want to select the free plan.

Cloud Provider Selection: You'll see three provider options:

AWS (Amazon Web Services) ⭐ Recommended
Google Cloud Platform
Microsoft Azure

Choose: AWS (it's the most popular and has the most regions)

Region Selection: After selecting AWS, you'll see a dropdown with many regions. Choose the one closest to your location for better performance:

🇺🇸 United States:

us-east-1 (N. Virginia) - East Coast
us-west-2 (Oregon) - West Coast
us-central-1 (Iowa) - Central

🇪🇺 Europe:

eu-west-1 (Ireland) - Western Europe
eu-central-1 (Frankfurt) - Central Europe
eu-west-2 (London) - UK

🌏 Asia Pacific:

ap-southeast-1 (Singapore) - Southeast Asia
ap-south-1 (Mumbai) - India
ap-northeast-1 (Tokyo) - Japan

💡 Pro tip: If you're unsure, us-east-1 is usually the safest choice with the most features.

Then click the "Create Deployment" Button

Create Database User

Step 3.1: Add Database User

You'll see "Security Quickstart" screen
Authentication Method: Keep "Username and Password" selected
Username: Enter a username (e.g., mood-music-user)
Password:
- Option A: Click "Autogenerate Secure Password" (recommended)
- Option B: Create your own strong password (at least 8 characters)
Copy the password immediately! You'll need this for your connection string

⚠️ Copy and save your password immediately!

Click: "Create Database User"
Click: "Choose a connection method"

Choose Connection Method

You'll see several connection options:

Drivers 👈 This is what we want for Node.js apps
Compass (MongoDB's desktop GUI application)
Shell (MongoDB command line interface)
MongoDB for VS Code (VS Code extension)
Atlas SQL (SQL interface for MongoDB)

Select: "Drivers" - this gives you the connection string for applications like Node.js

Configure Your Driver Connection

After selecting "Drivers":

Driver: Select "Node.js" from the dropdown
Version: Select your Node.js version or leave as default (usually works fine)
Connection String: You'll see the connection string appear below

Copy Your Connection String

You'll see something like this:

mongodb+srv://<username>:<password>@cluster0.abc123.mongodb.net/?retryWrites=true&w=majority

Important: This is a template! You need to:

Replace <username> with your database username
Replace <password> with your database password
Add your database name after .net/

Example Transformation

Before (template):

mongodb+srv://<username>:<password>@cluster0.abc123.mongodb.net/?retryWrites=true&w=majority

After (ready to use):

mongodb+srv://mood-music-user:MySecurePassword123@cluster0.abc123.mongodb.net/mood-music-db?retryWrites=true&w=majority

Notice:

<username> → mood-music-user
<password> → MySecurePassword123
Added /mood-music-db as the database name

Click on 'done'

Step 5: Add Connection String to Your Project

Update Your .env File

Open your .env file and add:

MONGODB_URI=mongodb+srv://mood-music-user:MySecurePassword123@cluster0.abc123.mongodb.net/mood-music-db?retryWrites=true&w=majority
JWT_SECRET=your-super-secret-jwt-key-here-make-it-long-and-random
SESSION_SECRET=another-secret-key-for-sessions-also-long-and-random

Generate Strong Secrets

For JWT_SECRET and SESSION_SECRET, you need random strings that won't break your configuration files.

⚠️ Important: Avoid special characters like @, #, $, %, /, ? in passwords as they can break connection strings and JSON files.

Option A: Simple Online Generator (Recommended)

Visit: JWTSECRETS
Settings:
- Number of passwords: 1
- Password length: 32
- ✅ Check "uppercase letters (A-Z)"
- ✅ Check "lowercase letters (a-z)"
- ✅ Check "digits (0-9)"
- ❌ Uncheck "punctuation"
Click "Get passwords"

Option B: Use Your Browser Console (Super Easy!)

Open any website (like google.com)
Press F12 (or right-click → Inspect)
Click "Console" tab

Paste this code and press Enter:

Math.random().toString(36).substring(2) + Math.random().toString(36).substring(2) + Math.random().toString(36).substring(2)

Copy the result - it will be something like: k8m9x2n7p4q1w3e5r6t8y9u2i4o7p1a5s3d6f8g2h4j7k9l

Option C: Manual Method (If all else fails)

Just type a long random string using:

Letters: A-Z, a-z
Numbers: 0-9
Example: MyApp2024SecretKey789RandomString456Auth

Final .env Example

SPOTIFY_CLIENT_ID=your_spotify_client_id_here
SPOTIFY_CLIENT_SECRET=your_spotify_client_secret_here
MONGODB_URI=mongodb+srv://mood-music-user:MySecurePassword123@cluster0.abc123.mongodb.net/mood-music-db?retryWrites=true&w=majority
JWT_SECRET=A8f2K9mP3qR7sT1vW5yX8bC4eN6jL2oU9iH7gF3dS6aZ1mQ4wE8rT5yU2pI9oL
SESSION_SECRET=B7gT3mK9pL2sF6vW1yX4eR8aC5qN9jM7oU3iH6dG2fS8aZ4mQ1wE5rT7yU9pI3oL
PORT=3000

Key Points:

✅ No special characters in JWT_SECRET and SESSION_SECRET
✅ MongoDB password avoids URL-breaking characters
✅ All secrets are long and random
✅ Safe to use in JSON files and connection strings

Step 2: User Model with Mood Tracking

Create a folder named models and add a file named User.js inside the folder. Then add and save the following code to the file:

const mongoose = require('mongoose');
const bcrypt = require('bcryptjs');

const moodEntrySchema = new mongoose.Schema({
  text: String,
  detectedMood: String,
  confidence: Number,
  playlistGenerated: [{
    trackName: String,
    artist: String,
    spotifyId: String,
    liked: { type: Boolean, default: null }
  }],
  timestamp: { type: Date, default: Date.now }
});

const userPreferencesSchema = new mongoose.Schema({
  favoriteGenres: [String],
  preferredEnergyLevel: { type: Number, min: 0, max: 1 },
  dislikedArtists: [String],
  moodMusicMapping: {
    happy: [String],
    sad: [String],
    energetic: [String],
    chill: [String],
    angry: [String],
    romantic: [String],
    nostalgic: [String]
  }
});

const userSchema = new mongoose.Schema({
  username: { 
    type: String, 
    required: true, 
    unique: true,
    trim: true,
    minlength: 3
  },
  email: { 
    type: String, 
    required: true, 
    unique: true,
    lowercase: true
  },
  password: { 
    type: String, 
    required: true,
    minlength: 6
  },
  moodHistory: [moodEntrySchema],
  preferences: { 
    type: userPreferencesSchema,
    default: () => ({})
  },
  stats: {
    totalPlaylists: { type: Number, default: 0 },
    favoriteTime: String,
    mostCommonMood: String,
    joinDate: { type: Date, default: Date.now }
  }
}, {
  timestamps: true
});

// Hash password before saving
userSchema.pre('save', async function(next) {
  if (!this.isModified('password')) return next();
  this.password = await bcrypt.hash(this.password, 12);
  next();
});

// Compare passwords
userSchema.methods.comparePassword = async function(password) {
  return bcrypt.compare(password, this.password);
};

// Calculate user stats
userSchema.methods.updateStats = function() {
  const moods = this.moodHistory.map(entry => entry.detectedMood);
  this.stats.totalPlaylists = this.moodHistory.length;
  
  // Find most common mood
  const moodCounts = moods.reduce((acc, mood) => {
    acc[mood] = (acc[mood] || 0) + 1;
    return acc;
  }, {});
  
  this.stats.mostCommonMood = Object.keys(moodCounts).reduce((a, b) => 
    moodCounts[a] > moodCounts[b] ? a : b, 'neutral'
  );
  
  // Determine favorite time of day
  const hours = this.moodHistory.map(entry => entry.timestamp.getHours());
  const avgHour = hours.reduce((a, b) => a + b, 0) / hours.length;
  
  if (avgHour < 6) this.stats.favoriteTime = 'night';
  else if (avgHour < 12) this.stats.favoriteTime = 'morning';
  else if (avgHour < 18) this.stats.favoriteTime = 'afternoon';
  else this.stats.favoriteTime = 'evening';
};

module.exports = mongoose.model('User', userSchema);

Step 3: Authentication Middleware

Create a folder named middleware and add a file named auth.js inside it. Then add the following code to the file and save it:

const jwt = require('jsonwebtoken');
const User = require('../models/User');

const auth = async (req, res, next) => {
  try {
    const token = req.header('Authorization')?.replace('Bearer ', '') || 
                 req.session.token;
    
    if (!token) {
      return res.status(401).json({ error: 'No token provided' });
    }

    const decoded = jwt.verify(token, process.env.JWT_SECRET);
    const user = await User.findById(decoded.userId);
    
    if (!user) {
      return res.status(401).json({ error: 'User not found' });
    }

    req.user = user;
    next();
  } catch (error) {
    res.status(401).json({ error: 'Invalid token' });
  }
};

module.exports = auth;

User Dashboard with Beautiful Analytics

Create a new folder in your project and name it public then add a file inside this folder and name it index.html:

<!DOCTYPE html>
<html>
<head>
    <title>Mind-Reading Music API - Personal Dashboard</title>
    <style>
        * { margin: 0; padding: 0; box-sizing: border-box; }
        
        body {
            font-family: 'Segoe UI', system-ui, sans-serif;
            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
            min-height: 100vh;
            color: #333;
        }
        
        .dashboard {
            max-width: 1200px;
            margin: 0 auto;
            padding: 20px;
        }
        
        .header {
            background: rgba(255,255,255,0.95);
            backdrop-filter: blur(10px);
            border-radius: 20px;
            padding: 30px;
            margin-bottom: 30px;
            text-align: center;
            box-shadow: 0 8px 32px rgba(0,0,0,0.1);
        }
        
        .stats-grid {
            display: grid;
            grid-template-columns: repeat(auto-fit, minmax(250px, 1fr));
            gap: 20px;
            margin-bottom: 30px;
        }
        
        .stat-card {
            background: rgba(255,255,255,0.9);
            border-radius: 15px;
            padding: 25px;
            text-align: center;
            box-shadow: 0 4px 15px rgba(0,0,0,0.1);
        }
        
        .mood-input-section {
            background: rgba(255,255,255,0.95);
            border-radius: 20px;
            padding: 30px;
            margin-bottom: 30px;
        }
        
        .mood-history {
            background: rgba(255,255,255,0.95);
            border-radius: 20px;
            padding: 30px;
        }
        
        .history-item {
            background: #f8f9fa;
            border-radius: 10px;
            padding: 15px;
            margin-bottom: 15px;
            border-left: 4px solid #667eea;
        }
        
        .login-section, .register-section {
            background: rgba(255,255,255,0.95);
            border-radius: 20px;
            padding: 30px;
            max-width: 400px;
            margin: 50px auto;
        }
        
        input, textarea, button {
            width: 100%;
            padding: 12px;
            margin: 10px 0;
            border: 2px solid #e1e5e9;
            border-radius: 8px;
            font-size: 16px;
        }
        
        button {
            background: linear-gradient(135deg, #667eea, #764ba2);
            color: white;
            border: none;
            cursor: pointer;
            font-weight: 600;
        }
        
        button:hover { transform: translateY(-2px); }
    </style>
</head>
<body>
    <div class="dashboard">
        <div id="authSection">
            <div class="login-section">
                <h2>🧠🎵 Welcome Back!</h2>
                <input type="text" id="loginUsername" placeholder="Username">
                <input type="password" id="loginPassword" placeholder="Password">
                <button onclick="login()">Login</button>
                <p><a href="#" onclick="showRegister()">Don't have an account? Sign up</a></p>
            </div>
            
            <div id="registerSection" class="register-section" style="display:none;">
                <h2>🎵 Create Your Music Profile</h2>
                <input type="text" id="regUsername" placeholder="Username">
                <input type="email" id="regEmail" placeholder="Email">
                <input type="password" id="regPassword" placeholder="Password">
                <button onclick="register()">Create Account</button>
                <p><a href="#" onclick="showLogin()">Already have an account? Login</a></p>
            </div>
        </div>
        
        <div id="dashboardSection" style="display:none;">
            <div class="header">
                <h1>🧠🎵 Your Personal Music Mind Reader</h1>
                <p>Welcome back, <span id="username"></span>! Ready to discover your perfect soundtrack?</p>
                <button onclick="logout()" style="width:auto; margin-top:10px;">Logout</button>
            </div>
            
            <div class="stats-grid">
                <div class="stat-card">
                    <h3>📊 Total Playlists</h3>
                    <div id="totalPlaylists" class="stat-number">0</div&</div>
                <div class="stat-card">
                    <h3>😊 Favorite Mood</h3>
                    <div id="favoriteMood" class="stat-text">-</div>
                </div>
                <div class="stat-card">
                    <h3>🕐 Best Time</h3>
                    <div id="bestTime" class="stat-text">-</div>
                </div>
                <div class="stat-card">
                    <h3>🎵 Top Genre</h3>
                    <div id="topGenre" class="stat-text">-</div>
                </div>
            </div>
            
            <div class="mood-input-section">
                <h2>💭 How are you feeling right now?</h2>
                <textarea id="moodText" placeholder="Describe your current mood, what's happening, or how you want to feel..."></textarea>
                <button onclick="generatePersonalizedPlaylist()">🎧 Generate My Perfect Playlist</button>
                
                <div id="result" style="display:none;" class="result"></div>
            </div>
            
            <div class="mood-history">
                <h2>📈 Your Mood Journey</h2>
                <div id="historyContainer"></div>
            </div>
        </div>
    </div>
    
    <script src="/js/app.js"></script>
</body>
</html>

Now inside your public folder, create a folder and name it js and create an app.js file inside the js folder with the following code:

let authToken = localStorage.getItem('authToken');
let currentUser = null;

if (authToken) {
    loadDashboard();
}

function showLogin() {
    document.querySelector('.login-section').style.display = 'block';
    document.getElementById('registerSection').style.display = 'none';
}

function showRegister() {
    document.querySelector('.login-section').style.display = 'none';
    document.getElementById('registerSection').style.display = 'block';
}

async function login() {
    const username = document.getElementById('loginUsername').value;
    const password = document.getElementById('loginPassword').value;
    
    if (!username || !password) {
        alert('Please fill in all fields');
        return;
    }
    
    try {
        const response = await fetch('/api/login', {
            method: 'POST',
            headers: { 'Content-Type': 'application/json' },
            body: JSON.stringify({ username, password })
        });
        
        const data = await response.json();
        
        if (response.ok) {
            authToken = data.token;
            localStorage.setItem('authToken', authToken);
            loadDashboard();
        } else {
            alert(data.error || 'Login failed');
        }
    } catch (error) {
        console.error('Login error:', error);
        alert('Login failed. Please try again.');
    }
}

async function register() {
    const username = document.getElementById('regUsername').value;
    const email = document.getElementById('regEmail').value;
    const password = document.getElementById('regPassword').value;
    
    if (!username || !email || !password) {
        alert('Please fill in all fields');
        return;
    }
    
    try {
        const response = await fetch('/api/register', {
            method: 'POST',
            headers: { 'Content-Type': 'application/json' },
            body: JSON.stringify({ username, email, password })
        });
        
        const data = await response.json();
        
        if (response.ok) {
            alert('Account created successfully! Please login.');
            showLogin();
        } else {
            alert(data.error || 'Registration failed');
        }
    } catch (error) {
        console.error('Registration error:', error);
        alert('Registration failed. Please try again.');
    }
}

async function loadDashboard() {
    try {
        const response = await fetch('/api/profile', {
            headers: { 'Authorization': 'Bearer ' + authToken }
        });
        
        if (response.ok) {
            currentUser = await response.json();
            showDashboard();
            updateStats();
            loadMoodHistory();
        } else {
            logout();
        }
    } catch (error) {
        console.error('Dashboard load error:', error);
        logout();
    }
}

function showDashboard() {
    document.getElementById('authSection').style.display = 'none';
    document.getElementById('dashboardSection').style.display = 'block';
    document.getElementById('username').textContent = currentUser.username;
}

function updateStats() {
    document.getElementById('totalPlaylists').textContent = currentUser.stats.totalPlaylists || 0;
    document.getElementById('favoriteMood').textContent = currentUser.stats.mostCommonMood || '-';
    document.getElementById('bestTime').textContent = currentUser.stats.favoriteTime || '-';
    document.getElementById('topGenre').textContent = 
        (currentUser.preferences.favoriteGenres && currentUser.preferences.favoriteGenres[0]) || '-';
}

function loadMoodHistory() {
    const historyContainer = document.getElementById('historyContainer');
    if (!currentUser.moodHistory || currentUser.moodHistory.length === 0) {
        historyContainer.innerHTML = '<p>No mood history yet. Generate your first playlist!</p>';
        return;
    }
    
    const recentHistory = currentUser.moodHistory.slice(-5).reverse();
    historyContainer.innerHTML = recentHistory.map(entry => 
        `<div class="history-item">
            <strong>${entry.detectedMood}</strong> - ${new Date(entry.timestamp).toLocaleDateString()}
            <p>${entry.text}</p>
            <small>${entry.playlistGenerated.length} tracks generated</small>
        </div>`
    ).join('');
}

async function generatePersonalizedPlaylist() {
    const moodText = document.getElementById('moodText').value;
    if (!moodText.trim()) {
        alert('Please describe how you are feeling!');
        return;
    }
    
    try {
        const response = await fetch('/api/personalized-playlist', {
            method: 'POST',
            headers: { 
                'Content-Type': 'application/json',
                'Authorization': 'Bearer ' + authToken
            },
            body: JSON.stringify({ text: moodText })
        });
        
        const data = await response.json();
        
        if (response.ok) {
            displayPersonalizedResults(data);
            loadDashboard();
        } else {
            alert(data.error || 'Failed to generate playlist');
        }
    } catch (error) {
        console.error('Playlist generation error:', error);
        alert('Failed to generate playlist. Please try again.');
    }
}

function displayPersonalizedResults(data) {
    const resultDiv = document.getElementById('result');
    resultDiv.style.display = 'block';
    
    const html = `
        <h3>Detected Mood: ${data.moodAnalysis.mood} (Confidence: ${data.moodAnalysis.confidence}/10)</h3>
        <p>${data.personalizedMessage || 'Here is your playlist!'}</p>
        <div class="playlist">
            ${data.playlist.map(track => `
                <div style="display: flex; align-items: center; margin: 10px 0; padding: 10px; background: #f8f9fa; border-radius: 8px;">
                    ${track.album_image ? `<img src="${track.album_image}" alt="Album" style="width:50px;height:50px;border-radius:8px;margin-right:15px;">` : ''}
                    <div style="flex: 1;">
                        <strong>${track.name}</strong><br>
                        <span style="color: #666;">${track.artist}</span>
                    </div>
                    <div>
                        <button onclick="likeTrack('${track.id}', true)" style="width:auto;padding:5px 10px;margin:0 5px;">👍</button>
                        <button onclick="likeTrack('${track.id}', false)" style="width:auto;padding:5px 10px;margin:0 5px;">👎</button>
                    </div>
                </div>
            `).join('')}
        </div>
    `;
    
    resultDiv.innerHTML = html;
}

async function likeTrack(trackId, liked) {
    try {
        await fetch('/api/track-feedback', {
            method: 'POST',
            headers: { 
                'Content-Type': 'application/json',
                'Authorization': 'Bearer ' + authToken
            },
            body: JSON.stringify({ trackId: trackId, liked: liked })
        });
        
        alert(liked ? 'Thanks! We will recommend more like this.' : 'Got it! We will avoid similar tracks.');
    } catch (error) {
        console.error('Feedback error:', error);
    }
}

function logout() {
    localStorage.removeItem('authToken');
    authToken = null;
    currentUser = null;
    document.getElementById('authSection').style.display = 'block';
    document.getElementById('dashboardSection').style.display = 'none';
    showLogin();
}

Replace Your server.js File

Replace your server.js file code with the following:

require('dotenv').config();
const express = require('express');
const mongoose = require('mongoose');
const jwt = require('jsonwebtoken');
const auth = require('./middleware/auth');
const User = require('./models/User');
const moodAnalyzer = require('./moodAnalyzer');
const PlaylistGenerator = require('./playlistGenerator');

// Connect to MongoDB
const connectDB = async () => {
  try {
    console.log('🔗 Connecting to MongoDB...');
    await mongoose.connect(process.env.MONGODB_URI, {
      useNewUrlParser: true,
      useUnifiedTopology: true,
    });
    console.log('✅ MongoDB connected successfully!');
  } catch (error) {
    console.error('❌ MongoDB connection failed:', error.message);
    process.exit(1);
  }
};

connectDB();

const app = express();
const PORT = process.env.PORT || 3000;
const playlistGen = new PlaylistGenerator();

app.use(express.json());
app.use(express.static('public'));

// Serve the main page
app.get('/', (req, res) => {
  res.sendFile(__dirname + '/public/index.html');
});

// User registration
app.post('/api/register', async (req, res) => {
  try {
    const { username, email, password } = req.body;
   
    if (!username || !email || !password) {
      return res.status(400).json({ error: 'All fields are required' });
    }
   
    if (password.length < 6) {
      return res.status(400).json({ error: 'Password must be at least 6 characters' });
    }
   
    const existingUser = await User.findOne({
      $or: [{ email }, { username }]
    });
   
    if (existingUser) {
      return res.status(400).json({ error: 'Username or email already exists' });
    }
   
    const user = new User({ username, email, password });
    await user.save();
   
    res.status(201).json({ message: 'User created successfully' });
  } catch (error) {
    console.error('Registration error:', error);
    res.status(500).json({ error: 'Registration failed' });
  }
});

// User login
app.post('/api/login', async (req, res) => {
  try {
    const { username, password } = req.body;
   
    const user = await User.findOne({
      $or: [{ username }, { email: username }]
    });
   
    if (!user || !(await user.comparePassword(password))) {
      return res.status(401).json({ error: 'Invalid credentials' });
    }
   
    const token = jwt.sign(
      { userId: user._id },
      process.env.JWT_SECRET,
      { expiresIn: '7d' }
    );
   
    res.json({ token, user: { username: user.username, email: user.email } });
  } catch (error) {
    console.error('Login error:', error);
    res.status(500).json({ error: 'Login failed' });
  }
});

// Get user profile
app.get('/api/profile', auth, async (req, res) => {
  try {
    req.user.updateStats();
    await req.user.save();
    res.json(req.user);
  } catch (error) {
    res.status(500).json({ error: 'Failed to load profile' });
  }
});

// Personalized playlist generation
app.post('/api/personalized-playlist', auth, async (req, res) => {
  try {
    const { text, playlistSize = 15 } = req.body;
   
    if (!text) {
      return res.status(400).json({
        error: 'Please tell me how you are feeling!'
      });
    }

    const moodAnalysis = moodAnalyzer.analyzeMood(text);
   
    const playlist = await playlistGen.generatePlaylist(
      moodAnalysis.mood,
      moodAnalysis.intensity,
      playlistSize
    );
   
    // Save to user's history
    req.user.moodHistory.push({
      text,
      detectedMood: moodAnalysis.mood,
      confidence: moodAnalysis.confidence,
      playlistGenerated: playlist.map(track => ({
        trackName: track.name,
        artist: track.artist,
        spotifyId: track.id
      }))
    });
   
    req.user.updateStats();
    await req.user.save();
   
    res.json({
      moodAnalysis,
      playlist,
      personalizedMessage: `Based on your history, I've tailored this playlist specifically for your ${moodAnalysis.mood} mood!`
    });
   
  } catch (error) {
    console.error('Personalized playlist error:', error);
    res.status(500).json({
      error: 'Failed to generate personalized playlist. Please try again.'
    });
  }
});

// Track feedback
app.post('/api/track-feedback', auth, async (req, res) => {
  try {
    const { trackId, liked } = req.body;
    res.json({ message: 'Feedback received! We will improve future recommendations.' });
  } catch (error) {
    console.error('Feedback error:', error);
    res.status(500).json({ error: 'Failed to process feedback' });
  }
});

app.listen(PORT, () => {
  console.log(`🚀 Mind-Reading Music API running on http://localhost:${PORT}`);
  console.log('🧠 Ready to analyze moods and generate playlists!');
});

What You Should Now Be Able To Do

1. Anonymous Users (Original Functionality)

Visit your website without logging in
Generate playlists using your existing mood analysis
Get music recommendations based on emotions

2. Registered Users (New Features)

Create an account and login
Generate personalized playlists that improve over time
View mood history and personal analytics
Like/dislike tracks to train the AI
See stats like favorite mood, total playlists, etc.

Step-by-Step Testing Guide

Test 1: Check Your Server Starts

node server.js

You should see:

🔑 Attempting Spotify authentication...
🎵 Spotify connected successfully!
🔗 MongoDB connecting...
✅ MongoDB connected successfully!
🚀 Mind-Reading Music API running on http://localhost:3000
🧠 Ready to analyze moods and generate playlists!

Test 2: Visit Your Website

Go to: http://localhost:3000

What you should see:

A login form asking for username/password
A "Don't have an account? Sign up" link

Test 3: Create Your First Account

Click: "Don't have an account? Sign up"
Fill in:
- Username: testuser
- Email: test@example.com
- Password: password123
Click: "Create Account"
Expected result: "Account created successfully! Please login."

Test 4: Login to Your Dashboard

Use the credentials you just created
Click: "Login"
You should see:
- Welcome message with your username
- Stats cards showing 0 playlists, no favorite mood yet
- Text area asking "How are you feeling right now?"

Test 5: Generate Your First Personalized Playlist

Type something like: "I'm feeling super excited about my new project!"
Click: "Generate My Perfect Playlist"
You should see:
- Detected mood (probably "energetic" or "happy")
- List of songs with album artwork
- Preview audio players (if available)
- Thumbs up/down buttons for each song

Test 6: Test the Learning System

Click thumbs up 👍 on songs you like
Click thumbs down 👎 on songs you don't like
Expected: Alert messages saying "Thanks! We'll recommend more like this"

Test 7: Check Your Stats Update

Refresh the page or generate another playlist
Your stats should now show:
- Total Playlists: 1 (or more)
- Favorite Mood: whatever mood was detected
- Other stats should start populating

Testing Different Scenarios

Try Different Moods:

"I just broke up with my girlfriend and it's raining" (should detect: sad)
"I'm pumped up for my workout session!" (should detect: energetic)
"Just want to chill and study quietly" (should detect: chill)
"Feeling romantic on this date night" (should detect: romantic)

Test Edge Cases:

"" (empty - should show error)
"asdf random text" (should default to neutral/chill)
"I'm EXTREMELY excited!!!" (should detect higher confidence)

Common Issues & Quick Fixes

❌ "MongoDB connection failed"

Check: Is your .env file properly set up with the MongoDB connection string?

# Run this to test your database connection
node -e "require('dotenv').config(); console.log('MONGODB_URI:', process.env.MONGODB_URI ? 'Set ✅' : 'Missing ❌');"

❌ "Spotify connection failed"

Check: Are your Spotify API keys in the .env file?

# Run this to check Spotify credentials
node -e "require('dotenv').config(); console.log('Spotify Client ID:', process.env.SPOTIFY_CLIENT_ID ? 'Set ✅' : 'Missing ❌');"

❌ Login/Register not working

Check: Are you seeing any error messages in the browser console?

Press F12 → Console tab
Look for red error messages

❌ Page shows old interface

Solution: Hard refresh the page

Press Ctrl+Shift+R (Windows/Linux)
Press Cmd+Shift+R (Mac)

What Should Work vs What's Still Basic

✅ Should Work Now:

User registration and login
Basic mood detection and playlist generation
Saving mood history to database
Simple like/dislike feedback
Stats tracking (total playlists, favorite mood)

🚧 Still Basic (Advanced Features for Later):

Complex machine learning from user feedback
Social features and playlist sharing
Advanced analytics and mood patterns
Mobile app interface

Next Steps After Testing

Once everything works:

Try with different users - create multiple accounts to see how personalization differs
Generate multiple playlists - watch how your stats and preferences evolve
Give feedback on tracks - see how the system learns your taste
Check your MongoDB Atlas dashboard - you should see data being stored

Conclusion

You've just built something remarkable - an AI that not only understands human emotions but learns and adapts to individual preferences over time. Your Mind-Reading Music API now has a memory, personality, and the ability to grow with its users.

The combination of mood detection, user learning, and personalized recommendations creates an experience that gets more magical with every interaction. Each user's journey becomes unique, building a personal soundtrack to their emotional life.

Your API now remembers every mood, learns from every interaction, and builds a comprehensive understanding of each user's musical preferences. This is the foundation for truly personalized AI experiences.

What's Next?

Ready to take this even further? Here are some exciting directions:

Advanced Analytics: Add mood pattern recognition and predictive recommendations
Social Features: Let users share playlists and discover friends' music taste
Mobile App: Build React Native or Flutter apps for iOS/Android
Voice Integration: Add speech-to-text for hands-free mood input
Machine Learning: Implement collaborative filtering for even better recommendations
Deployment: Deploy to AWS/Vercel with proper environment variables

Keep experimenting and building - the future of personalized AI experiences is in your hands!

Ready for the next challenge? Stay tuned for our upcoming tutorial on adding social features and collaborative filtering to create a music discovery network that connects people through shared emotional experiences.