import com.google.genai.Client;

// Use Builder class for instantiation. Explicitly set the API key to use Gemini
// Developer backend.
Client client = Client.builder().apiKey("your-api-key").build();

import com.google.genai.Client;

// Use Builder class for instantiation. Explicitly set the project and location,
// and set `vertexAI(true)` to use Vertex AI backend.
Client client = Client.builder()
  .project("your-project")
  .location("your-location")
  .vertexAI(true)
  .build();

import com.google.genai.Client;

// Explicitly set the `apiKey` and `vertexAI(true)` to use Vertex AI backend
// in express mode.
Client client = Client.builder()
  .apiKey("your-api-key")
  .vertexAI(true)
  .build();

import com.google.genai.Client;

Client client = new Client();

import com.google.genai.Client;
import com.google.genai.types.HttpOptions;

Client client = Client.builder()
  .project("your-project")
  .location("your-location")
  .vertexAI(true)
  .httpOptions(HttpOptions.builder().apiVersion("v1"))
  .build();

import com.google.genai.Client;
import com.google.genai.types.HttpOptions;

Client client = Client.builder()
  .apiKey("your-api-key")
  .httpOptions(HttpOptions.builder().apiVersion("v1alpha"))
  .build();

HttpOptions httpOptions = HttpOptions.builder()
  .baseUrl("your-own-endpoint.com")
  .headers(ImmutableMap.of("key", "value"))
  .timeout(600)
  .build();

import com.google.genai.Client;
import com.google.genai.types.ClientOptions;

Client client = Client.builder()
  .apiKey("your-api-key")
  .clientOptions(ClientOptions.builder().maxConnections(64).maxConnectionsPerHost(16))
  .build();

package <your package name>;

import com.google.genai.Client;
import com.google.genai.types.GenerateContentResponse;

public class GenerateContentWithTextInput {
  public static void main(String[] args) {
    // Instantiate the client. The client by default uses the Gemini API. It
    //  gets the API key from the environment variable `GOOGLE_API_KEY`.
    Client client = new Client();

    GenerateContentResponse response =
        client.models.generateContent("gemini-2.5-flash", "What is your name?", null);

    // Gets the text string from the response by the quick accessor method `text()`.
    System.out.println("Unary response: " + response.text());

    // Gets the http headers from the response.
    response
        .sdkHttpResponse()
        .ifPresent(
            httpResponse ->
                System.out.println("Response headers: " + httpResponse.headers().orElse(null)));
  }
}

package <your package name>;

import com.google.common.collect.ImmutableList;
import com.google.genai.Client;
import com.google.genai.types.Content;
import com.google.genai.types.GenerateContentResponse;
import com.google.genai.types.Part;

public class GenerateContentWithImageInput {
  public static void main(String[] args) {
    // Instantiate the client using Vertex API. The client gets the project and
    // location from the environment variables `GOOGLE_CLOUD_PROJECT` and
    // `GOOGLE_CLOUD_LOCATION`.
    Client client = Client.builder().vertexAI(true).build();

    // Construct a multimodal content with quick constructors
    Content content =
        Content.fromParts(
            Part.fromText("describe the image"),
            Part.fromUri("gs://path/to/image.jpg", "image/jpeg"));

    GenerateContentResponse response =
        client.models.generateContent("gemini-2.5-flash", content, null);

    System.out.println("Response: " + response.text());
  }
}

package <your package name>;

import com.google.common.collect.ImmutableList;
import com.google.genai.Client;
import com.google.genai.types.Content;
import com.google.genai.types.GenerateContentConfig;
import com.google.genai.types.GenerateContentResponse;
import com.google.genai.types.GoogleSearch;
import com.google.genai.types.HarmBlockThreshold;
import com.google.genai.types.HarmCategory;
import com.google.genai.types.Part;
import com.google.genai.types.SafetySetting;
import com.google.genai.types.ThinkingConfig;
import com.google.genai.types.Tool;

