Gemini API in Vertex AI quickstart

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:
# ...

import(
	"context"
	"fmt"
	"io"
	"google.golang.org/genai"
)
// generateWithText shows how to generate text using a text prompt.
func generateWithText(w io.Writer) error {
	ctx := context.Background()
	client, err := genai.NewClient(ctx, &genai.ClientConfig{
		HTTPOptions: genai.HTTPOptions{APIVersion: "v1"},
	})
	if err != nil {
		return fmt.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,
	)
	if err != nil {
		return fmt.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**
	// ...
	return nil
}

const{GoogleGenAI}=require('@google/genai');
constGOOGLE_CLOUD_PROJECT=process.env.GOOGLE_CLOUD_PROJECT;
constGOOGLE_CLOUD_LOCATION=process.env.GOOGLE_CLOUD_LOCATION||'global';
asyncfunctiongenerateContent(
projectId=GOOGLE_CLOUD_PROJECT,
location=GOOGLE_CLOUD_LOCATION
){
constclient=newGoogleGenAI({
vertexai:true,
project:projectId,
location:location,
});
constresponse=awaitclient.models.generateContent({
model:'gemini-2.5-flash',
contents:'How does AI work?',
});
console.log(response.text);
returnresponse.text;
}

importcom.google.genai.Client;
importcom.google.genai.types.GenerateContentResponse;
importcom.google.genai.types.HttpOptions;
public classTextGenerationWithText {
 public static void main(String[] args) {
 // TODO(developer): Replace these variables before running the sample.
 String modelId = "gemini-2.5-flash";
 generateContent(modelId);
 }
 // Generates text with text input
 public static String generateContent(String modelId) {
 // Initialize client that will be used to send requests. This client only needs to be created
 // once, and can be reused for multiple requests.
 try (Client client =
 Client.builder()
 .location("global")
 .vertexAI(true)
 .httpOptions(HttpOptions.builder().apiVersion("v1").build())
 .build()) {
 GenerateContentResponse response =
 client.models.generateContent(modelId, "How does AI work?", null);
 System.out.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:
 // ...
 return response.text();
 }
 }
}

fromgoogleimport genai
fromgoogle.genai.typesimport GenerateContentConfig, Modality
fromPILimport Image
fromioimport BytesIO
client = genai.Client()
response = client.models.generate_content(
 model="gemini-2.5-flash-image",
 contents=("Generate an image of the Eiffel tower with fireworks in the background."),
 config=GenerateContentConfig(
 response_modalities=[Modality.TEXT, Modality.IMAGE],
 candidate_count=1,
 safety_settings=[
 {"method": "PROBABILITY"},
 {"category": "HARM_CATEGORY_DANGEROUS_CONTENT"},
 {"threshold": "BLOCK_MEDIUM_AND_ABOVE"},
 ],
 ),
)
for part in response.candidates[0].content.parts:
 if part.text:
 print(part.text)
 elif part.inline_data:
 image = Image.open(BytesIO((part.inline_data.data)))
 image.save("output_folder/example-image-eiffel-tower.png")
# Example response:
# I will generate an image of the Eiffel Tower at night, with a vibrant display of
# colorful fireworks exploding in the dark sky behind it. The tower will be
# illuminated, standing tall as the focal point of the scene, with the bursts of
# light from the fireworks creating a festive atmosphere.

constfs=require('fs');
const{GoogleGenAI,Modality}=require('@google/genai');
constGOOGLE_CLOUD_PROJECT=process.env.GOOGLE_CLOUD_PROJECT;
constGOOGLE_CLOUD_LOCATION=
process.env.GOOGLE_CLOUD_LOCATION||'us-central1';
asyncfunctiongenerateImage(
projectId=GOOGLE_CLOUD_PROJECT,
location=GOOGLE_CLOUD_LOCATION
){
constclient=newGoogleGenAI({
vertexai:true,
project:projectId,
location:location,
});
constresponse=awaitclient.models.generateContentStream({
model:'gemini-2.5-flash-image',
contents:
'Generate an image of the Eiffel tower with fireworks in the background.',
config:{
responseModalities:[Modality.TEXT,Modality.IMAGE],
},
});
constgeneratedFileNames=[];
letimageIndex=0;
forawait(constchunkofresponse){
consttext=chunk.text;
constdata=chunk.data;
if(text){
console.debug(text);
}elseif(data){
constoutputDir='output-folder';
if(!fs.existsSync(outputDir)){
fs.mkdirSync(outputDir,{recursive:true});
}
constfileName=`${outputDir}/generate_content_streaming_image_${imageIndex++}.png`;
console.debug(`Writingresponseimagetofile:${fileName}.`);
try{
fs.writeFileSync(fileName,data);
generatedFileNames.push(fileName);
}catch(error){
console.error(`Failedtowriteimagefile${fileName}:`,error);
}
}
}
//Exampleresponse:
//IwillgenerateanimageoftheEiffelToweratnight,withavibrantdisplayof
//colorfulfireworksexplodinginthedarkskybehindit.Thetowerwillbe
//illuminated,standingtallasthefocalpointofthescene,withtheburstsof
//lightfromthefireworkscreatingafestiveatmosphere.
returngeneratedFileNames;
}

importcom.google.genai.Client;
importcom.google.genai.types.Blob;
importcom.google.genai.types.Candidate;
importcom.google.genai.types.Content;
importcom.google.genai.types.GenerateContentConfig;
importcom.google.genai.types.GenerateContentResponse;
importcom.google.genai.types.Part;
importcom.google.genai.types.SafetySetting;
importjava.awt.image.BufferedImage;
importjava.io.ByteArrayInputStream;
importjava.io.File;
importjava.io.IOException;
importjava.util.ArrayList;
importjava.util.List;
importjavax.imageio.ImageIO;
public classImageGenMmFlashWithText {
 public static void main(String[] args) throws IOException {
 // TODO(developer): Replace these variables before running the sample.
 String modelId = "gemini-2.5-flash-image";
 String outputFile = "resources/output/example-image-eiffel-tower.png";
 generateContent(modelId, outputFile);
 }
 // Generates an image with text input
 public static void generateContent(String modelId, String outputFile) throws IOException {
 // Client Initialization. Once created, it can be reused for multiple requests.
 try (Client client = Client.builder().location("global").vertexAI(true).build()) {
 GenerateContentConfig contentConfig =
 GenerateContentConfig.builder()
 .responseModalities("TEXT", "IMAGE")
 .candidateCount(1)
 .safetySettings(
 SafetySetting.builder()
 .method("PROBABILITY")
 .category("HARM_CATEGORY_DANGEROUS_CONTENT")
 .threshold("BLOCK_MEDIUM_AND_ABOVE")
 .build())
 .build();
 GenerateContentResponse response =
 client.models.generateContent(
 modelId,
 "Generate an image of the Eiffel tower with fireworks in the background.",
 contentConfig);
 // Get parts of the response
 List<Part> parts =
 response
 .candidates()
 .flatMap(candidates -> candidates.stream().findFirst())
 .flatMap(Candidate::content)
 .flatMap(Content::parts)
 .orElse(new ArrayList<>());
 // For each part print text if present, otherwise read image data if present and
 // write it to the output file
 for (Part part : parts) {
 if (part.text().isPresent()) {
 System.out.println(part.text().get());
 } else if (part.inlineData().flatMap(Blob::data).isPresent()) {
 BufferedImage image =
 ImageIO.read(new ByteArrayInputStream(part.inlineData().flatMap(Blob::data).get()));
 ImageIO.write(image, "png", new File(outputFile));
 }
 }
 System.out.println("Content written to: " + outputFile);
 // Example response:
 // Here is the Eiffel Tower with fireworks in the background...
 //
 // Content written to: resources/output/example-image-eiffel-tower.png
 }
 }
}

fromgoogleimport genai
fromgoogle.genai.typesimport HttpOptions, Part
client = genai.Client(http_options=HttpOptions(api_version="v1"))
response = client.models.generate_content(
 model="gemini-2.5-flash",
 contents=[
 "What is shown in this image?",
 Part.from_uri(
 file_uri="gs://cloud-samples-data/generative-ai/image/scones.jpg",
 mime_type="image/jpeg",
 ),
 ],
)
print(response.text)
# Example response:
# The image shows a flat lay of blueberry scones arranged on parchment paper. There are ...

import(
	"context"
	"fmt"
	"io"
	genai "google.golang.org/genai"
)
// generateWithTextImage shows how to generate text using both text and image input
func generateWithTextImage(w io.Writer) error {
	ctx := context.Background()
	client, err := genai.NewClient(ctx, &genai.ClientConfig{
		HTTPOptions: genai.HTTPOptions{APIVersion: "v1"},
	})
	if err != nil {
		return fmt.Errorf("failed to create genai client: %w", err)
	}
	modelName := "gemini-2.5-flash"
	contents := []*genai.Content{
		{Parts: []*genai.Part{
			{Text: "What is shown in this image?"},
			{FileData: &genai.FileData{
				// Image source: https://storage.googleapis.com/cloud-samples-data/generative-ai/image/scones.jpg
				FileURI: "gs://cloud-samples-data/generative-ai/image/scones.jpg",
				MIMEType: "image/jpeg",
			}},
		},
			Role: "user"},
	}
	resp, err := client.Models.GenerateContent(ctx, modelName, contents, nil)
	if err != nil {
		return fmt.Errorf("failed to generate content: %w", err)
	}
	respText := resp.Text()
	fmt.Fprintln(w, respText)
	// Example response:
	// The image shows an overhead shot of a rustic, artistic arrangement on a surface that ...
	return nil
}

const{GoogleGenAI}=require('@google/genai');
constGOOGLE_CLOUD_PROJECT=process.env.GOOGLE_CLOUD_PROJECT;
constGOOGLE_CLOUD_LOCATION=process.env.GOOGLE_CLOUD_LOCATION||'global';
asyncfunctiongenerateContent(
projectId=GOOGLE_CLOUD_PROJECT,
location=GOOGLE_CLOUD_LOCATION
){
constclient=newGoogleGenAI({
vertexai:true,
project:projectId,
location:location,
});
constimage={
fileData:{
fileUri:'gs://cloud-samples-data/generative-ai/image/scones.jpg',
mimeType:'image/jpeg',
},
};
constresponse=awaitclient.models.generateContent({
model:'gemini-2.5-flash',
contents:[image,'What is shown in this image?'],
});
console.log(response.text);
returnresponse.text;
}

importcom.google.genai.Client;
importcom.google.genai.types.Content;
importcom.google.genai.types.GenerateContentResponse;
importcom.google.genai.types.HttpOptions;
importcom.google.genai.types.Part;
public classTextGenerationWithTextAndImage {
 public static void main(String[] args) {
 // TODO(developer): Replace these variables before running the sample.
 String modelId = "gemini-2.5-flash";
 generateContent(modelId);
 }
 // Generates text with text and image input
 public static String generateContent(String modelId) {
 // Initialize client that will be used to send requests. This client only needs to be created
 // once, and can be reused for multiple requests.
 try (Client client =
 Client.builder()
 .location("global")
 .vertexAI(true)
 .httpOptions(HttpOptions.builder().apiVersion("v1").build())
 .build()) {
 GenerateContentResponse response =
 client.models.generateContent(
 modelId,
 Content.fromParts(
 Part.fromText("What is shown in this image?"),
 Part.fromUri(
 "gs://cloud-samples-data/generative-ai/image/scones.jpg", "image/jpeg")),
 null);
 System.out.print(response.text());
 // Example response:
 // The image shows a flat lay of blueberry scones arranged on parchment paper. There are ...
 return response.text();
 }
 }
}

fromgoogleimport genai
fromgoogle.genai.typesimport (
 HttpOptions,
 Tool,
 ToolCodeExecution,
 GenerateContentConfig,
)
client = genai.Client(http_options=HttpOptions(api_version="v1"))
model_id = "gemini-2.5-flash"
code_execution_tool = Tool(code_execution=ToolCodeExecution())
response = client.models.generate_content(
 model=model_id,
 contents="Calculate 20th fibonacci number. Then find the nearest palindrome to it.",
 config=GenerateContentConfig(
 tools=[code_execution_tool],
 temperature=0,
 ),
)
print("# Code:")
print(response.executable_code)
print("# Outcome:")
print(response.code_execution_result)
# Example response:
# # Code:
# def fibonacci(n):
# if n <= 0:
# return 0
# elif n == 1:
# return 1
# else:
# a, b = 0, 1
# for _ in range(2, n + 1):
# a, b = b, a + b
# return b
#
# fib_20 = fibonacci(20)
# print(f'{fib_20=}')
#
# # Outcome:
# fib_20=6765

import(
	"context"
	"fmt"
	"io"
	genai "google.golang.org/genai"
)
// generateWithCodeExec shows how to generate text using the code execution tool.
func generateWithCodeExec(w io.Writer) error {
	ctx := context.Background()
	client, err := genai.NewClient(ctx, &genai.ClientConfig{
		HTTPOptions: genai.HTTPOptions{APIVersion: "v1"},
	})
	if err != nil {
		return fmt.Errorf("failed to create genai client: %w", err)
	}
	prompt := "Calculate 20th fibonacci number. Then find the nearest palindrome to it."
	contents := []*genai.Content{
		{Parts: []*genai.Part{
			{Text: prompt},
		},
			Role: "user"},
	}
	config := &genai.GenerateContentConfig{
		Tools: []*genai.Tool{
			{CodeExecution: &genai.ToolCodeExecution{}},
		},
		Temperature: genai.Ptr(float32(0.0)),
	}
	modelName := "gemini-2.5-flash"
	resp, err := client.Models.GenerateContent(ctx, modelName, contents, config)
	if err != nil {
		return fmt.Errorf("failed to generate content: %w", err)
	}
	for _, p := range resp.Candidates[0].Content.Parts {
		if p.Text != "" {
			fmt.Fprintf(w, "Gemini: %s", p.Text)
		}
		if p.ExecutableCode != nil {
			fmt.Fprintf(w, "Language: %s\n%s\n", p.ExecutableCode.Language, p.ExecutableCode.Code)
		}
		if p.CodeExecutionResult != nil {
			fmt.Fprintf(w, "Outcome: %s\n%s\n", p.CodeExecutionResult.Outcome, p.CodeExecutionResult.Output)
		}
	}
	// Example response:
	// Gemini: Okay, I can do that. First, I'll calculate the 20th Fibonacci number. Then, I need ...
	//
	// Language: PYTHON
	//
	// deffibonacci(n):
	// ...
	//
	// fib_20 = fibonacci(20)
	// print(f'{fib_20=}')
	//
	// Outcome: OUTCOME_OK
	// fib_20=6765
	//
	// Now that I have the 20th Fibonacci number (6765), I need to find the nearest palindrome. ...
	// ...
	return nil
}

const{GoogleGenAI}=require('@google/genai');
constGOOGLE_CLOUD_PROJECT=process.env.GOOGLE_CLOUD_PROJECT;
constGOOGLE_CLOUD_LOCATION=process.env.GOOGLE_CLOUD_LOCATION||'global';
asyncfunctiongenerateAndExecuteCode(
projectId=GOOGLE_CLOUD_PROJECT,
location=GOOGLE_CLOUD_LOCATION
){
constclient=newGoogleGenAI({
vertexai:true,
project:projectId,
location:location,
});
constresponse=awaitclient.models.generateContent({
model:'gemini-2.5-flash',
contents:
'Calculate 20th fibonacci number. Then find the nearest palindrome to it.',
config:{
tools:[{codeExecution:{}}],
temperature:0,
},
});
console.debug(response.executableCode);
//Exampleresponse:
//Code:
//functionfibonacci(n){
//if(n<=0){
//return0;
//}elseif(n===1){
//return1;
//}else{
//leta=0,b=1;
//for(leti=2;i<=n;i++){
//[a,b]=[b,a+b];
//}
//returnb;
//}
//}
//
//constfib20=fibonacci(20);
//console.log(`fib20=${fib20}`);
console.debug(response.codeExecutionResult);
//Outcome:
//fib20=6765
returnresponse.codeExecutionResult;
}

importcom.google.genai.Client;
importcom.google.genai.types.GenerateContentConfig;
importcom.google.genai.types.GenerateContentResponse;
importcom.google.genai.types.HttpOptions;
importcom.google.genai.types.Tool;
importcom.google.genai.types.ToolCodeExecution;
public classToolsCodeExecWithText {
 public static void main(String[] args) {
 // TODO(developer): Replace these variables before running the sample.
 String modelId = "gemini-2.5-flash";
 generateContent(modelId);
 }
 // Generates text using the Code Execution tool
 public static String generateContent(String modelId) {
 // Initialize client that will be used to send requests. This client only needs to be created
 // once, and can be reused for multiple requests.
 try (Client client =
 Client.builder()
 .location("global")
 .vertexAI(true)
 .httpOptions(HttpOptions.builder().apiVersion("v1").build())
 .build()) {
 // Create a GenerateContentConfig and set codeExecution tool
 GenerateContentConfig contentConfig =
 GenerateContentConfig.builder()
 .tools(Tool.builder().codeExecution(ToolCodeExecution.builder().build()).build())
 .temperature(0.0F)
 .build();
 GenerateContentResponse response =
 client.models.generateContent(
 modelId,
 "Calculate 20th fibonacci number. Then find the nearest palindrome to it.",
 contentConfig);
 System.out.println("Code: \n" + response.executableCode());
 System.out.println("Outcome: \n" + response.codeExecutionResult());
 // Example response
 // Code:
 // deffibonacci(n):
 // if n <= 0:
 // return 0
 // elif n == 1:
 // return 1
 // else:
 // a, b = 1, 1
 // for _ in range(2, n):
 // a, b = b, a + b
 // return b
 //
 // fib_20 = fibonacci(20)
 // print(f'{fib_20=}')
 //
 // Outcome:
 // fib_20=6765
 return response.executableCode();
 }
 }
}