CtrlK
BlogDocsLog inGet started
Tessl Logo

tessl/maven-io-quarkiverse-langchain4j--quarkus-langchain4j-gemini-common

Common shared infrastructure for integrating Google Gemini AI models with Quarkus applications through the LangChain4j framework, providing base chat model functionality, schema mapping, and embedding model support.

Overview
Eval results
Files

index.mddocs/

Quarkus LangChain4j Gemini Common

Common shared infrastructure for integrating Google Gemini AI models with Quarkus applications through the LangChain4j framework. This module provides base implementations for chat models, embedding models, schema mapping utilities, request/response handlers, and function calling support for Google's Gemini API.

Package Information

  • Package Name: io.quarkiverse.langchain4j:quarkus-langchain4j-gemini-common
  • Package Type: Maven
  • Language: Java
  • Installation: 
    <dependency>
    <groupId>io.quarkiverse.langchain4j</groupId>
    <artifactId>quarkus-langchain4j-gemini-common</artifactId>
    <version>1.7.4</version>
</dependency>

Core Imports

import io.quarkiverse.langchain4j.gemini.common.*;

Common specific imports:

// Chat Models
import io.quarkiverse.langchain4j.gemini.common.GeminiChatLanguageModel;
import io.quarkiverse.langchain4j.gemini.common.GeminiStreamingChatLanguageModel;
import io.quarkiverse.langchain4j.gemini.common.BaseGeminiChatModel;

// Embedding Models
import io.quarkiverse.langchain4j.gemini.common.GeminiEmbeddingModel;

// Content Types
import io.quarkiverse.langchain4j.gemini.common.Content;
import io.quarkiverse.langchain4j.gemini.common.Content.Part;

// Function Calling
import io.quarkiverse.langchain4j.gemini.common.FunctionDeclaration;
import io.quarkiverse.langchain4j.gemini.common.FunctionCall;
import io.quarkiverse.langchain4j.gemini.common.FunctionResponse;

// Configuration
import io.quarkiverse.langchain4j.gemini.common.GenerationConfig;
import io.quarkiverse.langchain4j.gemini.common.Schema;

Basic Usage

Using Chat Model

// Extend the abstract base class
public class MyGeminiChatModel extends GeminiChatLanguageModel {

    public MyGeminiChatModel(String apiKey) {
        super(
            "gemini-1.5-pro",           // modelId
            0.7,                         // temperature
            1024,                        // maxOutputTokens
            40,                          // topK
            0.9,                         // topP
            null,                        // responseFormat
            Collections.emptyList(),     // listeners
            null,                        // thinkingBudget
            false,                       // includeThoughts
            false                        // useGoogleSearch
        );
    }

    @Override
    protected GenerateContentResponse generateContext(GenerateContentRequest request) {
        // Implementation specific to your Gemini API endpoint
        return callGeminiApi(request);
    }
}

// Use the model
MyGeminiChatModel model = new MyGeminiChatModel(apiKey);
ChatResponse response = model.chat(chatRequest);

Using Embedding Model

// Extend the abstract base class
public class MyGeminiEmbeddingModel extends GeminiEmbeddingModel {

    public MyGeminiEmbeddingModel() {
        super(
            "text-embedding-004",  // modelId
            768,                   // dimension
            "RETRIEVAL_DOCUMENT"   // taskType
        );
    }

    @Override
    protected EmbedContentResponse embedContent(EmbedContentRequest request) {
        // Implementation specific to your Gemini API endpoint
        return callGeminiEmbeddingApi(request);
    }

    @Override
    protected EmbedContentResponses batchEmbedContents(EmbedContentRequests requests) {
        // Batch implementation
        return callGeminiBatchEmbeddingApi(requests);
    }
}

// Use the model
MyGeminiEmbeddingModel model = new MyGeminiEmbeddingModel();
Response<Embedding> response = model.embed("Hello, world!");

Architecture

This module is designed as a foundation component that provides:

  • Abstract Base Classes: Template method pattern for chat and embedding models, requiring subclasses to implement endpoint-specific logic
  • Immutable DTOs: Record-based request/response types for type-safe API interaction
  • Schema Mapping: Utilities to convert between LangChain4j and Gemini formats
  • Function Calling: Complete support for Gemini's function calling capabilities
  • Multi-modal Content: Support for text, images (inline and file-based), and function calls

The module integrates with:

  • Quarkus REST Client: For HTTP communication with Gemini API
  • LangChain4j Core: Standard interfaces for chat and embedding models
  • Google Auth Library: Authentication support via ModelAuthProviderFilter

Capabilities

Chat Model Implementation

Abstract base classes for implementing Gemini chat models with support for both synchronous and streaming responses. Includes configuration for temperature, token limits, thinking budgets, and Google Search integration.

public abstract class BaseGeminiChatModel {
    public BaseGeminiChatModel(String modelId, Double temperature, Integer maxOutputTokens,
                              Integer topK, Double topP, ResponseFormat responseFormat,
                              List<ChatModelListener> listeners, Long thinkingBudget,
                              boolean includeThoughts, boolean useGoogleSearch);

