Developing a Robust System Prompt for a Personal Tutor in Go

Developing a Robust System Prompt for a Personal Tutor

Welcome back! Building on your previous experience with the OpenAI SDK, this course will guide you in developing a RESTful API for a Personal Tutor using Go . In this lesson, we begin by crafting a robust system prompt that provides the DeepSeek model with clear guidelines and ample context for effective educational interactions. You'll learn how to store this prompt in a file and seamlessly load it into your code, setting the foundation for a well-structured tutoring service.

Importance of a Robust System Prompt

Join the 1M+ learners on CodeSignal

Be a part of our community of 1M+ users who develop and demonstrate their skills on CodeSignal

Loading the System Prompt in Go

Now that we understand the structure of a system prompt, let's see how to load it into our Go code. We will create a loadSystemPrompt function that accepts a file path as an argument. This function will read the system prompt from the specified file and return its content as a string. If an error occurs while reading the file, a default prompt will be returned instead.

Here's the code for the loadSystemPrompt function:

package main

import (
    "fmt"
    "os"
)

// loadSystemPrompt loads the tutor system prompt from a file.
// If the file cannot be read, it returns a default prompt.
func loadSystemPrompt(filePath string) string {
    data, err := os.ReadFile(filePath)
    if err != nil {
        fmt.Printf("Error loading system prompt: %v\n", err)
        return "You are a helpful tutor."
    }
    fmt.Println("System prompt loaded successfully.")
    return string(data)
}

package main

import (
    "fmt"
    "os"
)

// loadSystemPrompt loads the tutor system prompt from a file.
// If the file cannot be read, it returns a default prompt.
func loadSystemPrompt(filePath string) string {
    data, err := os.ReadFile(filePath)
    if err != nil {
        fmt.Printf("Error loading system prompt: %v\n", err)
        return "You are a helpful tutor."
    }
    fmt.Println("System prompt loaded successfully.")
    return string(data)
}

This function uses os.ReadFile to read the contents of the file. If the file is successfully read, its content is returned as a string. If there is an error (for example, if the file does not exist), an error message is printed, and a default prompt is returned.

To use this function, you can load the system prompt into your code by passing the file path as follows:

systemPrompt := loadSystemPrompt("app/data/system_prompt.txt")

systemPrompt := loadSystemPrompt("app/data/system_prompt.txt")

By loading the system prompt, we ensure that our tutor is equipped with the necessary context and guidelines to interact effectively with students.

Testing the System Prompt

With the system prompt loaded, we can now integrate it with the DeepSeek model using the openai-go library to create a tutoring conversation. The following example demonstrates how to use the openai-go library to send a conversation to the DeepSeek model, using the loaded system prompt as part of the conversation context.

Below is an example of how you might structure this in Go. This example assumes you have set up the openai-go library and have the necessary API key configured in your environment.

package main

import (
    "context"
    "fmt"
    "log"
    "os"

    "github.com/openai/openai-go"
    "github.com/openai/openai-go/option"
)

type Message struct {
    Role    string
    Content string
}

// SendQuery sends a conversation session to the DeepSeek model and returns the assistant's reply.
func SendQuery(client *openai.Client, session []Message) (string, error) {
    var messages []openai.ChatCompletionMessageParamUnion
    for _, m := range session {
        switch m.Role {
        case "user":
            messages = append(messages, openai.UserMessage(m.Content))
        case "assistant":
            messages = append(messages, openai.AssistantMessage(m.Content))
        case "system":
            messages = append(messages, openai.SystemMessage(m.Content))
        }
    }

    chatCompletion, err := client.Chat.Completions.New(
        context.Background(),
        openai.ChatCompletionNewParams{
            Messages: messages,
            Model:    "deepseek-ai/DeepSeek-V3",
        },
    )
    if err != nil {
        return "", err
    }
    if len(chatCompletion.Choices) == 0 {
        return "", nil
    }
    return chatCompletion.Choices[0].Message.Content, nil
}

func loadSystemPrompt(filePath string) string {
    data, err := os.ReadFile(filePath)
    if err != nil {
        fmt.Printf("Error loading system prompt: %v\n", err)
        return "You are a helpful tutor."
    }
    return string(data)
}

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

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

    // Create a client and take its address
    client := openai.NewClient(
        option.WithAPIKey(apiKey),
        option.WithBaseURL(baseURL),
    )
    clientPtr := &client

    // Load the system prompt from file
    systemPrompt := loadSystemPrompt("app/data/system_prompt.txt")

    // Structure the conversation history with system and user messages
    conversation := []Message{
        {Role: "system", Content: systemPrompt},
        {Role: "user", Content: "Can you explain the basics of algebra?"},
    }

    // Request response from the tutor AI
    reply, err := SendQuery(clientPtr, conversation)
    if err != nil {
        log.Fatal(err)
    }

    // Show the response
    fmt.Println("Student:\n", conversation[1].Content)
    fmt.Println("\nTutor:\n", reply)
}

package main

import (
    "context"
    "fmt"
    "log"
    "os"

    "github.com/openai/openai-go"
    "github.com/openai/openai-go/option"
)

type Message struct {
    Role    string
    Content string
}