public class GenerateContentWithConfigs {
  public static void main(String[] args) {
    Client client = new Client();

    // Sets the safety settings in the config.
    ImmutableList<SafetySetting> safetySettings =
        ImmutableList.of(
            SafetySetting.builder()
                .category(HarmCategory.Known.HARM_CATEGORY_HATE_SPEECH)
                .threshold(HarmBlockThreshold.Known.BLOCK_ONLY_HIGH)
                .build(),
            SafetySetting.builder()
                .category(HarmCategory.Known.HARM_CATEGORY_DANGEROUS_CONTENT)
                .threshold(HarmBlockThreshold.Known.BLOCK_LOW_AND_ABOVE)
                .build());

    // Sets the system instruction in the config.
    Content systemInstruction = Content.fromParts(Part.fromText("You are a history teacher."));

    // Sets the Google Search tool in the config.
    Tool googleSearchTool = Tool.builder().googleSearch(GoogleSearch.builder()).build();

    GenerateContentConfig config =
        GenerateContentConfig.builder()
            // Sets the thinking budget to 0 to disable thinking mode
            .thinkingConfig(ThinkingConfig.builder().thinkingBudget(0))
            .candidateCount(1)
            .maxOutputTokens(1024)
            .safetySettings(safetySettings)
            .systemInstruction(systemInstruction)
            .tools(googleSearchTool)
            .build();

    GenerateContentResponse response =
        client.models.generateContent("gemini-2.5-flash", "Tell me the history of LLM", config);

    System.out.println("Response: " + response.text());
  }
}

import com.google.common.collect.ImmutableList;
import com.google.genai.Client;
import com.google.genai.types.GenerateContentConfig;
import com.google.genai.types.GenerateContentResponse;
import com.google.genai.types.Tool;
import java.lang.reflect.Method;

public class GenerateContentWithFunctionCall {
  public static String getCurrentWeather(String location, String unit) {
    return "The weather in " + location + " is " + "very nice.";
  }

  public static void main(String[] args) throws NoSuchMethodException {
    Client client = new Client();

    // Load the method as a reflected Method object so that it can be
    // automatically executed on the client side.
    Method method =
        GenerateContentWithFunctionCall.class.getMethod(
            "getCurrentWeather", String.class, String.class);

    GenerateContentConfig config =
        GenerateContentConfig.builder()
            .tools(Tool.builder().functions(method))
            .build();

    GenerateContentResponse response =
        client.models.generateContent(
            "gemini-2.5-flash",
            "What is the weather in Vancouver?",
            config);

    System.out.println("The response is: " + response.text());
    System.out.println(
        "The automatic function calling history is: "
            + response.automaticFunctionCallingHistory().get());
  }
}

package <your package name>;

import com.google.genai.Client;
import com.google.genai.ResponseStream;
import com.google.genai.types.GenerateContentResponse;

public class StreamGeneration {
  public static void main(String[] args) {
    Client client = new Client();

    ResponseStream<GenerateContentResponse> responseStream =
        client.models.generateContentStream(
            "gemini-2.5-flash", "Tell me a story in 300 words.", null);

    System.out.println("Streaming response: ");
    for (GenerateContentResponse res : responseStream) {
      System.out.print(res.text());
    }

    // To save resources and avoid connection leaks, it is recommended to close the response
    // stream after consumption (or using try block to get the response stream).
    responseStream.close();
  }
}

package <your package name>;

import com.google.genai.Client;
import com.google.genai.types.GenerateContentResponse;
import java.util.concurrent.CompletableFuture;

public class GenerateContentAsync {
  public static void main(String[] args) {
    Client client = new Client();

    CompletableFuture<GenerateContentResponse> responseFuture =
        client.async.models.generateContent(
            "gemini-2.5-flash", "Introduce Google AI Studio.", null);

    responseFuture
        .thenAccept(
            response -> {
              System.out.println("Async response: " + response.text());
            })
        .join();
  }
}

package <your package name>;

import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
import com.google.genai.Client;
import com.google.genai.types.GenerateContentConfig;
import com.google.genai.types.GenerateContentResponse;
import com.google.genai.types.Schema;
import com.google.genai.types.Type;

