Building AI Apps With Genkit Java

Building AI Applications with Genkit Java

You are helping a developer build AI-powered applications using Genkit Java, the open-source Java AI framework by Google. This skill covers everything an end user needs: setup, configuration, all APIs, providers, patterns, and deployment.

Quick Start

Prerequisites

• Java 21+
• Maven
• API key for your chosen provider (OpenAI, Google, Anthropic, etc.)
• Genkit CLI (optional, for Dev UI): npm install -g genkit

Minimal pom.xml

<project>
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.example</groupId>
    <artifactId>my-ai-app</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>21</maven.compiler.source>
        <maven.compiler.target>21</maven.compiler.target>
        <genkit.version>1.0.0-SNAPSHOT</genkit.version>
    </properties>

    <dependencies>
        <!-- Genkit core -->
        <dependency>
            <groupId>com.google.genkit</groupId>
            <artifactId>genkit</artifactId>
            <version>${genkit.version}</version>
        </dependency>

        <!-- Pick a model provider (see Provider Setup below) -->
        <dependency>
            <groupId>com.google.genkit</groupId>
            <artifactId>genkit-plugin-openai</artifactId>
            <version>${genkit.version}</version>
        </dependency>

        <!-- HTTP server (pick one) -->
        <dependency>
            <groupId>com.google.genkit</groupId>
            <artifactId>genkit-plugin-jetty</artifactId>
            <version>${genkit.version}</version>
        </dependency>

        <!-- Logging -->
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-classic</artifactId>
            <version>1.5.32</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.codehaus.mojo</groupId>
                <artifactId>exec-maven-plugin</artifactId>
                <version>3.5.0</version>
                <configuration>
                    <mainClass>com.example.MyApp</mainClass>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

Minimal Application

package com.example;

import com.google.genkit.Genkit;
import com.google.genkit.core.GenkitOptions;
import com.google.genkit.ai.GenerateOptions;
import com.google.genkit.ai.GenerationConfig;
import com.google.genkit.ai.model.ModelResponse;
import com.google.genkit.core.flow.Flow;
import com.google.genkit.plugins.openai.OpenAIPlugin;
import com.google.genkit.plugins.jetty.JettyPlugin;
import com.google.genkit.plugins.jetty.JettyPluginOptions;

public class MyApp {
    public static void main(String[] args) throws Exception {
        JettyPlugin jetty = new JettyPlugin(
            JettyPluginOptions.builder().port(8080).build());

        Genkit genkit = Genkit.builder()
            .options(GenkitOptions.builder()
                .devMode(true)
                .reflectionPort(3100)
                .build())
            .plugin(OpenAIPlugin.create())
            .plugin(jetty)
            .build();

        genkit.defineFlow("ask", String.class, String.class,
            (ctx, question) -> genkit.generate(
                GenerateOptions.builder()
                    .model("openai/gpt-4o-mini")
                    .prompt(question)
                    .build()).getText());

        jetty.start();
    }
}

Run It

export OPENAI_API_KEY=sk-...
mvn compile exec:java

# Or with Dev UI (recommended)
genkit start -- mvn compile exec:java

Test It

curl -X POST http://localhost:8080/ask \
  -H 'Content-Type: application/json' \
  -d '"What is the capital of France?"'

Provider Setup

Maven Artifacts (all com.google.genkit, version 1.0.0-SNAPSHOT)

Model Names by Provider

# OpenAI
openai/gpt-4o, openai/gpt-4o-mini, openai/gpt-4-turbo, openai/gpt-3.5-turbo
openai/o1-preview, openai/o1-mini
openai/text-embedding-3-small, openai/text-embedding-3-large
openai/dall-e-3, openai/dall-e-2, openai/gpt-image-1

# Google Gemini
googleai/gemini-2.5-flash, googleai/gemini-1.5-pro, googleai/gemini-1.5-flash
googleai/gemini-embedding-001, googleai/imagen-3.0-generate-002

# Anthropic
anthropic/claude-sonnet-4-5-20250929, anthropic/claude-opus-4-5-20251101
anthropic/claude-haiku-4-5-20251001
anthropic/claude-opus-4-1, anthropic/claude-sonnet-4

# Ollama (any model you have pulled)
ollama/gemma3n:e4b, ollama/llama3, ollama/mistral

