Introduction to Java and Large Language Models

Welcome to the first lesson of the LangChain Chat Essentials in Java course. In this course, we'll explore conversational AI using Java, a versatile language with robust tools for interacting with large language models (LLMs). Java simplifies model communication, allowing developers to focus on building innovative solutions. It offers advanced features like conversation history management and customizable model parameters, making it ideal for sophisticated AI-driven applications.

LangChain4j is a Java framework that streamlines the development of applications powered by LLMs. It provides abstractions and tools for building complex applications with clean code. The framework supports integration with various AI providers, manages conversation memory, and offers tools for structuring prompts and handling responses.

In this lesson, we will concentrate on the essential skills needed to send messages to AI models using Java. While Java supports a variety of models and providers, we will specifically focus on working with OpenAI, laying the groundwork for more advanced topics in future lessons.

Before we dive into the code, it's important to ensure that your Java environment is set up correctly. You will need to use a build tool like Maven or Gradle to manage dependencies and build your project.

For Maven, you can add the necessary dependencies to your pom.xml file:

<dependencies>
    <dependency>
        <groupId>dev.langchain4j</groupId>
        <artifactId>langchain4j</artifactId>
        <version>1.0.0-beta2</version>
    </dependency>
    <dependency>
        <groupId>dev.langchain4j</groupId>
        <artifactId>langchain4j-open-ai</artifactId>
        <version>1.0.0-beta2</version>
    </dependency>
</dependencies>

For Gradle, you can add the dependencies to your build.gradle file:

dependencies {
    implementation 'dev.langchain4j:langchain4j:1.0.0-beta2'
    implementation 'dev.langchain4j:langchain4j-open-ai:1.0.0-beta2'
}

These dependencies provide everything you need to start working with OpenAI models in Java. They handle the API communication, response parsing, and model configuration, allowing you to focus on building your applications rather than managing the underlying infrastructure.

In this course, you'll be using a Java development environment, where you need to set up your OpenAI API key to access their services. This API key is essential for making requests to OpenAI's API.

To keep your API key secure, you can use environment variables. Here's how you can set it up:

• First, set the API key as an environment variable in your operating system. For example, on a Unix-based system, you can add the following lines to your shell configuration file (e.g., .bashrc or .zshrc):

  Shell

  export OPENAI_API_KEY=your_api_key_here

• In your Java code, you can retrieve these environment variables using System.getenv:

  Java

  String apiKey = System.getenv("OPENAI_API_KEY");

This method will ensure that your API key is securely managed and not hardcoded into your source code.

With your OpenAI API key securely set, you can now utilize Java to communicate with OpenAI models. The ChatLanguageModel interface is a crucial part of the LangChain4j library that enables communication with OpenAI's chat-based models like GPT-5.6 Luna. It provides a simple way to interact with these models through the chat() method.

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

ChatLanguageModel model = OpenAiChatModel.builder()
    .apiKey(System.getenv("OPENAI_API_KEY"))
    .baseUrl(System.getenv("OPENAI_API_BASE"))
    .modelName("gpt-5.6-luna")
    .defaultRequestParameters(OpenAiChatRequestParameters.builder().reasoningEffort("none").build())
    .build();

In this code snippet, we import the necessary classes and create a ChatLanguageModel instance using the OpenAiChatModel.builder(). We configure it with our API key, base URL, and specify the model name as gpt-5.6-luna. We also pass OpenAiChatRequestParameters with reasoningEffort("none") so the model answers directly instead of reasoning first. This instance is ready to send messages to the AI model, utilizing the OpenAI API for secure and authenticated access.

The baseUrl parameter specifies the endpoint URL for the OpenAI API. By default, this points to OpenAI's official API server, but it can be customized if you are using a proxy, a different region, or a compatible third-party or self-hosted service. If you are using the standard OpenAI API, you can set baseUrl to "https://api.openai.com/v1", or you can omit it if the library provides a default.

To communicate with the OpenAI model, you can use the chat() method of the ChatLanguageModel instance. This method takes a string message and returns the AI's response.

String response = model.chat("Who are you?");

In this example, we send a single message, "Who are you?", to the model. The chat() method processes this message and returns a response string containing the AI's reply. This is a convenient way to have simple interactions with the model.

Once you have the response from the AI model, you can directly use the returned string in your application.

// Display the AI's response
System.out.println("AI Response:");
System.out.println(response);

Here, we print the AI's response to the console. The response might look something like:

AI Response:
I am an AI language model created by OpenAI. I'm designed to assist users by providing information, answering questions, and helping with various tasks through text-based interactions.

Understanding how to extract and interpret the AI's response is essential for building applications that effectively interact with AI models. As you experiment with different messages, observe how the AI responds and think about how you can use this information in your projects.

Let's look at the complete example of sending a message to an OpenAI model using Java:

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) {
        ChatLanguageModel model = OpenAiChatModel.builder()
            .apiKey(System.getenv("OPENAI_API_KEY"))
            .baseUrl(System.getenv("OPENAI_API_BASE"))
            .modelName("gpt-5.6-luna")
            .defaultRequestParameters(OpenAiChatRequestParameters.builder().reasoningEffort("none").build())
            .build();
            
        // Send a message to the AI model using the chat() method
        String response = model.chat("Who are you?");
        
        // Print the AI's response
        System.out.println("AI Response:");
        System.out.println(response);
    }
}

This simple script demonstrates the entire process: importing the necessary classes, creating a ChatLanguageModel instance, sending a message to the model, and displaying the response.

One of the powerful features of LangChain4j is its ability to work with various language models beyond just OpenAI. The ChatLanguageModel interface remains consistent across different model providers, making it easy to switch between them or even compare responses from multiple models for the same prompt. This flexibility allows you to choose the model that best suits your specific needs, budget, or performance requirements.

LangChain4j also supports integration with local language models, which can be beneficial when you need to work offline, have privacy concerns, or want to reduce API costs. Local models run directly on your machine, eliminating the need for internet connectivity and external API calls.

In this lesson, we covered the basics of sending a message to an AI model using Java and LangChain4j. You learned how to set up your environment, initialize the ChatLanguageModel object, and send a simple message to the model. We also briefly explored how LangChain4j's consistent interface allows you to work with various AI providers and local models.

As you move on to the practice exercises, I encourage you to experiment with different messages and observe how the AI responds. This foundational skill will be built upon in future lessons, where we will explore more advanced topics such as customizing model parameters and managing conversation history.

Congratulations on completing the first step in your journey into conversational AI with Java!