Quarkus LangChain4j

https://docs.quarkiverse.io/quarkus-langchain4j/dev/
Admin
Quarkus LangChain4j is an extension that integrates Large Language Models into Quarkus applications...
Tokens:214,199
Snippets:684
Trust Score:6.8
Update:1 year ago
Show doc for...
Tokens:
Raw
### Example: Ingesting Documents with Easy RAG

Source: https://docs.quarkiverse.io/quarkus-langchain4j/dev/rag-easy-rag

This example demonstrates the basic setup for the Easy RAG extension. Add the extension, specify the document path, and optionally an embedding model provider.

```java
import io.quarkus.langchain4j.easy.rag.runtime.EasyRagConfig;
import jakarta.enterprise.context.ApplicationScoped;

@ApplicationScoped
public class MyRagApp {

    // Quarkus will automatically configure and inject necessary components
    // based on the application.properties settings.

    // Example: If you have quarkus-langchain4j-openai configured,
    // you can inject the embedding model like this:
    // @Inject
    // EmbeddingModel embeddingModel;

    // The EasyRagConfig can be injected to access configuration values if needed
    // @Inject
    // EasyRagConfig easyRagConfig;

    public void processDocuments() {
        // Documents are automatically ingested on startup based on configuration.
        // You can then use the RetrievalAugmentor (if not using the default)
        // or directly interact with the embedding store.
        System.out.println("Easy RAG setup complete. Documents are being ingested.");
    }
}
```

--------------------------------

### Add Few-Shot Examples to AI Service

Source: https://docs.quarkiverse.io/quarkus-langchain4j/dev/guide-few-shots

Enhances the AI Service interface by adding a method with a `@UserMessage` annotation. This method includes inline few-shot examples (input-output pairs) to guide the LLM's response format and style.

```java
package io.quarkiverse.langchain4j.samples.fewshots;

import dev.langchain4j.service.SystemMessage;
import dev.langchain4j.service.UserMessage;
import io.quarkiverse.langchain4j.RegisterAiService;

@RegisterAiService
@SystemMessage("You are an assistant that classifies text sentiment.")
public interface SentimentAiService {

    @UserMessage("""
                INPUT: This product is fantastic!   **(1)**
                OUTPUT: POSITIVE

                INPUT: Terrible customer service.
                OUTPUT: NEGATIVE

                INPUT: {text}
                OUTPUT:
            """)
    String classifySentiment(String text); **(2)**
}
```

--------------------------------

### Install WebSocket Client

Source: https://docs.quarkiverse.io/quarkus-langchain4j/dev/guide-streamed-responses

This command installs the `wscat` tool globally using npm, which is a command-line WebSocket client used for testing WebSocket connections.

```npm
npm install -g wscat
```

--------------------------------

### Install Ollama

Source: https://docs.quarkiverse.io/quarkus-langchain4j/dev/guide-ollama

Commands to install and run Ollama, and pull specific models. Ollama allows running Large Language Models locally.

```bash
ollama run llama3
```

```bash
ollama pull qwen3:1.7b
ollama pull snowflake-arctic-embed:latest
```

--------------------------------

### Uploading and Starting Text Extraction from Local File

Source: https://docs.quarkiverse.io/quarkus-langchain4j/dev/watsonx-chat-model

Illustrates how to upload a local file and then start the text extraction process for it.

```Java
import io.quarkiverse.langchain4j.TextExtraction;
import jakarta.inject.Inject;
import java.io.File;

// Assuming textExtraction is injected
// File file = new File("path/to/document.pdf");
// String extractionId = textExtraction.uploadAndStartExtraction(file);
```

--------------------------------

### Example Ollama Chat Model Output

Source: https://docs.quarkiverse.io/quarkus-langchain4j/dev/guide-ollama

Example output from the Ollama chat model when the 'greeting' method is called, demonstrating a 4-line poem.

```text
In the quiet dawn, a whisper breaks the silence,
Hello, world, where dreams take flight and light.
The sun ascends, a golden, warm embrace,
A greeting to the earth, a heart's soft grace.
```

--------------------------------

### Basic RetrievalAugmentor Example

Source: https://docs.quarkiverse.io/quarkus-langchain4j/dev/rag-query

Demonstrates how to configure and create a basic RetrievalAugmentor using Quarkus LangChain4j. This setup involves an EmbeddingStore and an EmbeddingModel to define a content retriever, which then feeds into the default RetrievalAugmentor.

