• Integration with Helidon Inject

  Automatically creates and registers selected LangChain4j components in the Helidon service registry based on configuration.

• Integration with CDI

  Thanks to the Helidon Inject to CDI Bridge, LangChain4j components can be used in CDI environments, including Helidon MP applications.

• Convention Over Configuration

  Simplifies configuration by offering sensible defaults, reducing manual setup for common use cases.

• Declarative AI Services

  Supports LangChain4j’s AI Services within the declarative programming model, allowing for clean, easy-to-manage code structures.

• LangChain4j Core

  • AI Services

  • EmbeddingStoreContentRetriever

  • MessageWindowChatMemory

• Open AI

  • OpenAiChatModel

  • OpenAiStreamingChatModel

  • OpenAiEmbeddingModel

  • OpenAiImageModel

  • OpenAiLanguageModel

  • OpenAiModerationModel

• OCI GenAI

  • OciGenAiChatModel

  • OciGenAiStreamingChatModel

  • OciGenAiCohereChatModel

  • OciGenAiCohereStreamingChatModel

• Ollama

  • OllamaChatModel

  • OllamaStreamingChatModel

  • OllamaEmbeddingModel

  • OllamaLanguageModel

• Cohere

  • CohereEmbeddingModel

  • CohereScoringModel

• Oracle

  • OracleEmbeddingStore

• Coherence

  • CoherenceEmbeddingStore

  • CoherenceChatMemoryStore

• Jlama

  • JlamaChatModel

  • JlamaStreamingChatModel

  • JlamaEmbeddingModel

  • JlamaLanguageModel

• LangChain4j Model Provider Generator

We will extend the number of supported components in future releases.

Supported LangChain4j components are automatically created and registered in service registry if exists the corresponding configuration and enabled property is set to true.

For example, adding the following lines to application.yaml cause of automatic creating and registering OpenAiChatModel, which later can be injected in other classes of your application:

langchain4j:
  open-ai:
    chat-model:
      enabled: true
      api-key: "demo"
      base-url: "http://langchain4j.dev/demo/openai/v1"
      model-name: "gpt-4o-mini"

If enabled is set to false, the configuration is ignored, and the component is not created. Configurable properties for each supported component are listed in the corresponding documentation section below.

Supplier Factory provide another way to create and register LangChain4j components. It is useful for creating components that are not yet natively supported by the integration. This method is not limited to LangChain4j and suitable for creating and registering other classes.

Example below demonstrates a supplier factory for AllMiniLmL6V2EmbeddingModel.

@Service.Singleton
class EmbeddingModelFactory implements Supplier<EmbeddingModel> {
    @Override
    public EmbeddingModel get() {
        return new AllMiniLmL6V2EmbeddingModel();
    }
}

By default, the default or unnamed Helidon bean is created. To create a named service, you need to add @Service.Named("name") annotation.

You can inject Helidon services into another Helidon services using constructor injection like this:

@Service.Singleton
public class Foo {
    private final Bar bar;

    @Service.Inject
    public Foo(Bar bar) {
        this.bar = bar;
    }
}

To inject a named service, annotate the constructor parameter with @Service.Named("name"):

@Service.Singleton
public class Foo {
    private final Bar bar;

    @Service.Inject
    public Foo(@Service.Named("another-bar") Bar bar) {
        this.bar = bar;
    }
}

In a CDI environment such as Helidon MP, Helidon Inject components are exposed as CDI beans, allowing them to be injected into other CDI beans without any restrictions.

AI Service is defined by a Java interface. It’s a pure LangChain4j component. Refer to LangChain4j documentation to read more details about it.

Helidon’s LangChain4j integration provides a specialized set of annotations for creating, configuring, and using LangChain4j AI Services in Helidon applications.

To create an AI Service define an interface and annotate it with @AI.Service.

@Ai.Service
public interface ChatAiService {
    String chat(String question);
}

In this scenario all LangChain4j components from the list above are taken from the service registry. User still has an ability to manually control the process by putting any of the following annotations which specify a service name which must be used for this particular function instead of discovering it automatically.

For example, in the snippet below a service with name "myCustomChatMemory" will be used as chat memory and all other components are discovered automatically.

@Ai.Service
@Ai.ChatMemory("myCustomChatMemory")
public interface ChatAiService {
    String chat(String question);
}

Since Ai.ToolProvider and Ai.McpClients are mutually exclusive, some clarification is needed regarding their functionality. Assume that automatic discovery is set to true in this context:

• If neither annotation is present, a ToolProvider will be automatically discovered from the service registry.

• If the Ai.McpClients annotation is present, corresponding MCP client services will be discovered, and no ToolProvider will be discovered.

• If both annotations are present, an exception will be thrown.

In LangChain4j, tools are callback functions that the language model can invoke during a conversation to perform specific tasks, retrieve information, or execute external logic. These tools extend the model’s capabilities beyond simple text generation, allowing it to dynamically interact with external systems. For instance, a tool might query a database, call an external API, or perform calculations. Based on user input, the model can decide to call a tool, interpret its response, and incorporate it into the conversation for a more context-aware and multi-step interaction.

To expose a method in a Helidon service as a tool, annotate it with the @Tool annotation from dev.langchain4j.agent.tool.Tool, as shown in the example below:

@Service.Singleton
public class OrderService {

    @Tool("Get order details for specified order number")
    public Order getOrderDetails(String orderNumber) {
        // ...
    }
}

For more details, read the LangChain4j Documentation on Tools.

In LangChain4j, an MCP (Model Context Protocol) client acts as a bridge between the language model and external services or resources that follow the MCP standard. Instead of directly embedding custom logic into the application, the MCP client enables the model to discover, connect to, and interact with external tools and data providers in a standardized way.

To add MCP Clients to your AI Service, use the following:

@Ai.Service
@Ai.McpClients
public interface ChatAiService {
    String chat(String question);
}

If you want to have your MCP clients created from the configuration, it should be placed under the langchain4j.mcp-clients. These are all the MCP Client configuration options currently supported:

Type: io.helidon.integrations.langchain4j.McpClientConfig

Configuration options

While LangChain4j doesn’t provide Observability out-of-box, it provides for user to supplement it using ChatModelListener. For more details, read the LangChain4j Documentation on Observability.

Helidon provides MetricsChatModelListener which generates metrics that follow the OpenTelemetry Semantic Conventions for GenAI Metrics v1.36.0. This is done out-of-box for Chat API calls.