A partire dal 29 aprile 2025, i modelli Gemini 1.5 Pro e Gemini 1.5 Flash non sono disponibili nei progetti che non li hanno mai utilizzati, inclusi i nuovi progetti. Per maggiori dettagli, vedi Versioni e ciclo di vita dei modelli.

Questa pagina è stata tradotta dall'API Cloud Translation.

Guida alla migrazione dell'SDK Vertex AI

Il modulo di AI generativa nell'SDK Vertex AI è deprecato e non sarà più disponibile dopo il 24 giugno 2026. L'SDK Google Gen AI contiene tutte le funzionalità dell'SDK Vertex AI e supporta molte funzionalità aggiuntive.

Utilizza questa guida alla migrazione per convertire il codice Python, Java, JavaScript e Go utilizzando l'SDK Vertex AI nell'SDK Google Gen AI.

Modifiche principali

I seguenti spazi dei nomi nell'SDK Vertex AI sono nella fase di ritiro. Le release dell'SDK successive al 24 giugno 2026 non includeranno questi moduli. Utilizza gli spazi dei nomi equivalenti di Google Gen AI SDK, che offre la stessa parità di funzionalità dei moduli e dei pacchetti ritirati.

SDK Vertex AI	Codice interessato	Sostituzione dell'SDK Google Gen AI
`google-cloud-aiplatform`	Moduli rimossi: `vertexai.generative_models` `vertexai.language_models` `vertexai.vision_models` `vertexai.caching` `vertexai.tuning`	`google-genai`
`cloud.google.com/go/vertexai/genai`	Pacchetto rimosso: `vertex.genai`	`google.golang.org/genai`
`@google-cloud/vertexai`	Moduli rimossi: `vertexai.generative_models` `vertexai.chat_session` `vertexai.functions`	`@google/genai`
`com.google.cloud:google-cloud-vertexai`	Pacchetto rimosso: `com.google.cloud.vertexai.generativeai`	`com.google.genai:google-genai`

Migrazione del codice

Utilizza le sezioni seguenti per eseguire la migrazione di snippet di codice specifici dall'SDK Vertex AI all'SDK Google Gen AI.

Installazione

Sostituisci la dipendenza dell'SDK Vertex AI con la dipendenza dell'SDK Google Gen AI.

Prima

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

Vai

go get cloud.google.com/go/vertexai/genai

Dopo

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

Vai

go get google.golang.org/genai

Memorizzazione nella cache del contesto

La memorizzazione nella cache del contesto prevede l'archiviazione e il riutilizzo delle parti dei prompt del modello utilizzate di frequente per richieste simili. Sostituisci l'implementazione dell'SDK Vertex AI con la dipendenza dell'SDK Google Gen AI.

Prima

Python

Importazioni

from google.cloud import aiplatform
import vertexai
import datetime

Crea

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

Scarica

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

Elimina

cache_content.delete()

Aggiorna

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

Elenca

cache_contents = vertexai.caching.CachedContent.list()

Java

La memorizzazione nella cache del contesto non è supportata dall'SDK Vertex AI Java, ma è supportata dall'SDK Google Gen AI.

JavaScript

La memorizzazione nella cache del contesto non è supportata dall'SDK Vertex AI JavaScript, ma è supportata dall'SDK Google Gen AI.

Vai

Importazioni

package contextcaching

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

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

Crea

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)

Scarica

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

Elimina

err = client.DeleteCachedContent(context, contentName)

Aggiorna

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

Elenca

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

Dopo

Python

Importazioni

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

Crea

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

Scarica

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

Elimina

client.caches.delete(name=cache_name)

Aggiorna

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

Elenca

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

Java

Importazioni

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;

Crea

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

Scarica

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

Elimina

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

Aggiorna

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

Elenca

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

Importazioni

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

Crea

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

Scarica

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

Elimina

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

Aggiorna

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

Elenca

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

Vai

Importazioni

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

  genai "google.golang.org/genai"
)

Crea

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)

Scarica

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

Elimina

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

Aggiorna

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

Elenca

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

Configurazione e istruzioni di sistema

La configurazione definisce i parametri che controllano il comportamento del modello, mentre le istruzioni di sistema forniscono indicazioni guida per orientare le risposte del modello verso un ruolo, uno stile o un'attività specifici. Sostituisci la configurazione e le istruzioni di sistema dell'SDK Vertex AI con il seguente codice che utilizza l'SDK Google Gen AI.

Prima

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

Vai

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

Dopo

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

Importa GenerateContentConfig:

import com.google.genai.types.GenerateContentConfig;

Crea l'istruzione di sistema:

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

Aggiungi le istruzioni di sistema alla configurazione dei contenuti:

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

Per l'implementazione completa, vedi 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),
);

Vai

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)

Incorporamenti