```Java
@ApplicationScoped
public class RetrievalAugmentorExample implements Supplier<RetrievalAugmentor> {

    private final RetrievalAugmentor augmentor;

    RetrievalAugmentorExample(EmbeddingStore store, EmbeddingModel model) {
        // Configure the content retriever, responsible for fetching relevant content based on the user query
        var contentRetriever = EmbeddingStoreContentRetriever.builder()
          .embeddingModel(model)
          .embeddingStore(store)
          .maxResults(3)
          .build();

        // Create the RetrievalAugmentor that combines the retriever and a default content injector
        augmentor = DefaultRetrievalAugmentor
            .builder()
            .contentRetriever(contentRetriever)
            .build();
    }

    @Override
    public RetrievalAugmentor get() {
      return augmentor;
    }

}
```

--------------------------------

### Quarkus LangChain4j Generation Service Example

Source: https://docs.quarkiverse.io/quarkus-langchain4j/dev/watsonx-chat-model

Java code example demonstrating a Quarkus AI service for generation tasks with IBM watsonx.ai, including custom prompt formatting for user and system messages.

```java
@RegisterAiService(chatMemoryProviderSupplier = RegisterAiService.NoChatMemoryProviderSupplier.class)
public interface AiService {
    @SystemMessage("[INST] You are a helpful assistant [/INST]")
    @UserMessage("[INST] What is the capital of {capital}? [/INST]")
    String askCapital(String capital);
}
```

--------------------------------

### Run Quarkus Chatbot Example

Source: https://docs.quarkiverse.io/quarkus-langchain4j/dev/rag-easy-rag

Instructions to clone the repository, set the OpenAI API key, and run the Quarkus chatbot application in development mode.

```Shell
git clone https://github.com/quarkiverse/quarkus-langchain4j.git
cd quarkus-langchain4j/samples/chatbot-easy-rag
export QUARKUS_LANGCHAIN4J_OPENAI_API_KEY=<your-openai-api-key>
mvn quarkus:dev
```

--------------------------------

### Enriching Summary with Context

Source: https://docs.quarkiverse.io/quarkus-langchain4j/dev/guide-prompt-engineering

This example demonstrates how to enrich a summary by first extracting key themes from an article and then using those themes to guide the summarization process. It involves two AI services: one for theme extraction and another for summarization.

```java
@QuarkusMain
public class StepBackMain implements QuarkusApplication {
    @Inject
    BackgroundService background;

    @Inject
    SummaryService summarizer;

    @Override
    public int run(String... args) throws IOException {
        var text = Files.readString(Path.of("<some article file>"));

        // Step 1: Ask for key themes
        var context = background.extractThemes(text);

        // Step 2: Generate the summary using the extracted context
        var summary = summarizer.summarize(text, context);

        System.out.println("== Summary ==");
        System.out.println(summary);

        return 0;
    }

    @RegisterAiService
    @ApplicationScoped
    interface BackgroundService {

        @UserMessage("""
            Read the following article and list the 5 most important themes discussed.

            ---\n            {input}
            ---
        """)
        String extractThemes(String input);
    }

    @RegisterAiService
    @ApplicationScoped
    interface SummaryService {

        @SystemMessage("""
        You are a professional summarizer. Use the given context to enrich the summary output.
        """)
        @UserMessage("""
            Article:
            ---
            {input}
            ---

            Context (Themes): {context}

            Write a concise, well-structured summary of the article above, integrating the key themes provided in the context.
        """)
        String summarize(String input, String context);
    }
}
```

--------------------------------

### Quarkus LangChain4j Chat Service Example

Source: https://docs.quarkiverse.io/quarkus-langchain4j/dev/watsonx-chat-model

Java code example demonstrating a Quarkus AI service for chat interactions with IBM watsonx.ai, including system and user messages.

```java
@RegisterAiService
public interface AiService {
    @SystemMessage("You are a helpful assistant")
    String chat(@MemoryId String id, @UserMessage String message);
}
```

--------------------------------

### Verify Ollama Installation

Source: https://docs.quarkiverse.io/quarkus-langchain4j/dev/ollama-chat-model

Command to verify if Ollama is installed and check its version.

```shell
$ ollama --version
```

--------------------------------

### Install OpenAI Extension

Source: https://docs.quarkiverse.io/quarkus-langchain4j/dev/quickstart

Add the quarkus-langchain4j-openai dependency to your project to use the OpenAI model provider.

```xml
<dependency>
  <groupId>io.quarkiverse.langchain4j</groupId>
  <artifactId>quarkus-langchain4j-openai</artifactId>
  <version>1.1.1</version>
</dependency>
```

