# Create project directory
mkdir ai-discord-bot
cd ai-discord-bot

# Create virtual environment
python -m venv venv
source venv/bin/activate # On Windows: venv\Scripts\activate

# Install dependencies
pip install discord.py openai python-dotenv aiohttp

ai-discord-bot/
├── .env # Environment variables
├── bot.py # Main bot code
├── models.py # AI model configurations
├── context_manager.py # Conversation context
├── utils.py # Helper functions
└── requirements.txt # Dependencies

# Discord
DISCORD_TOKEN=your_discord_bot_token

# Crazyrouter (recommended - supports all models)
CRAZYROUTER_API_KEY=your_crazyrouter_key

# Or use individual providers
OPENAI_API_KEY=your_openai_key
ANTHROPIC_API_KEY=your_anthropic_key
GOOGLE_API_KEY=your_google_key

# Bot settings
MAX_CONTEXT_MESSAGES=10
DEFAULT_MODEL=gpt-5-mini
ADMIN_USER_IDS=123456789,987654321

"""AI model configurations and pricing"""

MODELS = {
 # OpenAI Models
 "gpt-5": {
 "name": "gpt-5.2",
 "display": "GPT-5.2",
 "provider": "openai",
 "max_tokens": 4096,
 "cost_per_1k": 0.015, # Input cost
 "description": "Most capable GPT model"
 },
 "gpt-5-mini": {
 "name": "gpt-5-mini",
 "display": "GPT-5 Mini",
 "provider": "openai",
 "max_tokens": 4096,
 "cost_per_1k": 0.001,
 "description": "Fast and affordable"
 },
 
 # Anthropic Models
 "claude": {
 "name": "claude-opus-4-6-20260101",
 "display": "Claude Opus 4.6",
 "provider": "anthropic",
 "max_tokens": 4096,
 "cost_per_1k": 0.015,
 "description": "Best reasoning and analysis"
 },
 "claude-sonnet": {
 "name": "claude-sonnet-4-5-20250929",
 "display": "Claude Sonnet 4.5",
 "provider": "anthropic",
 "max_tokens": 4096,
 "cost_per_1k": 0.003,
 "description": "Balanced performance"
 },
 
 # Google Models
 "gemini": {
 "name": "gemini-2.5-pro",
 "display": "Gemini 2.5 Pro",
 "provider": "google",
 "max_tokens": 8192,
 "cost_per_1k": 0.00125,
 "description": "Long context, multimodal"
 },
 "gemini-flash": {
 "name": "gemini-2.5-flash",
 "display": "Gemini 2.5 Flash",
 "provider": "google",
 "max_tokens": 8192,
 "cost_per_1k": 0.0001,
 "description": "Fastest, cheapest"
 },
 
 # Other Models
 "deepseek": {
 "name": "deepseek-v3.2",
 "display": "DeepSeek V3.2",
 "provider": "deepseek",
 "max_tokens": 4096,
 "cost_per_1k": 0.00027,
 "description": "Budget-friendly, good quality"
 },
 "grok": {
 "name": "grok-4.1-fast",
 "display": "Grok 4.1 Fast",
 "provider": "xai",
 "max_tokens": 4096,
 "cost_per_1k": 0.005,
 "description": "Fast, witty responses"
 }
}

def get_model_list():
 """Return formatted model list for Discord embed"""
 return "\n".join([
 f"**{key}**: {config['display']} - {config['description']}"
 for key, config in MODELS.items()
 ])

def get_model_config(model_key):
 """Get model configuration by key"""
 return MODELS.get(model_key, MODELS["gpt-5-mini"])

"""Manage conversation context per Discord channel"""

from collections import defaultdict, deque
import os

MAX_CONTEXT = int(os.getenv("MAX_CONTEXT_MESSAGES", 10))

class ContextManager:
 def __init__(self):
 # Store context per channel: {channel_id: deque([messages])}
 self.contexts = defaultdict(lambda: deque(maxlen=MAX_CONTEXT))
 
 def add_message(self, channel_id, role, content):
 """Add message to channel context"""
 self.contexts[channel_id].append({
 "role": role,
 "content": content
 })
 
 def get_context(self, channel_id):
 """Get conversation context for channel"""
 return list(self.contexts[channel_id])
 
 def clear_context(self, channel_id):
 """Clear context for channel"""
 self.contexts[channel_id].clear()
 
 def get_context_size(self, channel_id):
 """Get number of messages in context"""
 return len(self.contexts[channel_id])

# Global context manager
context_manager = ContextManager()

"""AI-powered Discord bot with multiple LLM support"""

import discord
from discord import app_commands
from discord.ext import commands
import openai
import os
from dotenv import load_dotenv
import asyncio
from models import MODELS, get_model_list, get_model_config
from context_manager import context_manager

# Load environment variables
load_dotenv()