Gli incorporamenti sono rappresentazioni vettoriali numeriche di testo, immagini o video che acquisiscono il loro significato e le loro relazioni semantiche o visive in uno spazio ad alta dimensione. Sostituisci l'implementazione dell'incorporamento dall'SDK Vertex AI con il seguente codice che utilizza l'SDK Google Gen AI.

Prima

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

Gli incorporamenti non sono supportati dall'SDK Vertex AI per Java, ma sono supportati dall'SDK Google Gen AI.

JavaScript

Gli incorporamenti non sono supportati dall'SDK Vertex AI JavaScript, ma sono supportati dall'SDK Google Gen AI.

Vai

Gli incorporamenti non sono supportati dall'SDK Vertex AI per Go, ma sono supportati dall'SDK Google Gen AI.

Dopo

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

Vai

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

Chiamata di funzione

La chiamata di funzione consente a un modello di identificare quando richiamare uno strumento esterno o un'API e quindi generare dati strutturati contenenti la funzione e gli argomenti necessari per l'esecuzione. Sostituisci l'implementazione della chiamata di funzione con l'SDK Vertex AI con il seguente codice che utilizza l'SDK Google Gen AI.

Prima

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

Vai

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

Dopo

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

Utilizza i metodi Chat o GenerateContent per implementare la chiamata di funzioni.

Utilizzo di Chat

Dichiara i metodi che diventeranno funzioni chiamabili:

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

Aggiungi i due metodi come funzioni richiamabili allo strumento all'interno della configurazione dei contenuti:

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

Crea una sessione di chat con la configurazione:

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

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

Per l'implementazione completa, vedi ChatWithFunctionCall.java.

Utilizzo di GenerateContent

Dichiara i metodi che diventeranno funzioni chiamabili:

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

Aggiungi i due metodi come funzioni richiamabili allo strumento all'interno della configurazione dei contenuti:

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

Utilizza generateContent con la configurazione:

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

Per l'implementazione completa, vedi 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);

Vai

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

Grounding

La fondatezza è il processo di fornitura a un modello di informazioni esterne e specifiche del dominio per migliorare l'accuratezza, la pertinenza e la coerenza delle risposte. Sostituisci l'implementazione del grounding con l'SDK Vertex AI con il seguente codice che utilizza l'SDK Google Gen AI.

Prima

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

Vai

La grounding non è supportata dall'SDK Go Vertex AI, ma è supportata dall'SDK Google Gen AI.

Dopo

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

Importa il modulo Tool:

import com.google.genai.types.Tool;

Imposta lo strumento Ricerca Google nella configurazione:

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

Aggiungi lo strumento alla configurazione dei contenuti:

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

Per l'implementazione completa, vedi 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));

Vai

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

Impostazioni di sicurezza

Le impostazioni di sicurezza sono parametri configurabili che consentono agli utenti di gestire le risposte del modello filtrando o bloccando i contenuti correlati a categorie dannose specifiche, come incitamento all'odio, contenuti di natura sessuale o violenza. Sostituisci l'implementazione delle impostazioni di sicurezza con l'SDK Vertex AI con il seguente codice che utilizza l'SDK Google Gen AI.

Prima

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

Vai

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
}

Dopo

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

Importa i moduli HarmBlockThreshold, HarmCategory e SafetySetting:

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

Imposta le impostazioni di sicurezza nella configurazione:

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

Aggiungi le impostazioni di sicurezza alla configurazione dei contenuti:

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

Per l'implementazione completa, vedi 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));

Vai

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

Sessioni di chat

Le sessioni di chat sono interazioni conversazionali in cui il modello mantiene il contesto su più turni richiamando i messaggi precedenti e utilizzandoli per definire le risposte attuali. Sostituisci l'implementazione dell'SDK Vertex AI con il seguente codice che utilizza l'SDK Google Gen AI.

Prima

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

Vai

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

Dopo

Python

Sincrono

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)

Asincrono

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

Streaming sincrono

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 asincrono

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

Importa i moduli Chat e GenerateContentResponse:

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

Creare una sessione di chat:

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

Utilizza GenerateContentResponse per fornire prompt:

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

Per l'implementazione completa, vedi 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));
}

Vai

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

Input multimodali

Gli input multimodali si riferiscono alla capacità di un modello di elaborare e comprendere informazioni da tipi di dati diversi dal testo, come immagini, audio e video. Sostituisci l'implementazione con l'SDK Vertex AI con il seguente codice che utilizza l'SDK Google Gen AI.

Prima

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

Vai

Immagini

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

Video

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

Dopo

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

Importa il modulo GenerateContentResponse:

import com.google.genai.types.GenerateContentResponse;

Fornisci una combinazione di testo, immagini e video per i prompt multimodali:

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

Fornisci il prompt combinato al modello:

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

Per l'implementazione completa, vedi 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);
  }
}

Vai

Immagini

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

Video e audio

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

Generazione di testo

