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

The following Python libraries are required to enable basic functionality for a Discord bot and to safely load environmental variables (such as the bot token):

```python
import os
import discord
from dotenv import load_dotenv
from discord_slash import SlashCommand
```

- `discord` and `discord_slash` provide the core bot features and slash command support.
- `load_dotenv` allows loading the environmental variables saved in a local `.env` file, while `os` allows the script to access these variables regardless of the operating system.

University of Michigan - Ann Arbor

Google

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.

Creating your first bot script

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)
```

Learn Before

Related

Learn After