    protected Schema detectSchema(ResponseFormat effectiveResponseFormat);
    protected Map<String, Object> detectRawSchema(ResponseFormat effectiveResponseFormat);
    protected String computeMimeType(ResponseFormat responseFormat, Schema schema, Map<String, Object> rawSchema);
}

public abstract class GeminiChatLanguageModel extends BaseGeminiChatModel implements ChatModel {
    public Set<Capability> supportedCapabilities();
    public ChatResponse chat(ChatRequest chatRequest);
    public ChatResponse doChat(ChatRequest chatRequest);
    protected abstract GenerateContentResponse generateContext(GenerateContentRequest request);
}

public abstract class GeminiStreamingChatLanguageModel extends BaseGeminiChatModel implements StreamingChatModel {
    public Set<Capability> supportedCapabilities();
    public void doChat(ChatRequest chatRequest, StreamingChatResponseHandler handler);
    protected abstract Multi<SseEvent<GenerateContentResponse>> generateStreamContext(GenerateContentRequest request);
}

Chat Models

Embedding Model Implementation

Abstract base class for implementing Gemini embedding models with support for single and batch embeddings, configurable output dimensions, and task-specific embeddings.

public abstract class GeminiEmbeddingModel implements EmbeddingModel {
    public GeminiEmbeddingModel(String modelId, Integer dimension, String taskType);

    public Response<Embedding> embed(String text);
    public Response<List<Embedding>> embedAll(List<TextSegment> textSegments);

    protected abstract EmbedContentResponse embedContent(EmbedContentRequest request);
    protected abstract EmbedContentResponses batchEmbedContents(EmbedContentRequests requests);
}

Embedding Models

Content Types

Multi-modal content structures supporting text, binary data (images), file references, function calls, and function responses. Content is organized into parts with role-based messaging.

public record Content(String role, List<Part> parts);
public record Blob(String mimeType, String data);
public record FileData(String mimeType, String fileUri);

Content Types

Function Calling

Complete support for Gemini's function calling capabilities, including function declarations with parameter schemas, function calls from the model, and function responses back to the model.

public record FunctionDeclaration(String name, String description, Parameters parameters);
public record FunctionCall(String name, Map<String, Object> args);
public record FunctionResponse(String name, Response response);

Function Calling

Request and Response Types

Comprehensive request and response structures for content generation and embedding operations, including support for system instructions, tools, generation configuration, and usage metadata.

public record GenerateContentRequest(List<Content> contents, SystemInstruction systemInstruction,
                                    List<Tool> tools, GenerationConfig generationConfig);

public record GenerateContentResponse(List<Candidate> candidates, UsageMetadata usageMetadata,
                                     String modelVersion, String responseId);

public record EmbedContentRequest(String model, Content content, TaskType taskType,
                                  String title, Integer outputDimensionality);

public record EmbedContentResponse(Embedding embedding);

Requests and Responses

Configuration

Configuration classes for controlling content generation behavior, including temperature, token limits, structured output schemas, thinking/reasoning budgets, and JSON schema definitions.

public class GenerationConfig {
    public static Builder builder();
    public Double getTemperature();
    public Integer getMaxOutputTokens();
    public Schema getResponseSchema();
    public ThinkingConfig getThinkingConfig();
}

public class Schema {
    public static Builder builder();
    public Type getType();
    public Map<String, Schema> getProperties();
    public List<String> getRequired();
}

public class ThinkingConfig {
    public ThinkingConfig(Long thinkingBudget, Boolean includeThoughts);
    public Long getThinkingBudget();
    public Boolean getIncludeThoughts();
}

Configuration

Utilities

Utility classes for mapping between LangChain4j and Gemini formats, handling responses, and providing REST client authentication.

public final class ContentMapper {
    public static GenerateContentRequest map(List<ChatMessage> messages,
                                            List<ToolSpecification> toolSpecifications,
                                            GenerationConfig generationConfig,
                                            String modelId, boolean useGoogleSearch);
}

public final class SchemaMapper {
    public static Schema fromJsonSchemaToSchema(JsonSchema jsonSchema);
}

public final class GenerateContentResponseHandler {
    public static String getText(GenerateContentResponse response);
    public static List<ToolExecutionRequest> getToolExecutionRequests(GenerateContentResponse response);
    public static TokenUsage getTokenUsage(UsageMetadata usageMetadata);
}

public class ModelAuthProviderFilter implements ResteasyReactiveClientRequestFilter {
    public ModelAuthProviderFilter(String modelId);
    public void filter(ResteasyReactiveClientRequestContext requestContext);
}

Utilities

Install with Tessl CLI

npx tessl i tessl/maven-io-quarkiverse-langchain4j--quarkus-langchain4j-gemini-common@1.7.0

docs

chat-models.md

configuration.md

content-types.md

embedding-models.md

function-calling.md

index.md

requests-responses.md

utilities.md

tile.json