Google Gen AI SDK

fromgoogleimport genai
fromgoogle.genai.typesimport HttpOptions
client = genai.Client(http_options=HttpOptions(api_version="v1"))
response = client.models.generate_content(
 model="gemini-2.5-flash",
 contents="How does AI work?",
)
print(response.text)
# Example response:
# Okay, let's break down how AI works. It's a broad field, so I'll focus on the ...
#
# Here's a simplified overview:
# ...

fromgoogleimport genai
# TODO(developer): Update below line
API_KEY = "YOUR_API_KEY"
client = genai.Client(vertexai=True, api_key=API_KEY)
response = client.models.generate_content(
 model="gemini-2.5-flash",
 contents="Explain bubble sort to me.",
)
print(response.text)
# Example response:
# Bubble Sort is a simple sorting algorithm that repeatedly steps through the list

import(
"context"
"fmt"
"io"
"google.golang.org/genai"
)
// generateWithText shows how to generate text using a text prompt.
funcgenerateWithText(wio.Writer)error{
ctx:=context.Background()
client,err:=genai.NewClient(ctx,&genai.ClientConfig{
HTTPOptions:genai.HTTPOptions{APIVersion:"v1"},
})
iferr!=nil{
returnfmt.Errorf("failed to create genai client: %w",err)
}
resp,err:=client.Models.GenerateContent(ctx,
"gemini-2.5-flash",
genai.Text("How does AI work?"),
nil,
)
iferr!=nil{
returnfmt.Errorf("failed to generate content: %w",err)
}
respText:=resp.Text()
fmt.Fprintln(w,respText)
// Example response:
// That's a great question! Understanding how AI works can feel like ...
// ...
// **1. The Foundation: Data and Algorithms**
// ...
returnnil
}

/**
 * @license
 * Copyright 2025 Google LLC
 * SPDX-License-Identifier: Apache-2.0
 */
import{GoogleGenAI}from'@google/genai';
constGEMINI_API_KEY=process.env.GEMINI_API_KEY;
constGOOGLE_CLOUD_PROJECT=process.env.GOOGLE_CLOUD_PROJECT;
constGOOGLE_CLOUD_LOCATION=process.env.GOOGLE_CLOUD_LOCATION;
constGOOGLE_GENAI_USE_VERTEXAI=process.env.GOOGLE_GENAI_USE_VERTEXAI;
asyncfunctiongenerateContentFromMLDev(){
constai=newGoogleGenAI({vertexai:false,apiKey:GEMINI_API_KEY});
constresponse=awaitai.models.generateContent({
model:'gemini-2.0-flash',
contents:'why is the sky blue?',
});
console.debug(response.text);
}
asyncfunctiongenerateContentFromVertexAI(){
constai=newGoogleGenAI({
vertexai:true,
project:GOOGLE_CLOUD_PROJECT,
location:GOOGLE_CLOUD_LOCATION,
});
constresponse=awaitai.models.generateContent({
model:'gemini-2.0-flash',
contents:'why is the sky blue?',
});
console.debug(response.text);
}
asyncfunctionmain(){
if(GOOGLE_GENAI_USE_VERTEXAI){
awaitgenerateContentFromVertexAI().catch((e)=>
console.error('got error',e),
);
}else{
awaitgenerateContentFromMLDev().catch((e)=>
console.error('got error',e),
);
}
}
main();

/*
 * Copyright 2025 Google LLC
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * https://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
/**
 * Usage:
 *
 * <p>1a. If you are using Vertex AI, setup ADC to get credentials:
 * https://cloud.google.com/docs/authentication/provide-credentials-adc#google-idp
 *
 * <p>Then set Project, Location, and USE_VERTEXAI flag as environment variables:
 *
 * <p>export GOOGLE_CLOUD_PROJECT=YOUR_PROJECT
 *
 * <p>export GOOGLE_CLOUD_LOCATION=YOUR_LOCATION
 *
 * <p>export GOOGLE_GENAI_USE_VERTEXAI=true
 *
 * <p>1b. If you are using Gemini Developer API, set an API key environment variable. You can find a
 * list of available API keys here: https://aistudio.google.com/app/apikey
 *
 * <p>export GOOGLE_API_KEY=YOUR_API_KEY
 *
 * <p>2. Compile the java package and run the sample code.
 *
 * <p>mvn clean compile exec:java -Dexec.mainClass="com.google.genai.examples.GenerateContent"
 * -Dexec.args="YOUR_MODEL_ID"
 */
packagecom.google.genai.examples;
importcom.google.genai.Client;
importcom.google.genai.types.GenerateContentResponse;
/** An example of using the Unified Gen AI Java SDK to generate content. */
publicfinalclass GenerateContent{
publicstaticvoidmain(String[]args){
finalStringmodelId;
if(args.length!=0){
modelId=args[0];
}else{
modelId=Constants.GEMINI_MODEL_NAME;
}
// Instantiate the client. The client by default uses the Gemini Developer API. It gets the API
// key from the environment variable `GOOGLE_API_KEY`. Vertex AI API can be used by setting the
// environment variables `GOOGLE_CLOUD_LOCATION` and `GOOGLE_CLOUD_PROJECT`, as well as setting
// `GOOGLE_GENAI_USE_VERTEXAI` to "true".
//
// Note: Some services are only available in a specific API backend (Gemini or Vertex), you will
// get a `UnsupportedOperationException` if you try to use a service that is not available in
// the backend you are using.
Clientclient=newClient();
if(client.vertexAI()){
System.out.println("Using Vertex AI");
}else{
System.out.println("Using Gemini Developer API");
}
GenerateContentResponseresponse=
client.models.generateContent(modelId,"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)));
}
privateGenerateContent(){}
}