**Discord libraries**

The following libraries are required to get basic functionality in your Discord bot:
```python
import discord
from discord_slash import SlashCommand
```

**Environmental Variables (optional)**

If you have your own libraries for creating environmental variables then you can skip this step, otherwise, add the following lines of code:
```python
from dotenv import load_dotenv
import os
```
**load_dotenv** will allow us to load the environmental variables we have saved in our .env file and **os** allows us to access those variables no matter what our operating system is.

Importing necessary libraries

Before we can run the bot, we need to load our environmental variables and configure our bot's commands. If using **dotenv**, run the follow line of code to load up the variables you have stored in your **.env** file:
```python
load_dotenv()
```
To actually access those variables you need to access them from within your operating system which can be done as follows:
```python
TOKEN = os.environ["TOKEN"]
GUILD_ID = [int(os.environ["GUILD_ID"])]
```
Environmental variables are stored as strings and we need GUILD_ID to be an int for later so we convert it at this stage.

Next up we will define what our bot is called in code. Common names are "client" or "bot" and in this case we will use "client".
```python
client = discord.Client(intents=discord.Intents.default())
slash = SlashCommand(client, sync_commands=True)
```
This will initialize the bot as "client" and specifies what the bot intends to do, which in this case is just the default as we won't be needing additional actions given by privileged intents (read more in the linked reference node). **slash** stores our slash commands as a variable which we will use to define behaviors for command calls.

Initializing bot variables

Now that pretty much everything is set up, we can get the bot to send a message after a user types a command. Every slash command must begin with some basic descriptions of the command:
```python
@slash.slash(
    name="Hello",
    description="Responds with a Hello World message",
    guild_ids=GUILD_ID,
)
```
**@slash.slash** tells the bot that we are creating a slash command and the arguments are how the user can interact. 


1. The name is what the user will actually use to call the command. In this case, they would type "/Hello" and the bot would respond. 

2. The description is a hint that the user sees when typing in the command. This helps users understand what the command does.

3. **guild_ids** is a list of IDs in which the bot is allowed to send slash commands. This is required so that the bot can initialize slash commands in that server which the user can then interact with.


On the next line immediately following the ending parenthesis of the previous command we will define a function that is executed once the above command is called:
```python
async def _hello(ctx);
    await ctx.send("Hello world!")
```

1. **async** defines this function as asynchronous which is required when using any Discord functions that interact with the Discord application (sending a message, deleting a message, sending an embed, etc).

2. **ctx** is an object that is received once a user calls the command. It contains the context of the interaction, including information such as what user used the command, what time it was used, what channel, etc.

3. **await** is a required keyword in an asynchronous function as the command following the keyword must be awaited before continuing.

4. **ctx.send** will send the message inside of the parenthesis to the channel in which the user used the slash command. 

At the very bottom of your script, include the following line of code to run the bot using your token, replacing "client" with whatever you called your bot in the "Initializing bot variables" node:
```python
client.run(TOKEN)
```

Get your bot to send a "Hello world!" message

In your favorite code editor create a Python file in the root directory of your project and name it whatever you want. The following child nodes will show you what libraries need to be imported to get started and what steps need to be taken to get your bot running.

University of Michigan - Ann Arbor

In order to get your bot up and running, there are a few steps that you have to do first. These few nodes will guide you through a quickstart on what you need to do to get started.

Getting started with your first Discord bot

**Installing Discord.py**

If you don't already have pip installed, then look through the intro modules for this Python course or follow the pip documentation linked in this node. Once you have it installed, run the following command from your terminal:
```python
python3 -m pip install discord.py
```

**Installing Discord Slash Commands**

The main way of interacting with modern Discord bots is via slash commands which makes it easier to provide options to the user and simplifies using the bot. To get started with slash commands, run the follow command from your terminal:
```python
python3 -m pip install discord-py-slash-command
```

Prerequisites

Creating your first bot script

Sending a message on command might be useful sometimes but these types of interactions are limited. There are times when you want the bot to automatically respond to users based on messages or have some sort of follow-up to a message.

Learn Before

Related

Learn After