Integrating AI Agents with External APIs - Part 3: Discord Integration

Discord integration opens up a massive community-focused ecosystem for your AI agent. Unlike Slack's business-oriented approach, Discord excels at community building, gaming, and social interactions. With over 150 million monthly active users, Discord provides unique opportunities for AI agents to engage with vibrant communities.

However, Discord has a fundamentally different architecture from business platforms. Understanding Discord's guild system, permission model, and community-centric features is crucial for building successful Discord AI agents.

Why Discord is Different for AI Agents

Community-First Design Discord is built around communities (called "guilds") rather than workspaces. This affects how your AI agent interacts with users and manages conversations across multiple servers.

Gaming and Entertainment Focus Discord users expect fun, engaging, and interactive experiences. Your AI agent needs to adapt its personality and features to match this more casual, entertainment-focused environment.

Generous Bot Policies Unlike many platforms, Discord is extremely bot-friendly with generous rate limits, extensive API access, and strong support for automated interactions.

Rich Media Support Discord excels at handling images, videos, files, and voice communications - capabilities your AI agent can leverage for richer interactions.

What You'll Learn in This Tutorial

By the end of this tutorial, you'll have:

• ✅ Complete Discord bot setup with proper permissions and intents
• ✅ Community-focused AI interactions tailored for Discord's social environment
• ✅ Advanced Discord features including slash commands, embeds, and reactions
• ✅ Guild management capabilities for multi-server deployment
• ✅ Voice channel integration for audio-based AI interactions
• ✅ Moderation tools for community management

Estimated Time: 40-45 minutes

---

Step 1: Understanding Discord's Architecture

Before building your Discord AI agent, it's essential to understand Discord's unique structure and how it differs from other platforms.

Discord's Hierarchical Structure

Discord's Organization:

Discord Platform
└── Guild (Server)
    ├── Text Channels
    ├── Voice Channels  
    ├── Categories
    ├── Roles & Permissions
    └── Members

Key Concepts Explained:

Guilds (Servers) Think of guilds as separate communities. Your AI agent can be in multiple guilds simultaneously, each with different rules, channels, and member expectations.

Channels Unlike Slack's flat channel structure, Discord organizes channels into categories with specific purposes (general chat, gaming channels, help channels, etc.).

Roles and Permissions Discord's permission system is more complex than most platforms, with role hierarchies that determine what users and bots can do in specific channels.

Intents Discord requires you to explicitly declare what data your bot needs access to (messages, member lists, etc.). This is crucial for privacy and performance.

Discord vs Other Platforms

Feature	Discord	Slack	Key Difference
Focus	Communities & Gaming	Business & Productivity	Affects user expectations
Rate Limits	Very generous	More restrictive	Allows more bot activity
User Base	Younger, gaming-focused	Professional, work-focused	Different interaction styles
Rich Media	Excellent support	Limited	More engaging possibilities
Voice/Video	Built-in	Basic	Unique AI opportunities

---

Step 2: Discord Bot Setup and Configuration

Let's create a properly configured Discord bot that follows best practices for AI agents.

Creating Your Discord Application

Step-by-Step Setup:

1. Visit Discord Developer Portal

   • Go to discord.com/developers/applications
   • Click "New Application"
   • Choose a name for your AI agent

