Image Generation

/**
 * Image generation model for Google AI Gemini.
 * Creates and edits images from text prompts.
 * Marked as experimental feature.
 */
public class GoogleAiGeminiImageModel {
    /**
     * Creates a new builder for configuring the image model.
     * @return GoogleAiGeminiImageModelBuilder instance
     */
    public static GoogleAiGeminiImageModelBuilder builder();

    /**
     * Returns the model name being used.
     * @return Model name string
     */
    public String modelName();

    /**
     * Generates an image from a text prompt.
     * @param prompt Text description of the desired image
     * @return Response containing the generated Image
     */
    public Response<Image> generate(String prompt);

    /**
     * Edits an existing image based on a text prompt.
     * @param image The image to edit
     * @param prompt Text description of desired edits
     * @return Response containing the edited Image
     */
    public Response<Image> edit(Image image, String prompt);

    /**
     * Edits an image using a mask to specify the edit region.
     * @param image The image to edit
     * @param mask Mask image indicating regions to edit (white = edit, black = preserve)
     * @param prompt Text description of desired edits
     * @return Response containing the edited Image
     */
    public Response<Image> edit(Image image, Image mask, String prompt);
}

/**
 * Builder for GoogleAiGeminiImageModel.
 * Provides configuration for image generation parameters.
 */
public static class GoogleAiGeminiImageModelBuilder {
    /**
     * Sets the HTTP client builder for customizing requests.
     * @param httpClientBuilder HTTP client builder instance
     * @return Builder instance for chaining
     */
    public GoogleAiGeminiImageModelBuilder httpClientBuilder(HttpClientBuilder httpClientBuilder);

    /**
     * Sets the API key for authentication (required).
     * @param apiKey Google AI API key
     * @return Builder instance for chaining
     */
    public GoogleAiGeminiImageModelBuilder apiKey(String apiKey);

    /**
     * Sets the base URL for the API endpoint.
     * @param baseUrl Custom base URL (optional)
     * @return Builder instance for chaining
     */
    public GoogleAiGeminiImageModelBuilder baseUrl(String baseUrl);

    /**
     * Sets the model name to use for image generation.
     * @param modelName Model identifier (e.g., "gemini-2.5-flash")
     * @return Builder instance for chaining
     */
    public GoogleAiGeminiImageModelBuilder modelName(String modelName);

    /**
     * Sets the aspect ratio for generated images.
     * @param aspectRatio Aspect ratio string (e.g., "16:9", "4:3", "1:1")
     * @return Builder instance for chaining
     */
    public GoogleAiGeminiImageModelBuilder aspectRatio(String aspectRatio);

    /**
     * Sets the size of generated images.
     * @param imageSize Image size specification
     * @return Builder instance for chaining
     */
    public GoogleAiGeminiImageModelBuilder imageSize(String imageSize);

    /**
     * Sets the request timeout duration.
     * @param timeout Timeout duration
     * @return Builder instance for chaining
     */
    public GoogleAiGeminiImageModelBuilder timeout(Duration timeout);

    /**
     * Sets the maximum number of retry attempts for failed requests.
     * @param maxRetries Number of retries (default: 3)
     * @return Builder instance for chaining
     */
    public GoogleAiGeminiImageModelBuilder maxRetries(Integer maxRetries);

    /**
     * Enables logging of both requests and responses.
     * @param logRequestsAndResponses True to enable full logging
     * @return Builder instance for chaining
     */
    public GoogleAiGeminiImageModelBuilder logRequestsAndResponses(Boolean logRequestsAndResponses);

    /**
     * Enables logging of requests only.
     * @param logRequests True to enable request logging
     * @return Builder instance for chaining
     */
    public GoogleAiGeminiImageModelBuilder logRequests(Boolean logRequests);

    /**
     * Enables logging of responses only.
     * @param logResponses True to enable response logging
     * @return Builder instance for chaining
     */
    public GoogleAiGeminiImageModelBuilder logResponses(Boolean logResponses);

    /**
     * Sets a custom logger for the model.
     * @param logger Logger instance
     * @return Builder instance for chaining
     */
    public GoogleAiGeminiImageModelBuilder logger(Logger logger);

    /**
     * Sets safety settings for content filtering.
     * @param safetySettings List of safety settings
     * @return Builder instance for chaining
     */
    public GoogleAiGeminiImageModelBuilder safetySettings(List<GeminiSafetySetting> safetySettings);