La generazione di testo è il processo mediante il quale un modello produce contenuti scritti simili a quelli umani in base a un prompt specificato. Sostituisci l'implementazione con l'SDK Vertex AI con il seguente codice che utilizza l'SDK Google Gen AI.

Generazione sincrona

Prima

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

Sia l'SDK Vertex AI sia Google Gen AI SDK supportano solo la generazione di testo asincrona per JavaScript.

Vai

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)

Dopo

Python

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

Java

Importa il modulo GenerateContentResponse:

import com.google.genai.types.GenerateContentResponse;

Genera testo con generateContent:

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

Per l'implementazione completa, vedi GenerateContent.java.

JavaScript

Sia l'SDK Vertex AI sia Google Gen AI SDK supportano solo la generazione di testo asincrona per JavaScript.

Vai

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)

Generazione asincrona

Prima

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

Vai

Non applicabile: Go gestisce le attività simultanee senza operazioni asincrone.

Dopo

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

Importa il modulo GenerateContentResponse:

import com.google.genai.types.GenerateContentResponse;

Genera testo in modo asincrono:

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

Per l'implementazione completa, vedi 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);

Vai

Non applicabile: Go gestisce le attività simultanee senza operazioni asincrone.

Streaming

Prima

Python

Streaming sincrono

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 asincrono

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

Vai

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

Dopo

Python

Streaming sincrono

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 asincrono

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

Importa i moduli ResponseStream e GenerateContentResponse:

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

Fornisci un prompt al modello e trasmetti in streaming i risultati:

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

Per l'implementazione completa, vedi 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);
  }
}

Vai

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

Generazione di immagini

La generazione di immagini è il processo mediante il quale un modello crea immagini da descrizioni testuali o altre modalità di input. Sostituisci l'implementazione con l'SDK Vertex AI con il seguente codice che utilizza l'SDK Google Gen AI.

Prima

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

La generazione di immagini non è supportata dall'SDK Vertex AI per Java, ma è supportata dall'SDK Google Gen AI.

JavaScript

La generazione di immagini non è supportata dall'SDK Vertex AI JavaScript, ma è supportata dall'SDK Google Gen AI.

Vai

La generazione di immagini non è supportata dall'SDK Go Vertex AI, ma è supportata dall'SDK Google Gen AI.

Dopo

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

Vai

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

Generazione controllata

La generazione controllata si riferisce al processo di guida dell'output del modello in modo che rispetti vincoli, formati, stili o attributi specifici, anziché generare testo in formato libero. Sostituisci l'implementazione con l'SDK Vertex AI con il seguente codice che utilizza l'SDK Google Gen AI.

Prima

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

Vai

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

Dopo

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

Importa i moduli Schema e Type:

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

Crea lo schema della risposta:

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

Aggiungi lo schema alla configurazione dei contenuti:

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

Genera risposte con la configurazione:

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

Per l'implementazione completa, vedi 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);

Vai

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

Conteggio dei token

I token sono le unità fondamentali di testo (lettere, parole, frasi) che i modelli elaborano, analizzano e generano. Per conteggiare o calcolare i token in una risposta, sostituisci l'implementazione con l'SDK Vertex AI con il seguente codice che utilizza l'SDK Google Gen AI.

Prima

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

Vai

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)

Dopo

Python

Conteggio token

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

Token di computing

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

Java

Importa i moduli CountTokensResponse e ComputeTokensResponse:

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

Utilizza countTokens per contare il numero di token utilizzati per un prompt:

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

Utilizza computeTokens per un'analisi più granulare di come viene suddiviso in token il prompt:

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

Per l'implementazione completa, consulta CountTokens.java.

JavaScript

const response = await ai.models.countTokens({
  model: 'gemini-2.5-flash',
  contents: 'The quick brown fox jumps over the lazy dog.',
});

Vai

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)

Guida alla migrazione dell'SDK Vertex AI Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.

Modifiche principali

Migrazione del codice

Installazione

Python

Java

JavaScript

Vai

Python

Java

JavaScript

Vai

Memorizzazione nella cache del contesto

Python

Java

JavaScript

Vai

Python

Java

JavaScript

Vai

Configurazione e istruzioni di sistema

Python

Java

JavaScript

Vai

Python

Java

JavaScript

Vai

Incorporamenti

Python

Java

JavaScript

Vai

Python

Java

JavaScript

Vai

Chiamata di funzione

Python

Java

JavaScript

Vai

Python

Java

JavaScript

Vai

Grounding

Python

Java

JavaScript

Vai

Python

Java

JavaScript

Vai

Impostazioni di sicurezza

Python

Java

JavaScript

Vai

Python

Java

JavaScript

Vai

Sessioni di chat

Python

Java

JavaScript

Vai

Python

Java

JavaScript

Vai

Input multimodali

Python

Java

JavaScript

Vai

Guida alla migrazione dell'SDK Vertex AI