Build a Discord Bot with Python (Step by Step)

mkdir discord-bot
cd discord-bot
python -m venv venv
source venv/bin/activate
pip install discord.py[voice] python-dotenv requests

# bot.py
import discord
from discord.ext import commands
import os
from dotenv import load_dotenv

load_dotenv()

# Bot configuration
TOKEN = os.getenv("DISCORD_TOKEN")
intents = discord.Intents.default()
intents.message_content = True
intents.members = True

bot = commands.Bot(
    command_prefix="!",
    intents=intents,
    description="UtilityBot — your all-in-one Discord helper",
    activity=discord.Game(name="!help for commands"),
)

@bot.event
async def on_ready():
    print(f"✅ Logged in as {bot.user.name} (ID: {bot.user.id})")
    print(f"📡 Connected to {len(bot.guilds)} guilds")
    print(f"👥 Total members: {sum(g.member_count for g in bot.guilds)}")

    # Sync slash commands with Discord
    try:
        synced = await bot.tree.sync()
        print(f"✨ Synced {len(synced)} slash command(s)")
    except Exception as e:
        print(f"⚠️ Failed to sync commands: {e}")

@bot.event
async def on_message(message):
    # Don't respond to self
    if message.author == bot.user:
        return

    # Log messages in debug
    print(f"[{message.guild}] #{message.channel} {message.author}: {message.content[:80]}")

    await bot.process_commands(message)

# Load all cogs
async def load_cogs():
    for cog_file in ["cogs.basic", "cogs.moderation", "cogs.utility", "cogs.tickets"]:
        try:
            await bot.load_extension(cog_file)
            print(f"✅ Loaded cog: {cog_file}")
        except Exception as e:
            print(f"❌ Failed to load {cog_file}: {e}")

if __name__ == "__main__":
    import asyncio
    asyncio.run(load_cogs())
    bot.run(TOKEN)

# cogs/basic.py
import discord
from discord.ext import commands
from discord import app_commands
import datetime

class BasicCog(commands.Cog):
    def __init__(self, bot):
        self.bot = bot

    @commands.command(name="ping")
    async def ping(self, ctx):
        """Check the bot's latency."""
        latency = round(self.bot.latency * 1000)
        await ctx.send(f"🏓 Pong! {latency}ms")

    @commands.command(name="say")
    async def say(self, ctx, *, message: str):
        """Make the bot repeat your message."""
        await ctx.send(f"{ctx.author.mention} says: {message}")
        await ctx.message.delete()

    @commands.command(name="info")
    async def info(self, ctx):
        """Show bot information in an embed."""
        embed = discord.Embed(
            title="UtilityBot Info",
            description="A multi-purpose Discord bot built with discord.py",
            color=discord.Color.blue(),
            timestamp=datetime.datetime.utcnow()
        )
        embed.add_field(name="Developer", value="DodaTech", inline=True)
        embed.add_field(name="Library", value="discord.py 2.x", inline=True)
        embed.add_field(name="Servers", value=len(self.bot.guilds), inline=True)
        embed.add_field(name="Commands", value=len(self.bot.commands), inline=True)
        embed.set_footer(text=f"Requested by {ctx.author}", icon_url=ctx.author.display_avatar.url)
        await ctx.send(embed=embed)

    # Slash command equivalent
    @app_commands.command(name="ping", description="Check the bot's latency")
    async def slash_ping(self, interaction: discord.Interaction):
        latency = round(self.bot.latency * 1000)
        await interaction.response.send_message(f"🏓 Pong! {latency}ms")

    @app_commands.command(name="info", description="Show bot information")
    async def slash_info(self, interaction: discord.Interaction):
        embed = discord.Embed(
            title="UtilityBot Info",
            color=discord.Color.blue(),
            timestamp=datetime.datetime.utcnow()
        )
        embed.add_field(name="Library", value="discord.py 2.x")
        embed.add_field(name="Servers", value=len(self.bot.guilds))
        await interaction.response.send_message(embed=embed)

    @commands.Cog.listener()
    async def on_member_join(self, member):
        """Welcome new members."""
        channel = member.guild.system_channel
        if channel:
            embed = discord.Embed(
                title="Welcome!",
                description=f"Hey {member.mention}, welcome to **{member.guild.name}**!",
                color=discord.Color.green()
            )
            embed.set_thumbnail(url=member.display_avatar.url)
            embed.add_field(name="Member Count", value=member.guild.member_count)
            await channel.send(embed=embed)

    @commands.Cog.listener()
    async def on_member_remove(self, member):
        channel = member.guild.system_channel
        if channel:
            await channel.send(f"👋 {member.name} left the server.")