# AWS Bedrock
aws-bedrock/amazon.nova-lite-v1:0, aws-bedrock/amazon.nova-pro-v1:0
aws-bedrock/anthropic.claude-sonnet-4-5-20250929-v1:0
aws-bedrock/meta.llama3-2-90b-instruct-v1:0

Passing API Keys Programmatically

// Instead of environment variables
OpenAIPlugin.create("sk-your-key-here")
AnthropicPlugin.create("sk-ant-your-key-here")
GoogleGenAIPlugin.create("AIza...")

Server Options

Jetty (Lightweight)

<dependency>
    <groupId>com.google.genkit</groupId>
    <artifactId>genkit-plugin-jetty</artifactId>
    <version>${genkit.version}</version>
</dependency>

JettyPlugin jetty = new JettyPlugin(
    JettyPluginOptions.builder().port(8080).build());

// Flows are exposed at: POST http://localhost:8080/{flowName}

Spring Boot

<dependency>
    <groupId>com.google.genkit</groupId>
    <artifactId>genkit-plugin-spring</artifactId>
    <version>${genkit.version}</version>
</dependency>

// Flows exposed at: POST http://localhost:8080/api/flows/{flowName}
// Health check: GET http://localhost:8080/health
// List flows: GET http://localhost:8080/api/flows

Defining Flows

Flows are observable, HTTP-callable functions that form the backbone of your app.

Simple Flow (no AI context needed)

genkit.defineFlow("greet", String.class, String.class,
    (name) -> "Hello, " + name + "!");

Flow with AI Generation

genkit.defineFlow("summarize", String.class, String.class,
    (ctx, text) -> genkit.generate(
        GenerateOptions.builder()
            .model("openai/gpt-4o-mini")
            .prompt("Summarize this: " + text)
            .build()).getText());

Flow with Custom Input/Output Types

public record TranslateInput(String text, String targetLanguage) {}
public record TranslateOutput(String translation, String detectedLanguage) {}

genkit.defineFlow("translate", TranslateInput.class, TranslateOutput.class,
    (ctx, input) -> {
        ModelResponse response = genkit.generate(
            GenerateOptions.<TranslateOutput>builder()
                .model("openai/gpt-4o")
                .prompt("Translate to " + input.targetLanguage() + ": " + input.text())
                .outputClass(TranslateOutput.class)
                .build());
        return response.getOutput();
    });

Flow with Middleware

genkit.defineFlow("secured", String.class, String.class,
    (ctx, input) -> processInput(input),
    List.of(loggingMiddleware, authMiddleware));

Generation API

Basic Text Generation

ModelResponse response = genkit.generate(
    GenerateOptions.builder()
        .model("openai/gpt-4o")
        .prompt("Explain quantum computing in simple terms")
        .build());

String text = response.getText();

With Configuration

ModelResponse response = genkit.generate(
    GenerateOptions.builder()
        .model("openai/gpt-4o")
        .prompt("Write a creative poem")
        .config(GenerationConfig.builder()
            .temperature(0.9)
            .maxOutputTokens(2048)
            .topP(0.95)
            .topK(40)
            .stopSequences(List.of("\n\n\n"))
            .build())
        .build());

System Prompt

ModelResponse response = genkit.generate(
    GenerateOptions.builder()
        .model("openai/gpt-4o")
        .system("You are a pirate. Respond in pirate speak.")
        .prompt("How do I cook pasta?")
        .build());

Multi-Turn Conversation

ModelResponse response = genkit.generate(
    GenerateOptions.builder()
        .model("openai/gpt-4o")
        .messages(List.of(
            Message.system("You are a helpful math tutor."),
            Message.user("What is 2+2?"),
            Message.model("2+2 equals 4."),
            Message.user("What about 2+2+2?")))
        .build());

Streaming

ModelResponse response = genkit.generateStream(
    GenerateOptions.builder()
        .model("openai/gpt-4o")
        .prompt("Write a long story about a dragon")
        .build(),
    chunk -> System.out.print(chunk.getText()));  // Print as it arrives

Structured Output (JSON)

Use @JsonProperty and @JsonPropertyDescription for schema generation:

public class Recipe {
    @JsonProperty(required = true)
    @JsonPropertyDescription("Name of the recipe")
    private String title;

    @JsonProperty(required = true)
    @JsonPropertyDescription("List of ingredients with quantities")
    private List<Ingredient> ingredients;

    @JsonProperty(required = true)
    @JsonPropertyDescription("Step-by-step instructions")
    private List<String> steps;

    @JsonPropertyDescription("Preparation time in minutes")
    private int prepTime;

