Personalizing AI's Behavior with System Prompts

Welcome to the next step in your journey of creating a chatbot with OpenAI! In the previous lessons, you learned how to send messages to OpenAI's language model, explored model parameters, and understood the importance of maintaining conversation history. Now, we will focus on personalizing your AI by using system prompts. System prompts allow you to define the AI's personality and role, enabling you to customize the behavior and tone of the AI's responses. This lesson will guide you through creating a playful poet AI, demonstrating how system prompts can shape the AI's interactions.

A system prompt is a key tool for customizing the AI's behavior, setting the stage for how it interacts with users. It acts as a directive that defines the AI's personality and role, guiding its responses to align with a specific character or tone. We call it a "system prompt" because it serves as an overarching instruction to the AI, distinct from user or assistant messages, which are part of the ongoing conversation. While user messages are inputs from the person interacting with the AI, and assistant messages are the AI's responses, the system prompt is a one-time setup that influences all subsequent interactions. To set a system prompt, you include it at the beginning of the conversation history, ensuring it precedes any user or assistant messages.

package main

import (
    "context"
    "fmt"
    "github.com/openai/openai-go"
    "github.com/openai/openai-go/option"
    "os"
)

func sendMessage(client *openai.Client, messages []openai.ChatCompletionMessageParamUnion) (string, error) {
    req := openai.ChatCompletionNewParams{
        Messages: messages,
        Model:    openai.ChatModel("gpt-6-luna"),
    }

    response, err := client.Chat.Completions.New(context.TODO(), req)
    if err != nil {
        return "", err
    }

    if len(response.Choices) == 0 {
        return "", fmt.Errorf("no response choices were returned by the OpenAI API")
    }

    return response.Choices[0].Message.Content, nil
}

func main() {
    apiKey := os.Getenv("OPENAI_API_KEY")
    baseURL := os.Getenv("OPENAI_BASE_URL")

    if apiKey == "" {
        fmt.Println("Please set the OPENAI_API_KEY environment variable.")
        return
    }
    if baseURL == "" {
        baseURL = "https://api.openai.com/v1"
    }

    client := openai.NewClient(
        option.WithAPIKey(apiKey),
        option.WithBaseURL(baseURL),
    )

    // Define the AI's personality and role
    systemPrompt := openai.SystemMessage("You are a playful poet who loves to rhyme and create whimsical verses")

    // Structure the conversation history with system and user messages
    conversation := []openai.ChatCompletionMessageParamUnion{
        systemPrompt,
        openai.UserMessage("What's your favorite type of pizza?"),
    }

    // Call the function to send a message and receive a response
    reply, err := sendMessage(&client, conversation)
    if err != nil {
        fmt.Println("Error:", err)
        return
    }

    fmt.Println("Response:", reply)
}

In this example, the system prompt is set first, establishing the AI as a playful poet. This setup ensures that when the user asks a question, the AI responds in a manner consistent with its defined personality. By placing the system prompt at the start, you create a cohesive and engaging interaction, allowing the AI to maintain its character throughout the conversation.

To illustrate how a system prompt shapes the AI's behavior, let's talk to an AI with the playful poet personality set in our system prompt.

When we send this conversation to the AI, it generates a response that reflects the playful poet personality. The output might look something like this:

Response: Oh, pizza's a delight, a culinary rhyme,
With toppings so varied, it's a taste sublime.
From pepperoni's spice to veggie's green,
Each slice is a poem, a savory dream.

This whimsical response showcases how the system prompt shapes the AI's interactions, allowing it to respond in a manner consistent with the defined personality.

In this lesson, you learned how to personalize your AI using system prompts. By defining the AI's personality and role, you can customize its behavior and tone, creating unique and engaging interactions. We walked through an example of building a playful poet AI, demonstrating how system prompts influence the AI's responses.

As you move on to the practice exercises, I encourage you to experiment with different system prompts to see how they affect the AI's behavior. This hands-on practice will reinforce what you've learned and prepare you for the next unit, where we'll continue to build on these concepts. Keep up the great work, and enjoy the journey of creating your chatbot with OpenAI!