--------------------------------

### Run Application in Dev Mode

Source: https://docs.quarkiverse.io/quarkus-langchain4j/dev/quickstart

Start the Quarkus application in development mode using the Maven wrapper.

```shell
./mvnw quarkus:dev
```

--------------------------------

### Custom ToolProviderSupplier Implementation

Source: https://docs.quarkiverse.io/quarkus-langchain4j/dev/function-calling

Provides an example of a ToolProviderSupplier implementation, which must be marked as @ApplicationScoped. It injects and returns a custom ToolProvider.

```java
@ApplicationScoped
public class MyToolProviderSupplier implements Supplier<ToolProvider> {
    @Inject MyCustomToolProvider provider;

    public ToolProvider get() {
        return provider;
    }
}
```

--------------------------------

### Quarkus LangChain4j Next Steps

Source: https://docs.quarkiverse.io/quarkus-langchain4j/dev/index

Provides guidance on where to go next after learning about Quarkus LangChain4j, including quickstarts, reference documentation, prompt engineering, RAG, and workshops.

```Markdown
**Quickstart** | Build your first AI-powered Quarkus app using OpenAI or HuggingFace in just a few minutes.  
**Reference Documentation** | Learn how to declare and use AI services with annotations and CDI — the core of the extension.  
**Prompt Engineering** | Discover how to craft prompts effectively and structure conversations for better model control.  
**Retrieval-Augmented Generation (RAG)** | Combine your own knowledge sources with LLMs to build powerful search and Q&A systems.  
**Hands-on Workshop** | Try the full guided workshop with code, exercises, and step-by-step labs.
```

--------------------------------

### Sentiment Classification with Few-Shot Prompt (Java)

Source: https://docs.quarkiverse.io/quarkus-langchain4j/dev/guide-prompt-engineering

Demonstrates how to use few-shot prompting in Java with Quarkus LangChain4j for sentiment classification. It includes an AI service interface with a `@UserMessage` annotation containing examples to guide the model.

```Java
public enum Sentiment {
    POSITIVE, NEUTRAL, NEGATIVE
}

@RegisterAiService
public interface SentimentClassifier {

    @UserMessage("""
        Classify the sentiment of each movie review using one of the following categories:
        POSITIVE, NEUTRAL, or NEGATIVE.

        Here are a few examples:

        - \"I love this product.\" - POSITIVE
        - \"Not bad, but could be better.\" - NEUTRAL
        - \"I\'m thoroughly disappointed.\" - NEGATIVE

        Review:
        {review}

        Sentiment:
        """)
    Sentiment classify(String review);
}
```

--------------------------------

### Register AI Service with @ToolBox

Source: https://docs.quarkiverse.io/quarkus-langchain4j/dev/quickstart-function-calling

Registers an AI service using `@RegisterAiService` and specifies available tools via `@ToolBox`. The `@SystemMessage` provides context and instructions for the LLM, while `@UserMessage` defines the user input prompt.

```java
package me.escoffier.quarkus.ai;

import dev.langchain4j.service.UserMessage;
import dev.langchain4j.service.SystemMessage;
import io.quarkiverse.langchain4j.RegisterAiService;
import io.quarkiverse.langchain4j.ToolBox;
import jakarta.enterprise.context.ApplicationScoped;

@RegisterAiService
@ApplicationScoped
@SystemMessage("""
    You are a smart travel planner. Your job is to help users plan their trips.
    You may call available tools to determine the weather and propose activities.
    Always reflect on tool results before giving a final answer.
""")
public interface TravelPlanner {

    @UserMessage("I want to go to {destination}. What should I do?")
    @ToolBox(TripTools.class)
    String plan(String destination);
}

```

--------------------------------

### Java Random Seed Example

Source: https://docs.quarkiverse.io/quarkus-langchain4j/dev/ollama-chat-model

Example of how to generate a random seed in Java for the chat model.

```java
Random random = new Random();
int x = random.nextInt(Integer.MAX_VALUE);
```

--------------------------------

### Java Seed Example

Source: https://docs.quarkiverse.io/quarkus-langchain4j/dev/ollama-embedding-model

Example of how to generate a random seed for the chat model using Java.

```java
Random random = new Random();
int x = random.nextInt(Integer.MAX_VALUE);
```

--------------------------------

### Main Application Class

Source: https://docs.quarkiverse.io/quarkus-langchain4j/dev/quickstart-summarization

The main Quarkus application class that injects the SummarizationService, reads a text file specified by command-line arguments, and prints the summarized output.