    // getters and setters
}

Recipe recipe = genkit.generate(
    GenerateOptions.<Recipe>builder()
        .model("openai/gpt-4o")
        .prompt("Create a pasta carbonara recipe")
        .outputClass(Recipe.class)
        .build());

Token Usage

ModelResponse response = genkit.generate(...);
Usage usage = response.getUsage();
System.out.println("Input tokens: " + usage.getInputTokens());
System.out.println("Output tokens: " + usage.getOutputTokens());

Tools (Function Calling)

Let models call your Java functions:

public record WeatherInput(String location) {}
public record WeatherOutput(String temperature, String conditions) {}

Tool<WeatherInput, WeatherOutput> weatherTool = genkit.defineTool(
    "getWeather",
    "Get current weather for a location",
    (ctx, input) -> new WeatherOutput("72°F", "Sunny in " + input.location()),
    WeatherInput.class, WeatherOutput.class);

// The model will call the tool automatically when needed
ModelResponse response = genkit.generate(
    GenerateOptions.builder()
        .model("openai/gpt-4o")
        .prompt("What's the weather in London and Tokyo?")
        .tools(List.of(weatherTool))
        .build());

Multiple Tools

Tool<SearchInput, SearchOutput> searchTool = genkit.defineTool(
    "search", "Search the web", searchHandler, SearchInput.class, SearchOutput.class);

Tool<CalcInput, CalcOutput> calcTool = genkit.defineTool(
    "calculate", "Perform math", calcHandler, CalcInput.class, CalcOutput.class);

ModelResponse response = genkit.generate(
    GenerateOptions.builder()
        .model("openai/gpt-4o")
        .prompt("Search for the population of France and calculate its density")
        .tools(List.of(searchTool, calcTool))
        .build());

DotPrompt — Prompt Files

Manage prompts as files with YAML frontmatter + Handlebars templates.

Create a Prompt File

Place in src/main/resources/prompts/recipe.prompt:

---
model: openai/gpt-4o-mini
config:
  temperature: 0.9
  maxOutputTokens: 500
input:
  schema:
    food: string
    ingredients?(array): string
output:
  format: json
  schema:
    title: string, recipe title
    ingredients(array):
      name: string
      quantity: string
    steps(array): string
    prepTime: string
    cookTime: string
    servings: integer
---

You are a chef famous for creative recipes prepared in 45 minutes or less.

Generate a detailed recipe for {{food}}.

