A partir de 29 de abril de 2025, os modelos Gemini 1.5 Pro e Gemini 1.5 Flash não estão disponíveis em projetos que não tenham usado estes modelos anteriormente, incluindo novos projetos. Para ver detalhes, consulte o artigo Versões e ciclo de vida dos modelos.

Esta página foi traduzida pela API Cloud Translation.

Guia de migração do SDK Vertex AI

O módulo de IA generativa no SDK Vertex AI está descontinuado e vai deixar de estar disponível após 24 de junho de 2026. O SDK de IA gen da Google contém todas as capacidades do SDK Vertex AI e suporta muitas capacidades adicionais.

Use este guia de migração para converter código Python, Java, JavaScript e Go usando o SDK Vertex AI para o SDK Google Gen AI.

Principais alterações

Os seguintes espaços de nomes no SDK Vertex AI estão na fase de descontinuação. Os lançamentos do SDK após 24 de junho de 2026 não vão incluir estes módulos. Use os espaços de nomes equivalentes do SDK de IA gen da Google, que tem paridade total de funcionalidades com os módulos e os pacotes descontinuados.

SDK Vertex AI	Código afetado	Substituição do SDK Google Gen AI
`google-cloud-aiplatform`	Módulos removidos: `vertexai.generative_models` `vertexai.language_models` `vertexai.vision_models` `vertexai.caching` `vertexai.tuning`	`google-genai`
`cloud.google.com/go/vertexai/genai`	Pacote removido: `vertex.genai`	`google.golang.org/genai`
`@google-cloud/vertexai`	Módulos removidos: `vertexai.generative_models` `vertexai.chat_session` `vertexai.functions`	`@google/genai`
`com.google.cloud:google-cloud-vertexai`	Pacote removido: `com.google.cloud.vertexai.generativeai`	`com.google.genai:google-genai`

Migração de código

Use as secções seguintes para migrar fragmentos de código específicos do SDK do Vertex AI para o SDK de IA gen da Google.

Instalação

Substitua a dependência do SDK Vertex AI pela dependência do SDK Google Gen AI.

Antes

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

Depois

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

Colocação em cache de contexto

O armazenamento em cache de contexto envolve o armazenamento e a reutilização de partes usadas frequentemente de comandos do modelo para pedidos semelhantes. Substitua a implementação do SDK Vertex AI pela dependência do SDK Google Gen AI.

Antes

Python

Importações

from google.cloud import aiplatform
import vertexai
import datetime

Criar

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),
)

Obter

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}")

Eliminar

cache_content.delete()

Atualizar

cache_content.update(ttl=datetime.timedelta(days=2))

Lista

cache_contents = vertexai.caching.CachedContent.list()

Java

O armazenamento em cache de contexto não é suportado pelo Java Vertex AI SDK, mas é suportado pelo Google Gen AI SDK.

JavaScript

O armazenamento em cache de contexto não é suportado pelo SDK Vertex AI JavaScript, mas é suportado pelo SDK Google Gen AI.

Go

Importações

package contextcaching

// [START generativeaionvertexai_gemini_create_context_cache]
import (
  "context"
  "fmt"
  "io"
  "time"

  "cloud.google.com/go/vertexai/genai"
)

Criar

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)

Obter

cachedContent, err := client.GetCachedContent(context, contentName)

Eliminar

err = client.DeleteCachedContent(context, contentName)

Atualizar

newExpireTime := cc.Expiration.ExpireTime.Add(15 * time.Minute)
ccUpdated := client.UpdateCachedContent(context, cc, &genai.CachedContentToUpdate{
        Expiration: &genai.ExpireTimeOrTTL{ExpireTime: newExpireTime},
})

Lista

iter, err := client.ListCachedContents(context, contentName)

Depois

Python

Importações

from google import genai
from google.genai.types import Content, CreateCachedContentConfig, HttpOptions, Part

Criar

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",
    ),
)

Obter

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}")

Eliminar

client.caches.delete(name=cache_name)

Atualizar

content_cache = client.caches.update(
    name=cache_name, config=UpdateCachedContentConfig(ttl="36000s")
)

Lista

cache_contents = client.caches.list(config={'page_size': 2})

Java

Importações

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;

Criar

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);

Obter

CachedContent cachedContent2 = client.caches.get(cachedContent1.name().get(), null);
System.out.println("get cached content: " + cachedContent2);

Eliminar

DeleteCachedContentResponse unused = client.caches.delete(cachedContent1.name().get(), null);
System.out.println("Deleted cached content: " + cachedContent1.name().get());

Atualizar

