Discord AI Bot with Voice Commands: Complete 2025 Tutorial

// 1. Go to https://discord.com/developers/applications
// 2. Click "New Application" and give it a name
// 3. Go to "Bot" section and click "Add Bot"
// 4. Copy the bot token (keep it secret!)
// 5. Enable these Privileged Gateway Intents:
//    - Message Content Intent
//    - Server Members Intent

mkdir discord-voice-ai-bot
cd discord-voice-ai-bot
npm init -y

# Install dependencies
npm install discord.js @discordjs/voice
npm install openai axios
npm install @discordjs/opus libsodium-wrappers
npm install prism-media ffmpeg-static

const { Client, GatewayIntentBits } = require('discord.js');
const { 
    joinVoiceChannel, 
    createAudioPlayer, 
    createAudioResource,
    AudioPlayerStatus,
    EndBehaviorType
} = require('@discordjs/voice');
const OpenAI = require('openai');
const fs = require('fs');

class VoiceAIBot {
    constructor() {
        this.client = new Client({
            intents: [
                GatewayIntentBits.Guilds,
                GatewayIntentBits.GuildMessages,
                GatewayIntentBits.GuildVoiceStates,
                GatewayIntentBits.MessageContent
            ]
        });
        
        this.openai = new OpenAI({
            apiKey: process.env.OPENAI_API_KEY
        });
        
        this.connections = new Map();
        this.conversations = new Map();
        
        this.setupEventHandlers();
    }
    
    setupEventHandlers() {
        this.client.on('ready', () => {
            console.log(`🤖 ${this.client.user.tag} is ready!`);
        });
        
        this.client.on('messageCreate', async (message) => {
            if (message.content === '!join' && message.member?.voice?.channel) {
                await this.joinVoiceChannel(message);
            }
            
            if (message.content === '!leave') {
                await this.leaveVoiceChannel(message);
            }
        });
    }
    
    async joinVoiceChannel(message) {
        const channel = message.member.voice.channel;
        
        try {
            const connection = joinVoiceChannel({
                channelId: channel.id,
                guildId: message.guild.id,
                adapterCreator: message.guild.voiceAdapterCreator,
                selfDeaf: false,
                selfMute: false
            });
            
            this.connections.set(message.guild.id, connection);
            this.setupVoiceReceiver(connection, message.channel);
            
            message.reply('🎤 I\'m now listening for voice commands!');
            
        } catch (error) {
            console.error('Error joining voice channel:', error);
            message.reply('Failed to join voice channel.');
        }
    }
    
    async processVoiceInput(audioStream, userId, textChannel) {
        try {
            const audioBuffer = await this.streamToBuffer(audioStream);
            if (audioBuffer.length < 1000) return;
            
            const tempFile = `temp_${Date.now()}.wav`;
            fs.writeFileSync(tempFile, audioBuffer);
            
            const transcription = await this.openai.audio.transcriptions.create({
                file: fs.createReadStream(tempFile),
                model: 'whisper-1',
                language: 'en'
            });
            
            fs.unlinkSync(tempFile);
            
            const text = transcription.text.trim();
            if (text.length < 3) return;
            
            const response = await this.generateAIResponse(text, userId);
            textChannel.send(`🗣️ **Heard:** ${text}\n🤖 **Response:** ${response}`);
            
        } catch (error) {
            console.error('Error processing voice:', error);
        }
    }
    
    async generateAIResponse(message, userId) {
        try {
            let conversation = this.conversations.get(userId) || [];
            conversation.push({ role: 'user', content: message });
            
            if (conversation.length > 10) {
                conversation = conversation.slice(-10);
            }
            
            const completion = await this.openai.chat.completions.create({
                model: 'gpt-4',
                messages: [
                    {
                        role: 'system',
                        content: 'You are a helpful AI assistant in a Discord voice channel. Keep responses conversational and under 100 words.'
                    },
                    ...conversation
                ],
                max_tokens: 150,
                temperature: 0.7
            });
            
            const response = completion.choices[0].message.content;
            conversation.push({ role: 'assistant', content: response });
            this.conversations.set(userId, conversation);
            
            return response;
            
        } catch (error) {
            return 'Sorry, I had trouble processing that.';
        }
    }
    
    start() {
        this.client.login(process.env.DISCORD_TOKEN);
    }
}

const bot = new VoiceAIBot();
bot.start();

DISCORD_TOKEN=your_discord_bot_token_here
OPENAI_API_KEY=your_openai_api_key_here

async generateSpeech(text) {
    try {
        const response = await this.openai.audio.speech.create({
            model: 'tts-1',
            voice: 'nova',
            input: text.substring(0, 300)
        });
        
        const buffer = Buffer.from(await response.arrayBuffer());
        const filename = `speech_${Date.now()}.mp3`;
        fs.writeFileSync(filename, buffer);
        
        return filename;
    } catch (error) {
        console.error('Error generating speech:', error);
        return null;
    }
}