Message Types and Conversation History in JavaScript

Welcome back! In the previous lessons, you learned how to send a simple message to OpenAI's language model and explored various model parameters to customize the AI's responses. Now, we will delve into the concept of message types and the importance of maintaining conversation history. These elements are crucial for creating dynamic and context-aware interactions with the AI, allowing your chatbot to engage in more meaningful conversations.

Before we dive into building and managing conversation history, it's important to understand the concept of message types and how a conversation history is structured. In a chatbot interaction, messages are typically categorized by roles officially recognized by OpenAI: "system", "user", and "assistant". While we'll explore system prompts more thoroughly in a later lesson, remember that these primary roles help define the flow of dialogue and ensure the AI understands who is speaking at any given time. You can technically specify other roles, but doing so may produce unpredictable results because they are not officially supported by OpenAI's chat completion API.

OpenAI expects the conversation history to be formatted as an array of objects, where each object represents a message with two key-value pairs: "role" and "content". Here's an example of what a simple conversation history might look like:

[
    {"role": "user", "content": "Can you recommend a good book?"},
    {"role": "assistant", "content": "I recommend 'To Kill a Mockingbird' by Harper Lee."},
    {"role": "user", "content": "What's it about?"},
    {"role": "assistant", "content": "It's a novel about racial injustice and moral growth in the American South."}
]

In this example, the conversation history consists of alternating messages between the user (the person interacting with the AI) and the assistant (the AI itself). Each message is stored with its respective role, providing context for the AI to generate appropriate responses. Understanding this structure is key to effectively managing conversations and ensuring that the AI can engage in more meaningful interactions.

To manage conversations effectively, we will create a function called sendMessage. This function will send messages to the AI and receive responses, allowing us to handle multiple interactions seamlessly. Here's how the function is structured:

import 'dotenv/config';
import OpenAI from 'openai';

// Initialize the OpenAI client
const openai = new OpenAI({
    apiKey: process.env.OPENAI_API_KEY,
});

// Function to send a message and receive a response
async function sendMessage(messages) {
    const response = await openai.chat.completions.create({
        model: "gpt-6-luna",
        messages: messages
    });
    return response.choices[0].message.content.trim();
}

In this function, we use the chat.completions.create method to send an array of messages to the AI. The messages parameter contains the conversation history, which provides context for the AI's response. The function returns the AI's response, which is extracted from the API result and stripped of any leading or trailing whitespace.