CachedContent cachedContentUpdate =
    client.caches.update(
        cachedContent.name().get(),
        UpdateCachedContentConfig.builder().ttl(Duration.ofMinutes(10)).build());
System.out.println("Update cached content: " + cachedContentUpdate);

Lista

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

Importações

import {GoogleGenAI, Part} from '@google/genai';

Criar

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]},
});

Obter

const getResponse = await ai.caches.get({name: cacheName});

Eliminar

await ai.caches.delete({name: cacheName});

Atualizar

const updateResponse = await ai.caches.update({
  name: cacheName,
  config: {ttl: '86400s'},
});

Lista

const listResponse = await ai.caches.list();
let i = 1;
for await (const cachedContent of listResponse) {
  console.debug(`List response ${i++}: `, JSON.stringify(cachedContent));
}

Go

Importações

import (
  "context"
  "encoding/json"
  "fmt"
  "io"

  genai "google.golang.org/genai"
)

Criar

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)

Obter

cachedContent, err := client.GetCachedContent(ctx, contentName)

Eliminar

_, err = client.Caches.Delete(ctx, result.Name, &genai.DeleteCachedContentConfig{})

Atualizar

result, err = client.Caches.Update(ctx, result.Name, &genai.UpdateCachedContentConfig{
  ExpireTime: time.Now().Add(time.Hour),
})

Lista

// 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})

Instruções de configuração e do sistema

A configuração define parâmetros que controlam o comportamento do modelo, e as instruções do sistema fornecem diretivas orientadoras para direcionar as respostas do modelo para uma personagem, um estilo ou uma tarefa específicos. Substitua as instruções de configuração e do sistema do SDK do Vertex AI pelo seguinte código que usa o SDK de IA Gen da Google.

Antes

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)},
}

Depois

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

Importar GenerateContentConfig:

import com.google.genai.types.GenerateContentConfig;

Crie a instrução do sistema:

Content systemInstruction = Content.fromParts(Part.fromText("You are a history teacher."));

Adicione as instruções do sistema à configuração de conteúdo:

GenerateContentConfig config =
  GenerateContentConfig.builder()
    ...
    .systemInstruction(systemInstruction)
    .build();

Para a implementação completa, consulte o ficheiro 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)

Incorporações

As incorporações são representações vetoriais numéricas de texto, imagens ou vídeo que captam o respetivo significado semântico ou visual e relações num espaço de alta dimensão. Substitua a implementação da incorporação do SDK Vertex AI pelo seguinte código que usa o SDK Google Gen AI.

Antes

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

As incorporações não são suportadas pelo SDK Java Vertex AI, mas são suportadas pelo SDK Google Gen AI.

JavaScript

As incorporações não são suportadas pelo SDK Vertex AI JavaScript, mas são suportadas pelo SDK Google Gen AI.

Go

As incorporações não são suportadas pelo SDK Vertex AI Go, mas são suportadas pelo SDK Google Gen AI.

Depois

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])

Chamada de funções

A chamada de funções permite que um modelo identifique quando invocar uma ferramenta ou uma API externa e, em seguida, gere dados estruturados que contenham a função e os argumentos necessários para a execução. Substitua a implementação de chamadas de funções pelo SDK da Vertex AI com o seguinte código que usa o SDK de IA generativa da Google.

Antes

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")
}

Depois

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

Use os métodos Chat ou GenerateContent para implementar a chamada de funções.

Usar Chat

Declare os métodos que se vão tornar funções chamáveis:

Method method1 =
    ChatWithFunctionCall.class.getDeclaredMethod("getCurrentWeather", String.class);
Method method2 =
    ChatWithFunctionCall.class.getDeclaredMethod("divideTwoIntegers", int.class, int.class);

Adicione os dois métodos como funções chamáveis à ferramenta na configuração de conteúdo:

GenerateContentConfig config =
    GenerateContentConfig.builder().tools(Tool.builder().functions(method1, method2)).build();

Crie uma sessão de chat com a seguinte configuração:

Chat chatSession = client.chats.create("gemini-2.5-flash", config);

GenerateContentResponse response1 =
    chatSession.sendMessage("what is the weather in San Francisco?");

Para a implementação completa, consulte o ficheiro ChatWithFunctionCall.java.

Usar GenerateContent

Declare os métodos que se vão tornar funções chamáveis:

Method method1 =
  GenerateContentWithFunctionCall.class.getMethod(
    "getCurrentWeather", String.class, String.class);
Method method2 =
  GenerateContentWithFunctionCall.class.getMethod(
    "divideTwoIntegers", Integer.class, Integer.class);