```java
@QuarkusMain
public class Main implements QuarkusApplication {

    @Inject
    SummarizationService ai;

    @Override
    public int run(String... args) throws IOException {
        if (args.length == 0) {
            System.err.println("Please provide the path to the text file as an argument.");
            return 1;
        }
        var article = Files.readString(new File(args[0]).toPath());
        System.out.println(ai.summarize(article));
        return 0;
    }

    public static void main(String[] args) {
        Quarkus.run(Main.class, args);
    }
}
```

--------------------------------

### Build and Run Quarkus Application in Prod Mode

Source: https://docs.quarkiverse.io/quarkus-langchain4j/dev/quickstart-rag

Commands to build the Quarkus application into a package and then run it in production mode. Assumes PostgreSQL with pgvector extension is set up.

```bash
./mvnw clean package
java -jar target/quarkus-app/quarkus-run.jar
```

--------------------------------

### Build and Run Quarkus Application

Source: https://docs.quarkiverse.io/quarkus-langchain4j/dev/quickstart

Builds the Quarkus application using Maven and runs the packaged JAR file with specified arguments.

```shell
./mvnw package
```

```java
java -jar target/quarkus-app/quarkus-run.jar --lines=5 "AI with Quarkus"
```

--------------------------------

### Custom Content Injector Example

Source: https://docs.quarkiverse.io/quarkus-langchain4j/dev/rag-query

Demonstrates how to create a custom content injector for a RetrievalAugmentor in Quarkus. This example shows how to append user-provided information to the prompt.

```java
@Produces
@ApplicationScoped
// If you have multiple stores and embedding models, you can inject specific types:
public RetrievalAugmentor create(
        PgVectorEmbeddingStore store,
        BgeSmallEnQuantizedEmbeddingModel model) {

    EmbeddingStoreContentRetriever retriever =  EmbeddingStoreContentRetriever.builder()
        .embeddingModel(model)
        .embeddingStore(store)
        .maxResults(3)
        .build();

    return DefaultRetrievalAugmentor.builder()
        .contentRetriever(retriever)
        .contentInjector((contentList, userMessage) -> {
            StringBuffer prompt = new StringBuffer(userMessage.singleText());
            prompt.append("\nPlease, only use the following information:\n");
            contentList.forEach(content -> prompt.append("- ").append(content.textSegment().text()).append("\n"));
            return new UserMessage(prompt.toString());
        })
        .build();
}

```

--------------------------------

### Add CLI Support

Source: https://docs.quarkiverse.io/quarkus-langchain4j/dev/quickstart

Include the quarkus-picocli extension to build command-line interface applications that can interact with your AI services.

```xml
<dependency>
  <groupId>io.quarkus</groupId>
  <artifactId>quarkus-picocli</artifactId>
</dependency>
```

--------------------------------

### Vector Query Execution Example

Source: https://docs.quarkiverse.io/quarkus-langchain4j/dev/rag-neo4j

Example of a vector query using the KNN clause in Neo4j for retrieving similar documents based on a query vector.

```cypher
MATCH (d:Document)
RETURN d.text, gds.similarity.cosine(d.vector, $queryVector) AS score
ORDER BY score DESC
LIMIT 5
```

--------------------------------

### ReAct Prompting with Tool Integration

Source: https://docs.quarkiverse.io/quarkus-langchain4j/dev/guide-prompt-engineering

This example demonstrates ReAct (Reason + Act) prompting, combining step-by-step reasoning with action-taking using tools. The AI reasons about the problem, selects a tool (like a weather forecast tool), and updates its thinking based on the tool's output.

```java
import io.quarkiverse.langchain4j.ToolBox;@RegisterAiService
@ApplicationScoped
@SystemMessage("""
You are a reasoning agent. For each problem, reason about the solution, and when necessary, use available tools.
""")
public interface AgentService {

@UserMessage("""
    What’s the weather like in Tokyo tomorrow?
")
@ToolBox(WeatherForecastTool.class)
String answer();

}
```

--------------------------------

### Ollama Chat Model Seed Example

Source: https://docs.quarkiverse.io/quarkus-langchain4j/dev/ollama-chat-model

Example demonstrating how to set a static or random seed for the Ollama chat model to control response variability.

```java
Random random = new Random();
int x = random.nextInt(Integer.MAX_VALUE);
```

--------------------------------

### Quarkus Langchain4j OpenAI Model Configuration Examples

Source: https://docs.quarkiverse.io/quarkus-langchain4j/dev/openai-chat-model