# Initialize OpenAI client (works with Crazyrouter)
client = openai.OpenAI(
 api_key=os.getenv("CRAZYROUTER_API_KEY"),
 base_url="https://api.crazyrouter.com/v1"
)

# Bot setup
intents = discord.Intents.default()
intents.message_content = True
bot = commands.Bot(command_prefix="!", intents=intents)

# Admin user IDs
ADMIN_IDS = [int(id) for id in os.getenv("ADMIN_USER_IDS", "").split(",") if id]

@bot.event
async def on_ready():
 """Bot startup"""
 print(f"✅ {bot.user} is online!")
 print(f"📊 Connected to {len(bot.guilds)} servers")
 
 # Sync slash commands
 try:
 synced = await bot.tree.sync()
 print(f"✅ Synced {len(synced)} slash commands")
 except Exception as e:
 print(f"❌ Failed to sync commands: {e}")

@bot.tree.command(name="ask", description="Ask AI a question")
@app_commands.describe(
 model="AI model to use",
 prompt="Your question or prompt"
)
@app_commands.choices(model=[
 app_commands.Choice(name=config["display"], value=key)
 for key, config in list(MODELS.items())[:25] # Discord limit: 25 choices
])
async def ask(interaction: discord.Interaction, model: str, prompt: str):
 """Main AI chat command"""
 await interaction.response.defer(thinking=True)
 
 try:
 # Get model config
 model_config = get_model_config(model)
 
 # Get conversation context
 channel_id = interaction.channel_id
 context = context_manager.get_context(channel_id)
 
 # Add user message to context
 context_manager.add_message(channel_id, "user", prompt)
 
 # Build messages for API
 messages = context + [{"role": "user", "content": prompt}]
 
 # Call AI API
 response = await asyncio.to_thread(
 client.chat.completions.create,
 model=model_config["name"],
 messages=messages,
 max_tokens=model_config["max_tokens"],
 temperature=0.7
 )
 
 # Extract response
 ai_response = response.choices[0].message.content
 
 # Add AI response to context
 context_manager.add_message(channel_id, "assistant", ai_response)
 
 # Create embed
 embed = discord.Embed(
 title=f"🤖 {model_config['display']}",
 description=ai_response[:4000], # Discord limit
 color=discord.Color.blue()
 )
 embed.set_footer(text=f"Context: {context_manager.get_context_size(channel_id)} messages")
 
 await interaction.followup.send(embed=embed)
 
 except Exception as e:
 error_embed = discord.Embed(
 title="❌ Error",
 description=f"Failed to get AI response: {str(e)}",
 color=discord.Color.red()
 )
 await interaction.followup.send(embed=error_embed, ephemeral=True)

@bot.tree.command(name="models", description="List available AI models")
async def models(interaction: discord.Interaction):
 """Show available models"""
 embed = discord.Embed(
 title="🤖 Available AI Models",
 description=get_model_list(),
 color=discord.Color.green()
 )
 embed.set_footer(text="Use /ask <model> <prompt> to chat")
 await interaction.response.send_message(embed=embed)

@bot.tree.command(name="clear", description="Clear conversation context")
async def clear(interaction: discord.Interaction):
 """Clear channel context"""
 channel_id = interaction.channel_id
 context_manager.clear_context(channel_id)
 
 embed = discord.Embed(
 title="🧹 Context Cleared",
 description="Conversation history has been reset.",
 color=discord.Color.orange()
 )
 await interaction.response.send_message(embed=embed, ephemeral=True)

@bot.tree.command(name="context", description="Show current conversation context")
async def show_context(interaction: discord.Interaction):
 """Display current context"""
 channel_id = interaction.channel_id
 context = context_manager.get_context(channel_id)
 
 if not context:
 await interaction.response.send_message("No context yet. Start chatting!", ephemeral=True)
 return
 
 context_text = "\n\n".join([
 f"**{msg['role'].title()}**: {msg['content'][:100]}..."
 for msg in context
 ])
 
 embed = discord.Embed(
 title=f"💬 Conversation Context ({len(context)} messages)",
 description=context_text[:4000],
 color=discord.Color.purple()
 )
 await interaction.response.send_message(embed=embed, ephemeral=True)

@bot.tree.command(name="stats", description="Show bot usage statistics")
async def stats(interaction: discord.Interaction):
 """Show bot stats (admin only)"""
 if interaction.user.id not in ADMIN_IDS:
 await interaction.response.send_message("❌ Admin only command", ephemeral=True)
 return
 
 total_contexts = len(context_manager.contexts)
 total_messages = sum(len(ctx) for ctx in context_manager.contexts.values())
 
 embed = discord.Embed(
 title="📊 Bot Statistics",
 color=discord.Color.gold()
 )
 embed.add_field(name="Servers", value=len(bot.guilds), inline=True)
 embed.add_field(name="Active Channels", value=total_contexts, inline=True)
 embed.add_field(name="Total Messages", value=total_messages, inline=True)
 
 await interaction.response.send_message(embed=embed, ephemeral=True)

