Discord bots have evolved from simple moderation tools to interactive companions that can answer questions, generate stories, or summarize conversations. Adding an AI layer—using large language models—transforms a static command bot into something that feels alive. This guide walks you through building your first AI-powered Discord bot using Python, the discord.py library, and OpenAI’s GPT-3.5 API (the same model behind ChatGPT, with a January 2024 snapshot). You’ll end with a working bot that can respond to messages contextually, remember conversation history within a channel, and gracefully handle errors. I assume you have basic Python knowledge (variables, functions, installing packages) and a Discord account. No prior bot experience is required.
Before writing any code, gather the following. Each tool is free for development, though OpenAI’s API costs a few cents per month at small scale.
Create a new folder called ‘discord_ai_bot’. Inside, create two files: main.py and a .env file (to store secrets). Open a terminal in this folder and install the required packages:
pip install discord.py python-dotenv openai
discord.py version 2.3.2 (released July 2023) is the latest stable at time of writing. python-dotenv (1.0.0) loads environment variables without hardcoding them. openai (1.6.0) gives access to GPT-3.5-turbo. Pin these versions in a requirements.txt file for reproducibility:
discord.py==2.3.2
python-dotenv==1.0.0
openai==1.6.0
Hardcoding tokens in your script risks accidental exposure when sharing code. A .env file stores them outside the source. Here's what your .env should contain:
DISCORD_TOKEN=your_72_char_token_here
OPENAI_API_KEY=sk-your_51_char_key_here
Add a .gitignore file if you use Git, and include ‘.env’ as a line so it never gets uploaded.
Start with the skeleton to confirm your token works. In main.py, write:
import discord
from discord.ext import commands
from dotenv import load_dotenv
import os
load_dotenv()
TOKEN = os.getenv('DISCORD_TOKEN')
intents = discord.Intents.default()
intents.message_content = True # required to read message text
bot = commands.Bot(command_prefix='!', intents=intents)
@bot.event
async def on_ready():
print(f'{bot.user} has connected to Discord!')
bot.run(TOKEN)
Run it with python main.py. You should see “BotName has connected to Discord!” in your terminal. If you get a Privileged Intent error, go back to the Discord Developer Portal > Bot > toggle “Message Content Intent” to ON. This is a common omission that blocks the bot from seeing messages.
Now we add the AI layer. The bot will read messages in a specific channel (designate one by name, e.g., “ai-chat”) and respond to every message that mentions it or starts with the prefix.
Below the bot initialization, add:
from openai import OpenAI
client = OpenAI(api_key=os.getenv('OPENAI_API_KEY'))
Write a command !ask that takes user input and returns a GPT response:
@bot.command(name='ask')
async def ask(ctx, *, question):
try:
response = client.chat.completions.create(
model='gpt-3.5-turbo-1106', # November 2023 snapshot
messages=[
{'role': 'system', 'content': 'You are a helpful Discord assistant. Keep responses under 2000 characters.'},
{'role': 'user', 'content': question}
],
max_tokens=500,
temperature=0.7
)
answer = response.choices[0].message.content
await ctx.send(answer[:2000])
except Exception as e:
await ctx.send(f'Sorry, something went wrong: {str(e)[:100]}')
Test by typing !ask what is the capital of France? in your designated channel. The bot should reply “Paris.” If you get a 401 error, double-check your API key in the .env file.
A raw !ask command has no memory. Each query is isolated. To make the bot feel like a conversation partner, you can pass previous messages as context. This is the most common expectation for an “AI-powered” bot—users assume it remembers what they said ten messages ago. Be careful: context costs money (each token in the input is billed).
Store the last 10 messages per channel in a dictionary. Add this outside the bot:
conversation_history = {} # key: channel_id, value: list of dicts
MAX_HISTORY = 10
Modify the ask command to build a messages list from history:
@bot.command(name='ask')
async def ask(ctx, *, question):
channel_id = ctx.channel.id
if channel_id not in conversation_history:
conversation_history[channel_id] = [
{'role': 'system', 'content': 'You are a helpful Discord assistant. Keep responses under 2000 characters.'}
]
conversation_history[channel_id].append({'role': 'user', 'content': question})
# Keep only the last MAX_HISTORY user+assistant turns (plus system prompt)
if len(conversation_history[channel_id]) > MAX_HISTORY * 2 + 1:
# Remove oldest user+assistant pair (skip system prompt)
conversation_history[channel_id] = [conversation_history[channel_id][0]] + conversation_history[channel_id][-20:]
try:
response = client.chat.completions.create(
model='gpt-3.5-turbo-1106',
messages=conversation_history[channel_id],
max_tokens=500
)
reply = response.choices[0].message.content
conversation_history[channel_id].append({'role': 'assistant', 'content': reply})
await ctx.send(reply[:2000])
except Exception as e:
await ctx.send(f'Error: {str(e)[:100]}')
Now ask a follow-up: “And what is its population?” The bot will infer you’re still talking about Paris. If you switch channels, the context resets—preventing context leaks across conversations.
Discord has a 5 requests per 5 seconds limit per bot for most endpoints. The OpenAI API throttles at 3500 RPM (requests per minute) for free-tier users, but you can hit Discord’s limit faster. If users spam !ask, you’ll get a 429 error. Implement a simple cooldown per user:
@commands.cooldown(1, 5, commands.BucketType.user) # one use per 5 seconds per user
@bot.command(name='ask')
async def ask(ctx, *, question):
# ... existing code ...
Also handle the cooldown error:
@ask.error
async def ask_error(ctx, error):
if isinstance(error, commands.CommandOnCooldown):
await ctx.send(f'Please wait {error.retry_after:.1f} seconds before asking again.')
If you expect high traffic, consider asynchronous queue management using asyncio.Queue, but for a first bot, a simple cooldown suffices.
Robust bots don’t crash on weird input. Users will send 10,000-character messages, emoji-only strings, or slash commands that break your parser. Address these:
[:2000]. Warn users if truncation happens.if not question.strip() and reply with “Please ask a non-empty question.”timeout=30 in the client so the bot doesn’t hang. Catch openai.APITimeoutError.A bot running on your laptop dies when you close the lid. For always-on availability, deploy to a cloud server. Here are two budget-friendly options:
python main.py, add environment variables in the dashboard.Whichever you use, ensure the token and API key are stored as environment variables, not in your code. Use git push to deploy changes automatically if you set up continuous integration.
If your cloud server uses a very old Linux distribution (e.g., CentOS 7), Python’s SSL module might not connect to OpenAI’s servers. Upgrade with pip install pyopenssl or use a newer Ubuntu image (22.04 LTS works reliably).
Your bot is now live and functional. Start with the basic !ask command, then add memory throttling, then deploy. The real power comes from iterating: watch where users get confused, add error messages that explain what went wrong, and consider adding a !stats command that shows how many queries were handled today. Resist the temptation to add every feature at once—a simple, reliable bot beats a feature-packed one that breaks weekly. The one thing you should do right now: test your bot in a private server with a few friends, collect feedback for a week, then ship version 2 with conversation history persistence (Redis or SQLite) and per-user preferences.
Browse the latest reads across all four sections — published daily.
← Back to BestLifePulse