Demonstrates how to configure default and custom OpenAI models in Quarkus Langchain4j, including API keys and model-specific settings.

```properties
# Default OpenAI model configuration
quarkus.langchain4j.openai.chat-model.model-name=gpt-4o-mini
quarkus.langchain4j.openai.api-key=sk-...

# Custom OpenAI model configuration
quarkus.langchain4j.openai.some-name.chat-model.model-name=o3
quarkus.langchain4j.openai.some-name.api-key=sk-...
quarkus.langchain4j.openai.some-name.chat-model.temperature=0.8
```

--------------------------------

### Ollama Chat Model Seed Example

Source: https://docs.quarkiverse.io/quarkus-langchain4j/dev/ollama-embedding-model

Example demonstrating how to set a static or random seed for the Ollama chat model to control response variability.

```java
Random random = new Random();
int x = random.nextInt(Integer.MAX_VALUE);
```

--------------------------------

### Custom Chat Memory Provider Supplier Example

Source: https://docs.quarkiverse.io/quarkus-langchain4j/dev/messages-and-memory

An example implementation of a `ChatMemoryProviderSupplier` that provides a custom `ChatMemoryProvider` configured with a specific message window size.

```Java
public class MyMemoryProviderSupplier implements Supplier<ChatMemoryProvider> {
    @Override
    public ChatMemoryProvider get() {
        return new ChatMemoryProvider() {
            @Override
            public ChatMemory get(Object memoryId) {
                return new MessageWindowChatMemory.Builder().maxMessages(5).build();
            }
        };
    }
}

```

--------------------------------

### Blocking Tool Execution Example

Source: https://docs.quarkiverse.io/quarkus-langchain4j/dev/function-calling

Provides an example of a blocking tool method that retrieves customer information by ID. This method is suitable for operations that do not need to be non-blocking.

```java
@Tool("get the customer name for the given customerId")
public String getCustomerName(long id) {
    return find("id", id).firstResult().name;
}
```

--------------------------------

### Compile Quarkus Application to Native Image

Source: https://docs.quarkiverse.io/quarkus-langchain4j/dev/quickstart

Compiles the Quarkus application into a native executable using Maven and provides instructions on how to run the native executable.

```shell
./mvnw package -Dnative
```

```shell
./target/*-runner --lines=5 "Quarkus poetry"
```

--------------------------------

### Weaviate Embedding Store Ingestion Example

Source: https://docs.quarkiverse.io/quarkus-langchain4j/dev/rag-weaviate

A Java example demonstrating how to use the WeaviateEmbeddingStore with Quarkus LangChain4j to ingest documents. It injects the WeaviateEmbeddingStore and an EmbeddingModel to create an EmbeddingStoreIngestor.

```java
package io.quarkiverse.langchain4j.samples;

import static dev.langchain4j.data.document.splitter.DocumentSplitters.recursive;

import java.util.List;

import jakarta.enterprise.context.ApplicationScoped;
import jakarta.inject.Inject;

import dev.langchain4j.data.document.Document;
import dev.langchain4j.model.embedding.EmbeddingModel;
import dev.langchain4j.store.embedding.EmbeddingStoreIngestor;
import dev.langchain4j.store.embedding.weaviate.WeaviateEmbeddingStore;

@ApplicationScoped
public class IngestorExampleWithWeaviate {

    /**
     * The embedding store (the database).
     * The bean is provided by the quarkus-langchain4j-weaviate extension.
     */
    @Inject
    WeaviateEmbeddingStore store;

    /**
     * The embedding model (how is computed the vector of a document).
     * The bean is provided by the LLM (like openai) extension.
     */
    @Inject
    EmbeddingModel embeddingModel;

    public void ingest(List<Document> documents) {
        EmbeddingStoreIngestor ingestor = EmbeddingStoreIngestor.builder()
                .embeddingStore(store)
                .embeddingModel(embeddingModel)
                .documentSplitter(recursive(500, 0))
                .build();
        // Warning - this can take a long time...
        ingestor.ingest(documents);
    }
}
```

--------------------------------

### Milvus Embedding Store Ingestion Example

Source: https://docs.quarkiverse.io/quarkus-langchain4j/dev/rag-milvus-store

Java example demonstrating how to use Milvus as an embedding store with Quarkus LangChain4j. It injects `MilvusEmbeddingStore` and `EmbeddingModel` to ingest documents.