Adicione os dois métodos como funções chamáveis à ferramenta na configuração de conteúdo:

GenerateContentConfig config =
    GenerateContentConfig.builder().tools(Tool.builder().functions(method1, method2)).build();

Use generateContent com a configuração:

GenerateContentResponse response =
    client.models.generateContent(
        "gemini-2.5-flash",
        "What is the weather in Vancouver? And can you divide 10 by 0?",
        config);

Para a implementação completa, consulte o ficheiro 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)
}

Fundamentação

A fundamentação é o processo de fornecer a um modelo informações externas e específicas do domínio para melhorar a precisão, a relevância e a consistência das respostas. Substitua a implementação da fundamentação pelo SDK da Vertex AI com o seguinte código que usa o SDK de IA gen da Google.

Antes

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

A fundamentação não é suportada pelo SDK Go Vertex AI, mas é suportada pelo SDK Google Gen AI.

Depois

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

Importe o módulo Tool:

import com.google.genai.types.Tool;

Defina a ferramenta de pesquisa Google na configuração:

Tool googleSearchTool = Tool.builder().googleSearch(GoogleSearch.builder()).build();

Adicione a ferramenta à configuração de conteúdo:

GenerateContentConfig config =
    GenerateContentConfig.builder()
        ...
        .tools(googleSearchTool)
        .build();

Para a implementação completa, consulte o ficheiro 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)
}

Definições de segurança

As definições de segurança são parâmetros configuráveis que permitem aos utilizadores gerir as respostas do modelo filtrando ou bloqueando conteúdo relacionado com categorias prejudiciais específicas, como incitamento ao ódio, conteúdo sexual ou violência. Substitua a implementação das definições de segurança pelo SDK do Vertex AI com o seguinte código que usa o SDK de IA gen da Google.

Antes

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
}

Depois

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

Importe os módulos HarmBlockThreshold, HarmCategory e SafetySetting:

import com.google.genai.types.HarmBlockThreshold;
import com.google.genai.types.HarmCategory;
import com.google.genai.types.SafetySetting;

Defina as definições de segurança na configuração:

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());

Adicione as definições de segurança à configuração de conteúdo:

GenerateContentConfig config =
GenerateContentConfig.builder()
    ...
    .safetySettings(safetySettings)
    .build();

Para a implementação completa, consulte o ficheiro 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)
}

Sessões de chat

As sessões de chat são interações conversacionais em que o modelo mantém o contexto em várias fases, recordando mensagens anteriores e usando-as para informar as respostas atuais. Substitua a implementação do SDK Vertex AI pelo seguinte código que usa o SDK Google Gen AI.

Antes

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))

Depois

Python

Síncrono

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)

Assíncrono

chat = client.aio.chats.create(model='gemini-2.5-flash')
response = await chat.send_message('tell me a story')
print(response.text)

Streaming síncrono

chat = client.chats.create(model='gemini-2.5-flash')
for chunk in chat.send_message_stream('tell me a story'):
    print(chunk.text, end='')

Streaming assíncrono

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

Importe os módulos Chat e GenerateContentResponse:

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

Crie uma sessão de chat:

Chat chatSession = client.chats.create("gemini-2.5-flash");

Use GenerateContentResponse para fornecer comandos:

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());

Para a implementação completa, consulte o ficheiro 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())

Entradas multimodais

As entradas multimodais referem-se à capacidade de um modelo processar e compreender informações de tipos de dados além do texto, como imagens, áudio e vídeo. Substitua a implementação pelo SDK Vertex AI com o seguinte código que usa o SDK Google Gen AI.

Antes

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

Imagens

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)
}

Vídeo

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.
`))

Depois

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

Importe o módulo GenerateContentResponse:

import com.google.genai.types.GenerateContentResponse;

Forneça uma combinação de texto, imagem e vídeo para comandos multimodais:

Content content =
  Content.fromParts(
    Part.fromText("describe the image"),
    Part.fromUri("gs://cloud-samples-data/generative-ai/image/scones.jpg", "image/jpeg"));

Forneça o comando combinado ao modelo:

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

Para a implementação completa, consulte o ficheiro 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

Imagens

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)
}

Vídeo e áudio

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.
`))

Geração de texto

A geração de texto é o processo através do qual um modelo produz conteúdo escrito semelhante ao de um humano com base num comando específico. Substitua a implementação pelo SDK da Vertex AI com o seguinte código que usa o SDK de IA gen da Google.

Geração síncrona

Antes

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

O SDK Vertex AI e o SDK Google Gen AI só suportam a geração de texto assíncrona para 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)

Depois

