Setting Up AI Chatbots for Your Crypto Community: Complete Discord & Telegram Guide

// Install dependencies: npm install discord.js openai dotenv

const { Client, GatewayIntentBits, EmbedBuilder, ActivityType } = require('discord.js');
require('dotenv').config();

const client = new Client({
  intents: [
    GatewayIntentBits.Guilds,
    GatewayIntentBits.GuildMessages,
    GatewayIntentBits.MessageContent,
    GatewayIntentBits.GuildMembers,
  ],
});

// Bot ready event
client.once('ready', () => {
  console.log(`🤖 ${client.user.tag} is online!`);
  client.user.setActivity('!help for commands', { type: ActivityType.Watching });
});

// Command handling
const PREFIX = '!';

client.on('messageCreate', async (message) => {
  // Ignore bot messages
  if (message.author.bot) return;
  
  // Check for prefix
  if (!message.content.startsWith(PREFIX)) return;
  
  const args = message.content.slice(PREFIX.length).trim().split(/ +/);
  const command = args.shift().toLowerCase();
  
  // Commands
  switch (command) {
    case 'help':
      const helpEmbed = new EmbedBuilder()
        .setColor(0x00FF00)
        .setTitle('🤖 Bot Commands')
        .setDescription('Available commands for community members:')
        .addFields(
          { name: '!price', value: 'Get current token price' },
          { name: '!contract', value: 'Get contract address' },
          { name: '!links', value: 'Official project links' },
          { name: '!buy', value: 'How to buy guide' },
          { name: '!faq', value: 'Frequently asked questions' }
        )
        .setFooter({ text: 'Memecoin Community Bot' });
      message.channel.send({ embeds: [helpEmbed] });
      break;
      
    case 'contract':
      message.reply('📝 **Contract Address:**\
`0x1234...abcd`\
\
Always verify on our official website!');
      break;
      
    case 'links':
      const linksEmbed = new EmbedBuilder()
        .setColor(0x00FF00)
        .setTitle('🔗 Official Links')
        .addFields(
          { name: 'Website', value: 'https://yourmemecoin.xyz', inline: true },
          { name: 'Twitter', value: '@yourmemecoin', inline: true },
          { name: 'Telegram', value: 't.me/yourmemecoin', inline: true }
        );
      message.channel.send({ embeds: [linksEmbed] });
      break;
  }
});

client.login(process.env.DISCORD_TOKEN);

const OpenAI = require('openai');

const openai = new OpenAI({
  apiKey: process.env.OPENAI_API_KEY,
});

// System prompt for your memecoin
const SYSTEM_PROMPT = `
You are the official AI assistant for [MEMECOIN NAME].
Provide helpful, friendly responses about:
- Token information and contract address
- How to buy and trade
- Project roadmap and features
- Community guidelines
Always be helpful and never give financial advice.
Contract: 0x1234...abcd
Website: https://yourmemecoin.xyz
`;

// AI-powered chat
client.on('messageCreate', async (message) => {
  if (message.author.bot) return;
  
  // AI trigger (could be in specific channel or mention)
  if (message.channel.name === '🤖-ai-chat' || message.mentions.has(client.user)) {
    try {
      const response = await openai.chat.completions.create({
        model: 'gpt-4o-mini',
        messages: [
          { role: 'system', content: SYSTEM_PROMPT },
          { role: 'user', content: message.content }
        ],
        max_tokens: 500,
      });
      
      const aiResponse = response.choices[0].message.content;
      message.reply(aiResponse);
    } catch (error) {
      console.error('AI Error:', error);
      message.reply('Sorry, I encountered an error. Please try again.');
    }
  }
});

// Anti-spam configuration
const spamConfig = {
  maxMessages: 5,
  timeWindow: 5000, // 5 seconds
};

const userMessages = new Map();

client.on('messageCreate', async (message) => {
  if (message.author.bot) return;
  
  // Spam detection
  const userId = message.author.id;
  const now = Date.now();
  
  if (!userMessages.has(userId)) {
    userMessages.set(userId, []);
  }
  
  const messages = userMessages.get(userId);
  messages.push(now);
  
  // Filter old messages
  const recentMessages = messages.filter(time => now - time < spamConfig.timeWindow);
  userMessages.set(userId, recentMessages);
  
  // Check for spam
  if (recentMessages.length >= spamConfig.maxMessages) {
    // Delete recent messages
    const channelMessages = await message.channel.messages.fetch({ limit: 10 });
    const userRecentMessages = channelMessages.filter(m => m.author.id === userId);
    userRecentMessages.forEach(m => m.delete());
    
    // Mute user
    const member = message.guild.members.cache.get(userId);
    if (member && member.moderatable) {
      await member.timeout(spamConfig.muteDuration, 'Spam detection');
      message.channel.send(`â›” <@${userId}> has been muted for spamming.`);
    }
  }
  
  // Scam link detection
  const scamPatterns = [
    /frees*nft/i,
    /claims*now/i,
    /wallet.*drain/i,
    /connect.*wallet.*verify/i,
  ];
  
  for (const pattern of scamPatterns) {
    if (pattern.test(message.content)) {
      await message.delete();
      message.author.send('⚠️ Your message was removed for containing suspicious content.');
      return;
    }
  }
});