```java
package io.quarkiverse.langchain4j.samples;

import static dev.langchain4j.data.document.splitter.DocumentSplitters.recursive;

import java.util.List;

import jakarta.enterprise.context.ApplicationScoped;
import jakarta.inject.Inject;

import dev.langchain4j.data.document.Document;
import dev.langchain4j.model.embedding.EmbeddingModel;
import dev.langchain4j.store.embedding.EmbeddingStoreIngestor;
import dev.langchain4j.store.embedding.milvus.MilvusEmbeddingStore;

@ApplicationScoped
public class IngestorExampleWithMilvus {

    /**
     * The embedding store (the database).
     * The bean is provided by the quarkus-langchain4j-milvus extension.
     */
    @Inject
    MilvusEmbeddingStore store;

    /**
     * The embedding model (how is computed the vector of a document).
     * The bean is provided by the LLM (like openai) extension.
     */
    @Inject
    EmbeddingModel embeddingModel;

    public void ingest(List<Document> documents) {
        EmbeddingStoreIngestor ingestor = EmbeddingStoreIngestor.builder()
                .embeddingStore(store)
                .embeddingModel(embeddingModel)
                .documentSplitter(recursive(500, 0))
                .build();
        // Warning - this can take a long time...
        ingestor.ingest(documents);
    }
}
```

--------------------------------

### AI Service Example for Tracing

Source: https://docs.quarkiverse.io/quarkus-langchain4j/dev/observability

Demonstrates defining an AI service using Quarkus `@RegisterAiService` and triggering an AI operation in a startup event. This operation will be traced if OpenTelemetry and Langfuse are configured.

```java
@RegisterAiService(tools = EmailService.class)
public interface MyAiService {

    /**
     * Ask the LLM to create a poem about the given topic.
     *
     * @param topic the topic of the poem
     * @param lines the number of line of the poem
     * @return the poem
     */
    @SystemMessage("You are a professional poet")
    @UserMessage("""
            Write a single poem about {topic}. The poem should be {lines} lines long and your response should only include the poem itself, nothing else.
            Then send this poem by email. Your response should include the poem.
            """)
    String writeAPoem(String topic, int lines);

}

@Singleton
public class Startup {

    public void writeAPoem(@Observes StartupEvent event, MyAiService service) {
        System.out.println(service.writeAPoem("LangFuse", 4));
    }
}
```

--------------------------------

### Metadata Filtering Example

Source: https://docs.quarkiverse.io/quarkus-langchain4j/dev/rag-neo4j

Example Cypher query demonstrating metadata filtering on Neo4j nodes, restricting results based on node properties like 'author' and 'year'.

```cypher
MATCH (d:Document)
WHERE d.author = 'Alice' AND d.year = 2023
RETURN ...
```

--------------------------------

### Watsonx Chat Model Configuration

Source: https://docs.quarkiverse.io/quarkus-langchain4j/dev/watsonx-chat-model

Configuration for enabling and setting up the Watsonx chat model. This includes enabling the model, setting the base URL, API key, timeout, version, and space/project IDs.

```APIDOC
quarkus.langchain4j.watsonx.chat-model.enabled: boolean (default: true)
  Whether the chat model should be enabled.
  Environment variable: QUARKUS_LANGCHAIN4J_WATSONX_CHAT_MODEL_ENABLED

quarkus.langchain4j.watsonx.mode: string (default: "chat")
  Specifies the mode of interaction with the LLM model (chat or generation).
  Allowable values: [chat, generation]
  Environment variable: QUARKUS_LANGCHAIN4J_WATSONX_MODE

quarkus.langchain4j.watsonx.base-url: string
  Specifies the base URL of the watsonx.ai API.
  Environment variable: QUARKUS_LANGCHAIN4J_WATSONX_BASE_URL

quarkus.langchain4j.watsonx.api-key: string
  IBM Cloud API key.
  Environment variable: QUARKUS_LANGCHAIN4J_WATSONX_API_KEY

quarkus.langchain4j.watsonx.timeout: Duration (default: 10s)
  Timeout for watsonx.ai calls.
  Environment variable: QUARKUS_LANGCHAIN4J_WATSONX_TIMEOUT

quarkus.langchain4j.watsonx.version: string (default: "2025-04-23")
  The version date for the API of the form YYYY-MM-DD.
  Environment variable: QUARKUS_LANGCHAIN4J_WATSONX_VERSION

quarkus.langchain4j.watsonx.space-id: string
  The space that contains the resource. Either space_id or project_id has to be given.
  Environment variable: QUARKUS_LANGCHAIN4J_WATSONX_SPACE_ID

quarkus.langchain4j.watsonx.project-id: string
  The project that contains the resource. Either space_id or project_id has to be given.
  Environment variable: QUARKUS_LANGCHAIN4J_WATSONX_PROJECT_ID
```