    /**
     * Enables Google Search grounding for enhanced image generation.
     * @param useGoogleSearchGrounding True to enable search grounding
     * @return Builder instance for chaining
     */
    public GoogleAiGeminiImageModelBuilder useGoogleSearchGrounding(Boolean useGoogleSearchGrounding);

    /**
     * Builds the GoogleAiGeminiImageModel instance.
     * @return Configured GoogleAiGeminiImageModel
     * @throws IllegalArgumentException if required fields are missing
     */
    public GoogleAiGeminiImageModel build();
}

/**
 * Exception thrown when image generation or editing fails.
 * Extends RuntimeException for unchecked exception handling.
 */
public static class GeminiImageGenerationException extends RuntimeException {
    /**
     * Creates a new exception with the specified message.
     * @param message Error message describing the failure
     */
    public GeminiImageGenerationException(String message);
}

import dev.langchain4j.model.googleai.GoogleAiGeminiImageModel;
import dev.langchain4j.data.image.Image;
import dev.langchain4j.model.output.Response;

// Create image generation model
GoogleAiGeminiImageModel imageModel = GoogleAiGeminiImageModel.builder()
    .apiKey(System.getenv("GOOGLE_AI_API_KEY"))
    .modelName("gemini-2.5-flash")
    .build();

// Generate an image
Response<Image> response = imageModel.generate(
    "A serene mountain landscape at sunset with snow-capped peaks and a lake"
);

Image image = response.content();
System.out.println("Generated image URL: " + image.url());

// Generate with specific aspect ratio
GoogleAiGeminiImageModel imageModel = GoogleAiGeminiImageModel.builder()
    .apiKey(System.getenv("GOOGLE_AI_API_KEY"))
    .modelName("gemini-2.5-flash")
    .aspectRatio("16:9") // Wide format
    .build();

Response<Image> response = imageModel.generate(
    "A cinematic panoramic view of a futuristic city skyline at night"
);

// Save or display the image
Image image = response.content();

// Square image
GoogleAiGeminiImageModel squareModel = GoogleAiGeminiImageModel.builder()
    .apiKey(System.getenv("GOOGLE_AI_API_KEY"))
    .modelName("gemini-2.5-flash")
    .aspectRatio("1:1")
    .build();

Response<Image> square = squareModel.generate("A mandala design with intricate patterns");

// Portrait image
GoogleAiGeminiImageModel portraitModel = GoogleAiGeminiImageModel.builder()
    .apiKey(System.getenv("GOOGLE_AI_API_KEY"))
    .modelName("gemini-2.5-flash")
    .aspectRatio("9:16")
    .build();

Response<Image> portrait = portraitModel.generate("A tall waterfall in a rainforest");

// Landscape image
GoogleAiGeminiImageModel landscapeModel = GoogleAiGeminiImageModel.builder()
    .apiKey(System.getenv("GOOGLE_AI_API_KEY"))
    .modelName("gemini-2.5-flash")
    .aspectRatio("16:9")
    .build();

Response<Image> landscape = landscapeModel.generate("A vast desert with sand dunes");

import java.net.URI;

// Load existing image
Image originalImage = Image.fromUrl(URI.create("https://example.com/photo.jpg"));

GoogleAiGeminiImageModel imageModel = GoogleAiGeminiImageModel.builder()
    .apiKey(System.getenv("GOOGLE_AI_API_KEY"))
    .modelName("gemini-2.5-flash")
    .build();

// Edit the image
Response<Image> response = imageModel.edit(
    originalImage,
    "Add a rainbow in the sky and make the colors more vibrant"
);

Image editedImage = response.content();
System.out.println("Edited image URL: " + editedImage.url());

// Load original image and mask
Image originalImage = Image.fromUrl(URI.create("https://example.com/scene.jpg"));
Image maskImage = Image.fromUrl(URI.create("https://example.com/mask.png"));

GoogleAiGeminiImageModel imageModel = GoogleAiGeminiImageModel.builder()
    .apiKey(System.getenv("GOOGLE_AI_API_KEY"))
    .modelName("gemini-2.5-flash")
    .build();

// Edit only the masked region
Response<Image> response = imageModel.edit(
    originalImage,
    maskImage, // White areas will be edited, black areas preserved
    "Replace with blooming flowers"
);

Image editedImage = response.content();

