Vertex AI 中的 Gemini API 快速入門

本快速入門導覽課程說明如何為所選語言安裝 Google Gen AI SDK，然後提出您的第一個 API 要求。根據您是使用 API 金鑰或應用程式預設憑證 (ADC) 向 Vertex AI 進行驗證，範例會略有不同。

選擇驗證方法：

ADC API 金鑰

---

事前準備

如果尚未設定 ADC，請按照下列操作說明進行：

設定專案

選取專案、啟用帳單功能、啟用 Vertex AI API，然後安裝 gcloud CLI：

1. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

   Roles required to select or create a project

   • Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
   • Create a project: To create a project, you need the Project Creator (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.
   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   Go to project selector

2. Verify that billing is enabled for your Google Cloud project.

3. Enable the Vertex AI API.

   Roles required to enable APIs

   To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.

   Enable the API

4. Install the Google Cloud CLI.

5. 設定 gcloud CLI 以使用您的聯合身分。

   詳情請參閱「 使用聯合身分登入 gcloud CLI」。

6. 如要初始化 gcloud CLI，請執行下列指令：

   gcloud init

   建立本機驗證憑證

   Create local authentication credentials for your user account:

   gcloud auth application-default login

   If an authentication error is returned, and you are using an external identity provider (IdP), confirm that you have signed in to the gcloud CLI with your federated identity.

   必要的角色

   如要取得使用 Vertex AI 中 Gemini API 所需的權限，請要求管理員授予您專案的「Vertex AI 使用者」 (roles/aiplatform.user) IAM 角色。如要進一步瞭解如何授予角色，請參閱「管理專案、資料夾和機構的存取權」。

   您或許還可透過自訂角色或其他預先定義的角色取得必要權限。

   安裝 SDK 並設定環境

   在本機上，按一下下列其中一個分頁標籤，安裝您所用程式語言的 SDK。

   Python Gen AI SDK

   執行下列指令，安裝及更新 Gen AI SDK for Python。

   pip install --upgrade google-genai

   設定環境變數：

   # Replace the `GOOGLE_CLOUD_PROJECT_ID` and `GOOGLE_CLOUD_LOCATION` values
   # with appropriate values for your project.
   export GOOGLE_CLOUD_PROJECT=GOOGLE_CLOUD_PROJECT_ID
   export GOOGLE_CLOUD_LOCATION=global
   export GOOGLE_GENAI_USE_VERTEXAI=True

   Go Gen AI SDK

   執行下列指令，安裝及更新 Gen AI SDK for Go。

   go get google.golang.org/genai

   設定環境變數：

   # Replace the `GOOGLE_CLOUD_PROJECT_ID` and `GOOGLE_CLOUD_LOCATION` values
   # with appropriate values for your project.
   export GOOGLE_CLOUD_PROJECT=GOOGLE_CLOUD_PROJECT_ID
   export GOOGLE_CLOUD_LOCATION=global
   export GOOGLE_GENAI_USE_VERTEXAI=True

   Node.js Gen AI SDK

   執行下列指令，安裝及更新 Node.js 適用的 Gen AI SDK。

   npm install @google/genai

   設定環境變數：

   # Replace the `GOOGLE_CLOUD_PROJECT_ID` and `GOOGLE_CLOUD_LOCATION` values
   # with appropriate values for your project.
   export GOOGLE_CLOUD_PROJECT=GOOGLE_CLOUD_PROJECT_ID
   export GOOGLE_CLOUD_LOCATION=global
   export GOOGLE_GENAI_USE_VERTEXAI=True

   Java Gen AI SDK

   執行下列指令，安裝及更新 Java 適用的 Gen AI SDK。

   Maven

   請將以下內容新增到 pom.xml：

   <dependencies>
     <dependency>
       <groupId>com.google.genai</groupId>
       <artifactId>google-genai</artifactId>
       <version>0.7.0</version>
     </dependency>
   </dependencies>
   

   設定環境變數：

   # Replace the `GOOGLE_CLOUD_PROJECT_ID` and `GOOGLE_CLOUD_LOCATION` values
   # with appropriate values for your project.
   export GOOGLE_CLOUD_PROJECT=GOOGLE_CLOUD_PROJECT_ID
   export GOOGLE_CLOUD_LOCATION=global
   export GOOGLE_GENAI_USE_VERTEXAI=True

   REST

   設定環境變數：

   GOOGLE_CLOUD_PROJECT=GOOGLE_CLOUD_PROJECT_ID
   GOOGLE_CLOUD_LOCATION=global
   API_ENDPOINT=YOUR_API_ENDPOINT
   MODEL_ID="gemini-2.5-flash"
   GENERATE_CONTENT_API="generateContent"

   發出第一項要求

   使用 generateContent 方法，將要求傳送至 Vertex AI 的 Gemini API：

   Python

   from google import genai
   from google.genai.types import 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:
   # ...

   Go

   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
   }
   

   Node.js

   const {GoogleGenAI} = require('@google/genai');
   
   const GOOGLE_CLOUD_PROJECT = process.env.GOOGLE_CLOUD_PROJECT;
   const GOOGLE_CLOUD_LOCATION = process.env.GOOGLE_CLOUD_LOCATION || 'global';
   
   async function generateContent(
     projectId = GOOGLE_CLOUD_PROJECT,
     location = GOOGLE_CLOUD_LOCATION
   ) {
     const client = new GoogleGenAI({
       vertexai: true,
       project: projectId,
       location: location,
     });
   
     const response = await client.models.generateContent({
       model: 'gemini-2.5-flash',
       contents: 'How does AI work?',
     });
   
     console.log(response.text);
   
     return response.text;
   }

   Java

   
   import com.google.genai.Client;
   import com.google.genai.types.GenerateContentResponse;
   import com.google.genai.types.HttpOptions;
   
   public class TextGenerationWithText {
   
     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();
       }
     }
   }

   REST

   如要傳送這項提示要求，請從指令列執行 curl 指令，或在應用程式中加入 REST 呼叫。

   curl
   -X POST
   -H "Content-Type: application/json"
   -H "Authorization: Bearer $(gcloud auth print-access-token)"
   "https://${API_ENDPOINT}/v1/projects/${GOOGLE_CLOUD_PROJECT}/locations/${GOOGLE_CLOUD_LOCATION}/publishers/google/models/${MODEL_ID}:${GENERATE_CONTENT_API}" -d
   $'{
     "contents": {
       "role": "user",
       "parts": {
         "text": "Explain how AI works in a few words"
       }
     }
   }'

   模型會傳回回覆。請注意，系統會分段生成回覆，並分別評估每個段落的安全性。

   生成圖像

   注意： Gemini 圖像生成功能目前為預先發布版。 如需可供正式環境使用的圖像生成功能，請使用 Imagen。 詳情請參閱 Vertex AI 的 Imagen 快速入門指南。

   Gemini 可以生成及處理圖片，並以對話方式提供相關資訊。你可以使用文字、圖片或兩者組合提示 Gemini，執行各種圖片相關工作，例如生成和編輯圖片。下列程式碼示範如何根據描述性提示生成圖片：

   您必須在設定中加入 responseModalities: ["TEXT", "IMAGE"]。這些模型不支援僅輸出圖片。

   Python

   from google import genai
   from google.genai.types import GenerateContentConfig, Modality
   from PIL import Image
   from io import 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.

   Node.js

   const fs = require('fs');
   const {GoogleGenAI, Modality} = require('@google/genai');
   
   const GOOGLE_CLOUD_PROJECT = process.env.GOOGLE_CLOUD_PROJECT;
   const GOOGLE_CLOUD_LOCATION =
     process.env.GOOGLE_CLOUD_LOCATION || 'us-central1';
   
   async function generateContent(
     projectId = GOOGLE_CLOUD_PROJECT,
     location = GOOGLE_CLOUD_LOCATION
   ) {
     const client = new GoogleGenAI({
       vertexai: true,
       project: projectId,
       location: location,
     });
   
     const response = await client.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],
       },
     });
   
     const generatedFileNames = [];
     let imageIndex = 0;
     for await (const chunk of response) {
       const text = chunk.text;
       const data = chunk.data;
       if (text) {
         console.debug(text);
       } else if (data) {
         const fileName = `generate_content_streaming_image_${imageIndex++}.png`;
         console.debug(`Writing response image to file: ${fileName}.`);
         try {
           fs.writeFileSync(fileName, data);
           generatedFileNames.push(fileName);
         } catch (error) {
           console.error(`Failed to write image file ${fileName}:`, error);
         }
       }
     }
   
     return generatedFileNames;
   }

   Java

   
   import com.google.genai.Client;
   import com.google.genai.types.Blob;
   import com.google.genai.types.Candidate;
   import com.google.genai.types.Content;
   import com.google.genai.types.GenerateContentConfig;
   import com.google.genai.types.GenerateContentResponse;
   import com.google.genai.types.Part;
   import com.google.genai.types.SafetySetting;
   import java.awt.image.BufferedImage;
   import java.io.ByteArrayInputStream;
   import java.io.File;
   import java.io.IOException;
   import java.util.ArrayList;
   import java.util.List;
   import javax.imageio.ImageIO;
   
   public class ImageGenMmFlashWithText {
   
     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
       }
     }
   }

   圖像解讀

   Gemini 也能解讀圖片。下列程式碼會使用上一節中產生的圖片，並使用不同模型推斷圖片相關資訊：

   Python

   from google import genai
   from google.genai.types import 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 ...

   Go

   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
   }
   

   Node.js

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

   Java

   
   import com.google.genai.Client;
   import com.google.genai.types.Content;
   import com.google.genai.types.GenerateContentResponse;
   import com.google.genai.types.HttpOptions;
   import com.google.genai.types.Part;
   
   public class TextGenerationWithTextAndImage {
   
     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();
       }
     }
   }

   程式碼執行

   有了 Vertex AI 中 Gemini API 的程式碼執行功能，模型可生成及執行 Python 程式碼，並根據結果反覆試驗學習，直到生成最終輸出內容。Vertex AI 提供程式碼執行工具，與函式呼叫類似。透過這個程式碼執行功能，您能建構根據程式碼進行推論、生成文字輸出內容的應用程式。例如：

   Python

   from google import genai
   from google.genai.types import (
       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

   Go

   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
   	//
   	// def fibonacci(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
   }
   

   Node.js

   const {GoogleGenAI} = require('@google/genai');
   
   const GOOGLE_CLOUD_PROJECT = process.env.GOOGLE_CLOUD_PROJECT;
   const GOOGLE_CLOUD_LOCATION = process.env.GOOGLE_CLOUD_LOCATION || 'global';
   
   async function generateContent(
     projectId = GOOGLE_CLOUD_PROJECT,
     location = GOOGLE_CLOUD_LOCATION
   ) {
     const client = new GoogleGenAI({
       vertexai: true,
       project: projectId,
       location: location,
     });
   
     const response = await client.models.generateContent({
       model: 'gemini-2.5-flash',
       contents:
         'What is the sum of the first 50 prime numbers? Generate and run code for the calculation, and make sure you get all 50.',
       config: {
         tools: [{codeExecution: {}}],
         temperature: 0,
       },
     });
   
     console.debug(response.executableCode);
     console.debug(response.codeExecutionResult);
   
     return response.codeExecutionResult;
   }

   Java

   
   import com.google.genai.Client;
   import com.google.genai.types.GenerateContentConfig;
   import com.google.genai.types.GenerateContentResponse;
   import com.google.genai.types.HttpOptions;
   import com.google.genai.types.Tool;
   import com.google.genai.types.ToolCodeExecution;
   
   public class ToolsCodeExecWithText {
   
     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:
         // def fibonacci(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();
       }
     }
   }

   如需更多程式碼執行範例，請參閱程式碼執行說明文件。

   後續步驟

   您已發出第一個 API 要求，接下來不妨參考下列指南，瞭解如何為正式版程式碼設定更進階的 Vertex AI 功能：

   • Google Gen AI 程式庫
   • OpenAI 相容性