async def setup(bot):
    await bot.add_cog(BasicCog(bot))

# cogs/moderation.py
import discord
from discord.ext import commands
from discord import app_commands

class ModerationCog(commands.Cog):
    def __init__(self, bot):
        self.bot = bot

    @commands.command(name="kick")
    @commands.has_permissions(kick_members=True)
    async def kick(self, ctx, member: discord.Member, *, reason="No reason provided"):
        """Kick a member from the server."""
        if member == ctx.author:
            await ctx.send("You can't kick yourself!")
            return
        if member.top_role >= ctx.author.top_role:
            await ctx.send("You can't kick someone with equal or higher role!")
            return

        try:
            await member.kick(reason=reason)
            embed = discord.Embed(
                title="Member Kicked",
                description=f"{member.mention} was kicked",
                color=discord.Color.orange()
            )
            embed.add_field(name="Reason", value=reason)
            embed.add_field(name="Moderator", value=ctx.author.mention)
            await ctx.send(embed=embed)
        except discord.Forbidden:
            await ctx.send("I don't have permission to kick that member!")

    @commands.command(name="clear")
    @commands.has_permissions(manage_messages=True)
    async def clear(self, ctx, count: int):
        """Delete a number of messages (max 100)."""
        if count < 1 or count > 100:
            await ctx.send("Please specify a number between 1 and 100.")
            return
        deleted = await ctx.channel.purge(limit=count + 1)  # +1 for the command itself
        msg = await ctx.send(f"🗑 Deleted {len(deleted) - 1} messages.")
        await msg.delete(delay=3)

    @app_commands.command(name="clear", description="Delete messages (1-100)")
    @app_commands.default_permissions(manage_messages=True)
    async def slash_clear(self, interaction: discord.Interaction, count: int):
        if count < 1 or count > 100:
            await interaction.response.send_message("Use 1-100.", ephemeral=True)
            return
        deleted = await interaction.channel.purge(limit=count)
        await interaction.response.send_message(f"🗑 Deleted {len(deleted)} messages.", ephemeral=True)

    @commands.command(name="slowmode")
    @commands.has_permissions(manage_channels=True)
    async def slowmode(self, ctx, seconds: int = 5):
        """Set slowmode in the current channel."""
        if seconds < 0 or seconds > 21600:
            await ctx.send("Slowmode must be between 0 and 21600 seconds (6 hours).")
            return
        await ctx.channel.edit(slowmode_delay=seconds)
        if seconds == 0:
            await ctx.send("✅ Slowmode disabled.")
        else:
            await ctx.send(f"✅ Slowmode set to {seconds} seconds.")

    @commands.Cog.listener()
    async def on_message(self, message):
        """Auto-mod: delete messages with banned words."""
        if message.author.bot:
            return

        banned_words = ["badword1", "badword2"]  # Load from config file
        if any(word in message.content.lower() for word in banned_words):
            await message.delete()
            await message.channel.send(
                f"{message.author.mention} that word is not allowed!",
                delete_after=5
            )

    @kick.error
    async def kick_error(self, ctx, error):
        if isinstance(error, commands.MissingPermissions):
            await ctx.send("❌ You need the `Kick Members` permission to use this.")
        elif isinstance(error, commands.BadArgument):
            await ctx.send("❌ Could not find that member.")

async def setup(bot):
    await bot.add_cog(ModerationCog(bot))

# cogs/utility.py
import discord
from discord.ext import commands
from discord import app_commands
import requests
import os