2. Configure Bot Settings

   • Navigate to "Bot" section
   • Click "Add Bot"
   • Important: Copy the bot token immediately (you won't see it again)

3. Set Bot Permissions Discord bots need specific permissions. For AI agents, you typically need:

   • Send Messages: Basic communication ability
   • Read Message History: Understanding conversation context
   • Use Slash Commands: Modern Discord command interface
   • Add Reactions: Express emotions and provide feedback
   • Attach Files: Share images, documents, or generated content

Understanding Discord Intents

What Are Intents? Intents tell Discord what data your bot needs access to. This improves performance and privacy by only sending relevant events to your bot.

Required Intents for AI Agents:

// Essential intents for AI agents
const intents = [
    GatewayIntentBits.Guilds,           // Access to guild information
    GatewayIntentBits.GuildMessages,    // Receive messages in guilds
    GatewayIntentBits.MessageContent,   // Read actual message content (privileged)
    GatewayIntentBits.DirectMessages,   // Handle direct messages
    GatewayIntentBits.GuildMembers      // Access member information (privileged)
];

Privileged Intents: Some intents require approval for large bots (100+ guilds):

• Message Content: Required to read message text
• Guild Members: Needed for member-specific features

Discord Bot Implementation

Let's build a Discord AI agent with proper architecture:

// discord-integration/discord-bot.js

const { Client, GatewayIntentBits, EmbedBuilder, ActionRowBuilder, ButtonBuilder, ButtonStyle } = require('discord.js');
const { REST } = require('@discordjs/rest');
const { Routes } = require('discord-api-types/v10');

class DiscordAIAgent {
    constructor(config) {
        this.config = {
            botToken: config.botToken || process.env.DISCORD_BOT_TOKEN,
            clientId: config.clientId || process.env.DISCORD_CLIENT_ID,
            
            // AI Integration
            aiAgent: config.aiAgent,
            
            // Bot Settings
            activityType: config.activityType || 'LISTENING',
            activityName: config.activityName || 'to your questions',
            
            // Community Features
            enableModeration: config.enableModeration || false,
            enableGaming: config.enableGaming || false
        };
        
        // Validate configuration
        this.validateConfig();
        
        // Initialize Discord client
        this.client = new Client({
            intents: [
                GatewayIntentBits.Guilds,
                GatewayIntentBits.GuildMessages,
                GatewayIntentBits.MessageContent,
                GatewayIntentBits.DirectMessages
            ]
        });
        
        // Initialize REST client for slash commands
        this.rest = new REST({ version: '10' }).setToken(this.config.botToken);
        
        // Track bot state
        this.isReady = false;
        this.guilds = new Map();
        this.activeConversations = new Map();
        
        // Performance metrics
        this.metrics = {
            messagesProcessed: 0,
            commandsHandled: 0,
            guildsServed: 0,
            averageResponseTime: 0
        };
        
        this.setupEventHandlers();
    }
    
    validateConfig() {
        if (!this.config.botToken) {
            throw new Error('Discord bot token is required');
        }
        
        if (!this.config.botToken.startsWith('MTI')) {
            console.warn('⚠️ Discord bot token format appears invalid');
        }
        
        if (!this.config.aiAgent) {
            throw new Error('AI agent integration is required');
        }
    }
    
    setupEventHandlers() {
        // Bot ready event
        this.client.once('ready', () => {
            this.handleBotReady();
        });
        
        // Message events
        this.client.on('messageCreate', async (message) => {
            await this.handleMessage(message);
        });
        
        // Slash command interactions
        this.client.on('interactionCreate', async (interaction) => {
            await this.handleInteraction(interaction);
        });
        
        // Guild events (server join/leave)
        this.client.on('guildCreate', (guild) => {
            this.handleGuildJoin(guild);
        });
        
        this.client.on('guildDelete', (guild) => {
            this.handleGuildLeave(guild);
        });
    }
}

What's Happening in This Code:

Intent Configuration: We explicitly declare what data our bot needs. This is Discord's way of protecting user privacy while giving bots necessary access.

Event-Driven Architecture: Discord bots are entirely event-driven. Your bot responds to events (messages, interactions, etc.) rather than polling for data.

REST vs Gateway: We use two different connections:

• Gateway: Real-time events (messages, reactions)
• REST: API calls (sending messages, managing guilds)

---

Step 3: Implementing Discord-Specific AI Features

Discord's community focus requires AI agents with different capabilities than business-focused platforms.

Community-Focused Message Handling

// Enhanced message handling for Discord communities

async handleMessage(message) {
    // Skip messages from bots (including ourselves)
    if (message.author.bot) return;
    
    // Skip messages without content
    if (!message.content || message.content.trim().length === 0) return;
    
    const startTime = Date.now();
    
    try {
        // Check if message is directed at bot
        const isMention = message.mentions.has(this.client.user);
        const isDM = message.channel.type === 'DM';
        const hasPrefix = message.content.startsWith('!ai');
        
        // Only respond to direct interactions
        if (!isMention && !isDM && !hasPrefix) {
            return;
        }
        
        console.log(`💬 Processing Discord message from ${message.author.tag} in ${message.guild?.name || 'DM'}`);
        
        // Extract clean message content
        let cleanContent = message.content;
        
        // Remove bot mention from message
        if (isMention) {
            cleanContent = cleanContent.replace(`<@${this.client.user.id}>`, '').trim();
        }
        
        // Remove prefix if used
        if (hasPrefix) {
            cleanContent = cleanContent.substring(3).trim(); // Remove "!ai"
        }
        
        // Show typing indicator (Discord equivalent of "thinking...")
        await message.channel.sendTyping();
        
        // Get Discord-specific context
        const context = await this.buildDiscordContext(message);
        
        // Process with AI agent
        const aiResponse = await this.processWithAI({
            content: cleanContent,
            user: message.author,
            channel: message.channel,
            guild: message.guild,
            context: context
        });
        
        // Send response with Discord-specific formatting
        await this.sendDiscordResponse(message, aiResponse);
        
        // Update metrics
        this.metrics.messagesProcessed++;
        this.metrics.averageResponseTime = this.updateAverageResponseTime(Date.now() - startTime);
        
    } catch (error) {
        console.error('❌ Error processing Discord message:', error);
        await this.sendErrorMessage(message, error);
    }
}

async buildDiscordContext(message) {
    const context = {
        platform: 'discord',
        channel_type: message.channel.type,
        is_dm: message.channel.type === 'DM',
        
        // User context
        user: {
            id: message.author.id,
            username: message.author.username,
            discriminator: message.author.discriminator,
            avatar: message.author.displayAvatarURL()
        },
        
        // Guild context (if in server)
        guild: message.guild ? {
            id: message.guild.id,
            name: message.guild.name,
            member_count: message.guild.memberCount,
            
            // User's role in this guild
            member_roles: message.member?.roles.cache.map(role => ({
                name: role.name,
                color: role.hexColor,
                position: role.position
            })) || []
        } : null,
        
        // Channel context
        channel: {
            id: message.channel.id,
            name: message.channel.name || 'DM',
            type: message.channel.type
        }
    };
    
    // Add conversation history if available
    try {
        const recentMessages = await message.channel.messages.fetch({ limit: 10 });
        context.recent_messages = recentMessages
            .filter(msg => !msg.author.bot)
            .map(msg => ({
                author: msg.author.username,
                content: msg.content.substring(0, 100), // Truncate for context
                timestamp: msg.createdTimestamp
            }));
    } catch (error) {
        console.warn('Could not fetch message history:', error.message);
        context.recent_messages = [];
    }
    
    return context;
}

Why This Approach Works for Discord:

Community Context Awareness: The bot understands which server it's in and adapts responses accordingly. A gaming community might get different responses than a study group.

Role-Based Responses: Discord's role system lets your AI agent provide different levels of service based on user permissions.

Conversation History: Unlike API-only interactions, Discord lets you access recent messages for better context understanding.

Discord-Specific Response Formatting

Discord supports rich message formatting that can make your AI agent more engaging:

async sendDiscordResponse(originalMessage, aiResponse) {
    try {
        // For short responses, use simple text
        if (aiResponse.text.length < 200) {
            await originalMessage.reply(aiResponse.text);
            return;
        }
        
        // For longer responses, use embeds for better formatting
        const embed = new EmbedBuilder()
            .setTitle('🤖 AI Assistant Response')
            .setDescription(aiResponse.text)
            .setColor(0x5865F2) // Discord blurple
            .setTimestamp()
            .setFooter({ 
                text: `Processed in ${aiResponse.processingTime}ms`,
                iconURL: this.client.user.displayAvatarURL()
            });
        
        // Add interactive buttons for engagement
        const actionRow = new ActionRowBuilder()
            .addComponents(
                new ButtonBuilder()
                    .setCustomId('ai_expand')
                    .setLabel('📚 More Detail')
                    .setStyle(ButtonStyle.Primary),
                new ButtonBuilder()
                    .setCustomId('ai_clarify')
                    .setLabel('❓ Clarify')
                    .setStyle(ButtonStyle.Secondary),
                new ButtonBuilder()
                    .setCustomId('ai_rate')
                    .setLabel('⭐ Rate Response')
                    .setStyle(ButtonStyle.Success)
            );
        
        await originalMessage.reply({
            embeds: [embed],
            components: [actionRow]
        });
        
    } catch (error) {
        console.error('Failed to send Discord response:', error);
        
        // Fallback to simple text response
        await originalMessage.reply('I encountered an error processing your request. Please try again.');
    }
}

Discord Formatting Benefits:

Embeds: Rich message format with titles, descriptions, colors, and fields. Much more engaging than plain text.

Interactive Components: Buttons and dropdowns let users interact with your AI agent beyond just text messages.

Visual Appeal: Discord users expect visually appealing messages. Embeds help your AI agent fit in with community expectations.

---

Step 4: Implementing Slash Commands

Slash commands are the modern way to interact with Discord bots and provide structured input for your AI agent.

Understanding Slash Commands vs Traditional Commands

Traditional Commands (!ask question):

• User types command with prefix
• Bot parses text manually
• Error-prone and less user-friendly

Slash Commands (/ask question):

• Discord provides structured interface
• Automatic parameter validation
• Better user experience with autocomplete

Implementing Slash Commands

// Slash command registration and handling

async registerSlashCommands() {
    const commands = [
        {
            name: 'ask',
            description: 'Ask the AI agent a question',
            options: [
                {
                    name: 'question',
                    description: 'Your question for the AI',
                    type: 3, // STRING type
                    required: true
                },
                {
                    name: 'private',
                    description: 'Should the response be private?',
                    type: 5, // BOOLEAN type
                    required: false
                }
            ]
        },
        {
            name: 'chat',
            description: 'Start a conversation with the AI agent',
            options: [
                {
                    name: 'message',
                    description: 'Your message to the AI',
                    type: 3,
                    required: true
                }
            ]
        },
        {
            name: 'help',
            description: 'Get help with AI agent commands'
        }
    ];
    
    try {
        // Register commands globally (takes up to 1 hour to propagate)
        await this.rest.put(
            Routes.applicationCommands(this.config.clientId),
            { body: commands }
        );
        
        console.log('✅ Discord slash commands registered successfully');
    } catch (error) {
        console.error('❌ Failed to register slash commands:', error);
    }
}

async handleSlashCommand(interaction) {
    const { commandName, options, user, guild, channel } = interaction;
    
    console.log(`🔘 Slash command: /${commandName} from ${user.tag}`);
    
    try {
        switch (commandName) {
            case 'ask':
                await this.handleAskCommand(interaction, options);
                break;
            case 'chat':
                await this.handleChatCommand(interaction, options);
                break;
            case 'help':
                await this.handleHelpCommand(interaction);
                break;
            default:
                await interaction.reply({
                    content: '❓ Unknown command. Use `/help` for assistance.',
                    ephemeral: true
                });
        }
        
        this.metrics.commandsHandled++;
        
    } catch (error) {
        console.error(`❌ Error handling slash command /${commandName}:`, error);
        
        if (!interaction.replied) {
            await interaction.reply({
                content: '❌ An error occurred processing your command.',
                ephemeral: true
            });
        }
    }
}

async handleAskCommand(interaction, options) {
    const question = options.getString('question');
    const isPrivate = options.getBoolean('private') || false;
    
    // Acknowledge the command immediately (Discord requires response within 3 seconds)
    await interaction.deferReply({ ephemeral: isPrivate });
    
    try {
        // Build context for AI processing
        const context = {
            platform: 'discord',
            command: 'ask',
            user: interaction.user,
            guild: interaction.guild,
            channel: interaction.channel,
            is_private: isPrivate
        };
        
        // Process with AI agent
        const aiResponse = await this.config.aiAgent.processMessage({
            content: question,
            context: context
        });
        
        // Create response embed
        const embed = new EmbedBuilder()
            .setTitle('🤖 AI Assistant Answer')
            .setDescription(aiResponse.text)
            .setColor(0x00AE86)
            .addFields([
                {
                    name: '❓ Your Question',
                    value: question,
                    inline: false
                }
            ])
            .setFooter({ text: `Asked by ${interaction.user.tag}` })
            .setTimestamp();
        
        await interaction.editReply({
            embeds: [embed]
        });
        
    } catch (error) {
        await interaction.editReply({
            content: `❌ Sorry, I couldn't process your question: ${error.message}`
        });
    }
}

Why Slash Commands Work Well for AI Agents:

Structured Input: Discord validates the input format, ensuring your AI agent receives properly formatted data.

Better UX: Users get autocomplete and parameter hints, making it easier to interact with your AI agent correctly.

Permission Integration: Slash commands respect Discord's permission system automatically.

---

Step 5: Guild Management for Multi-Server Deployment

Unlike other platforms, your Discord AI agent will likely serve multiple communities (guilds) with different needs.

Guild-Aware AI Agent Architecture

// Guild management and customization

class GuildManager {
    constructor(discordBot) {
        this.bot = discordBot;
        this.guildConfigs = new Map();
        this.defaultConfig = {
            ai_personality: 'helpful',
            response_style: 'casual',
            moderation_enabled: false,
            custom_commands: [],
            allowed_channels: [], // Empty means all channels
            banned_users: new Set()
        };
    }
    
    async handleGuildJoin(guild) {
        console.log(`📥 Joined new guild: ${guild.name} (${guild.memberCount} members)`);
        
        // Initialize default configuration for this guild
        this.guildConfigs.set(guild.id, { ...this.defaultConfig });
        
        // Send welcome message to default channel
        const defaultChannel = guild.systemChannel || 
                              guild.channels.cache.find(ch => ch.name === 'general') ||
                              guild.channels.cache.find(ch => ch.type === 'GUILD_TEXT');
        
        if (defaultChannel) {
            const welcomeEmbed = new EmbedBuilder()
                .setTitle('👋 Hello! I\'m your new AI Assistant')
                .setDescription(`Thanks for adding me to **${guild.name}**! I'm here to help your community with questions, conversations, and automation.`)
                .setColor(0x5865F2)
                .addFields([
                    {
                        name: '🚀 Quick Start',
                        value: 'Try `/ask` to ask me any question\nUse `/help` to see all my capabilities',
                        inline: false
                    },
                    {
                        name: '⚙️ Configuration',
                        value: 'Server admins can use `/config` to customize my behavior',
                        inline: false
                    }
                ])
                .setThumbnail(this.bot.client.user.displayAvatarURL())
                .setFooter({ text: 'Use /help anytime for assistance' });
            
            await defaultChannel.send({ embeds: [welcomeEmbed] });
        }
        
        this.bot.metrics.guildsServed++;
    }
    
    getGuildConfig(guildId) {
        return this.guildConfigs.get(guildId) || { ...this.defaultConfig };
    }
    
    async updateGuildConfig(guildId, configUpdates) {
        const currentConfig = this.getGuildConfig(guildId);
        const newConfig = { ...currentConfig, ...configUpdates };
        
        this.guildConfigs.set(guildId, newConfig);
        
        // In production, save to database
        console.log(`⚙️ Updated configuration for guild ${guildId}`);
        
        return newConfig;
    }
    
    async processMessageWithGuildContext(message, aiResponse) {
        const guildConfig = this.getGuildConfig(message.guild?.id);
        
        // Adapt AI response based on guild configuration
        if (guildConfig.response_style === 'formal') {
            aiResponse.text = this.convertToFormalTone(aiResponse.text);
        } else if (guildConfig.response_style === 'gaming') {
            aiResponse.text = this.addGamingElements(aiResponse.text);
        }
        
        // Check if user is banned in this guild
        if (guildConfig.banned_users.has(message.author.id)) {
            return null; // Don't respond to banned users
        }
        
        // Check channel restrictions
        if (guildConfig.allowed_channels.length > 0 && 
            !guildConfig.allowed_channels.includes(message.channel.id)) {
            
            await message.reply({
                content: '⚠️ I can only respond in designated channels.',
                ephemeral: true
            });
            return null;
        }
        
        return aiResponse;
    }
}

Guild Management Benefits:

Customization: Each Discord server can have different AI personalities and behaviors.

Flexibility: Gaming servers might want a more casual, fun AI agent, while study groups might want formal, educational responses.

Scalability: Your single AI agent can serve hundreds of Discord servers with appropriate customization.

---

Step 6: Advanced Discord Features

Let's implement advanced features that make your AI agent stand out in the Discord ecosystem.

Interactive Components and Reactions

// Interactive features for better user engagement

async handleButtonInteraction(interaction) {
    const { customId, user, message } = interaction;
    
    console.log(`🔘 Button interaction: ${customId} from ${user.tag}`);
    
    try {
        switch (customId) {
            case 'ai_expand':
                await this.handleExpandResponse(interaction);
                break;
            case 'ai_clarify':
                await this.handleClarifyRequest(interaction);
                break;
            case 'ai_rate':
                await this.handleRateResponse(interaction);
                break;
            default:
                await interaction.reply({
                    content: '❓ Unknown button action.',
                    ephemeral: true
                });
        }
    } catch (error) {
        console.error('❌ Button interaction error:', error);
        
        if (!interaction.replied) {
            await interaction.reply({
                content: '❌ Error processing button action.',
                ephemeral: true
            });
        }
    }
}

async handleExpandResponse(interaction) {
    // Get the original message context
    const originalEmbed = interaction.message.embeds[0];
    if (!originalEmbed) {
        await interaction.reply({
            content: '❌ Could not find original message to expand.',
            ephemeral: true
        });
        return;
    }
    
    // Extract original question from embed
    const originalQuestion = originalEmbed.fields?.find(field => 
        field.name.includes('Question')
    )?.value || 'Previous question';
    
    // Request expanded response from AI
    const expandedResponse = await this.config.aiAgent.expandResponse({
        original_question: originalQuestion,
        original_response: originalEmbed.description,
        user_context: {
            discord_user: interaction.user.tag,
            guild: interaction.guild?.name
        }
    });
    
    // Create expanded embed
    const expandedEmbed = new EmbedBuilder()
        .setTitle('📚 Detailed AI Response')
        .setDescription(expandedResponse.text)
        .setColor(0x57F287) // Green for expanded content
        .addFields([
            {
                name: '❓ Original Question',
                value: originalQuestion,
                inline: false
            },
            {
                name: '🔍 Additional Details',
                value: 'This response includes more context and examples.',
                inline: false
            }
        ])
        .setTimestamp();
    
    await interaction.reply({
        embeds: [expandedEmbed],
        ephemeral: true // Only visible to the user who clicked
    });
}

Interactive Component Benefits:

Enhanced Engagement: Users can get more detail, ask for clarification, or rate responses without typing new messages.

Reduced Chat Clutter: Follow-up actions can be private (ephemeral), keeping channels clean.

Better User Experience: Point-and-click interactions are often easier than remembering command syntax.

---

Step 7: Production Deployment and Monitoring

Bot Hosting Strategies

24/7 Availability Requirement Unlike web APIs, Discord bots need to maintain persistent connections to receive real-time events.

Hosting Options for Discord Bots:

1. VPS/Dedicated Server: Most reliable, requires server management
2. Cloud Platforms: AWS EC2, Google Cloud Compute, Azure VMs
3. Container Platforms: Docker on various cloud providers
4. Specialized Bot Hosting: Services designed specifically for Discord bots

Simple Bot Monitoring

// Basic monitoring for Discord bot health

class DiscordBotMonitor {
    constructor(bot) {
        this.bot = bot;
        this.startTime = Date.now();
        this.lastActivity = Date.now();
        
        // Start monitoring tasks
        this.startHealthChecks();
        this.startMetricsReporting();
    }
    
    startHealthChecks() {
        // Check bot health every minute
        setInterval(() => {
            this.performHealthCheck();
        }, 60000);
    }
    
    performHealthCheck() {
        const now = Date.now();
        const uptimeMinutes = (now - this.startTime) / 60000;
        const timeSinceActivity = (now - this.lastActivity) / 60000;
        
        const healthStatus = {
            uptime_minutes: Math.round(uptimeMinutes),
            last_activity_minutes: Math.round(timeSinceActivity),
            guilds_connected: this.bot.client.guilds.cache.size,
            websocket_status: this.bot.client.ws.status,
            memory_usage: process.memoryUsage(),
            is_healthy: timeSinceActivity < 10 && this.bot.client.ws.status === 0
        };
        
        console.log('🏥 Health Check:', healthStatus);
        
        // Alert if bot appears unhealthy
        if (!healthStatus.is_healthy) {
            console.error('🚨 Bot health check failed!', healthStatus);
            // In production, send alert to monitoring service
        }
        
        return healthStatus;
    }
    
    recordActivity() {
        this.lastActivity = Date.now();
    }
    
    startMetricsReporting() {
        // Report metrics every 5 minutes
        setInterval(() => {
            this.reportMetrics();
        }, 300000);
    }
    
    reportMetrics() {
        const metrics = {
            ...this.bot.metrics,
            uptime: Date.now() - this.startTime,
            guilds: this.bot.client.guilds.cache.size,
            channels: this.bot.client.channels.cache.size,
            users: this.bot.client.users.cache.size
        };