Python

response = client.models.generate_content(
  model='gemini-2.5-flash', contents='Why is the sky blue?'
)
print(response.text)

Java

Importe o módulo GenerateContentResponse:

import com.google.genai.types.GenerateContentResponse;

Gerar texto com generateContent:

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

Para a implementação completa, consulte o ficheiro GenerateContent.java.

JavaScript

O SDK Vertex AI e o SDK Google Gen AI só suportam a geração de texto assíncrona para 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)

Geração assíncrona

Antes

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

Não aplicável: o Go gere tarefas simultâneas sem operações assíncronas.

Depois

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

Importe o módulo GenerateContentResponse:

import com.google.genai.types.GenerateContentResponse;

Gerar texto de forma assíncrona:

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();

Para a implementação completa, consulte o ficheiro 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

Não aplicável: o Go gere tarefas simultâneas sem operações assíncronas.

Streaming

Antes

Python

Streaming síncrono

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
  )

Streaming assíncrono

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)
    }
  }
}

Depois

Python

Streaming síncrono

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='')

Streaming assíncrono

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

Importe os módulos ResponseStream e GenerateContentResponse:

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

Forneça um comando ao modelo e transmita os resultados:

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());
}

Para a implementação completa, consulte o ficheiro 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())
}

Geração de imagens

A geração de imagens é o processo através do qual um modelo cria imagens a partir de descrições textuais ou outras modalidades de entrada. Substitua a implementação pelo SDK da Vertex AI com o seguinte código que usa o SDK de IA gen da Google.

Antes

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

A geração de imagens não é suportada pelo Java Vertex AI SDK, mas é suportada pelo Google Gen AI SDK.

JavaScript

A geração de imagens não é suportada pelo SDK Vertex AI JavaScript, mas é suportada pelo SDK Google Gen AI.

Go

A geração de imagens não é suportada pelo Go Vertex AI SDK, mas é suportada pelo Google Gen AI SDK.

Depois

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",
  },
)

Geração controlada

A geração controlada refere-se ao processo de orientar o resultado do modelo para cumprir restrições, formatos, estilos ou atributos específicos, em vez de gerar texto de forma livre. Substitua a implementação pelo SDK Vertex AI com o seguinte código que usa o SDK Google Gen AI.

Antes

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))

Depois

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

Importe os módulos Schema e Type:

import com.google.genai.types.Schema;
import com.google.genai.types.Type;

Crie o esquema de resposta:

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();

Adicione o esquema à configuração de conteúdo:

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

Gere respostas com a configuração:

GenerateContentResponse response =
client.models.generateContent(
    "gemini-2.5-flash", "List a few popular cookie recipes.", config);

Para a implementação completa, consulte o ficheiro 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)
}

Contar tokens

Os tokens são as unidades fundamentais de texto (letras, palavras, expressões) que os modelos processam, analisam e geram. Para contar ou calcular tokens numa resposta, substitua a implementação pelo SDK do Vertex AI com o seguinte código que usa o SDK de IA gen da Google.

Antes

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)

Depois

Python

Contagem de tokens

response = client.models.count_tokens(
    model='gemini-2.5-flash',
    contents='why is the sky blue?',
)
print(response)

Tokens de computação

response = client.models.compute_tokens(
    model='gemini-2.5-flash',
    contents='why is the sky blue?',
)
print(response)

Java

Importe os módulos CountTokensResponse e ComputeTokensResponse:

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

Use countTokens para contar o número de tokens usados para um comando:

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

Use computeTokens para uma análise mais detalhada de como o comando é dividido em tokens:

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

Para a implementação completa, consulte o ficheiro 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)

Guia de migração do SDK Vertex AI Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.

Principais alterações

Migração de código

Instalação

Python

Java

JavaScript

Go

Python

Java

JavaScript

Go

Colocação em cache de contexto

Python

Java

JavaScript

Go

Python

Java

JavaScript

Go

Instruções de configuração e do sistema

Python

Java

JavaScript

Go

Python

Java

JavaScript

Go

Incorporações

Python

Java

JavaScript

Go

Python

Java

JavaScript

Go

Chamada de funções

Python

Java

JavaScript

Go

Python

Java

JavaScript

Go

Fundamentação

Python

Java

JavaScript

Go

Python

Java

JavaScript

Go

Definições de segurança

Python

Java

JavaScript

Go

Python

Java

JavaScript

Go

Sessões de chat

Python

Java

JavaScript

Go

Python

Java

JavaScript

Go

Entradas multimodais

Python

Java

JavaScript

Go

Guia de migração do SDK Vertex AI