// Install: npm install telegraf openai dotenv

const { Telegraf, Markup } = require('telegraf');
const OpenAI = require('openai');
require('dotenv').config();

const bot = new Telegraf(process.env.TELEGRAM_BOT_TOKEN);
const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });

// Start command
bot.start((ctx) => {
  ctx.reply(
    `Welcome to ${ctx.me.first_name}! 🚀\
\
I'm your AI assistant for everything [MEMECOIN]. Use the menu below to get started.`,
    Markup.keyboard([
      ['💰 Price', '📝 Contract'],
      ['📊 Chart', '🔗 Links'],
      ['❓ Help', '🤖 AI Chat']
    ]).resize()
  );
});

// Price command (integrate with CoinGecko API)
bot.hears('💰 Price', async (ctx) => {
  try {
    const response = await fetch(
      'https://api.coingecko.com/api/v3/simple/price?ids=your-token-id&vs_currencies=usd&include_24hr_change=true'
    );
    const data = await response.json();
    
    ctx.reply(
      `💰 **Current Price**\
\
`${data['your-token-id'].usd}`\
24h Change: ${data['your-token-id'].usd_24h_change.toFixed(2)}%`,
      { parse_mode: 'Markdown' }
    );
  } catch (error) {
    ctx.reply('Unable to fetch price. Please try again later.');
  }
});

// Contract command
bot.hears('📝 Contract', (ctx) => {
  ctx.reply(
    `📝 **Contract Address:**\
\
\```\
0x1234567890abcdef...\
\```\
\
[TView on Etherscan](https://etherscan.io/token/0x123...)`,
    { parse_mode: 'Markdown', disable_web_page_preview: true }
  );
});

// Links command
bot.hears('🔗 Links', (ctx) => {
  ctx.reply(
    '🔗 **Official Links**',
    Markup.inlineKeyboard([
      [Markup.button.url('🌐 Website', 'https://yourmemecoin.xyz')],
      [Markup.button.url('🐦 Twitter', 'https://twitter.com/yourmemecoin')],
      [Markup.button.url('💬 Discord', 'https://discord.gg/yourmemecoin')],
      [Markup.button.url('📊 DEXScreener', 'https://dexscreener.com/...')]
    ])
  );
});

// AI Chat handler
bot.hears('🤖 AI Chat', (ctx) => {
  ctx.reply('Send me any question about [MEMECOIN] and I\'ll help you!');
});

// AI response for text messages
bot.on('text', async (ctx) => {
  // Skip commands and button responses
  if (ctx.message.text.startsWith('/')) return;
  
  try {
    const response = await openai.chat.completions.create({
      model: 'gpt-4o-mini',
      messages: [
        { role: 'system', content: 'You are a helpful AI assistant for [MEMECOIN]. Be concise and helpful.' },
        { role: 'user', content: ctx.message.text }
      ],
      max_tokens: 300,
    });
    
    ctx.reply(response.choices[0].message.content);
  } catch (error) {
    ctx.reply('Sorry, I encountered an error. Please try again.');
  }
});

// Launch bot
bot.launch();
console.log('🤖 Telegram bot is running!');

// Enable graceful stop
process.once('SIGINT', () => bot.stop('SIGINT'));
process.once('SIGTERM', () => bot.stop('SIGTERM'));

// Track transactions from DEX
bot.command('track', async (ctx) => {
  // This would connect to a WebSocket or webhook from your DEX tracker
  ctx.reply('🔔 Transaction tracking enabled for this chat!');
});

// Announce new buys
async function announceBuy(buyData) {
  const message = `🐋 **New Buy!**\
\
💰 Amount: ${buyData.amount}\
📊 Tokens: ${buyData.tokens}\
👤 Buyer: ${buyData.buyer.slice(0,6)}...${buyData.buyer.slice(-4)}`;
  
  await bot.telegram.sendMessage(process.env.TELEGRAM_CHANNEL_ID, message, {
    parse_mode: 'Markdown'
  });
}

const rateLimiter = new Map();
const RATE_LIMIT = 10; // requests
const RATE_WINDOW = 60000; // 1 minute

function checkRateLimit(userId) {
  const now = Date.now();
  const userRequests = rateLimiter.get(userId) || [];
  
  const recentRequests = userRequests.filter(time => now - time < RATE_WINDOW);
  
  if (recentRequests.length >= RATE_LIMIT) {
    return false; // Rate limited
  }
  
  recentRequests.push(now);
  rateLimiter.set(userId, recentRequests);
  return true;
}

const fs = require('fs');

function log(message) {
  const timestamp = new Date().toISOString();
  const logEntry = `[${timestamp}] ${message}\n`;
  fs.appendFile('bot.log', logEntry, (err) => {
    if (err) console.error('Log error:', err);
  });
  console.log(logEntry);
}

const { SlashCommandBuilder } = require('discord.js');

const commands = [
  new SlashCommandBuilder()
    .setName('price')
    .setDescription('Get current token price'),
  new SlashCommandBuilder()
    .setName('contract')
    .setDescription('Get the contract address'),
].map(command => command.toJSON());

// Register commands
const rest = new REST({ version: '10' }).setToken(process.env.DISCORD_TOKEN);
rest.put(Routes.applicationCommands(process.env.CLIENT_ID), { body: commands });