public class GenerateContentWithSchema {
  public static void main(String[] args) {
    Client client = new Client();

    // Define the schema for the response, in Json format.
    ImmutableMap<String, Object> schema = ImmutableMap.of(
        "type", "object",
        "properties", ImmutableMap.of(
            "recipe_name", ImmutableMap.of("type", "string"),
            "ingredients", ImmutableMap.of(
                "type", "array",
                "items", ImmutableMap.of("type", "string")
            )
        ),
        "required", ImmutableList.of("recipe_name", "ingredients")
    );

    // Set the response schema in GenerateContentConfig
    GenerateContentConfig config =
        GenerateContentConfig.builder()
            .responseMimeType("application/json")
            .candidateCount(1)
            .responseSchema(schema)
            .build();

    GenerateContentResponse response =
        client.models.generateContent("gemini-2.5-flash", "Tell me your name", config);

    System.out.println("Response: " + response.text());
  }
}

package <your package name>;

import com.google.genai.Client;
import com.google.genai.types.CountTokensResponse;

public class CountTokens {
  public static void main(String[] args) {
    Client client = new Client();

    CountTokensResponse response =
        client.models.countTokens("gemini-2.5-flash", "What is your name?", null);

    System.out.println("Count tokens response: " + response);
  }
}

package <your package name>;

import com.google.genai.Client;
import com.google.genai.types.ComputeTokensResponse;

public class ComputeTokens {
  public static void main(String[] args) {
    Client client = Client.builder().vertexAI(true).build();

    ComputeTokensResponse response =
        client.models.computeTokens("gemini-2.5-flash", "What is your name?", null);

    System.out.println("Compute tokens response: " + response);
  }
}

package <your package name>;

import com.google.genai.Client;
import com.google.genai.types.EmbedContentResponse;

public class EmbedContent {
  public static void main(String[] args) {
    Client client = new Client();

    EmbedContentResponse response =
        client.models.embedContent("gemini-embedding-001", "why is the sky blue?", null);

    System.out.println("Embedding response: " + response);
  }
}

package <your package name>;

import com.google.genai.Client;
import com.google.genai.types.GenerateImagesConfig;
import com.google.genai.types.GenerateImagesResponse;
import com.google.genai.types.Image;

public class GenerateImages {
  public static void main(String[] args) {
    Client client = new Client();

    GenerateImagesConfig config =
        GenerateImagesConfig.builder()
            .numberOfImages(1)
            .outputMimeType("image/jpeg")
            .includeSafetyAttributes(true)
            .build();

    GenerateImagesResponse response =
        client.models.generateImages(
            "imagen-3.0-generate-002", "Robot holding a red skateboard", config);

    response.generatedImages().ifPresent(
        images -> {
            System.out.println("Generated " + images.size() + " images.");
            Image image = images.get(0).image().orElse(null);
            // Do something with the image.
        }
    );
  }
}

package <your package name>;

import com.google.genai.Client;
import com.google.genai.types.Image;
import com.google.genai.types.UpscaleImageConfig;
import com.google.genai.types.UpscaleImageResponse;

public class UpscaleImage {
  public static void main(String[] args) {
    Client client = Client.builder().vertexAI(true).build();

    Image image = Image.fromFile("path/to/your/image");

    UpscaleImageConfig config =
        UpscaleImageConfig.builder()
            .outputMimeType("image/jpeg")
            .enhanceInputImage(true)
            .imagePreservationFactor(0.6f)
            .build();

    UpscaleImageResponse response =
        client.models.upscaleImage("imagen-3.0-generate-002", image, "x2", config);

    response.generatedImages().ifPresent(
        images -> {
            Image upscaledImage = images.get(0).image().orElse(null);
            // Do something with the upscaled image.
        }
    );
  }
}

package <your package name>;

import com.google.genai.Client;
import com.google.genai.types.EditImageConfig;
import com.google.genai.types.EditImageResponse;
import com.google.genai.types.EditMode;
import com.google.genai.types.Image;
import com.google.genai.types.MaskReferenceConfig;
import com.google.genai.types.MaskReferenceImage;
import com.google.genai.types.MaskReferenceMode;
import com.google.genai.types.RawReferenceImage;
import com.google.genai.types.ReferenceImage;
import java.util.ArrayList;