--------------------------------

### Define Summarization Service Interface

Source: https://docs.quarkiverse.io/quarkus-langchain4j/dev/quickstart-summarization

Defines a declarative AI service for summarization. It includes system messages to guide the LLM and a user message to format the input.

```java
@RegisterAiService
@ApplicationScoped
@SystemMessage("""
You are an expert content summarizer. You take content in and output a Markdown formatted summary using the format below.

# OUTPUT SECTIONS
- Combine all of your understanding of the content into a single, 20-word sentence in a section called ONE SENTENCE SUMMARY:.
- Output the 10 most important points of the content as a list with no more than 15 words per point into a section called MAIN POINTS:
- Output a list of the 5 best takeaways from the content in a section called TAKEAWAYS:.

# OUTPUT INSTRUCTIONS
- Create the output using the formatting above.
- You only output human readable Markdown.
- Output numbered lists, not bullets.
- Do not output warnings or notes—just the requested sections.
- Do not repeat items in the output sections.
- Do not start items with the same opening words.
")
public interface SummarizationService {

    @UserMessage("Input: {input}")
    String summarize(String input);
}
```

--------------------------------

### Define Evaluation Samples using Builder Pattern

Source: https://docs.quarkiverse.io/quarkus-langchain4j/dev/testing

Demonstrates how to create evaluation samples programmatically using the `EvaluationSample` builder. Samples include a name, parameters, expected output, and optional tags for targeted evaluation.

```java
var s1 = EvaluationSample.<String>builder()
            .withName("sample1")
            .withParameter("value1")
            .withExpectedOutput("my expected result2")
            .build();

    var s2 = EvaluationSample.<String>builder()
            .withName("sample2")
            .withParameter("value2")
            .withExpectedOutput("my expected results")
            .build();

    Samples<String> samples = new Samples<>(List.of(s1, s2));
```

--------------------------------

### Create CLI Command

Source: https://docs.quarkiverse.io/quarkus-langchain4j/dev/quickstart

Implement a CLI command using picocli that injects and uses the AI service to generate poems based on user input.

```java
package io.quarkiverse.langchain4j.samples;

import jakarta.enterprise.context.control.ActivateRequestContext;
import jakarta.inject.Inject;
import picocli.CommandLine;
import picocli.CommandLine.Command;
import picocli.CommandLine.Parameters;

@Command(name = "poem", mixinStandardHelpOptions = true)
public class PoemCommand implements Runnable {

    @Parameters(paramLabel = "<topic>", defaultValue = "quarkus",
            description = "The topic.")
    String topic;

    @CommandLine.Option(names = "--lines", defaultValue = "4",
            description = "The number of lines in the poem.")
    int lines;

    @Inject
    MyAiService myAiService;

    @Override
    public void run() {
        System.out.println(myAiService.writeAPoem(topic, lines));
    }
}
```

--------------------------------

### Infinispan Embedding Store Ingestion Example

Source: https://docs.quarkiverse.io/quarkus-langchain4j/dev/rag-infinispan-store

This Java code example shows how to ingest documents into the Infinispan embedding store using the `EmbeddingStoreIngestor`. It injects the `InfinispanEmbeddingStore` and an `EmbeddingModel` to process and store document embeddings.

```java
package io.quarkiverse.langchain4j.samples;

import static dev.langchain4j.data.document.splitter.DocumentSplitters.recursive;

import java.util.List;

import jakarta.enterprise.context.ApplicationScoped;
import jakarta.inject.Inject;

import dev.langchain4j.data.document.Document;
import dev.langchain4j.model.embedding.EmbeddingModel;
import dev.langchain4j.store.embedding.EmbeddingStoreIngestor;
import io.quarkiverse.langchain4j.infinispan.InfinispanEmbeddingStore;

@ApplicationScoped
public class IngestorExampleWithInfinispan {

    /**
     * The embedding store (Infinispan).
     * The bean is provided by the quarkus-langchain4j-infinispan extension.
     */
    @Inject
    InfinispanEmbeddingStore store;

    /**
     * The embedding model (how is computed the vector of a document).
     * The bean is provided by the LLM (like openai) extension.
     */
    @Inject
    EmbeddingModel embeddingModel;

    public void ingest(List<Document> documents) {
        EmbeddingStoreIngestor ingestor = EmbeddingStoreIngestor.builder()
                .embeddingStore(store)
                .embeddingModel(embeddingModel)
                .documentSplitter(recursive(500, 0))
                .build();
        // Warning - this can take a long time...
        ingestor.ingest(documents);
    }
}
```

