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

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.

Importing Python libraries for a Discord bot

Create a Python file in the project's root directory to serve as the bot script. Build the script by importing the required libraries, loading environment variables, configuring the Discord client and slash commands, and implementing a command that sends a "Hello world!" response.

University of Michigan - Ann Arbor

Google

Creating a Discord bot in Python involves completing necessary prerequisites such as installing the `discord.py` library, writing the initial bot script to establish a connection with the Discord API, and implementing advanced features like event-driven responses and interactive UI elements.

Getting Started with a Discord Bot in Python

**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

Beyond basic message commands, advanced Discord bot features enable automated, event-driven responses to user activity and enhanced custom interactions. These features include dynamically changing the bot's presence or status and implementing interactive UI elements like buttons and select menus.

Learn Before

Related

Learn After