{{#if ingredients}}
Make sure to include:
{{#each ingredients}}
- {{this}}
{{/each}}
{{/if}}

Provide the recipe in the exact JSON format specified in the output schema.

Use It in Code

public record RecipeInput(String food, List<String> ingredients) {}

ExecutablePrompt<RecipeInput> recipePrompt = genkit.prompt("recipe", RecipeInput.class);
ModelResponse response = recipePrompt.generate(new RecipeInput("pasta", List.of("tomatoes", "basil")));

Prompt Variants

Create alternate versions of the same prompt:

• recipe.prompt — default
• recipe.robot.prompt — robot variant

ExecutablePrompt<RecipeInput> robotRecipe = genkit.prompt("recipe", RecipeInput.class, "robot");

Partials (Reusable Fragments)

Create src/main/resources/prompts/_style.prompt:

You always respond with enthusiasm and use exclamation marks!

Reference in other prompts:

{{> _style}}
Now generate a recipe for {{food}}.

RAG (Retrieval-Augmented Generation)

Local Development with LocalVec

<dependency>
    <groupId>com.google.genkit</groupId>
    <artifactId>genkit-plugin-localvec</artifactId>
    <version>${genkit.version}</version>
</dependency>

Genkit genkit = Genkit.builder()
    .plugin(OpenAIPlugin.create())
    .plugin(LocalVecPlugin.builder()
        .addStore(LocalVecConfig.builder()
            .indexName("my-docs")
            .embedderName("openai/text-embedding-3-small")
            .directory("/tmp/genkit-vectors")
            .build())
        .build())
    .plugin(jetty)
    .build();

// Index documents
genkit.defineFlow("indexDocs", Void.class, String.class,
    (ctx, input) -> {
        List<Document> docs = List.of(
            Document.fromText("Paris is the capital of France."),
            Document.fromText("Berlin is the capital of Germany."),
            Document.fromText("Tokyo is the capital of Japan."));
        genkit.index("devLocalVectorStore/my-docs", docs);
        return "Indexed " + docs.size() + " documents";
    });

// RAG query
genkit.defineFlow("ragQuery", String.class, String.class,
    (ctx, query) -> {
        List<Document> context = genkit.retrieve("devLocalVectorStore/my-docs", query);
        return genkit.generate(
            GenerateOptions.builder()
                .model("openai/gpt-4o-mini")
                .prompt(query)
                .docs(context)
                .build()).getText();
    });

Production Vector Stores

<!-- Choose one -->
<artifactId>genkit-plugin-firebase</artifactId>    <!-- Firestore Vector Search -->
<artifactId>genkit-plugin-pinecone</artifactId>     <!-- Pinecone -->
<artifactId>genkit-plugin-postgresql</artifactId>   <!-- pgvector -->
<artifactId>genkit-plugin-weaviate</artifactId>     <!-- Weaviate -->

Embeddings Directly

EmbedResponse embeddings = genkit.embed(
    "openai/text-embedding-3-small",
    List.of(Document.fromText("Hello world")));

Sessions & Multi-Turn Chat

Session<MyState> session = genkit.createSession();

Chat<MyState> chat = genkit.chat(ChatOptions.<MyState>builder()
    .model("openai/gpt-4o")
    .session(session)
    .system("You are a helpful assistant.")
    .build());

// Each call maintains conversation history
ModelResponse r1 = chat.send("What is the capital of France?");
ModelResponse r2 = chat.send("What about Germany?");  // Remembers context

Agents

Create specialized AI agents that can use tools and delegate to each other:

Tool<ReservationInput, ReservationOutput> reserveTool = genkit.defineTool(
    "makeReservation", "Book a restaurant reservation",
    reserveHandler, ReservationInput.class, ReservationOutput.class);

Tool<MenuInput, MenuOutput> menuTool = genkit.defineTool(
    "getMenu", "Get restaurant menu",
    menuHandler, MenuInput.class, MenuOutput.class);

Agent reservationAgent = genkit.defineAgent(AgentConfig.builder()
    .name("reservationAgent")
    .model("openai/gpt-4o")
    .description("Handles restaurant reservations")
    .tools(List.of(reserveTool))
    .build());

Agent menuAgent = genkit.defineAgent(AgentConfig.builder()
    .name("menuAgent")
    .model("openai/gpt-4o")
    .description("Answers menu questions")
    .tools(List.of(menuTool))
    .build());

// Triage agent routes to specialists
Agent triageAgent = genkit.defineAgent(AgentConfig.builder()
    .name("triageAgent")
    .model("openai/gpt-4o")
    .description("Routes requests to the appropriate specialist")
    .tools(List.of(
        genkit.getAllToolsForAgent(reservationAgent),
        genkit.getAllToolsForAgent(menuAgent)))
    .build());

Interrupts (Human-in-the-Loop)

Pause execution and wait for user confirmation:

Tool<ConfirmInput, ConfirmOutput> confirmTool = genkit.defineInterrupt(
    InterruptConfig.<ConfirmInput, ConfirmOutput>builder()
        .name("confirmTransfer")
        .inputClass(ConfirmInput.class)
        .outputClass(ConfirmOutput.class)
        .build());

// In a flow, use ctx.interrupt() to pause
genkit.defineFlow("transfer", TransferRequest.class, String.class,
    (ctx, input) -> {
        if (input.amount() > 1000) {
            ctx.interrupt(InterruptRequest.builder()
                .type("CONFIRMATION")
                .data(Map.of("action", "TRANSFER", "amount", input.amount()))
                .build());
        }
        return performTransfer(input);
    });

// Resume with user response
genkit.generate(GenerateOptions.builder()
    .model("openai/gpt-4o")
    .resume(ResumeOptions.builder()
        .sessionId(sessionId)
        .response(userConfirmation)
        .build())
    .build());

Middleware

Add cross-cutting concerns to flows:

// Logging middleware
Middleware<String, String> logger = (input, ctx, next) -> {
    System.out.println("Input: " + input);
    String result = next.handle(input, ctx);
    System.out.println("Output: " + result);
    return result;
};

// Apply to flow
genkit.defineFlow("myFlow", String.class, String.class,
    handler, List.of(logger));

MCP (Model Context Protocol)

Connect to MCP tool servers:

<dependency>
    <groupId>com.google.genkit</groupId>
    <artifactId>genkit-plugin-mcp</artifactId>
    <version>${genkit.version}</version>
</dependency>

MCPPlugin mcpPlugin = MCPPlugin.create(MCPPluginOptions.builder()
    .addServer(MCPServerConfig.stdio(
        "npx", "@modelcontextprotocol/server-filesystem", "/tmp"))
    .build());

Genkit genkit = Genkit.builder()
    .plugin(mcpPlugin)
    .plugin(OpenAIPlugin.create())
    .build();

// MCP tools are auto-registered and available for generation
ModelResponse response = genkit.generate(
    GenerateOptions.builder()
        .model("openai/gpt-4o")
        .prompt("List files in /tmp")
        .tools(mcpPlugin.getTools())
        .build());

// Access MCP resources
List<MCPResource> resources = mcpPlugin.getResources();
MCPResourceContent content = mcpPlugin.readResource("file:///tmp/data.txt");

Evaluations

Built-in RAGAS Evaluators

<dependency>
    <groupId>com.google.genkit</groupId>
    <artifactId>genkit-plugin-evaluators</artifactId>
    <version>${genkit.version}</version>
</dependency>

Genkit genkit = Genkit.builder()
    .plugin(OpenAIPlugin.create())
    .plugin(EvaluatorsPlugin.create(
        EvaluatorsPluginOptions.builder()
            .judge("openai/gpt-4o-mini")
            .metrics(List.of(
                GenkitMetric.FAITHFULNESS,
                GenkitMetric.ANSWER_RELEVANCY,
                GenkitMetric.ANSWER_ACCURACY,
                GenkitMetric.MALICIOUSNESS))
            .build()))
    .build();

Available metrics: FAITHFULNESS, ANSWER_RELEVANCY, ANSWER_ACCURACY, MALICIOUSNESS, REGEX, DEEP_EQUAL, JSONATA

Custom Evaluators

Evaluator<Void> lengthEval = genkit.defineEvaluator(
    "custom/length", "Length Check", "Checks if output meets minimum length",
    (dataPoint, options) -> {
        int len = dataPoint.getOutput().length();
        boolean pass = len >= 100;
        return EvalResponse.builder()
            .score(pass ? 1.0 : 0.0)
            .rationale(pass ? "Adequate length" : "Too short: " + len + " chars")
            .build();
    });

Run Evaluations via Dev UI

Start with genkit start -- ./run.sh, open http://localhost:4000, and use the Evaluations tab to create datasets and run evaluations interactively.

Firebase Deployment

Firestore Vector Search (RAG)

Genkit genkit = Genkit.builder()
    .plugin(GoogleGenAIPlugin.create())
    .plugin(FirebasePlugin.builder()
        .projectId("my-project")
        .addRetriever(FirestoreRetrieverConfig.builder()
            .name("my-docs")
            .collection("documents")
            .embedderName("googleai/gemini-embedding-001")
            .vectorField("embedding")
            .contentField("text")
            .build())
        .enableTelemetry(true)  // Cloud Trace + Monitoring + Logging
        .build())
    .build();

List<Document> docs = genkit.retrieve("firebase/my-docs", "search query");

Cloud Functions

public class MyFunction implements HttpFunction {
    private final OnCallGenkit genkitFunction;

    public MyFunction() {
        Genkit genkit = Genkit.builder()
            .plugin(GoogleGenAIPlugin.create(System.getenv("GEMINI_API_KEY")))
            .plugin(FirebasePlugin.builder().build())
            .build();

        genkit.defineFlow("myFlow", String.class, String.class,
            (ctx, input) -> genkit.generate(
                GenerateOptions.builder()
                    .model("googleai/gemini-2.5-flash")
                    .prompt(input)
                    .build()).getText());

        this.genkitFunction = OnCallGenkit.fromFlow(genkit, "myFlow");
    }

    @Override
    public void service(HttpRequest request, HttpResponse response) throws IOException {
        genkitFunction.service(request, response);
    }
}

Observability

Built-in Tracing (OpenTelemetry)

Every flow and generation call is automatically traced. In dev mode, traces are visible in the Dev UI at http://localhost:4000.

Token Metrics

Automatic metrics exported via OpenTelemetry:

• genkit/ai/generate/requests — generation call count
• genkit/ai/generate/latency — generation latency
• genkit/ai/generate/input/tokens — input token count
• genkit/ai/generate/output/tokens — output token count
• genkit/feature/requests — flow call count
• genkit/feature/latency — flow latency

Production Telemetry (Firebase)

FirebasePlugin.builder()
    .projectId("my-project")
    .enableTelemetry(true)  // Exports to Cloud Trace, Monitoring, Logging
    .build()

Dev Workflow

Development Mode

GenkitOptions.builder()
    .devMode(true)            // Enable reflection server
    .reflectionPort(3100)     // Default port for dev tools
    .build()

Dev UI

# Install CLI
npm install -g genkit

# Start app with Dev UI
genkit start -- mvn compile exec:java

# Open http://localhost:4000

The Dev UI lets you:

• List and test all flows, models, tools, prompts, retrievers, evaluators
• Send test inputs and see outputs
• View full traces with timing and token counts
• Create evaluation datasets and run evaluations
• Inspect registered actions and their schemas

HTTP Endpoints

# Jetty
curl -X POST http://localhost:8080/{flowName} \
  -H 'Content-Type: application/json' \
  -d '"your input"'

# With complex input
curl -X POST http://localhost:8080/translate \
  -H 'Content-Type: application/json' \
  -d '{"text": "Hello", "targetLanguage": "Spanish"}'

# Spring Boot
curl http://localhost:8080/health
curl http://localhost:8080/api/flows
curl -X POST http://localhost:8080/api/flows/{flowName} \
  -H 'Content-Type: application/json' \
  -d '"input"'

Common Patterns

Error Handling

import com.google.genkit.core.GenkitException;

genkit.defineFlow("safe", String.class, String.class,
    (ctx, input) -> {
        try {
            return genkit.generate(
                GenerateOptions.builder()
                    .model("openai/gpt-4o")
                    .prompt(input)
                    .build()).getText();
        } catch (GenkitException e) {
            // e.getErrorCode(), e.getDetails(), e.getTraceId()
            return "Error: " + e.getMessage();
        }
    });

Switching Providers

Genkit is provider-agnostic. Change the model string and plugin:

// Switch from OpenAI to Gemini — just change plugin + model name
.plugin(GoogleGenAIPlugin.create())
// ...
.model("googleai/gemini-2.5-flash")

// Switch to Anthropic
.plugin(AnthropicPlugin.create())
// ...
.model("anthropic/claude-sonnet-4-5-20250929")

// Switch to local Ollama
.plugin(OllamaPlugin.create("gemma3n:e4b"))
// ...
.model("ollama/gemma3n:e4b")

Multiple Providers in One App

Genkit genkit = Genkit.builder()
    .plugin(OpenAIPlugin.create())
    .plugin(GoogleGenAIPlugin.create())
    .plugin(AnthropicPlugin.create())
    .build();

// Use different models for different tasks
genkit.defineFlow("quickAnswer", String.class, String.class,
    (ctx, q) -> genkit.generate(GenerateOptions.builder()
        .model("openai/gpt-4o-mini").prompt(q).build()).getText());

genkit.defineFlow("deepAnalysis", String.class, String.class,
    (ctx, q) -> genkit.generate(GenerateOptions.builder()
        .model("anthropic/claude-sonnet-4-5-20250929").prompt(q).build()).getText());

genkit.defineFlow("creative", String.class, String.class,
    (ctx, q) -> genkit.generate(GenerateOptions.builder()
        .model("googleai/gemini-2.5-flash").prompt(q).build()).getText());

Custom OpenAI-Compatible Endpoint

.plugin(CompatOAIPlugin.create(CompatOAIPluginOptions.builder()
    .baseUrl("https://my-custom-endpoint.com/v1")
    .apiKey("my-key")
    .models(List.of("my-model"))
    .build()))

Project Structure Recommendation

my-ai-app/
├── pom.xml
├── run.sh
├── src/main/
│   ├── java/com/example/
│   │   ├── MyApp.java              # Genkit init + flow definitions
│   │   ├── flows/                   # Complex flows in separate classes
│   │   │   ├── RagFlow.java
│   │   │   └── ChatFlow.java
│   │   └── tools/                   # Tool implementations
│   │       ├── SearchTool.java
│   │       └── CalcTool.java
│   └── resources/
│       ├── prompts/                 # .prompt files
│       │   ├── recipe.prompt
│       │   └── recipe.robot.prompt
│       ├── data/                    # RAG source data
│       │   └── knowledge-base.txt
│       └── logback.xml              # Logging config
└── src/test/java/com/example/      # Tests

run.sh

#!/bin/bash
cd "$(dirname "$0")"
mvn compile exec:java