class UtilityCog(commands.Cog):
    def __init__(self, bot):
        self.bot = bot
        self.weather_key = os.getenv("WEATHER_API_KEY")

    @commands.command(name="weather")
    async def weather(self, ctx, *, city: str):
        """Get current weather for a city."""
        if not self.weather_key:
            await ctx.send("Weather API key not configured.")
            return

        url = "https://api.openweathermap.org/data/2.5/weather"
        params = {"q": city, "appid": self.weather_key, "units": "metric"}

        try:
            res = requests.get(url, params=params, timeout=5)
            res.raise_for_status()
            data = res.json()

            embed = discord.Embed(
                title=f"Weather in {data['name']}, {data['sys']['country']}",
                color=discord.Color.blue()
            )
            embed.add_field(name="Temperature", value=f"{data['main']['temp']}°C", inline=True)
            embed.add_field(name="Feels Like", value=f"{data['main']['feels_like']}°C", inline=True)
            embed.add_field(name="Humidity", value=f"{data['main']['humidity']}%", inline=True)
            embed.add_field(name="Wind", value=f"{data['wind']['speed']} m/s", inline=True)
            embed.add_field(name="Conditions", value=data['weather'][0]['description'].capitalize(), inline=True)
            embed.set_thumbnail(url=f"https://openweathermap.org/img/wn/{data['weather'][0]['icon']}@2x.png")
            await ctx.send(embed=embed)
        except requests.exceptions.HTTPError:
            await ctx.send(f"❌ City '{city}' not found.")
        except requests.exceptions.RequestException:
            await ctx.send("❌ Could not fetch weather data.")

    @app_commands.command(name="weather", description="Get weather for a city")
    async def slash_weather(self, interaction: discord.Interaction, city: str):
        """Same functionality as a slash command."""
        if not self.weather_key:
            await interaction.response.send_message("Weather API not configured.", ephemeral=True)
            return
        # (Same logic as above, with interaction.response)
        url = "https://api.openweathermap.org/data/2.5/weather"
        params = {"q": city, "appid": self.weather_key, "units": "metric"}
        try:
            res = requests.get(url, params=params, timeout=5)
            res.raise_for_status()
            data = res.json()
            embed = discord.Embed(title=f"Weather in {data['name']}", color=discord.Color.blue())
            embed.add_field(name="Temp", value=f"{data['main']['temp']}°C")
            await interaction.response.send_message(embed=embed)
        except Exception:
            await interaction.response.send_message("City not found.", ephemeral=True)

    @commands.command(name="poll")
    async def poll(self, ctx, question: str, *options):
        """Create a poll with reactions. Usage: !poll "Question?" opt1 opt2 opt3"""
        if len(options) < 2:
            await ctx.send("Need at least 2 options.")
            return
        if len(options) > 10:
            await ctx.send("Maximum 10 options.")
            return

        emojis = ["1️⃣","2️⃣","3️⃣","4️⃣","5️⃣","6️⃣","7️⃣","8️⃣","9️⃣","🔟"]
        description = "\n".join(f"{emojis[i]} {opt}" for i, opt in enumerate(options))
        embed = discord.Embed(title=f"📊 {question}", description=description, color=discord.Color.blue())
        msg = await ctx.send(embed=embed)
        for i in range(len(options)):
            await msg.add_reaction(emojis[i])

async def setup(bot):
    await bot.add_cog(UtilityCog(bot))

# cogs/tickets.py
import discord
from discord.ext import commands
from discord import app_commands

class TicketCog(commands.Cog):
    def __init__(self, bot):
        self.bot = bot

    @commands.command(name="ticket")
    @commands.has_permissions(manage_channels=True)
    async def ticket(self, ctx, *, reason: str = "No reason"):
        """Create a private support ticket channel."""
        guild = ctx.guild
        overwrites = {
            guild.default_role: discord.PermissionOverwrite(read_messages=False),
            ctx.author: discord.PermissionOverwrite(read_messages=True, send_messages=True),
            guild.me: discord.PermissionOverwrite(read_messages=True, send_messages=True),
        }
        channel_name = f"ticket-{ctx.author.name}".lower()
        channel = await guild.create_text_channel(channel_name, overwrites=overwrites)
        embed = discord.Embed(
            title="Ticket Created",
            description=f"Support ticket by {ctx.author.mention}",
            color=discord.Color.green()
        )
        embed.add_field(name="Reason", value=reason)
        embed.add_field(name="Channel", value=channel.mention)
        await ctx.send(embed=embed)
        await channel.send(f"{ctx.author.mention} your ticket has been created. Staff will be with you shortly.")

    @commands.command(name="close")
    async def close(self, ctx):
        """Close a ticket channel."""
        if "ticket-" not in ctx.channel.name:
            await ctx.send("This is not a ticket channel.")
            return
        await ctx.send("🔒 Closing ticket in 5 seconds...")
        await discord.utils.get(ctx.guild.text_channels, name=ctx.channel.name).delete(delay=5)

async def setup(bot):
    await bot.add_cog(TicketCog(bot))

mkdir cogs
# Place cog files in cogs/ directory
python bot.py