--------------------------------

### Configure OpenAI API Key

Source: https://docs.quarkiverse.io/quarkus-langchain4j/dev/quickstart-summarization

Sets the OpenAI API key in the application.properties file for authentication with the OpenAI service.

```properties
quarkus.langchain4j.openai.api-key=sk-...
```

--------------------------------

### Non-Blocking Tool Execution Example

Source: https://docs.quarkiverse.io/quarkus-langchain4j/dev/function-calling

Illustrates a non-blocking tool method using the `@NonBlocking` annotation, suitable for operations that should run on an event loop without blocking it. This example shows a simple sum function.

```java
@Tool("add a and b")
@NonBlocking
int sum(int a, int b) {
    return a + b;
}
```

--------------------------------

### Test Chat Compression with cURL

Source: https://docs.quarkiverse.io/quarkus-langchain4j/dev/guide-semantic-compression

Provides example cURL commands to test the chat compression functionality. By sending multiple POST requests to the '/chat' endpoint with the same memory ID but different user messages, you can observe the compression in action. The examples simulate a conversation flow.

```bash
# User Message A
curl -X POST http://localhost:8080/chat \
     -H "Content-Type: text/plain" \
     -d "Hello, my name is Bob. I would like to discuss planning a trip to Athens, Greece."

# User Message B
curl -X POST http://localhost:8080/chat \
     -H "Content-Type: text/plain" \
     -d "Thanks, let's look at transportation options. What are the available flights from Lyon to Athens?"

# User Message C
curl -X POST http://localhost:8080/chat \
     -H "Content-Type: text/plain" \
     -d "Ok, I found a flight from Lyon to Athens on August 15th at 10:00 AM. The flight is operated by Air France and arrives in Athens at 1:30 PM. The cost is approximately €150. Once in Athens, what are the available transportation options to get to the city center?"
```

--------------------------------

### Hugging Face Client General Configuration

Source: https://docs.quarkiverse.io/quarkus-langchain4j/dev/huggingface-chat-model

Configures general settings for the Hugging Face client integration, including logging and integration enablement.

```APIDOC
quarkus.langchain4j.huggingface."model-name".log-requests
  Description: Whether the HuggingFace client should log requests.
  Environment Variable: QUARKUS_LANGCHAIN4J_HUGGINGFACE__MODEL_NAME__LOG_REQUESTS
  Type: boolean
  Default: false

quarkus.langchain4j.huggingface."model-name".log-responses
  Description: Whether the HuggingFace client should log responses.
  Environment Variable: QUARKUS_LANGCHAIN4J_HUGGINGFACE__MODEL_NAME__LOG_RESPONSES
  Type: boolean
  Default: false

quarkus.langchain4j.huggingface."model-name".enable-integration
  Description: Whether or not to enable the integration. Defaults to true.
  Environment Variable: QUARKUS_LANGCHAIN4J_HUGGINGFACE__MODEL_NAME__ENABLE_INTEGRATION
  Type: boolean
  Default: true
```

--------------------------------

### LangChain4j vs. Quarkus LangChain4j

Source: https://docs.quarkiverse.io/quarkus-langchain4j/dev/index

Compares the direct use of LangChain4j with the Quarkus extension. Direct use requires manual wiring of components, while the Quarkus extension provides an opinionated, enterprise-grade integration handling boilerplate.

```English
Direct LangChain4j:
- Manual wiring of agents, tools, retrievers, chains.
- Responsibility for model client configuration, lifecycle, observability, configuration, memory.
- Powerful but low-level and manual.

Quarkus LangChain4j Extension:
- Declarative AI services with CDI and annotations.
- Native support for OpenAI, Hugging Face, Ollama, etc.
- Centralized configuration.
- Build-time optimization and validation.
- Observability (logs, metrics, traces).
- Dev Services for embedding stores and model servings.
- Dev UI for introspection and testing.
- Automatic chat memory management.
- Focus on application logic over infrastructure.
```

--------------------------------

### Inject EmbeddingModel in Java

Source: https://docs.quarkiverse.io/quarkus-langchain4j/dev/mistral-embedding-model

Example of how to inject the EmbeddingModel into a Java class using Quarkus dependency injection.

```java
@Inject
EmbeddingModel embeddingModel;
```
Tokens:
Raw