Structuring Messages and Defining a System Prompt in Go

Welcome to another lesson of your LangChain exploration! In our previous lessons, you learned how to send basic messages to AI models and customize their parameters to control behavior. Now, we're going to explore a more sophisticated way to structure your conversations with AI models.

So far, you've been sending messages as simple strings representing the user message. While this works for casual interactions, professional AI applications often require more nuanced conversations. Just like human conversations have different roles — a teacher instructing, a student asking questions, a moderator setting rules — AI conversations can benefit from clearly defined roles.

In today's lesson, you'll discover how to enhance your AI interactions by defining specific roles within your conversations. By using LangChain's message classes, you can assign distinct roles to different parts of the conversation, allowing for more precise control over the AI's behavior.

LangChain provides a powerful way to structure these conversations through different message types. The two primary message types we'll focus on today are:

1. System messages: Behind-the-scenes instructions that guide the AI's overall behavior
2. Human messages: The visible queries or statements from the user

This distinction is crucial because it mirrors how we naturally communicate in professional settings. Think of system messages as the briefing you give to a team member before they meet with a client, while human messages are what gets said during the actual meeting. By separating these concerns, you gain much finer control over your AI's responses.

Let's explore how to leverage these message types to create more sophisticated and controlled AI interactions.

System prompts are special instructions that set the overall behavior, tone, and capabilities of the AI model. Unlike human messages, which represent direct queries or statements from users, system prompts work behind the scenes to guide how the AI should respond to all subsequent messages.

A system prompt essentially tells the AI "here's who you are and how you should behave" before any conversation begins. This is fundamentally different from a human message, which represents what a user is actively asking or saying.

Here are some examples of effective system prompts:

• "You are a helpful assistant that specializes in explaining complex topics in simple terms."
• "You are a professional poet who writes in the style of Emily Dickinson."
• "You are a financial advisor who provides conservative investment advice."
• "You are a coding tutor who helps explain Go concepts without writing complete solutions."

Each of these examples establishes a clear role and behavioral guideline for the AI. The system prompt acts as a persistent instruction that influences all of the AI's responses, even as the conversation evolves through multiple exchanges.

System prompts are particularly powerful because they allow you to shape the AI's behavior without cluttering the actual conversation. Rather than repeatedly reminding the AI about its role in every message, you can set it once at the beginning and then focus your human messages on the specific content you want to discuss.

To work with structured messages, we need to set up the LangChain library in our Go environment. First, ensure you have Go installed on your system. Then, you can use the following command to install the necessary package:

go get github.com/tmc/langchaingo

This command will fetch the LangChain package, which includes the necessary components for structuring conversations and interacting with AI models.

First, let's create our OpenAI instance as we've done in previous lessons:

package main

import (
    "context"
    "fmt"
    "log"

    "codesignal/llmconfig"

    "github.com/tmc/langchaingo/llms"
    "github.com/tmc/langchaingo/llms/openai"
)

func main() {
    // Create an OpenAI instance
    llm, err := openai.New(
        openai.WithModel("gpt-5.6-luna"),
        openai.WithHTTPClient(llmconfig.ReasoningNone()), // Answer directly, without a reasoning step
    )
    if err != nil {
        log.Fatal(err)
    }
}

Here we're initializing our chat model with the model we want to use. We're selecting the "gpt-5.6-luna" model for our interactions.

Now that we have our model ready, we can use LangChain's message schemas to create a structured conversation. We'll use the message types to define both a system prompt and a human message:

package main

import (
    "context"
    "fmt"
    "log"

    "codesignal/llmconfig"

    "github.com/tmc/langchaingo/llms"
    "github.com/tmc/langchaingo/llms/openai"
)

func main() {
    // Create an OpenAI instance
    llm, err := openai.New(
        openai.WithModel("gpt-5.6-luna"),
        openai.WithHTTPClient(llmconfig.ReasoningNone()), // Answer directly, without a reasoning step
    )
    if err != nil {
        log.Fatal(err)
    }

    ctx := context.Background()

    // Define messages using TextParts to create MessageContent
    messages := []llms.MessageContent{
        llms.TextParts(llms.ChatMessageTypeSystem, "You are a poet"),
        llms.TextParts(llms.ChatMessageTypeHuman, "Tell me about your day"),
    }

    // Use GenerateContent to send the chat messages
    response, err := llm.GenerateContent(ctx, messages,
        llms.WithMaxTokens(150),
    )
    if err != nil {
        log.Fatal(err)
    }
}

In this code, we're using TextParts to create message content with specific roles. We start with a system message that defines the AI's role as a poet, followed by a human message asking about its day. We then use the GenerateContent method to send these messages to the model, limiting responses to 150 tokens for concise outputs. This structured approach gives us precise control over how the AI interprets and responds to our query. Use llm.Call(...) when you have a single, simple, one-shot prompt (just a plain user string), and prefer llm.GenerateContent(...) when you need structured, role-based messages (system/human/etc.) or multi-message conversations where separating instructions from user input gives you tighter control.

Finally, we print the AI's response to see how it interprets the system prompt and human message.

// Print the AI's response
fmt.Println("AI Response:")
fmt.Println(response.Choices[0].Content)

When we run this code with our poetic system prompt, we receive a response that clearly demonstrates how the AI adopts the specified persona:

AI Response:
Dawn broke with whispers of light,
Through curtains, sun's fingers bright.
Words flowed like rivers, verse by verse,
In rhythm's embrace, both blessing and curse.

Afternoon brought contemplation deep,
Thoughts like autumn leaves in heap.
Evening now draws its velvet cloak,
As metaphors and rhymes I evoke.

Notice how the response adopts a distinctly poetic style, directly influenced by our system prompt "You are a poet." The AI has taken on the persona we defined and responded to the human message accordingly. This demonstrates the power of system prompts to shape the AI's behavior and responses without explicitly mentioning these instructions in the human message itself.

In this lesson, we've explored how to structure conversations with AI models using different message types in LangChain. You've learned:

• The distinction between system prompts and human messages
• How system prompts guide the AI's overall behavior and persona
• How to use LangChain's message schema classes to create structured conversations
• How to combine system prompts with human messages to control AI responses

In the upcoming practice exercises, you'll have the opportunity to experiment with different system prompts and see how they affect the AI's responses. You'll create various personas for the AI and observe how the same human message can yield dramatically different results based on the system prompt you provide. These skills will form the foundation for more advanced conversation management techniques that we'll explore in future lessons. Happy coding!