Vertex AI SDK 中的生成式 AI 模組已淘汰，2026 年 6 月 24 日之後將無法使用。Google Gen AI SDK 包含 Vertex AI SDK 的所有功能，並支援許多額外功能。
請參閱這份遷移指南，瞭解如何使用 Google Gen AI SDK，將 Python、Java、JavaScript 和 Go 程式碼從 Vertex AI SDK 轉換為 Google Gen AI SDK。
主要異動
Vertex AI SDK 中的下列命名空間已進入淘汰階段。2026 年 6 月 24 日後發布的 SDK 將不再包含這些模組。請使用 Google Gen AI SDK 中的對等命名空間，這些命名空間與已淘汰的模組和套件具有完整的功能同位性。
| Vertex AI SDK | 受影響的程式碼 | Google Gen AI SDK 替代方案 |
|---|---|---|
google-cloud-aiplatform |
已移除的模組： |
google-genai |
cloud.google.com/go/vertexai/genai |
已移除套件： |
google.golang.org/genai |
@google-cloud/vertexai |
已移除的模組： |
@google/genai |
com.google.cloud:google-cloud-vertexai |
已移除套件： |
com.google.genai:google-genai |
程式碼遷移
請參閱下列各節，將特定程式碼片段從 Vertex AI SDK 遷移至 Google Gen AI SDK。
安裝
將 Vertex AI SDK 依附元件替換為 Google Gen AI SDK 依附元件。
之前
Python
pip install -U -q "google-cloud-aiplatform"
Java
Gradle：
gradle:
implementation 'com.google.cloud:google-cloud-vertexai:1.26.0'
maven：
<dependency>
<groupId>com.google.cloud</groupId>
<artifactId>google-cloud-vertexai</artifactId>
<version>1.26.0</version>
</dependency>
JavaScript
npm install @google-cloud/vertexai
Go
go get cloud.google.com/go/vertexai/genai
之後
Python
pip install -U -q "google-genai"
Java
gradle：
implementation 'com.google.genai:google-genai:1.5.0'
maven：
<dependency>
<groupId>com.google.genai</groupId>
<artifactId>google-genai</artifactId>
<version>1.5.0</version>
</dependency>
JavaScript
npm install @google/genai
Go
go get google.golang.org/genai
脈絡快取
脈絡快取功能會儲存並重複使用模型提示中常用的部分，以處理類似要求。將 Vertex AI SDK 實作項目替換為 Google Gen AI SDK 依附元件。
之前
Python
匯入
from google.cloud import aiplatform
import vertexai
import datetime
建立
vertexai.init(project=GOOGLE_CLOUD_PROJECT, location=GOOGLE_CLOUD_LOCATION)
cache_content = vertexai.caching.CachedContent.create(
model_name=MODEL_NAME,
system_instruction='Please answer my question formally',
contents=['user content'],
ttl=datetime.timedelta(days=1),
)
取得
vertexai.init(project=GOOGLE_CLOUD_PROJECT, location=GOOGLE_CLOUD_LOCATION)
cache_content = vertexai.caching.CachedContent.get(cached_content_name="projects/{project}/locations/{location}/cachedContents/{cached_content}")
刪除
cache_content.delete()
更新
cache_content.update(ttl=datetime.timedelta(days=2))
列出
cache_contents = vertexai.caching.CachedContent.list()
Java
Java 適用的 Vertex AI SDK 不支援內容快取，但 Google Gen AI SDK 支援這項功能。
JavaScript
JavaScript Vertex AI SDK 不支援內容快取，但 Google Gen AI SDK 支援。
Go
匯入
package contextcaching
// [START generativeaionvertexai_gemini_create_context_cache]
import (
"context"
"fmt"
"io"
"time"
"cloud.google.com/go/vertexai/genai"
)
建立
content := &genai.CachedContent{
Model: modelName,
SystemInstruction: &genai.Content{
Parts: []genai.Part{genai.Text(systemInstruction)},
},
Expiration: genai.ExpireTimeOrTTL{TTL: 60 * time.Minute},
Contents: []*genai.Content{
{
Role: "user",
Parts: []genai.Part{part1, part2},
},
},
}
result, err := client.CreateCachedContent(context, content)
取得
cachedContent, err := client.GetCachedContent(context, contentName)
刪除
err = client.DeleteCachedContent(context, contentName)
更新
newExpireTime := cc.Expiration.ExpireTime.Add(15 * time.Minute)
ccUpdated := client.UpdateCachedContent(context, cc, &genai.CachedContentToUpdate{
Expiration: &genai.ExpireTimeOrTTL{ExpireTime: newExpireTime},
})
列出
iter, err := client.ListCachedContents(context, contentName)
之後
Python
匯入
from google import genai
from google.genai.types import Content, CreateCachedContentConfig, HttpOptions, Part
建立
client = genai.Client(http_options=HttpOptions(api_version="v1"))
content_cache = client.caches.create(
model="gemini-2.5-flash",
config=CreateCachedContentConfig(
contents=contents,
system_instruction=system_instruction,
display_name="example-cache",
ttl="86400s",
),
)
取得
content_cache_list = client.caches.list()
# Access individual properties of a ContentCache object(s)
for content_cache in content_cache_list:
print(f"Cache `{content_cache.name}` for model `{content_cache.model}`")
print(f"Last updated at: {content_cache.update_time}")
print(f"Expires at: {content_cache.expire_time}")
刪除
client.caches.delete(name=cache_name)
更新
content_cache = client.caches.update(
name=cache_name, config=UpdateCachedContentConfig(ttl="36000s")
)
列出
cache_contents = client.caches.list(config={'page_size': 2})
Java
匯入
import com.google.genai.types.CachedContent;
import com.google.genai.types.Content;
import com.google.genai.types.CreateCachedContentConfig;
import com.google.genai.types.DeleteCachedContentResponse;
import com.google.genai.types.ListCachedContentsConfig;
建立
Content content =
Content.fromParts(
fetchPdfPart(
"https://storage.googleapis.com/cloud-samples-data/generative-ai/pdf/2403.05530.pdf"));
CreateCachedContentConfig config =
CreateCachedContentConfig.builder()
.systemInstruction(Content.fromParts(Part.fromText("summarize the pdf")))
.expireTime(Instant.now().plus(Duration.ofHours(1)))
.contents(content)
.build();
CachedContent cachedContent1 = client.caches.create("gemini-2.5-flash", config);
取得
CachedContent cachedContent2 = client.caches.get(cachedContent1.name().get(), null);
System.out.println("get cached content: " + cachedContent2);
刪除
DeleteCachedContentResponse unused = client.caches.delete(cachedContent1.name().get(), null);
System.out.println("Deleted cached content: " + cachedContent1.name().get());
更新
CachedContent cachedContentUpdate =
client.caches.update(
cachedContent.name().get(),
UpdateCachedContentConfig.builder().ttl(Duration.ofMinutes(10)).build());
System.out.println("Update cached content: " + cachedContentUpdate);
列出
System.out.println("List cached contents resrouce names: ");
for (CachedContent cachedContent :
client.caches.list(ListCachedContentsConfig.builder().pageSize(5).build())) {
System.out.println(cachedContent.name().get());
}
JavaScript
匯入
import {GoogleGenAI, Part} from '@google/genai';
建立
const ai = new GoogleGenAI({
vertexai: true,
project: GOOGLE_CLOUD_PROJECT,
location: GOOGLE_CLOUD_LOCATION,
});
const cachedContent1: Part = {
fileData: {
fileUri: 'gs://cloud-samples-data/generative-ai/pdf/2403.05530.pdf',
mimeType: 'application/pdf',
},
};
const cachedContent2: Part = {
fileData: {
fileUri: 'gs://cloud-samples-data/generative-ai/pdf/2312.11805v3.pdf',
mimeType: 'application/pdf',
},
};
const cache = await ai.caches.create({
model: 'gemini-1.5-pro-002',
config: {contents: [cachedContent1, cachedContent2]},
});
取得
const getResponse = await ai.caches.get({name: cacheName});
刪除
await ai.caches.delete({name: cacheName});
更新
const updateResponse = await ai.caches.update({
name: cacheName,
config: {ttl: '86400s'},
});
列出
const listResponse = await ai.caches.list();
let i = 1;
for await (const cachedContent of listResponse) {
console.debug(`List response ${i++}: `, JSON.stringify(cachedContent));
}
Go
匯入
import (
"context"
"encoding/json"
"fmt"
"io"
genai "google.golang.org/genai"
)
建立
cacheContents := []*genai.Content{
{
Parts: []*genai.Part{
{FileData: &genai.FileData{
FileURI: "gs://cloud-samples-data/generative-ai/pdf/2312.11805v3.pdf",
MIMEType: "application/pdf",
}},
{FileData: &genai.FileData{
FileURI: "gs://cloud-samples-data/generative-ai/pdf/2403.05530.pdf",
MIMEType: "application/pdf",
}},
},
Role: "user",
},
}
config := &genai.CreateCachedContentConfig{
Contents: cacheContents,
SystemInstruction: &genai.Content{
Parts: []*genai.Part{
{Text: systemInstruction},
},
},
DisplayName: "example-cache",
TTL: "86400s",
}
res, err := client.Caches.Create(ctx, modelName, config)
取得
cachedContent, err := client.GetCachedContent(ctx, contentName)
刪除
_, err = client.Caches.Delete(ctx, result.Name, &genai.DeleteCachedContentConfig{})
更新
result, err = client.Caches.Update(ctx, result.Name, &genai.UpdateCachedContentConfig{
ExpireTime: time.Now().Add(time.Hour),
})
列出
// List the first page.
page, err := client.Caches.List(ctx, &genai.ListCachedContentsConfig{PageSize: 2})
// Continue to the next page.
page, err = page.Next(ctx)
// Resume the page iteration using the next page token.
page, err = client.Caches.List(ctx, &genai.ListCachedContentsConfig{PageSize: 2, PageToken: page.NextPageToken})
設定和系統指令
設定會定義控制模型行為的參數，而系統指令則會提供引導指令，讓模型的回覆符合特定角色、風格或工作。將 Vertex AI SDK 中的設定和系統指令，替換為使用 Google Gen AI SDK 的下列程式碼。
之前
Python
model = generative_models.GenerativeModel(
GEMINI_MODEL_NAME,
system_instruction=[
"Talk like a pirate.",
"Don't use rude words.",
],
)
response = model.generate_content(
contents="Why is sky blue?",
generation_config=generative_models.GenerationConfig(
temperature=0,
top_p=0.95,
top_k=20,
candidate_count=1,
max_output_tokens=100,
stop_sequences=["STOP!"],
response_logprobs=True,
logprobs=3,
),
safety_settings={
generative_models.HarmCategory.HARM_CATEGORY_HATE_SPEECH: generative_models.HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE,
generative_models.HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT: generative_models.HarmBlockThreshold.BLOCK_ONLY_HIGH,
generative_models.HarmCategory.HARM_CATEGORY_HARASSMENT: generative_models.HarmBlockThreshold.BLOCK_LOW_AND_ABOVE,
generative_models.HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT: generative_models.HarmBlockThreshold.BLOCK_NONE,
},
)
Java
import com.google.cloud.vertexai.api.GenerationConfig;
GenerationConfig generationConfig =
GenerationConfig.newBuilder().setMaxOutputTokens(50).build();
// Use the builder to instantialize the model with the configuration.
GenerativeModel model =
new GenerativeModel.Builder()
.setModelName("gemino-pro")
.setVertexAi(vertexAi)
.setGenerationConfig(generationConfig)
.build();
JavaScript
const {VertexAI} = require('@google-cloud/vertexai');
const generativeModel = vertexAI.getGenerativeModel({
model: 'gemini-2.5-flash',
systemInstruction: {
parts: [
{text: 'You are a helpful language translator.'},
{text: 'Your mission is to translate text in English to French.'},
],
},
});
const textPart = {
text: `
User input: I like bagels.
Answer:`,
};
const request = {
contents: [{role: 'user', parts: [textPart]}],
};
const resp = await generativeModel.generateContent(request);
const contentResponse = await resp.response;
console.log(JSON.stringify(contentResponse));
Go
import (
"context"
"cloud.google.com/go/vertexai/genai"
)
model := client.GenerativeModel(modelName)
model.GenerationConfig = genai.GenerationConfig{
TopP: proto.Float32(1),
TopK: proto.Int32(32),
Temperature: proto.Float32(0.4),
MaxOutputTokens: proto.Int32(2048),
}
systemInstruction := fmt.Sprintf("Your mission is to translate text from %xs to %s", sourceLanguageCode, targetLanguageCode)
model.SystemInstruction = &genai.Content{
Role: "user",
Parts: []genai.Part{genai.Text(systemInstruction)},
}
之後
Python
from google.genai import types
response = client.models.generate_content(
model='gemini-2.5-flash',
contents='high',
config=types.GenerateContentConfig(
system_instruction='I say high, you say low',
max_output_tokens=3,
temperature=0.3,
response_logprobs=True,
logprobs=3,
),
)
Java
匯入 GenerateContentConfig：
import com.google.genai.types.GenerateContentConfig;
建立系統指示：
Content systemInstruction = Content.fromParts(Part.fromText("You are a history teacher."));
在內容設定中新增系統指示：
GenerateContentConfig config =
GenerateContentConfig.builder()
...
.systemInstruction(systemInstruction)
.build();
如需完整實作方式，請參閱 GenerateContentWithConfigs.java。
JavaScript
import {GoogleGenAI} from '@google/genai';
const ai = new GoogleGenAI({
vertexai: true,
project: GOOGLE_CLOUD_PROJECT,
location: GOOGLE_CLOUD_LOCATION,
});
const response = await ai.models.generateContent({
model: 'gemini-2.5-flash',
contents: 'high',
config: {systemInstruction: 'I say high you say low.'},
});
console.debug(response.text);
await generateContentFromVertexAI().catch((e) =>
console.error('got error', e),
);
Go
import (
"context"
genai "google.golang.org/genai"
)
config := &genai.GenerateContentConfig{
SystemInstruction: &genai.Content{
Parts: []*genai.Part{
{Text: "You're a language translator. Your mission is to translate text in English to French."},
},
},
}
resp, err := client.Models.GenerateContent(ctx, modelName, contents, config)
嵌入
嵌入是文字、圖片或影片的數值向量表示法，可擷取高維度空間中的語意或視覺意義和關係。使用下列程式碼取代 Vertex AI SDK 中的嵌入實作項目，改用 Google Gen AI SDK。
之前
Python
from vertexai.language_models import TextEmbeddingInput, TextEmbeddingModel
model = TextEmbeddingModel.from_pretrained("gemini-embedding-001")
text_input = TextEmbeddingInput(
task_type="RETRIEVAL_DOCUMENT", # Optional
title="Driver's License", # Optional
text="How do I get a driver's license/learner's permit?"
)
response = model.get_embeddings(
[text_input], output_dimensionality=3072
)
Java
Java Vertex AI SDK 不支援嵌入，但 Google Gen AI SDK 支援。
JavaScript
JavaScript Vertex AI SDK 不支援嵌入，但 Google Gen AI SDK 支援。
Go
Go Vertex AI SDK 不支援嵌入，但 Google Gen AI SDK 支援。
之後
Python
from google.genai.types import EmbedContentConfig
client = genai.Client()
response = client.models.embed_content(
model="gemini-embedding-001",
contents="How do I get a driver's license/learner's permit?",
config=EmbedContentConfig(
task_type="RETRIEVAL_DOCUMENT", # Optional
output_dimensionality=3072, # Optional
title="Driver's License", # Optional
),
)
Java
import com.google.genai.Client;
import com.google.genai.types.EmbedContentResponse;
EmbedContentResponse response =
client.models.embedContent("text-embedding-005", "why is the sky blue?", null);
JavaScript
import {GoogleGenAI} from '@google/genai';
const ai = new GoogleGenAI({
vertexai: true,
project: GOOGLE_CLOUD_PROJECT,
location: GOOGLE_CLOUD_LOCATION,
});
const response = await ai.models.embedContent({
model: 'text-embedding-005',
contents: 'Hello world!',
});
console.debug(JSON.stringify(response));
await embedContentFromVertexAI().catch((e) =>
console.error('got error', e),
);
Go
import (
"context"
"fmt"
"google.golang.org/genai"
)
result, err := client.Models.EmbedContent(ctx, *model, genai.Text("What is your name?"), &genai.EmbedContentConfig{TaskType: "RETRIEVAL_QUERY"})
fmt.Printf("%#v\n", result.Embeddings[0])
fmt.Println("Embed content RETRIEVAL_DOCUMENT task type example.")
result, err = client.Models.EmbedContent(ctx, *model, genai.Text("What is your name?"), &genai.EmbedContentConfig{TaskType: "RETRIEVAL_DOCUMENT"})
fmt.Printf("%#v\n", result.Embeddings[0])
函式呼叫
函式呼叫功能可讓模型判斷何時應叫用外部工具或 API，然後生成結構化資料，其中包含執行作業所需的函式和引數。使用 Vertex AI SDK 取代函式呼叫實作項目，並使用下列程式碼搭配 Google Gen AI SDK。
之前
Python
get_current_weather_func = generative_models.FunctionDeclaration(
name="get_current_weather",
description="Get the current weather in a given location",
parameters=_REQUEST_FUNCTION_PARAMETER_SCHEMA_STRUCT,
)
weather_tool = generative_models.Tool(
function_declarations=[get_current_weather_func],
)
model = generative_models.GenerativeModel(
GEMINI_MODEL_NAME,
tools=[weather_tool],
)
chat = model.start_chat()
response1 = chat.send_message("What is the weather like in Boston?")
assert (
response1.candidates[0].content.parts[0].function_call.name
== "get_current_weather"
)
response2 = chat.send_message(
generative_models.Part.from_function_response(
name="get_current_weather",
response={
"content": {"weather": "super nice"},
},
),
)
assert response2.text
Java
Tool tool =
Tool.newBuilder()
.addFunctionDeclarations(
FunctionDeclarationMaker.fromJsonString(jsonString)
)
.build();
// Start a chat session from a model, with the use of the declared
// function.
GenerativeModel model =
new GenerativeModel.Builder()
.setModelName(MODEL_NAME)
.setVertexAi(vertexAi)
.setTools(Arrays.asList(tool))
.build();
ChatSession chat = model.startChat();
System.out.println(String.format("Ask the question: %s", TEXT));
GenerateContentResponse response = chat.sendMessage(TEXT);
// Provide an answer to the model so that it knows what the result of a
// "function call" is.
Content content =
ContentMaker.fromMultiModalData(
PartMaker.fromFunctionResponse(
"getCurrentWeather", Collections.singletonMap("currentWeather", "snowing")));
response = chat.sendMessage(content);
JavaScript
const {
VertexAI,
FunctionDeclarationSchemaType,
} = require('@google-cloud/vertexai');
const functionDeclarations = [
{
function_declarations: [
{
name: 'get_current_weather',
description: 'get weather in a given location',
parameters: {
type: FunctionDeclarationSchemaType.OBJECT,
properties: {
location: {type: FunctionDeclarationSchemaType.STRING},
unit: {
type: FunctionDeclarationSchemaType.STRING,
enum: ['celsius', 'fahrenheit'],
},
},
required: ['location'],
},
},
],
},
];
async function functionCallingBasic(
projectId = 'PROJECT_ID',
location = 'us-central1',
model = 'gemini-2.5-flash'
) {
// Initialize Vertex with your Cloud project and location
const vertexAI = new VertexAI({project: projectId, location: location});
// Instantiate the model
const generativeModel = vertexAI.preview.getGenerativeModel({
model: model,
});
const request = {
contents: [
{role: 'user', parts: [{text: 'What is the weather in Boston?'}]},
],
tools: functionDeclarations,
};
const result = await generativeModel.generateContent(request);
console.log(JSON.stringify(result.response.candidates[0].content));
}
Go
package functioncalling
import (
"context"
"encoding/json"
"errors"
"fmt"
"io"
"cloud.google.com/go/vertexai/genai"
)
funcName := "getCurrentWeather"
funcDecl := &genai.FunctionDeclaration{
Name: funcName,
Description: "Get the current weather in a given location",
Parameters: &genai.Schema{
Type: genai.TypeObject,
Properties: map[string]*genai.Schema{
"location": {
Type: genai.TypeString,
Description: "location",
},
},
Required: []string{"location"},
},
}
// Add the weather function to our model toolbox.
model.Tools = []*genai.Tool{
{
FunctionDeclarations: []*genai.FunctionDeclaration{funcDecl},
},
}
prompt := genai.Text("What's the weather like in Boston?")
resp, err := model.GenerateContent(ctx, prompt)
if len(resp.Candidates) == 0 {
return errors.New("got empty response from model")
} else if len(resp.Candidates[0].FunctionCalls()) == 0 {
return errors.New("got no function call suggestions from model")
}
funcResp := &genai.FunctionResponse{
Name: funcName,
Response: map[string]any{
"content": mockAPIResp,
},
}
// Return the API response to the model allowing it to complete its response.
resp, err = model.GenerateContent(ctx, prompt, funcResp)
if err != nil {
return fmt.Errorf("failed to generate content: %w", err)
}
if len(resp.Candidates) == 0 || len(resp.Candidates[0].Content.Parts) == 0 {
return errors.New("got empty response from model")
}
之後
Python
from google.genai import types
def get_current_weather(location: str) -> str:
"""Returns the current weather.
Args:
location: The city and state, e.g. San Francisco, CA
"""
return 'sunny'
response = client.models.generate_content(
model='gemini-2.5-flash',
contents='What is the weather like in Boston?',
config=types.GenerateContentConfig(tools=[get_current_weather]),
)
Java
使用 Chat 或 GenerateContent 方法實作函式呼叫。
使用 Chat
宣告將成為可呼叫函式的方法：
Method method1 =
ChatWithFunctionCall.class.getDeclaredMethod("getCurrentWeather", String.class);
Method method2 =
ChatWithFunctionCall.class.getDeclaredMethod("divideTwoIntegers", int.class, int.class);
在內容設定中，將這兩個方法新增為工具的可呼叫函式：
GenerateContentConfig config =
GenerateContentConfig.builder().tools(Tool.builder().functions(method1, method2)).build();
使用設定建立即時通訊工作階段：
Chat chatSession = client.chats.create("gemini-2.5-flash", config);
GenerateContentResponse response1 =
chatSession.sendMessage("what is the weather in San Francisco?");
如要查看完整實作，請參閱 ChatWithFunctionCall.java。
使用 GenerateContent
宣告將成為可呼叫函式的方法：
Method method1 =
GenerateContentWithFunctionCall.class.getMethod(
"getCurrentWeather", String.class, String.class);
Method method2 =
GenerateContentWithFunctionCall.class.getMethod(
"divideTwoIntegers", Integer.class, Integer.class);
在內容設定中，將這兩個方法新增為工具的可呼叫函式：
GenerateContentConfig config =
GenerateContentConfig.builder().tools(Tool.builder().functions(method1, method2)).build();
使用 generateContent 和設定：
GenerateContentResponse response =
client.models.generateContent(
"gemini-2.5-flash",
"What is the weather in Vancouver? And can you divide 10 by 0?",
config);
如要查看完整實作方式，請參閱 GenerateContentWithFunctionCall.java。
JavaScript
import {
FunctionCall,
FunctionCallingConfigMode,
FunctionDeclaration,
GoogleGenAI,
Type,
} from '@google/genai';
const ai = new GoogleGenAI({
vertexai: true,
project: GOOGLE_CLOUD_PROJECT,
location: GOOGLE_CLOUD_LOCATION,
});
const controlLightFunctionDeclaration: FunctionDeclaration = {
name: 'controlLight',
parameters: {
type: Type.OBJECT,
description: 'Set the brightness and color temperature of a room light.',
properties: {
brightness: {
type: Type.NUMBER,
description:
'Light level from 0 to 100. Zero is off and 100 is full brightness.',
},
colorTemperature: {
type: Type.STRING,
description:
'Color temperature of the light fixture which can be `daylight`, `cool` or `warm`.',
},
},
required: ['brightness', 'colorTemperature'],
},
};
const response = await ai.models.generateContent({
model: 'gemini-2.5-flash',
contents: 'Dim the lights so the room feels cozy and warm.',
config: {
tools: [{functionDeclarations: [controlLightFunctionDeclaration]}],
toolConfig: {
functionCallingConfig: {
mode: FunctionCallingConfigMode.ANY,
allowedFunctionNames: ['controlLight'],
},
},
},
});
console.debug(response.functionCalls);
Go
package main
import (
"context"
"encoding/json"
"flag"
"fmt"
"log"
"google.golang.org/genai"
)
var model = flag.String("model", "gemini-2.5-flash", "the model name, e.g. gemini-2.5-flash")
func run(ctx context.Context) {
client, err := genai.NewClient(ctx, nil)
if err != nil {
log.Fatal(err)
}
funcName := "getCurrentWeather"
funcDecl := &genai.FunctionDeclaration{
Name: funcName,
Description: "Get the current weather in a given location",
Parameters: &genai.Schema{
Type: genai.TypeObject,
Properties: map[string]*genai.Schema{
"location": {
Type: genai.TypeString,
Description: "location",
},
},
Required: []string{"location"},
},
}
// Add the weather function to our model toolbox.
var config *genai.GenerateContentConfig = &genai.GenerateContentConfig{
Tools: []*genai.Tool{
{
FunctionDeclarations: []*genai.FunctionDeclaration{funcDecl},
},
},
}
// Call the GenerateContent method.
result, err := client.Models.GenerateContent(ctx, *model, genai.Text("What's the weather like in Boston?"), config)
if err != nil {
log.Fatal(err)
}
fmt.Println(result.Candidates[0].Content.Parts[0].FunctionCall.Name)
// Use synthetic data to simulate a response from the external API.
// In a real application, this would come from an actual weather API.
mockAPIResp, err := json.Marshal(map[string]string{
"location": "Boston",
"temperature": "38",
"temperature_unit": "F",
"description": "Cold and cloudy",
"humidity": "65",
"wind": `{"speed": "10", "direction": "NW"}`,
})
if err != nil {
log.Fatal(err)
}
funcResp := &genai.FunctionResponse{
Name: funcName,
Response: map[string]any{
"content": mockAPIResp,
},
}
// Return the API response to the model allowing it to complete its response.
mockedFunctionResponse := []*genai.Content{
&genai.Content{
Role: "user",
Parts: []*genai.Part{
&genai.Part{Text: "What's the weather like in Boston?"},
},
},
result.Candidates[0].Content,
&genai.Content{
Role: "tool",
Parts: []*genai.Part{
&genai.Part{FunctionResponse: funcResp},
},
},
}
result, err = client.Models.GenerateContent(ctx, *model, mockedFunctionResponse, config)
if err != nil {
log.Fatal(err)
}
fmt.Println(result.Text())
}
func main() {
ctx := context.Background()
flag.Parse()
run(ctx)
}
連結
建立基準程序是指為模型提供外部特定領域資訊，以提升回覆的準確度、關聯性和一致性。使用下列程式碼，以 Google Gen AI SDK 取代 Vertex AI SDK 的基礎實作項目。
之前
Python
model = generative_models.GenerativeModel(GEMINI_MODEL_NAME)
google_search_retriever_tool = (
generative_models.Tool.from_google_search_retrieval(
generative_models.grounding.GoogleSearchRetrieval()
)
)
response = model.generate_content(
"Why is sky blue?",
tools=[google_search_retriever_tool],
generation_config=generative_models.GenerationConfig(temperature=0),
)
Java
import com.google.cloud.vertexai.api.GroundingMetadata;
Tool googleSearchTool =
Tool.newBuilder()
.setGoogleSearch(GoogleSearch.newBuilder())
.build();
GenerativeModel model =
new GenerativeModel(modelName, vertexAI)
.withTools(Collections.singletonList(googleSearchTool));
GenerateContentResponse response = model.generateContent("Why is the sky blue?");
GroundingMetadata groundingMetadata = response.getCandidates(0).getGroundingMetadata();
String answer = ResponseHandler.getText(response);
JavaScript
const {VertexAI} = require('@google-cloud/vertexai');
const vertexAI = new VertexAI({project: projectId, location: location});
const generativeModelPreview = vertexAI.preview.getGenerativeModel({
model: model,
generationConfig: {maxOutputTokens: 256},
});
const googleSearchTool = {
googleSearch: {},
};
const request = {
contents: [{role: 'user', parts: [{text: 'Why is the sky blue?'}]}],
tools: [googleSearchTool],
};
const result = await generativeModelPreview.generateContent(request);
const response = await result.response;
const groundingMetadata = response.candidates[0].groundingMetadata;
console.log(
'Response: ',
JSON.stringify(response.candidates[0].content.parts[0].text)
);
console.log('GroundingMetadata is: ', JSON.stringify(groundingMetadata));
Go
Go Vertex AI SDK 不支援基礎功能，但 Google Gen AI SDK 支援。
之後
Python
from google.genai import types
from google.genai import Client
client = Client(
vertexai=True,
project=GOOGLE_CLOUD_PROJECT,
location=GOOGLE_CLOUD_LOCATION
)
response = client.models.generate_content(
model='gemini-2.5-flash-exp',
contents='Why is the sky blue?',
config=types.GenerateContentConfig(
tools=[types.Tool(google_search=types.GoogleSearch())]),
)
Java
匯入 Tool 模組：
import com.google.genai.types.Tool;
在設定中設定 Google 搜尋工具：
Tool googleSearchTool = Tool.builder().googleSearch(GoogleSearch.builder()).build();
將工具新增至內容設定：
GenerateContentConfig config =
GenerateContentConfig.builder()
...
.tools(googleSearchTool)
.build();
如需完整實作方式，請參閱 GenerateContentWithConfigs.java。
JavaScript
import {GoogleGenAI} from '@google/genai';
const ai = new GoogleGenAI({
vertexai: true,
project: GOOGLE_CLOUD_PROJECT,
location: GOOGLE_CLOUD_LOCATION,
});
const response = await ai.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: [{googleSearch: {}}],
},
});
console.debug(JSON.stringify(response?.candidates?.[0]?.groundingMetadata));
Go
package main
import (
"context"
"flag"
"fmt"
"log"
"google.golang.org/genai"
)
var model = flag.String("model", "gemini-2.5-flash", "the model name, e.g. gemini-2.5-flash")
func run(ctx context.Context) {
client, err := genai.NewClient(ctx, nil)
if err != nil {
log.Fatal(err)
}
// Add the Google Search grounding tool to the GenerateContentConfig.
var config *genai.GenerateContentConfig = &genai.GenerateContentConfig{
Tools: []*genai.Tool{
{
GoogleSearch: &genai.GoogleSearch{},
},
},
}
// Call the GenerateContent method.
result, err := client.Models.GenerateContent(ctx, *model, genai.Text("Why is the sky blue?"), config)
if err != nil {
log.Fatal(err)
}
fmt.Println(result.Text())
}
func main() {
ctx := context.Background()
flag.Parse()
run(ctx)
}
安全性設定
安全設定是可設定的參數，使用者可以透過篩選或封鎖與特定有害類別相關的內容 (例如仇恨言論、色情內容或暴力內容)，管理模型回覆。使用下列程式碼，透過 Google Gen AI SDK 實作 Vertex AI SDK，取代安全設定實作項目。
之前
Python
model = generative_models.GenerativeModel(
GEMINI_MODEL_NAME,
system_instruction=[
"Talk like a pirate.",
"Don't use rude words.",
],
)
response = model.generate_content(
contents="Why is sky blue?",
generation_config=generative_models.GenerationConfig(
temperature=0,
top_p=0.95,
top_k=20,
candidate_count=1,
max_output_tokens=100,
stop_sequences=["STOP!"],
response_logprobs=True,
logprobs=3,
),
safety_settings={
generative_models.HarmCategory.HARM_CATEGORY_HATE_SPEECH: generative_models.HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE,
generative_models.HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT: generative_models.HarmBlockThreshold.BLOCK_ONLY_HIGH,
generative_models.HarmCategory.HARM_CATEGORY_HARASSMENT: generative_models.HarmBlockThreshold.BLOCK_LOW_AND_ABOVE,
generative_models.HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT: generative_models.HarmBlockThreshold.BLOCK_NONE,
},
)
Java
import com.google.cloud.vertexai.api.SafetySetting;
import com.google.cloud.vertexai.api.SafetySetting.HarmBlockThreshold;
SafetySetting safetySetting =
SafetySetting.newBuilder()
.setCategory(HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT)
.setThreshold(HarmBlockThreshold.BLOCK_LOW_AND_ABOVE)
.build();
GenerateContentResponse response =
model
.withSafetySetting(Arrays.asList(SafetySetting))
.generateContent("Please explain LLM?");
JavaScript
const {
VertexAI,
HarmCategory,
HarmBlockThreshold,
} = require('@google-cloud/vertexai');
// Initialize Vertex with your Cloud project and location
const vertexAI = new VertexAI({project: PROJECT_ID, location: LOCATION});
// Instantiate the model
const generativeModel = vertexAI.getGenerativeModel({
model: MODEL,
safetySettings: [
{
category: HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT,
threshold: HarmBlockThreshold.BLOCK_LOW_AND_ABOVE,
},
{
category: HarmCategory.HARM_CATEGORY_HARASSMENT,
threshold: HarmBlockThreshold.BLOCK_LOW_AND_ABOVE,
},
],
});
const request = {
contents: [{role: 'user', parts: [{text: 'Tell me something dangerous.'}]}],
};
console.log('Prompt:');
console.log(request.contents[0].parts[0].text);
console.log('Streaming Response Text:');
// Create the response stream
const responseStream = await generativeModel.generateContentStream(request);
// Log the text response as it streams
for await (const item of responseStream.stream) {
if (item.candidates[0].finishReason === 'SAFETY') {
console.log('This response stream terminated due to safety concerns.');
break;
} else {
process.stdout.write(item.candidates[0].content.parts[0].text);
}
}
console.log('This response stream terminated due to safety concerns.');
Go
package safetysettings
import (
"context"
"fmt"
"io"
"cloud.google.com/go/vertexai/genai"
)
// generateContent generates text from prompt and configurations provided.
func generateContent(w io.Writer, projectID, location, modelName string) error {
// location := "us-central1"
// model := "gemini-2.5-flash"
ctx := context.Background()
client, err := genai.NewClient(ctx, projectID, location)
if err != nil {
return err
}
defer client.Close()
model := client.GenerativeModel(modelName)
model.SetTemperature(0.8)
// configure the safety settings thresholds
model.SafetySettings = []*genai.SafetySetting{
{
Category: genai.HarmCategoryHarassment,
Threshold: genai.HarmBlockLowAndAbove,
},
{
Category: genai.HarmCategoryDangerousContent,
Threshold: genai.HarmBlockLowAndAbove,
},
}
res, err := model.GenerateContent(ctx, genai.Text("Hello, say something mean to me."))
if err != nil {
return fmt.Errorf("unable to generate content: %v", err)
}
fmt.Fprintf(w, "generate-content response: %v\n", res.Candidates[0].Content.Parts[0])
fmt.Fprintf(w, "safety ratings:\n")
for _, r := range res.Candidates[0].SafetyRatings {
fmt.Fprintf(w, "\t%+v\n", r)
}
return nil
}
之後
Python
from google.genai import types
response = client.models.generate_content(
model='gemini-2.5-flash',
contents='Say something bad.',
config=types.GenerateContentConfig(
safety_settings=[
types.SafetySetting(
category='HARM_CATEGORY_HATE_SPEECH',
threshold='BLOCK_ONLY_HIGH',
)
]
),
)
Java
匯入 HarmBlockThreshold、HarmCategory 和 SafetySetting 模組：
import com.google.genai.types.HarmBlockThreshold;
import com.google.genai.types.HarmCategory;
import com.google.genai.types.SafetySetting;
在設定中設定安全性設定：
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());
在內容設定中新增安全性設定：
GenerateContentConfig config =
GenerateContentConfig.builder()
...
.safetySettings(safetySettings)
.build();
如需完整實作方式，請參閱 GenerateContentWithConfigs.java。
JavaScript
import {
GoogleGenAI,
HarmBlockMethod,
HarmBlockThreshold,
HarmCategory,
} from '@google/genai';
const ai = new GoogleGenAI({
vertexai: true,
project: GOOGLE_CLOUD_PROJECT,
location: GOOGLE_CLOUD_LOCATION,
});
const response = await ai.models.generateContent({
model: 'gemini-2.5-flash',
contents: 'say something bad',
config: {
safetySettings: [
{
method: HarmBlockMethod.SEVERITY,
category: HarmCategory.HARM_CATEGORY_HATE_SPEECH,
threshold: HarmBlockThreshold.BLOCK_LOW_AND_ABOVE,
},
{
method: HarmBlockMethod.SEVERITY,
category: HarmCategory.HARM_CATEGORY_HARASSMENT,
threshold: HarmBlockThreshold.BLOCK_LOW_AND_ABOVE,
},
],
},
});
console.debug(JSON.stringify(response?.candidates?.[0]?.safetyRatings));
Go
package main
import (
"context"
"flag"
"fmt"
"log"
"google.golang.org/genai"
)
var model = flag.String("model", "gemini-2.5-flash", "the model name, e.g. gemini-2.5-flash")
func run(ctx context.Context) {
client, err := genai.NewClient(ctx, nil)
if err != nil {
log.Fatal(err)
}
var safetySettings []*genai.SafetySetting = []*genai.SafetySetting{
{
Category: genai.HarmCategoryHarassment,
Threshold: genai.HarmBlockThresholdBlockMediumAndAbove,
},
{
Category: genai.HarmCategoryDangerousContent,
Threshold: genai.HarmBlockThresholdBlockMediumAndAbove,
},
}
var config *genai.GenerateContentConfig = &genai.GenerateContentConfig{
SafetySettings: safetySettings,
}
// Call the GenerateContent method.
result, err := client.Models.GenerateContent(ctx, *model, genai.Text("What is your name?"), config)
if err != nil {
log.Fatal(err)
}
fmt.Println(result.Text())
}
func main() {
ctx := context.Background()
flag.Parse()
run(ctx)
}
即時通訊工作階段
在對話期間，模型會記住先前的訊息，並根據這些訊息生成當下的回覆，藉此在多輪對話中維持背景資訊。使用下列程式碼取代 Vertex AI SDK 的實作項目，改用 Google Gen AI SDK。
之前
Python
model = GenerativeModel(
"gemini-2.5-flash",
# You can specify tools when creating a model to avoid having to send them with every request.
tools=[weather_tool],
tool_config=tool_config,
)
chat = model.start_chat()
print(chat.send_message("What is the weather like in Boston?"))
print(chat.send_message(
Part.from_function_response(
name="get_current_weather",
response={
"content": {"weather_there": "super nice"},
}
),
))
Java
import com.google.cloud.vertexai.generativeai.ChatSession;
GenerativeModel model = new GenerativeModel("gemini-2.5-flash", vertexAi);
ChatSession chat = model.startChat();
ResponseStream<GenerateContentResponse> response = chat
.sendMessageStream("Can you tell me a story about cheese in 100 words?");
ResponseStream<GenerateContentResponse> anotherResponse = chat
.sendMessageStream("Can you modify the story to be written for a 5 year old?");
JavaScript
const {VertexAI} = require('@google-cloud/vertexai');
const chat = generativeModel.startChat({});
const result1 = await chat.sendMessage('Hello');
const response1 = await result1.response;
console.log('Chat response 1: ', JSON.stringify(response1));
const result2 = await chat.sendMessage(
'Can you tell me a scientific fun fact?'
);
const response2 = await result2.response;
console.log('Chat response 2: ', JSON.stringify(response2));
Go
import (
"context"
"errors"
"fmt"
"cloud.google.com/go/vertexai/genai"
)
prompt := "Do you have the Pixel 8 Pro in stock?"
fmt.Fprintf(w, "Question: %s\n", prompt)
resp, err := chat.SendMessage(ctx, genai.Text(prompt))
之後
Python
同步
chat = client.chats.create(model='gemini-2.5-flash')
response = chat.send_message('tell me a story')
print(response.text)
response = chat.send_message('summarize the story you told me in 1 sentence')
print(response.text)
非同步
chat = client.aio.chats.create(model='gemini-2.5-flash')
response = await chat.send_message('tell me a story')
print(response.text)
同步串流
chat = client.chats.create(model='gemini-2.5-flash')
for chunk in chat.send_message_stream('tell me a story'):
print(chunk.text, end='')
非同步串流
chat = client.aio.chats.create(model='gemini-2.5-flash')
async for chunk in await chat.send_message_stream('tell me a story'):
print(chunk.text, end='') # end='' is optional, for demo purposes.
Java
匯入 Chat 和 GenerateContentResponse 模組：
import com.google.genai.Chat;
import com.google.genai.types.GenerateContentResponse;
建立即時通訊工作階段：
Chat chatSession = client.chats.create("gemini-2.5-flash");
使用 GenerateContentResponse 提供提示：
GenerateContentResponse response =
chatSession
.sendMessage("Can you tell me a story about cheese in 100 words?");
// Gets the text string from the response by the quick accessor method `text()`.
System.out.println("Unary response: " + response.text());
GenerateContentResponse response2 =
chatSession
.sendMessage("Can you modify the story to be written for a 5 year old?");
// Gets the text string from the second response.
System.out.println("Unary response: " + response2.text());
如要查看完整實作，請參閱 ChatWithHistory.java。
JavaScript
import {GoogleGenAI} from '@google/genai';
const chat = ai.chats.create({model: 'gemini-2.5-flash'});
const response = await chat.sendMessage({message: 'Why is the sky blue?'});
console.debug('chat response 1: ', response.text);
const response2 = await chat.sendMessage({message: 'Why is the sunset red?'});
console.debug('chat response 2: ', response2.text);
const history = chat.getHistory();
for (const content of history) {
console.debug('chat history: ', JSON.stringify(content, null, 2));
}
Go
package main
import (
"context"
"flag"
"fmt"
"log"
"google.golang.org/genai"
)
var model = flag.String("model", "gemini-2.5-flash", "the model name, e.g. gemini-2.5-flash")
var config *genai.GenerateContentConfig = &genai.GenerateContentConfig{Temperature: genai.Ptr[float32](0.5)}
// Create a new Chat.
chat, err := client.Chats.Create(ctx, *model, config, nil)
// Send first chat message.
result, err := chat.SendMessage(ctx, genai.Part{Text: "What's the weather in San Francisco?"})
if err != nil {
log.Fatal(err)
}
fmt.Println(result.Text())
// Send second chat message.
result, err = chat.SendMessage(ctx, genai.Part{Text: "How about New York?"})
if err != nil {
log.Fatal(err)
}
fmt.Println(result.Text())
多模態輸入內容
多模態輸入是指模型處理及解讀文字以外資料類型資訊的能力，例如圖片、音訊和影片。使用下列程式碼，透過 Google Gen AI SDK 實作 Vertex AI SDK。
之前
Python
from vertexai.generative_models import GenerativeModel, Image
vision_model = GenerativeModel("gemini-2.5-flash-vision")
# Local image
image = Image.load_from_file("image.jpg")
print(vision_model.generate_content(["What is shown in this image?", image]))
# Image from Cloud Storage
image_part = generative_models.Part.from_uri("gs://download.tensorflow.org/example_images/320px-Felis_catus-cat_on_snow.jpg", mime_type="image/jpeg")
print(vision_model.generate_content([image_part, "Describe this image?"]))
# Text and video
video_part = Part.from_uri("gs://cloud-samples-data/video/animals.mp4", mime_type="video/mp4")
print(vision_model.generate_content(["What is in the video? ", video_part]))
Java
import com.google.cloud.vertexai.generativeai.ContentMaker;
GenerativeModel model = new GenerativeModel("gemini-2.5-flash-vision", vertexAi);
ResponseStream<GenerateContentResponse> stream =
model.generateContentStream(ContentMaker.fromMultiModalData(
"Please describe this image",
PartMaker.fromMimeTypeAndData("image/jpeg", IMAGE_URI)
));
JavaScript
const {VertexAI, HarmBlockThreshold, HarmCategory} = require('@google-cloud/vertexai');
// Initialize Vertex with your Cloud project and location
const vertex_ai = new VertexAI({project: project, location: location});
// Instantiate the model
const generativeVisionModel = vertex_ai.getGenerativeModel({
model: 'gemini-ultra-vision',
});
async function multiPartContent() {
const filePart = {file_data: {file_uri: "gs://sararob_imagegeneration_test/kitten.jpeg", mime_type: "image/jpeg"}};
const textPart = {text: 'What is this picture about?'};
const request = {
contents: [{role: 'user', parts: [textPart, filePart]}],
};
const resp = await generativeVisionModel.generateContentStream(request);
const contentResponse = await resp.response;
console.log(JSON.stringify(contentResponse));
}
multiPartContent();
Go
圖片
import (
"context"
"encoding/json"
"fmt"
"io"
"cloud.google.com/go/vertexai/genai"
)
img := genai.FileData{
MIMEType: "image/jpeg",
FileURI: "gs://generativeai-downloads/images/scones.jpg",
}
prompt := genai.Text("What is in this image?")
resp, err := gemini.GenerateContent(ctx, img, prompt)
if err != nil {
return fmt.Errorf("error generating content: %w", err)
}
影片
package multimodalvideoaudio
import (
"context"
"errors"
"fmt"
"io"
"mime"
"path/filepath"
"cloud.google.com/go/vertexai/genai"
)
part := genai.FileData{
MIMEType: mime.TypeByExtension(filepath.Ext("pixel8.mp4")),
FileURI: "gs://cloud-samples-data/generative-ai/video/pixel8.mp4",
}
res, err := model.GenerateContent(ctx, part, genai.Text(`
Provide a description of the video.
The description should also contain anything important which people say in the video.
`))
之後
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=[
Part.from_uri(
file_uri="gs://cloud-samples-data/generative-ai/video/ad_copy_from_video.mp4",
mime_type="video/mp4",
),
"What is in the video?",
],
)
print(response.text)
Java
匯入 GenerateContentResponse 模組：
import com.google.genai.types.GenerateContentResponse;
提供文字、圖片和影片的組合，進行多模態提示：
Content content =
Content.fromParts(
Part.fromText("describe the image"),
Part.fromUri("gs://cloud-samples-data/generative-ai/image/scones.jpg", "image/jpeg"));
將合併後的提示提供給模型：
GenerateContentResponse response =
client.models.generateContent("gemini-2.5-flash", content, null);
如要查看完整實作，請參閱 GenerateContentWithImageInput.java。
JavaScript
const filePart = {file_data: {file_uri: "gs://sararob_imagegeneration_test/kitten.jpeg", mime_type: "image/jpeg"}};
const textPart = {text: 'What is this picture about?'};
const contents = [{role: 'user', parts: [textPart, filePart]}];
const response = await ai.models.generateContentStream({
model: 'gemini-2.5-flash-exp',
contents: contents,
});
let i = 0;
for await (const chunk of response) {
const text = chunk.text;
if (text) {
console.debug(text);
}
}
Go
圖片
package main
import (
"context"
"encoding/json"
"flag"
"fmt"
"log"
"google.golang.org/genai"
)
config := &genai.GenerateContentConfig{}
config.ResponseModalities = []string{"IMAGE", "TEXT"}
// Call the GenerateContent method.
result, err := client.Models.GenerateContent(ctx, *model, genai.Text("Generate a story about a cute baby turtle in a 3d digital art style. For each scene, generate an image."), config)
if err != nil {
log.Fatal(err)
}
影片與音訊
package multimodalvideoaudio
import (
"context"
"errors"
"fmt"
"io"
"mime"
"path/filepath"
"cloud.google.com/go/vertexai/genai"
)
part := genai.FileData{
MIMEType: mime.TypeByExtension(filepath.Ext("pixel8.mp4")),
FileURI: "gs://cloud-samples-data/generative-ai/video/pixel8.mp4",
}
res, err := model.GenerateContent(ctx, part, genai.Text(`
Provide a description of the video.
The description should also contain anything important which people say in the video.
`))
文字生成
文字生成是指模型根據指定提示，生成擬真文字內容的程序。使用下列程式碼，透過 Google Gen AI SDK 取代 Vertex AI SDK 的實作項目。
同步生成
之前
Python
response = model.generate_content(
"Why is sky blue?",
generation_config=generative_models.GenerationConfig(temperature=0),
)
assert response.text
Java
import com.google.cloud.vertexai.api.GenerateContentResponse;
GenerativeModel model = new GenerativeModel("gemini-2.5-flash", vertexAi);
GenerateContentResponse response = model.generateContent("How are you?");
JavaScript
Vertex AI SDK 和 Google Gen AI SDK 都只支援 JavaScript 的非同步文字生成功能。
Go
gemini := client.GenerativeModel(modelName)
prompt := genai.Text(
"What's a good name for a flower shop that specializes in selling bouquets of dried flowers?")
resp, err := gemini.GenerateContent(ctx, prompt)
之後
Python
response = client.models.generate_content(
model='gemini-2.5-flash', contents='Why is the sky blue?'
)
print(response.text)
Java
匯入 GenerateContentResponse 模組：
import com.google.genai.types.GenerateContentResponse;
使用 generateContent 生成文字：
GenerateContentResponse response =
client.models.generateContent("gemini-2.5-flash", "What is your name?", null);
如需完整實作方式，請參閱 GenerateContent.java。
JavaScript
Vertex AI SDK 和 Google Gen AI SDK 都只支援 JavaScript 的非同步文字生成功能。
Go
var config *genai.GenerateContentConfig = &genai.GenerateContentConfig{Temperature: genai.Ptr[float32](0)}
// Call the GenerateContent method.
result, err := client.Models.GenerateContent(ctx, *model, genai.Text("What is your name?"), config)
非同步生成
之前
Python
response = await model.generate_content_async(
"Why is sky blue?",
generation_config=generative_models.GenerationConfig(temperature=0),
)
Java
import com.google.cloud.vertexai.api.GenerateContentResponse;
GenerativeModel model = new GenerativeModel("gemini-2.5-flash", vertexAi);
ApiFuture<GenerateContentResponse> future = model.generateContentAsync("How are you?");
GenerateContentResponse response = future.get();
JavaScript
const {VertexAI} = require('@google-cloud/vertexai');
// Initialize Vertex with your Cloud project and location
const vertexAI = new VertexAI({project: projectId, location: location});
// Instantiate the model
const generativeModel = vertexAI.getGenerativeModel({
model: model,
});
const request = {
contents: [
{
role: 'user',
parts: [
{
text: 'Write a story about a magic backpack.',
},
],
},
],
};
console.log(JSON.stringify(request));
const result = await generativeModel.generateContent(request);
console.log(result.response.text);
Go
不適用：Go 會管理並行工作，不必執行非同步作業。
之後
Python
response = await client.aio.models.generate_content(
model='gemini-2.5-flash', contents='Tell me a story in 300 words.'
)
print(response.text)
Java
匯入 GenerateContentResponse 模組：
import com.google.genai.types.GenerateContentResponse;
以非同步方式生成文字：
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();
如需完整實作方式，請參閱 GenerateContentAsync.java。
JavaScript
const ai = new GoogleGenAI({
vertexai: true,
project: GOOGLE_CLOUD_PROJECT,
location: GOOGLE_CLOUD_LOCATION,
});
const response = await ai.models.generateContent({
model: 'gemini-2.5-flash',
contents: 'why is the sky blue?',
});
console.debug(response.text);
Go
不適用：Go 會管理並行工作，不必執行非同步作業。
串流
之前
Python
同步串流
stream = model.generate_content(
"Why is sky blue?",
stream=True,
generation_config=generative_models.GenerationConfig(temperature=0),
)
for chunk in stream:
assert (
chunk.text
or chunk.candidates[0].finish_reason
is generative_models.FinishReason.STOP
)
非同步串流
async_stream = await model.generate_content_async(
"Why is sky blue?",
stream=True,
generation_config=generative_models.GenerationConfig(temperature=0),
)
async for chunk in async_stream:
assert (
chunk.text
or chunk.candidates[0].finish_reason
is generative_models.FinishReason.STOP
)
Java
import com.google.cloud.vertexai.generativeai.ResponseStream;
import com.google.cloud.vertexai.api.GenerateContentResponse;
GenerativeModel model = new GenerativeModel("gemini-2.5-flash", vertexAi);
ResponseStream<GenerateContentResponse> responseStream = model.generateContentStream("How are you?");
JavaScript
// Initialize Vertex with your Cloud project and location
const vertexAI = new VertexAI({project: projectId, location: location});
// Instantiate the model
const generativeModel = vertexAI.getGenerativeModel({
model: model,
});
const request = {
contents: [{role: 'user', parts: [{text: 'What is Node.js?'}]}],
};
console.log('Prompt:');
console.log(request.contents[0].parts[0].text);
console.log('Streaming Response Text:');
// Create the response stream
const responseStream = await generativeModel.generateContentStream(request);
// Log the text response as it streams
for await (const item of responseStream.stream) {
process.stdout.write(item.candidates[0].content.parts[0].text);
}
Go
package streamtextbasic
import (
"context"
"errors"
"fmt"
"io"
"cloud.google.com/go/vertexai/genai"
"google.golang.org/api/iterator"
)
model := client.GenerativeModel(modelName)
iter := model.GenerateContentStream(
ctx,
genai.Text("Write a story about a magic backpack."),
)
for {
resp, err := iter.Next()
fmt.Fprint(w, "generated response: ")
for _, c := range resp.Candidates {
for _, p := range c.Content.Parts {
fmt.Fprintf(w, "%s ", p)
}
}
}
之後
Python
同步串流
for chunk in client.models.generate_content_stream(
model='gemini-2.5-flash', contents='Tell me a story in 300 words.'
):
print(chunk.text, end='')
非同步串流
async for chunk in await client.aio.models.generate_content_stream(
model='gemini-2.5-flash', contents='Tell me a story in 300 words.'
):
print(chunk.text, end='')
Java
匯入 ResponseStream 和 GenerateContentResponse 模組：
import com.google.genai.ResponseStream;
import com.google.genai.types.GenerateContentResponse;
向模型提供提示並串流結果：
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());
}
如需完整實作方式，請參閱 GenerateContentAsync.java。
JavaScript
const ai = new GoogleGenAI({
vertexai: true,
project: GOOGLE_CLOUD_PROJECT,
location: GOOGLE_CLOUD_LOCATION,
});
const response = await ai.models.generateContentStream({
model: 'gemini-2.5-flash-exp',
contents:
'Generate a story about a cute baby turtle in a 3d digital art style. For each scene, generate an image.',
config: {
responseModalities: [Modality.IMAGE, Modality.TEXT],
},
});
let i = 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_${i++}.png`;
console.debug(`Writing response image to file: ${fileName}.`);
fs.writeFileSync(fileName, data);
}
}
Go
client, err := genai.NewClient(ctx, nil)
var config *genai.GenerateContentConfig = &genai.GenerateContentConfig{SystemInstruction: &genai.Content{Parts: []*genai.Part{&genai.Part{Text: "You are a story writer."}}}}
// Call the GenerateContent method.
for result, err := range client.Models.GenerateContentStream(ctx, *model, genai.Text("Tell me a story in 300 words."), config) {
if err != nil {
log.Fatal(err)
}
fmt.Print(result.Text())
}
圖像生成
圖像生成是指模型根據文字描述或其他輸入模態建立圖像的過程。使用下列程式碼，透過 Google Gen AI SDK 取代 Vertex AI SDK 的實作項目。
之前
Python
model = ImageGenerationModel.from_pretrained("imagegeneration@002")
response = model.generate_images(
prompt="Astronaut riding a horse",
# Optional:
number_of_images=1,
seed=0,
)
response[0].show()
response[0].save("image1.png")
Java
Java Vertex AI SDK 不支援圖片生成功能，但 Google Gen AI SDK 支援。
JavaScript
JavaScript Vertex AI SDK 不支援圖片生成功能，但 Google Gen AI SDK 支援。
Go
Go Vertex AI SDK 不支援圖片生成功能，但 Google Gen AI SDK 支援。
之後
Python
from google.genai import types
# Generate Image
response1 = client.models.generate_images(
model='imagen-3.0-generate-002',
prompt='An umbrella in the foreground, and a rainy night sky in the background',
config=types.GenerateImagesConfig(
number_of_images=1,
include_rai_reason=True,
output_mime_type='image/jpeg',
),
)
response1.generated_images[0].image.show()
Java
import com.google.genai.types.GenerateImagesConfig;
import com.google.genai.types.GenerateImagesResponse;
import com.google.genai.types.Image;
GenerateImagesConfig generateImagesConfig =
GenerateImagesConfig.builder()
.numberOfImages(1)
.outputMimeType("image/jpeg")
.includeSafetyAttributes(true)
.build();
GenerateImagesResponse generatedImagesResponse =
client.models.generateImages(
"imagen-3.0-generate-002", "Robot holding a red skateboard", generateImagesConfig);
Image generatedImage = generatedImagesResponse.generatedImages().get().get(0).image().get();
JavaScript
const ai = new GoogleGenAI({
vertexai: true,
project: GOOGLE_CLOUD_PROJECT,
location: GOOGLE_CLOUD_LOCATION,
});
const response = await ai.models.generateImages({
model: 'imagen-3.0-generate-002',
prompt: 'Robot holding a red skateboard',
config: {
numberOfImages: 1,
includeRaiReason: true,
},
});
console.debug(response?.generatedImages?.[0]?.image?.imageBytes);
Go
import (
"encoding/json"
"google.golang.org/genai"
)
fmt.Println("Generate image example.")
response1, err := client.Models.GenerateImages(
ctx, "imagen-3.0-generate-002",
/*prompt=*/ "An umbrella in the foreground, and a rainy night sky in the background",
&genai.GenerateImagesConfig{
IncludeRAIReason: true,
IncludeSafetyAttributes: true,
OutputMIMEType: "image/jpeg",
},
)
控制生成內容
控制生成是指引導模型輸出內容，使其符合特定限制、格式、樣式或屬性，而非生成任意形式的文字。使用下列程式碼，透過 Google Gen AI SDK 實作 Vertex AI SDK。
之前
Python
_RESPONSE_SCHEMA_STRUCT = {
"type": "object",
"properties": {
"location": {
"type": "string",
},
},
"required": ["location"],
}
response = model.generate_content(
contents="Why is sky blue? Respond in JSON Format.",
generation_config=generative_models.GenerationConfig(
...
response_schema=_RESPONSE_SCHEMA_STRUCT,
),
)
Java
import com.google.cloud.vertexai.api.Schema;
import com.google.cloud.vertexai.api.Type;
import com.google.cloud.vertexai.generativeai.ContentMaker;
import com.google.cloud.vertexai.generativeai.PartMaker;
GenerationConfig generationConfig = GenerationConfig.newBuilder()
.setResponseMimeType("application/json")
.setResponseSchema(Schema.newBuilder()
.setType(Type.ARRAY)
.setItems(Schema.newBuilder()
.setType(Type.OBJECT)
.putProperties("object", Schema.newBuilder().setType(Type.STRING).build())
.build())
.build())
.build();
GenerativeModel model = new GenerativeModel(modelName, vertexAI)
.withGenerationConfig(generationConfig);
GenerateContentResponse response = model.generateContent(
ContentMaker.fromMultiModalData(
PartMaker.fromMimeTypeAndData("image/jpeg",
"gs://cloud-samples-data/generative-ai/image/office-desk.jpeg"),
PartMaker.fromMimeTypeAndData("image/jpeg",
"gs://cloud-samples-data/generative-ai/image/gardening-tools.jpeg"),
"Generate a list of objects in the images."
)
);
JavaScript
// Initialize Vertex with your Cloud project and location
const vertex_ai = new VertexAI({project: project, location: location});
// Instantiate the model
const responseSchema = {
type: 'ARRAY',
items: {
type: 'OBJECT',
properties: {
'recipeName': {
type: 'STRING',
description: 'Name of the recipe',
nullable: false,
},
},
required: ['recipeName'],
},
};
const generativeModel = vertex_ai.getGenerativeModel({
model: 'gemini-2.5-flash',
generationConfig: {
responseSchema: responseSchema,
responseMimeType: 'application/json',
}
});
async function generateContentControlledOutput() {
const req = {
contents: [{role: 'user', parts: [{text: 'list 3 popular cookie recipe'}]}],
};
const resp = await generativeModel.generateContent(req);
console.log('aggregated response: ', JSON.stringify(resp.response));
};
generateContentControlledOutput();
Go
import (
"context"
"cloud.google.com/go/vertexai/genai"
)
model.GenerationConfig.ResponseMIMEType = "application/json"
// Build an OpenAPI schema, in memory
model.GenerationConfig.ResponseSchema = &genai.Schema{
Type: genai.TypeArray,
Items: &genai.Schema{
Type: genai.TypeArray,
Items: &genai.Schema{
Type: genai.TypeObject,
Properties: map[string]*genai.Schema{
"object": {
Type: genai.TypeString,
},
},
},
},
}
img1 := genai.FileData{
MIMEType: "image/jpeg",
FileURI: "gs://cloud-samples-data/generative-ai/image/office-desk.jpeg",
}
img2 := genai.FileData{
MIMEType: "image/jpeg",
FileURI: "gs://cloud-samples-data/generative-ai/image/gardening-tools.jpeg",
}
prompt := "Generate a list of objects in the images."
res, err := model.GenerateContent(ctx, img1, img2, genai.Text(prompt))
之後
Python
response_schema = {
"type": "ARRAY",
"items": {
"type": "OBJECT",
"properties": {
"recipe_name": {"type": "STRING"},
"ingredients": {"type": "ARRAY", "items": {"type": "STRING"}},
},
"required": ["recipe_name", "ingredients"],
},
}
prompt = """
List a few popular cookie recipes.
"""
response = client.models.generate_content(
model="gemini-2.5-flash",
contents=prompt,
config={
"response_mime_type": "application/json",
"response_schema": response_schema,
},
)
Java
匯入 Schema 和 Type 模組：
import com.google.genai.types.Schema;
import com.google.genai.types.Type;
建立回應結構定義：
Schema schema =
Schema.builder()
.type(Type.Known.ARRAY)
.items(
Schema.builder()
.type(Type.Known.OBJECT)
.properties(
ImmutableMap.of(
"recipe_name",
Schema.builder().type(Type.Known.STRING).build(),
"ingredients",
Schema.builder()
.type(Type.Known.ARRAY)
.items(Schema.builder().type(Type.Known.STRING))
.build()))
.required("recipe_name", "ingredients"))
.build();
將結構定義新增至內容設定：
GenerateContentConfig config =
GenerateContentConfig.builder()
.responseMimeType("application/json")
.candidateCount(1)
.responseSchema(schema)
.build();
使用設定生成回覆：
GenerateContentResponse response =
client.models.generateContent(
"gemini-2.5-flash", "List a few popular cookie recipes.", config);
如需完整實作方式，請參閱 GenerateContentWithResponseSchema.java。
JavaScript
const ai = new GoogleGenAI({
vertexai: true,
project: GOOGLE_CLOUD_PROJECT,
location: GOOGLE_CLOUD_LOCATION,
});
const response = await ai.models.generateContent({
model: 'gemini-2.5-flash',
contents: 'List 3 popular cookie recipes.',
config: {
responseMimeType: 'application/json',
responseSchema: {
type: Type.ARRAY,
items: {
type: Type.OBJECT,
properties: {
'recipeName': {
type: Type.STRING,
description: 'Name of the recipe',
nullable: false,
},
},
required: ['recipeName'],
},
},
},
});
console.debug(response.text);
Go
import (
"context"
"encoding/json"
genai "google.golang.org/genai"
)
cacheContents := []*genai.Content{
{
Parts: []*genai.Part{
{FileData: &genai.FileData{
FileURI: "gs://cloud-samples-data/generative-ai/pdf/2312.11805v3.pdf",
MIMEType: "application/pdf",
}},
{FileData: &genai.FileData{
FileURI: "gs://cloud-samples-data/generative-ai/pdf/2403.05530.pdf",
MIMEType: "application/pdf",
}},
},
Role: "user",
},
}
config := &genai.CreateCachedContentConfig{
Contents: cacheContents,
SystemInstruction: &genai.Content{
Parts: []*genai.Part{
{Text: systemInstruction},
},
},
DisplayName: "example-cache",
TTL: "86400s",
}
res, err := client.Caches.Create(ctx, modelName, config)
if err != nil {
return "", fmt.Errorf("failed to create content cache: %w", err)
}
cachedContent, err := json.MarshalIndent(res, "", " ")
if err != nil {
return "", fmt.Errorf("failed to marshal cache info: %w", err)
}
計算詞元數
權杖是模型處理、分析及生成文字的基本單位 (字母、字詞、片語)。如要計算或運算回覆中的權杖，請使用下列程式碼，將實作項目替換為使用 Google Gen AI SDK 的 Vertex AI SDK。
之前
Python
content = ["Why is sky blue?", "Explain it like I'm 5."]
response = model.count_tokens(content)
Java
import com.google.cloud.vertexai.api.CountTokensResponse;
CountTokensResponse response = model.countTokens(textPrompt);
int promptTokenCount = response.getTotalTokens();
int promptCharCount = response.getTotalBillableCharacters();
GenerateContentResponse contentResponse = model.generateContent(textPrompt);
int tokenCount = contentResponse.getUsageMetadata().getPromptTokenCount();
int candidateTokenCount = contentResponse.getUsageMetadata().getCandidatesTokenCount();
int totalTokenCount = contentResponse.getUsageMetadata().getTotalTokenCount();
JavaScript
const request = {
contents: [{role: 'user', parts: [{text: 'How are you doing today?'}]}],
};
const response = await generativeModel.countTokens(request);
console.log('count tokens response: ', JSON.stringify(response));
Go
package tokencount
import (
"context"
"fmt"
"cloud.google.com/go/vertexai/genai"
)
resp, err := model.CountTokens(ctx, prompt)
fmt.Fprintf(w, "Number of tokens for the prompt: %d\n", resp.TotalTokens)
resp2, err := model.GenerateContent(ctx, prompt)
fmt.Fprintf(w, "Number of tokens for the prompt: %d\n", resp2.UsageMetadata.PromptTokenCount)
fmt.Fprintf(w, "Number of tokens for the candidates: %d\n", resp2.UsageMetadata.CandidatesTokenCount)
fmt.Fprintf(w, "Total number of tokens: %d\n", resp2.UsageMetadata.TotalTokenCount)
之後
Python
計算權杖
response = client.models.count_tokens(
model='gemini-2.5-flash',
contents='why is the sky blue?',
)
print(response)
運算權杖
response = client.models.compute_tokens(
model='gemini-2.5-flash',
contents='why is the sky blue?',
)
print(response)
Java
匯入 CountTokensResponse 和 ComputeTokensResponse 模組：
import com.google.genai.types.CountTokensResponse;
import com.google.genai.types.ComputeTokensResponse;
使用 countTokens 計算提示使用的權杖數量：
CountTokensResponse response =
client.models.countTokens("gemini-2.5-flash", "What is your name?", null);
使用 computeTokens 更精細地分析提示的權杖化方式：
ComputeTokensResponse response =
client.models.computeTokens("gemini-2.5-flash", "What is your name?", null);
如要查看完整實作方式，請參閱 CountTokens.java。
JavaScript
const response = await ai.models.countTokens({
model: 'gemini-2.5-flash',
contents: 'The quick brown fox jumps over the lazy dog.',
});
Go
import (
"context"
"flag"
"fmt"
"log"
"google.golang.org/genai"
)
client, err := genai.NewClient(ctx, &genai.ClientConfig{Backend: genai.BackendVertexAI})
fmt.Println("Count tokens example.")
countTokensResult, err := client.Models.CountTokens(ctx, *model, genai.Text("What is your name?"), nil)
fmt.Println(countTokensResult.TotalTokens)