# Run bot
if __name__ == "__main__":
 token = os.getenv("DISCORD_TOKEN")
 if not token:
 print("❌ DISCORD_TOKEN not found in .env")
 exit(1)
 
 bot.run(token)

# Activate virtual environment
source venv/bin/activate

# Run bot
python bot.py

✅ AI Assistant#1234 is online!
📊 Connected to 1 servers
✅ Synced 5 slash commands

/models
# Shows all available AI models

/ask gpt-5-mini What is quantum computing?
# Ask GPT-5 Mini a question

/ask claude Explain relativity in simple terms
# Ask Claude Opus

/context
# View conversation history

/clear
# Reset conversation context

/stats
# View bot statistics (admin only)

@bot.tree.command(name="imagine", description="Generate an image with AI")
@app_commands.describe(prompt="Image description")
async def imagine(interaction: discord.Interaction, prompt: str):
 """Generate image with DALL-E"""
 await interaction.response.defer(thinking=True)
 
 try:
 response = await asyncio.to_thread(
 client.images.generate,
 model="dall-e-3",
 prompt=prompt,
 size="1024x1024",
 n=1
 )
 
 image_url = response.data[0].url
 
 embed = discord.Embed(
 title="🎨 Generated Image",
 description=prompt,
 color=discord.Color.purple()
 )
 embed.set_image(url=image_url)
 
 await interaction.followup.send(embed=embed)
 
 except Exception as e:
 await interaction.followup.send(f"❌ Error: {e}", ephemeral=True)

@bot.tree.command(name="compare", description="Compare responses from multiple models")
@app_commands.describe(prompt="Question to ask all models")
async def compare(interaction: discord.Interaction, prompt: str):
 """Compare responses from GPT, Claude, and Gemini"""
 await interaction.response.defer(thinking=True)
 
 models_to_compare = ["gpt-5-mini", "claude-sonnet", "gemini-flash"]
 responses = {}
 
 for model_key in models_to_compare:
 try:
 model_config = get_model_config(model_key)
 response = await asyncio.to_thread(
 client.chat.completions.create,
 model=model_config["name"],
 messages=[{"role": "user", "content": prompt}],
 max_tokens=500
 )
 responses[model_config["display"]] = response.choices[0].message.content[:500]
 except Exception as e:
 responses[model_config["display"]] = f"Error: {e}"
 
 embed = discord.Embed(
 title="🔍 Model Comparison",
 description=f"**Prompt**: {prompt}",
 color=discord.Color.teal()
 )
 
 for model_name, response_text in responses.items():
 embed.add_field(
 name=model_name,
 value=response_text[:1024],
 inline=False
 )
 
 await interaction.followup.send(embed=embed)

import json
from datetime import datetime

class UsageTracker:
 def __init__(self):
 self.usage = {}
 
 def track(self, user_id, model, tokens):
 """Track API usage"""
 if user_id not in self.usage:
 self.usage[user_id] = []
 
 self.usage[user_id].append({
 "model": model,
 "tokens": tokens,
 "timestamp": datetime.now().isoformat()
 })
 
 def get_user_usage(self, user_id):
 """Get usage for user"""
 return self.usage.get(user_id, [])
 
 def save(self, filename="usage.json"):
 """Save usage to file"""
 with open(filename, "w") as f:
 json.dump(self.usage, f, indent=2)

usage_tracker = UsageTracker()

def select_model_by_complexity(prompt):
 """Auto-select model based on prompt complexity"""
 if len(prompt) < 50:
 return "gemini-flash" # $0.0001/1K tokens
 elif any(word in prompt.lower() for word in ["code", "debug", "program"]):
 return "gpt-5-mini" # $0.001/1K tokens
 elif any(word in prompt.lower() for word in ["analyze", "research", "explain"]):
 return "claude-sonnet" # $0.003/1K tokens
 else:
 return "gpt-5-mini" # Default

# In .env
MAX_CONTEXT_MESSAGES=5 # Reduce from 10 to save tokens

worker: python bot.py

discord.py==2.3.2
openai==1.12.0
python-dotenv==1.0.0
aiohttp==3.9.3

heroku create your-bot-name
heroku config:set DISCORD_TOKEN=your_token
heroku config:set CRAZYROUTER_API_KEY=your_key
git push heroku main

from collections import defaultdict
import time

user_last_request = defaultdict(float)
COOLDOWN = 5 # seconds

@bot.tree.command(name="ask")
async def ask(interaction, model, prompt):
 user_id = interaction.user.id
 now = time.time()
 
 if now - user_last_request[user_id] < COOLDOWN:
 await interaction.response.send_message(
 f"⏳ Please wait {COOLDOWN}s between requests",
 ephemeral=True
 )
 return
 
 user_last_request[user_id] = now
 # ... rest of command