discord chatgpt教程的进一步展开说明

Introduction

In this blog post, we will explore the usage of several JavaScript libraries and APIs for building a Discord bot that can communicate using OpenAI’s ChatGPT model. We will discuss how to set up the necessary dependencies, authenticate the bot with Discord, handle user interactions, and use the OpenAI API to generate chat responses. Let’s dive in!

Prerequisites

• Basic knowledge of JavaScript.
• A Discord account and a server where you have administrative privileges.
• An OpenAI account with access to the ChatGPT model.

Setting Up the Dependencies

To get started, let’s install the required packages for our Discord bot. We will use the following libraries:

• Axios: A popular HTTP client for making API requests.
• Tweetnacl: A cryptographic library for generating digital signatures.
• OpenAI: A library for interacting with the OpenAI API.
• Discord.js: A powerful library for building Discord bots.
• Discord Interactions: A library for handling Discord interaction events.

You can install these dependencies by running the following command:

“`shell
npm install axios tweetnacl openai discord.js discord-interactions
“`

Authenticating with Discord

Before we can start building our bot, we need to authenticate it with Discord. This involves obtaining a Discord token and a public key. Here’s how you can do it:

1. Create a new Discord application in the Developer Portal.
2. Generate a bot token and keep it safe.
3. Retrieve the public key of your application.

Once you have the token and public key, you can store them in environment variables (process.env.DISCORD_BOT_TOKEN and process.env.DISCORD_PUBLIC_KEY) for security purposes.

Implementing the Slash Command

In Discord, a slash command is a way to interact with bots by typing / followed by a command name. We will implement a chat command (/chatgpt) that uses OpenAI’s ChatGPT model to provide responses.

First, let’s define the function getOpenAIChatCompletion that calls the OpenAI API to fetch the completion. We will use the gpt⑶.5-turbo model for generating chat responses.

“`javascript
const getOpenAIChatCompletion = async (question) => {
try {
const configuration = new Configuration({ apiKey });
const openai = new OpenAIApi(configuration);
const completion = await openai.createChatCompletion({
model: ‘gpt⑶.5-turbo’,
messages: [{ role: ‘assistant’, content: question }],
});

console.log(‘ChatGPT completion data:’, completion.data.choices[0].message.content.trim());

return {
code: 0,
data: completion.data.choices[0].message.content.trim(),
};
} catch (error) {
console.error(`OpenAI API error: ${error.message}`);

return {
code: 1,
message: `OpenAI API error: ${error.message}`,
};
}
};
“`

Next, we’ll implement the createResponseEmbed function that builds an Embed object for the replied message. This allows us to format the response with rich text and styling.

“`javascript
const createResponseEmbed = (response) => {
const embed = new EmbedBuilder()
.setColor(‘#37393E’)
.setDescription(response);

return {
embeds: ,
};
};
“`

Handling Interactions

Now that we have implemented the necessary functions, let’s handle the interactions with our bot. When a user interacts with the bot through a slash command, Discord sends a POST request to our bot’s endpoint. We can extract the interaction type, data, and token from the request payload. Here’s how we can handle the interactions:

“`javascript
module.exports = async function (params, context) {
console.log(‘params context’, params);

// Get signature and timestamp from headers
const signature = context.headers[‘X-Signature-Ed25519’];
const timestamp = context.headers[‘X-Signature-Timestamp’];

// Get rawBody content
const body = context.rawBody;

// Verify whether the request is from Discord
const isVerified = nacl.sign.detached.verify(
Buffer.from(timestamp + body),
Buffer.from(signature, ‘hex’),
Buffer.from(discordPublicKey, ‘hex’)
);

if (!isVerified) {
context.status(401);
return ‘Invalid request signature’;
}

// Extract interaction type and data
const { type, id, data, token } = params;
console.log(‘params’, params);

// Handle verification requests, reply with PONG
if (type === InteractionType.PING) {
return {
type: InteractionResponseType.PONG,
};
}

// Handle user registered interaction command
if (type === InteractionType.APPLICATION_COMMAND && data.name === slashCommandName) {
const userInput = data.options[0].value;

// Immediately acknowledge the interaction
try {
await axios.post(
`https://discord.com/api/v9/interactions/${id}/${token}/callback`,
{
type: InteractionResponseType.DEFERRED_CHANNEL_MESSAGE_WITH_SOURCE,
}
);
} catch (error) {
console.error(‘Error acknowledging the interaction:’, error);
return;
}

const response = await getOpenAIChatCompletion(userInput);
console.log(‘response from OpenAI ChatCompletion:’, response);

// Edit the original response message
if (response.code === 0) {
try {
await axios.patch(
`https://discord.com/api/v9/webhooks/${process.env.DISCORD_APP_ID}/${token}/messages/@original`,
{
content: `> ${userInput} ${response.data}`,
}
);
} catch (error) {
console.error(‘Error editing the original response:’, error.message);
return;
}
}
}
};
“`

Conclusion

In this article, we have explored how to build a Discord bot that can communicate using OpenAI’s ChatGPT model. We have covered the setup of dependencies, the authentication process with Discord, and the implementation of slash commands. We have also seen how to handle user interactions and generate responses using the OpenAI API. By following these steps, you can create your own interactive Discord bot powered by AI. Have fun experimenting and building amazing chat experiences with ChatGPT and Discord!

discord chatgpt教程的常见问答Q&A