// Enable Google Search for more accurate and up-to-date image generation
GoogleAiGeminiImageModel imageModel = GoogleAiGeminiImageModel.builder()
    .apiKey(System.getenv("GOOGLE_AI_API_KEY"))
    .modelName("gemini-2.5-flash")
    .useGoogleSearchGrounding(true)
    .build();

// Generate with search-informed context
Response<Image> response = imageModel.generate(
    "The latest SpaceX Starship rocket on the launch pad"
);

Image image = response.content();

import dev.langchain4j.model.googleai.GeminiSafetySetting;
import dev.langchain4j.model.googleai.GeminiHarmCategory;
import dev.langchain4j.model.googleai.GeminiHarmBlockThreshold;
import java.util.List;

GoogleAiGeminiImageModel imageModel = GoogleAiGeminiImageModel.builder()
    .apiKey(System.getenv("GOOGLE_AI_API_KEY"))
    .modelName("gemini-2.5-flash")
    .safetySettings(List.of(
        new GeminiSafetySetting(
            GeminiHarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT,
            GeminiHarmBlockThreshold.BLOCK_LOW_AND_ABOVE
        ),
        new GeminiSafetySetting(
            GeminiHarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT,
            GeminiHarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE
        )
    ))
    .build();

// Model will block inappropriate content based on safety settings
Response<Image> response = imageModel.generate("A family-friendly park scene");

import java.time.Duration;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

Logger logger = LoggerFactory.getLogger("ImageModel");

GoogleAiGeminiImageModel imageModel = GoogleAiGeminiImageModel.builder()
    .apiKey(System.getenv("GOOGLE_AI_API_KEY"))
    .modelName("gemini-2.5-flash")
    .aspectRatio("16:9")
    .imageSize("1024x768")
    .timeout(Duration.ofMinutes(2))
    .maxRetries(3)
    .useGoogleSearchGrounding(true)
    .logRequestsAndResponses(true)
    .logger(logger)
    .safetySettings(List.of(
        new GeminiSafetySetting(
            GeminiHarmCategory.HARM_CATEGORY_HATE_SPEECH,
            GeminiHarmBlockThreshold.BLOCK_LOW_AND_ABOVE
        )
    ))
    .build();

Response<Image> response = imageModel.generate(
    "An abstract representation of artificial intelligence"
);

import java.io.InputStream;
import java.io.FileOutputStream;
import java.net.URL;
import java.nio.file.Files;
import java.nio.file.Path;

GoogleAiGeminiImageModel imageModel = GoogleAiGeminiImageModel.builder()
    .apiKey(System.getenv("GOOGLE_AI_API_KEY"))
    .modelName("gemini-2.5-flash")
    .build();

Response<Image> response = imageModel.generate("A steampunk robot in a Victorian workshop");
Image image = response.content();

// Download and save the image
URL imageUrl = image.url().toURL();
try (InputStream in = imageUrl.openStream()) {
    Files.copy(in, Path.of("generated_image.png"));
    System.out.println("Image saved to generated_image.png");
}

GoogleAiGeminiImageModel imageModel = GoogleAiGeminiImageModel.builder()
    .apiKey(System.getenv("GOOGLE_AI_API_KEY"))
    .modelName("gemini-2.5-flash")
    .aspectRatio("1:1")
    .build();

String basePrompt = "A logo for a tech startup named 'InnovateAI'";

// Generate multiple variations by tweaking the prompt
List<String> prompts = List.of(
    basePrompt + " with modern minimalist design",
    basePrompt + " with bold geometric shapes",
    basePrompt + " with gradient colors and sleek typography"
);

List<Image> variations = new ArrayList<>();
for (String prompt : prompts) {
    Response<Image> response = imageModel.generate(prompt);
    variations.add(response.content());
}

System.out.println("Generated " + variations.size() + " logo variations");

GoogleAiGeminiImageModel imageModel = GoogleAiGeminiImageModel.builder()
    .apiKey(System.getenv("GOOGLE_AI_API_KEY"))
    .modelName("gemini-2.5-flash")
    .build();

try {
    Response<Image> response = imageModel.generate("A beautiful landscape");
    Image image = response.content();
    System.out.println("Image generated successfully: " + image.url());
} catch (GeminiImageGenerationException e) {
    System.err.println("Image generation failed: " + e.getMessage());
    // Handle error - possibly due to safety filters or invalid prompt
} catch (Exception e) {
    System.err.println("Unexpected error: " + e.getMessage());
}

import java.util.Base64;

GoogleAiGeminiImageModel imageModel = GoogleAiGeminiImageModel.builder()
    .apiKey(System.getenv("GOOGLE_AI_API_KEY"))
    .modelName("gemini-2.5-flash")
    .build();

Response<Image> response = imageModel.generate("A cosmic nebula with stars");
Image image = response.content();

// Convert to base64 if available
if (image.base64Data() != null) {
    String base64 = image.base64Data();
    byte[] imageBytes = Base64.getDecoder().decode(base64);
    System.out.println("Image size: " + imageBytes.length + " bytes");
}

GoogleAiGeminiImageModel imageModel = GoogleAiGeminiImageModel.builder()
    .apiKey(System.getenv("GOOGLE_AI_API_KEY"))
    .modelName("gemini-2.5-flash")
    .build();

// Step 1: Generate initial image
Response<Image> initial = imageModel.generate("A simple wooden house in a forest");
Image house = initial.content();

// Step 2: Edit to add details
Response<Image> enhanced = imageModel.edit(
    house,
    "Add smoke coming from the chimney and lights in the windows"
);
Image enhancedHouse = enhanced.content();

// Step 3: Further edit
Response<Image> final = imageModel.edit(
    enhancedHouse,
    "Add a path leading to the front door with flowers on both sides"
);
Image finalImage = final.content();

System.out.println("Final edited image: " + finalImage.url());

import dev.langchain4j.model.image.ImageModel;

// Use as ImageModel interface
ImageModel imageModel = GoogleAiGeminiImageModel.builder()
    .apiKey(System.getenv("GOOGLE_AI_API_KEY"))
    .modelName("gemini-2.5-flash")
    .build();

// Works with any LangChain4j component expecting ImageModel
Response<Image> response = imageModel.generate("A concept art for a sci-fi movie");

GoogleAiGeminiImageModel creativeModel = GoogleAiGeminiImageModel.builder()
    .apiKey(System.getenv("GOOGLE_AI_API_KEY"))
    .modelName("gemini-2.5-flash")
    .aspectRatio("16:9")
    .useGoogleSearchGrounding(true)
    .build();

// Marketing materials
Response<Image> banner = creativeModel.generate(
    "Professional banner for a software development company, modern and clean"
);

// Social media content
Response<Image> socialPost = creativeModel.generate(
    "Instagram post about healthy eating, vibrant colors, appetizing food"
);

// Product visualization
Response<Image> product = creativeModel.generate(
    "3D render of a smart watch with metallic finish on a minimalist background"
);

GoogleAiGeminiImageModel designModel = GoogleAiGeminiImageModel.builder()
    .apiKey(System.getenv("GOOGLE_AI_API_KEY"))
    .modelName("gemini-2.5-flash")
    .aspectRatio("4:3")
    .build();

// Character design
Response<Image> character = designModel.generate(
    "Fantasy character design: female elven warrior with silver armor and bow"
);

// Environment concept
Response<Image> environment = designModel.generate(
    "Concept art of a floating island city with waterfalls and bridges"
);

// UI mockup
Response<Image> ui = designModel.generate(
    "Modern mobile app login screen with gradient background and clean forms"
);

/**
 * Utility class for working with generated images in AI messages.
 * Provides helper methods to extract images from responses.
 */
public class GeneratedImageHelper {
    /**
     * Extracts all generated images from an AI message.
     * @param aiMessage The AI message potentially containing images
     * @return List of Image objects (empty list if no images)
     */
    public static List<Image> getGeneratedImages(AiMessage aiMessage);

    /**
     * Checks if an AI message contains generated images.
     * @param aiMessage The AI message to check
     * @return True if the message contains generated images
     */
    public static boolean hasGeneratedImages(AiMessage aiMessage);
}

import dev.langchain4j.model.googleai.GeneratedImageHelper;
import dev.langchain4j.data.message.AiMessage;
import dev.langchain4j.data.image.Image;

// After generating content with image response modality
Response<AiMessage> response = model.generate("Your prompt");
AiMessage message = response.content();

// Check if images were generated
if (GeneratedImageHelper.hasGeneratedImages(message)) {
    // Extract all generated images
    List<Image> images = GeneratedImageHelper.getGeneratedImages(message);

    System.out.println("Generated " + images.size() + " images");

    for (Image image : images) {
        System.out.println("Image URL: " + image.url());
        // Save or process the image
    }
} else {
    System.out.println("No images generated");
}