public class EditImage {
  public static void main(String[] args) {
    Client client = Client.builder().vertexAI(true).build();

    Image image = Image.fromFile("path/to/your/image");

    // Edit image with a mask.
    EditImageConfig config =
        EditImageConfig.builder()
            .editMode(EditMode.Known.EDIT_MODE_INPAINT_INSERTION)
            .numberOfImages(1)
            .outputMimeType("image/jpeg")
            .build();

    ArrayList<ReferenceImage> referenceImages = new ArrayList<>();
    RawReferenceImage rawReferenceImage =
        RawReferenceImage.builder().referenceImage(image).referenceId(1).build();
    referenceImages.add(rawReferenceImage);

    MaskReferenceImage maskReferenceImage =
        MaskReferenceImage.builder()
            .referenceId(2)
            .config(
                MaskReferenceConfig.builder()
                    .maskMode(MaskReferenceMode.Known.MASK_MODE_BACKGROUND)
                    .maskDilation(0.0f))
            .build();
    referenceImages.add(maskReferenceImage);

    EditImageResponse response =
        client.models.editImage(
            "imagen-3.0-capability-001", "Sunlight and clear sky", referenceImages, config);

    response.generatedImages().ifPresent(
        images -> {
            Image editedImage = images.get(0).image().orElse(null);
            // Do something with the edited image.
        }
    );
  }
}

package <your package name>;

import com.google.genai.Client;
import com.google.genai.types.GenerateVideosConfig;
import com.google.genai.types.GenerateVideosOperation;
import com.google.genai.types.Video;

public class GenerateVideosWithText {
  public static void main(String[] args) {
    Client client = new Client();

    GenerateVideosConfig config =
        GenerateVideosConfig.builder()
            .numberOfVideos(1)
            .enhancePrompt(true)
            .durationSeconds(5)
            .build();

    // generateVideos returns an operation
    GenerateVideosOperation operation =
        client.models.generateVideos(
            "veo-2.0-generate-001", "A neon hologram of a cat driving at top speed", null, config);

    // When the operation hasn't been finished, operation.done() is empty
    while (!operation.done().isPresent()) {
        try {
            System.out.println("Waiting for operation to complete...");
            Thread.sleep(10000);
            // Sleep for 10 seconds and check the operation again
            operation = client.operations.getVideosOperation(operation, null);
        } catch (InterruptedException e) {
            System.out.println("Thread was interrupted while sleeping.");
            Thread.currentThread().interrupt();
        }
    }

    operation.response().ifPresent(
        response -> {
            response.generatedVideos().ifPresent(
                videos -> {
                    System.out.println("Generated " + videos.size() + " videos.");
                    Video video = videos.get(0).video().orElse(null);
                    // Do something with the generated video
                }
            );
        }
    );
  }
}

package <your package name>;

import com.google.genai.Client;
import com.google.genai.types.GenerateVideosConfig;
import com.google.genai.types.GenerateVideosOperation;
import com.google.genai.types.Image;
import com.google.genai.types.Video;

public class GenerateVideosWithImage {
  public static void main(String[] args) {
    Client client = new Client();

    Image image = Image.fromFile("path/to/your/image");

    GenerateVideosConfig config =
        GenerateVideosConfig.builder()
            .numberOfVideos(1)
            .enhancePrompt(true)
            .durationSeconds(5)
            .build();

    // generateVideos returns an operation
    GenerateVideosOperation operation =
        client.models.generateVideos(
            "veo-2.0-generate-001",
            "Night sky",
            image,
            config);

    // When the operation hasn't been finished, operation.done() is empty
    while (!operation.done().isPresent()) {
        try {
            System.out.println("Waiting for operation to complete...");
            Thread.sleep(10000);
            // Sleep for 10 seconds and check the operation again
            operation = client.operations.getVideosOperation(operation, null);
        } catch (InterruptedException e) {
            System.out.println("Thread was interrupted while sleeping.");
            Thread.currentThread().interrupt();
        }
    }

    operation.response().ifPresent(
        response -> {
            response.generatedVideos().ifPresent(
                videos -> {
                    System.out.println("Generated " + videos.size() + " videos.");
                    Video video = videos.get(0).video().orElse(null);
                    // Do something with the generated video
                }
            );
        }
    );
  }
}