// SendQuery sends a conversation session to the DeepSeek model and returns the assistant's reply.
func SendQuery(client *openai.Client, session []Message) (string, error) {
    var messages []openai.ChatCompletionMessageParamUnion
    for _, m := range session {
        switch m.Role {
        case "user":
            messages = append(messages, openai.UserMessage(m.Content))
        case "assistant":
            messages = append(messages, openai.AssistantMessage(m.Content))
        case "system":
            messages = append(messages, openai.SystemMessage(m.Content))
        }
    }

    chatCompletion, err := client.Chat.Completions.New(
        context.Background(),
        openai.ChatCompletionNewParams{
            Messages: messages,
            Model:    "deepseek-ai/DeepSeek-V3",
        },
    )
    if err != nil {
        return "", err
    }
    if len(chatCompletion.Choices) == 0 {
        return "", nil
    }
    return chatCompletion.Choices[0].Message.Content, nil
}

func loadSystemPrompt(filePath string) string {
    data, err := os.ReadFile(filePath)
    if err != nil {
        fmt.Printf("Error loading system prompt: %v\n", err)
        return "You are a helpful tutor."
    }
    return string(data)
}

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

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

    // Create a client and take its address
    client := openai.NewClient(
        option.WithAPIKey(apiKey),
        option.WithBaseURL(baseURL),
    )
    clientPtr := &client

    // Load the system prompt from file
    systemPrompt := loadSystemPrompt("app/data/system_prompt.txt")

    // Structure the conversation history with system and user messages
    conversation := []Message{
        {Role: "system", Content: systemPrompt},
        {Role: "user", Content: "Can you explain the basics of algebra?"},
    }

    // Request response from the tutor AI
    reply, err := SendQuery(clientPtr, conversation)
    if err != nil {
        log.Fatal(err)
    }

    // Show the response
    fmt.Println("Student:\n", conversation[1].Content)
    fmt.Println("\nTutor:\n", reply)
}

In this example, the tutor uses the system prompt to understand its role and respond appropriately to the student's question. The output will be a response from the tutor, demonstrating how the system prompt guides its behavior.

Example Tutor Response

Upon executing the test, the tutor utilizes the system prompt to generate a response. This example illustrates how the system prompt effectively guides the tutor's interaction with the student:

text

Student:
Can you explain the basics of algebra?

Tutor:
I'd be happy to explain the basics of algebra! Algebra is a branch of mathematics that helps us solve problems by using letters and symbols to represent numbers and relationships.

Let me break down the fundamentals:

1. **Variables**: These are letters (like x, y, z) that represent unknown values or quantities that can change. They're like containers that can hold different numbers.

2. **Expressions**: These are combinations of variables, numbers, and operations (like +, -, ×, ÷). For example: 3x + 4 or y² - 7.

3. **Equations**: These are statements that show two expressions are equal, connected by an equals sign (=). For example: x + 5 = 12.

4. **Solving equations**: This involves finding the value of the variable that makes the equation true. For the equation x + 5 = 12, we can solve for x:
   - Subtract 5 from both sides: x = 12 - 5
   - Therefore: x = 7

5. **Properties**:
   - Commutative property: a + b = b + a and a × b = b × a
   - Associative property: (a + b) + c = a + (b + c) and (a × b) × c = a × (b × c)
   - Distributive property: a × (b + c) = (a × b) + (a × c)

Algebra helps us:
- Solve real-world problems by converting them into mathematical equations
- Find unknown values
- Express patterns and relationships
- Make predictions based on existing data

What's your current knowledge level with algebra? Would you like me to explain any specific concept in more detail or provide some simple practice problems to help you understand better?

Student:
Can you explain the basics of algebra?

Tutor:
I'd be happy to explain the basics of algebra! Algebra is a branch of mathematics that helps us solve problems by using letters and symbols to represent numbers and relationships.

Let me break down the fundamentals:

1. **Variables**: These are letters (like x, y, z) that represent unknown values or quantities that can change. They're like containers that can hold different numbers.

2. **Expressions**: These are combinations of variables, numbers, and operations (like +, -, ×, ÷). For example: 3x + 4 or y² - 7.

3. **Equations**: These are statements that show two expressions are equal, connected by an equals sign (=). For example: x + 5 = 12.

4. **Solving equations**: This involves finding the value of the variable that makes the equation true. For the equation x + 5 = 12, we can solve for x:
   - Subtract 5 from both sides: x = 12 - 5
   - Therefore: x = 7

5. **Properties**:
   - Commutative property: a + b = b + a and a × b = b × a
   - Associative property: (a + b) + c = a + (b + c) and (a × b) × c = a × (b × c)
   - Distributive property: a × (b + c) = (a × b) + (a × c)

Algebra helps us:
- Solve real-world problems by converting them into mathematical equations
- Find unknown values
- Express patterns and relationships
- Make predictions based on existing data

What's your current knowledge level with algebra? Would you like me to explain any specific concept in more detail or provide some simple practice problems to help you understand better?

This response showcases the tutor's ability to provide detailed and relevant educational information based on the system prompt, ensuring a consistent and informative learning experience. Notice how the tutor:

Breaks down the complex topic into manageable parts
Uses clear explanations for each concept
Provides examples to illustrate key points
Ends with a question to assess the student's understanding

These behaviors directly reflect the guidelines provided in the system prompt.