Table of contents
In this tutorial you'll use Python to build and deploy a Discord chat bot application that uses Flux Schnell to generate images from text prompts.
Follow discord.py's guide to set up a Discord Bot account. Give it a name like flux-bot
. At the end of the first section, you'll need to turn on the "message content intent" option on the bot page. That permission is needed for your bot to read the content of messages, to get the prompts!
In the second half of the guide – inviting your bot – when it tells you to "tick the permissions required for your bot to function", you'll want to give the bot permission to "Send messages".
This section walks you through steps required to set up a codebase.
mkdir flux-bot
cd flux-bot
Next you'll define some of the Python package dependencies needed by your project.
Install the poetry command-line tool and create a new pyproject.toml
file:
poetry init -n
Then add dependencies:
poetry add discord.py python-dotenv replicate
Create a file named .env
. This text file will be used to store secrets for your development environment. Paste in the following:
REPLICATE_API_TOKEN=<your-token>
DISCORD_TOKEN=<your-token>
Visit replicate.com/account/api-tokens to copy and paste your API token. If you didn't subscribe before, you'll need to now to get hold of the token.
The Discord token is the token you copied when creating your bot from the Discord guide. If you don't have it, you can generate a new one by visiting discord.com/applications, selecting your bot application, selecting "Bot" from the side menu, and clicking "Reset Token".
The .env
file contains secrets, so it should not be shared with anyone. If
you're planning to turn your project into a Git repository, be sure to create
a .gitignore
file and add .env
to
it.
Create a new file called bot.py
and paste the following code into it:
from discord import Intents
from discord.ext import commands
from dotenv import load_dotenv
import os
import replicate
load_dotenv()
intents = Intents.default()
intents.message_content = True
bot = commands.Bot(
command_prefix="!",
description="Runs models on Replicate!",
intents=intents,
)
@bot.command()
async def flux(ctx, *, prompt):
"""Generate an image from a text prompt using the Flux Schnell model"""
msg = await ctx.send(f""{prompt}"\n> Generating...")
output = replicate.run(
"black-forest-labs/flux-schnell",
input={"prompt": prompt}
)
# Convert the FileOutput to bytes for Discord's upload_file
file_data = output[0].read()
await msg.delete()
await ctx.send(f""{prompt}"", file=discord.File(file_data, "flux.png"))
bot.run(os.environ["DISCORD_TOKEN"])
This file defines the command for your bot (!flux
) and how it works. When you want to make changes to your bot later, this will be the file you come back to.
Now that you've written the code for your bot, it's time to run it!
The Discord API uses a system called Gateway which supports real-time communication over WebSockets. This means you can run your bot from any computer, even if it's not exposed to the public internet. No need to configure any webhooks!
Run this command to start your bot locally:
poetry run python bot.py
Check your bot is running by typing !help
into one of the channels on your Discord server. Your bot should respond with the list of commands it can run, including !flux
.
Now try generating an image:
!flux an astronaut riding a horse
Your bot should write a message saying "Generating...", and then a few seconds later it should swap out that message for the newly generated image. 🥳
Running your bot locally is convenient, especially when you're actively working on it. The downside, however, is that it can only run when you're online. If you're building a bot for a server, you probably want it to be online even when you aren't.
There are lots of ways to deploy an application like this. Some of the easiest are services like Vercel, Fly or Heroku. In this tutorial, you'll use Fly to deploy the bot to the cloud.
To get started, see Fly's "speedrun" guide to install the flyctl
command-line tool and create a Fly account.
Then create a new file called Dockerfile
and paste the following code into it:
FROM python:3.10
RUN pip install poetry
WORKDIR /code
COPY poetry.lock pyproject.toml /code/
RUN poetry config virtualenvs.create false && poetry install --no-interaction --no-ansi
COPY . /code
CMD python bot.py
Then create a new Fly application:
flyctl launch
That command will generate a new file called fly.toml
, but it's designed for running web apps so you'll need to make a few changes. Remove the [[services]]
block and everything below it. Your modified file should look something like this:
app = "name-of-your-fly-app"
kill_signal = "SIGINT"
kill_timeout = 5
processes = []
[env]
[experimental]
allowed_public_ports = []
auto_rollback = true
Then configure your Fly app using the secrets from your local .env
file:
flyctl secrets set REPLICATE_API_TOKEN=... DISCORD_TOKEN=...
That's it! Your bot is now running in the cloud.
Now might be a good time to tinker with the bot a bit. Some ideas: