Customizing Model Parameters in Java

Welcome to the next step in your journey with Java and AI! In the previous lesson, you mastered the basics of sending messages to an AI model using Java. 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 using Java.

The modelName parameter lets you select which AI "brain" will power your conversations. In Java, you can achieve this using the OpenAiChatModel class:

ChatLanguageModel model = OpenAiChatModel.builder()
    .modelName("gpt-5.6-luna")  // Using GPT-5.6 Luna
    .defaultRequestParameters(OpenAiChatRequestParameters.builder().reasoningEffort("none").build())
    .build();

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

GPT-5.6 models can also reason before they answer. Throughout this course we turn that off with reasoningEffort("none"), so the model replies right away — you'll see how this setting works later in this lesson.

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."

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

ChatLanguageModel model = OpenAiChatModel.builder()
    .temperature(0.7)  // Balanced creativity setting
    .build();

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."

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

ChatLanguageModel model = OpenAiChatModel.builder()
    .maxCompletionTokens(150)  // Caps the response at approximately 100-120 words
    .build();

This parameter sets a ceiling on how verbose the model's response can be:

• Lower values (50-100): Force concise, to-the-point answers
• Medium values (150-500): Allow for more detailed explanations
• Higher values (1000+): Enable comprehensive responses for complex topics

Think of this as giving your AI a specific amount of space to work with — like telling someone "explain this in a tweet" versus "write me an essay." Without this limit, models might ramble on, costing you more and potentially overwhelming your users.

While maxCompletionTokens controls how much the model can say, it's important to note that if the model hasn't finished its response by the time it hits the token limit, it will abruptly stop mid-sentence. This can result in incomplete answers, so be mindful to set the limit high enough for your use case.

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

ChatLanguageModel model = OpenAiChatModel.builder()
    .topP(0.9)  // Consider only the most likely 90% of possible next words
    .build();

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, topP 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. Many developers find that adjusting temperature is sufficient, but topP gives you another dimension of control.

GPT-5.6 models can reason through a problem before they reply. You control how much with reasoningEffort, which you set on OpenAiChatRequestParameters and pass to the builder through defaultRequestParameters(...):

ChatLanguageModel model = OpenAiChatModel.builder()
    .modelName("gpt-5.6-luna")
    .defaultRequestParameters(OpenAiChatRequestParameters.builder()
        .reasoningEffort("none")  // Answer directly, without a reasoning step
        .build())
    .build();

This setting determines how much thinking happens before the answer:

• "none": Replies right away with no reasoning step — the fastest and cheapest option, and the one this course uses
• "low" to "medium": The model thinks before answering; "medium" is the default if you don't set it
• "high" and above: More thinking for hard, multi-step problems, at the cost of speed and tokens

Keep in mind that reasoning tokens count toward maxCompletionTokens, so with a higher effort a tight limit can leave little room for the actual answer. For everyday chat like the examples in this course, "none" keeps responses quick and predictable — like asking a friend for a quick opinion instead of a written report.

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

package com.codesignal;

import dev.langchain4j.model.chat.ChatLanguageModel;
import dev.langchain4j.model.openai.OpenAiChatModel;
import dev.langchain4j.model.openai.OpenAiChatRequestParameters;

public class Main {
    public static void main(String[] args) {
        // Initialize the chat model with a complete set of custom parameters
        ChatLanguageModel model = OpenAiChatModel.builder()
            .apiKey(System.getenv("OPENAI_API_KEY"))
            .baseUrl(System.getenv("OPENAI_API_BASE"))
            .modelName("gpt-5.6-luna")     // Choose a fast, cost-efficient model
            .defaultRequestParameters(OpenAiChatRequestParameters.builder()
                .reasoningEffort("none")    // Answer directly, without a reasoning step
                .build())
            .temperature(0.7)               // Balanced creativity setting
            .maxCompletionTokens(50)        // Keep responses concise
            .topP(0.9)                      // Consider 90% of probability mass
            .build();

        // Send a message to the AI model
        String response = model.chat("Hello, can you tell me a joke?");

        // Print the AI's response
        System.out.println("AI Response:");
        System.out.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 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 maxCompletionTokens of 50 vs. 500
3. Compare reasoning effort "none" vs. "low" on the same question

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 using Java. You learned about key parameters such as model selection, temperature, max completion tokens, topP, and reasoning effort. 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 Java.