Customizing Model Parameters in LangChain with Go

Welcome to the next step in your LangChain journey! In the previous lesson, you mastered the basics of sending messages to an AI model. Now, it's time to unlock the full potential of your AI interactions by customizing model parameters. This crucial skill will empower you to tailor AI responses to meet your specific needs, making your AI more responsive and aligned with your goals. Get ready to dive deeper and enhance your AI experience by learning how to adjust these parameters effectively.

The model parameter lets you select which AI "brain" will power your conversations:

// Select a specific OpenAI model
llm, err := openai.New(
    openai.WithModel("gpt-5.6-luna"), // Using the cost-efficient GPT-5.6 Luna model
    openai.WithHTTPClient(llmconfig.ReasoningNone()), // Answer directly, without a reasoning step
)

This parameter determines the underlying AI model that processes your messages. Different models offer varying capabilities:

• gpt-5.6-luna: Fast and cost-efficient, a good default for everyday chat tasks
• gpt-5.6-terra: A balance of intelligence and cost for more demanding tasks
• gpt-5.6-sol: The most capable option, at a higher cost

Think of this like choosing between different experts for different tasks — some are more specialized, some more general, and they come with different "hiring costs."

Default: If you don't specify a model, the behavior is provider-specific. Consult your provider's documentation or the LangChainGo docs for the default model in your environment.

Once you've selected your model, you'll want to control how creative it gets. This is where temperature comes in:

// Set the creativity level of the AI
response, err := llm.Call(ctx, prompt,
    llms.WithTemperature(0.7), // Balanced creativity setting
)

Temperature values typically range from 0 to 2:

• Low temperature (0-0.3): More deterministic, focused, and predictable responses
• Medium temperature (0.4-0.7): Balanced creativity and coherence
• High temperature (0.8-2.0): More random, creative, and diverse outputs

For factual questions or coding help, turn the dial down. For creative writing or brainstorming, crank it up. It's like adjusting between "strictly follow the recipe" and "improvise with the ingredients."

Default: The default temperature is provider-specific. For OpenAI models, this is typically 1.0, but always consult the provider or LangChainGo documentation to confirm current defaults.

While temperature controls how your AI thinks, max_tokens controls how much it says:

// Limit the length of the AI's response
response, err := llm.Call(ctx, prompt,
    llms.WithMaxTokens(150), // Caps the response at approximately 100-115 words
)

This parameter sets a hard ceiling on how many tokens the model can generate in its response:

• Lower values (50-100): Results in brief responses that may be cut off before completing the thought
• Medium values (150-500): Provides enough space for most explanations, but complex answers might still be truncated
• Higher values (1000+): Allows for comprehensive responses with less risk of mid-sentence cutoffs

A token is typically about three-quarters of a word in English, so 150 tokens is approximately 100–115 words.

It's important to understand that the model has no awareness of this limit while generating its response. If a response would naturally exceed your max_tokens setting, it will simply be cut off mid-sentence or mid-thought. The model doesn't try to wrap up its answer as it approaches the limit. Without setting this limit, models might generate very lengthy responses, potentially increasing your costs and overwhelming your users with too much information.

Default: The default behavior when max_tokens is not specified varies by provider. Some providers may have no explicit limit (allowing the model to use its maximum context window), while others may apply their own defaults. Consult your provider's documentation or the LangChainGo docs for specific behavior.

Temperature isn't the only way to control randomness. top_p offers a complementary approach:

// Adjust how the AI selects its next words
response, err := llm.Call(ctx, prompt,
    llms.WithTopP(0.9), // Consider only the most likely 90% of possible next words
)

This parameter determines how the model selects the next token in its response:

• Value of 1.0: Consider all possible next words
• Value of 0.9: Only consider the most likely words that add up to 90% probability
• Lower values (0.5-0.7): More focused, less surprising responses

While temperature adjusts "how random" the selection is, top_p filters "which options are even considered." They work well together — like controlling both the size of a menu and how randomly you select from it.

It's common practice to adjust either temperature or top_p, but not both at the same time, since both control randomness. If you do use both, make sure you're doing so intentionally, as combining them can lead to unpredictable results. Many developers find that adjusting temperature is sufficient, but top_p gives you another dimension of control.

Default: The default top_p value is provider-specific. For OpenAI models, this is typically 1.0, but always consult the provider or LangChainGo documentation to confirm current defaults.

Sometimes you don't want creativity at all. For tests, data extraction, or factual lookups, you want the same question to get the same answer every time. Setting the temperature to 0 does exactly that:

// Ask for consistent, repeatable output
response, err := llm.Call(ctx, prompt,
    llms.WithTemperature(0), // Always favor the most likely next word
)

With a temperature of 0, the model consistently picks its most likely next word, so running the same prompt twice gives the same or nearly the same response. Raise the temperature again whenever you want variety — for example, to keep a list of ideas from repeating the same phrases.

With these dials in hand, you can match the configuration to the job:

• Factual answers or data extraction: Low temperature (0-0.3) for consistent, focused output
• Everyday chat: A moderate temperature (around 0.7) for natural, balanced responses
• Brainstorming or creative writing: A higher temperature (1.0-1.2) for fresh, varied wording
• Longer answers: Raise max_tokens so responses aren't cut off mid-sentence

Like any recipe, start from these defaults and adjust based on what you see in the responses.

Now that you understand each parameter individually, you can combine them to create your perfect AI recipe:

package main

import (
    "context"
    "fmt"
    "log"
    
    "codesignal/llmconfig"

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

func main() {
    // Initialize OpenAI model
    llm, err := openai.New(
        openai.WithModel("gpt-5.6-luna"), // Choose a fast, cost-efficient model
        openai.WithHTTPClient(llmconfig.ReasoningNone()), // Answer directly, without a reasoning step
    )
    if err != nil {
        log.Fatal(err)
    }
    
    ctx := context.Background()
    
    // Send a message to the AI model with custom parameters
    response, err := llm.Call(ctx, "Hello, can you tell me a joke?",
        llms.WithTemperature(0.7),           // Balanced creativity setting
        llms.WithMaxTokens(50),              // Keep responses concise
        llms.WithTopP(0.9),                  // Consider 90% of probability mass
    )
    if err != nil {
        log.Fatal(err)
    }

    // Print the AI's response
    fmt.Println("AI Response:")
    fmt.Println(response)
}

Each parameter adjustment contributes to the overall behavior of your AI, allowing you to fine-tune it for specific use cases. Like a chef combining ingredients, you'll develop your own preferred "recipes" for different situations. The values shown here illustrate typical usage patterns with OpenAI models, but remember that exact defaults and limits are provider-specific.

The best way to understand these parameters is to experiment with them. Try adjusting one parameter at a time to observe its effect on the AI's responses:

1. Set temperature to 0 vs. 1.5 for the same prompt
2. Compare max_tokens of 50 vs. 500
3. Run the same prompt twice at temperature 0 and compare the responses

Through experimentation, you'll develop an intuitive feel for how to configure the model for different use cases — just like a chef learns to adjust recipes by tasting as they go.

In this lesson, we explored how to customize model parameters to tailor AI responses to your specific needs. You learned about key parameters such as model selection, temperature, max tokens, and top p, and how to pick settings for consistent or creative results. As you move on to the practice exercises, experiment with different parameter values to reinforce your understanding and achieve the desired AI behavior. This skill will be invaluable as you continue your journey into conversational AI with LangChain.