Genera contenuti con l'API Gemini

Usa generateContent o streamGenerateContent per generare contenuti con Gemini.

La famiglia di modelli Gemini include modelli che funzionano con richieste di prompt multimodali. Il termine multimodale indica che puoi utilizzare più di una modalità o tipo di input in un prompt. I modelli che non sono multimodali accettano solo richieste di testo. Le modalità possono includere testo, audio, video e altro ancora.

Per iniziare, crea un account Google Cloud

Per iniziare a utilizzare l'API Vertex AI per Gemini, crea un account Google Cloud.

Dopo aver creato il tuo account, utilizza questo documento per esaminare il corpo della richiesta del modello Gemini, i parametri del modello, il corpo della risposta e alcune richieste di esempio.

Quando è tutto pronto, consulta la guida rapida dell'API Vertex AI per Gemini per scoprire come inviare una richiesta all'API Gemini di Vertex AI utilizzando un SDK per il linguaggio di programmazione o l'API REST.

Modelli supportati

Modello	Versione
Gemini 1.5 Flash	gemini-1.5-flash-001
Gemini 1.5 Pro	gemini-1.5-pro-001
Gemini 1.0 Pro Vision	gemini-1.0-pro-001 gemini-1.0-pro-vision-001
Gemini 1.0 Pro	gemini-1.0-pro gemini-1.0-pro-001 gemini-1.0-pro-002

Nota: l'aggiunta di molte immagini a una richiesta aumenta la latenza di risposta.

Sintassi di esempio

Sintassi per generare una risposta del modello.

Non in streaming

curl

curl -X POST \
  -H "Authorization: Bearer $(gcloud auth print-access-token)" \
  -H "Content-Type: application/json" \

https://${LOCATION}-aiplatform.googleapis.com/v1/projects/${PROJECT_ID}/locations/${LOCATION}/publishers/google/models/${MODEL_ID}:generateContent \
-d '{
  "contents": [{
    ...
  }],
  "generation_config": {
    ...
  },
  "safety_settings": {
    ...
  }
  ...
}'

Python

gemini_model = GenerativeModel(MODEL_ID)
generation_config = GenerationConfig(...)

model_response = gemini_model.generate_content([...], generation_config, safety_settings={...})

Dispositivi di streaming

curl

curl -X POST \
  -H "Authorization: Bearer $(gcloud auth print-access-token)" \
  -H "Content-Type: application/json" \
  https://${LOCATION}-aiplatform.googleapis.com/v1/projects/${PROJECT_ID}/locations/${LOCATION}/publishers/google/models/${MODEL_ID}:streamGenerateContent \
  -d '{
    "contents": [{
      ...
    }],
    "generation_config": {
      ...
    },
    "safety_settings": {
      ...
    }
    ...
  }'

Python

gemini_model = GenerativeModel(MODEL_ID)
model_response = gemini_model.generate_content([...], generation_config, safety_settings={...}, stream=True)

Elenco dei parametri

Consulta gli esempi per i dettagli dell'implementazione.

Corpo della richiesta

{
  "contents": [
    {
      "role": string,
      "parts": [
        {
          // Union field data can be only one of the following:
          "text": string,
          "inlineData": {
            "mimeType": string,
            "data": string
          },
          "fileData": {
            "mimeType": string,
            "fileUri": string
          },
          // End of list of possible types for union field data.

          "videoMetadata": {
            "startOffset": {
              "seconds": integer,
              "nanos": integer
            },
            "endOffset": {
              "seconds": integer,
              "nanos": integer
            }
          }
        }
      ]
    }
  ],
  "systemInstruction": {
    "role": string,
    "parts": [
      {
        "text": string
      }
    ]
  },
  "tools": [
    {
      "functionDeclarations": [
        {
          "name": string,
          "description": string,
          "parameters": {
            object (OpenAPI Object Schema)
          }
        }
      ]
    }
  ],
  "safetySettings": [
    {
      "category": enum (HarmCategory),
      "threshold": enum (HarmBlockThreshold)
    }
  ],
  "generationConfig": {
    "temperature": number,
    "topP": number,
    "topK": number,
    "candidateCount": integer,
    "maxOutputTokens": integer,
    "presencePenalty": float,
    "frequencyPenalty": float,
    "stopSequences": [
      string
    ],
    "responseMimeType": string
  }
}

Il corpo della richiesta contiene dati con i seguenti parametri:

Parametri
contents	Obbligatorio: Content I contenuti della conversazione corrente con il modello. Per le query a turno singolo, si tratta di una singola istanza. Per le query in più passaggi, si tratta di un campo ripetuto che contiene la cronologia delle conversazioni e l'ultima richiesta.
system_instruction	Facoltativo: Content Disponibile per gemini-1.5-pro e gemini-1.0-pro-002. Istruzioni per il modello per guidarlo verso un rendimento migliore. Ad esempio, "Rispondi nel modo più conciso possibile" o "Non utilizzare termini tecnici nella risposta". Le stringhe text vengono conteggiate ai fini del limite di token. Il campo role di systemInstruction viene ignorato e non influisce sulle prestazioni del modello. Nota: in parts deve essere utilizzato solo text, mentre i contenuti di ogni part devono essere in un paragrafo separato.
tools	Facoltativo. Una porzione di codice che consente al sistema di interagire con sistemi esterni per eseguire un'azione o un insieme di azioni al di fuori delle conoscenze e dell'ambito del modello. Vedi Chiamate di funzione.
tool_config	Facoltativo. Vedi Chiamate di funzione.
safety_settings	Facoltativo: SafetySetting Impostazioni su richiesta per il blocco di contenuti non sicuri. Data applicazione: GenerateContentResponse.candidates.
generation_config	Facoltativo: GenerationConfig Impostazioni di configurazione della generazione.
cached_content	Facoltativo: CachedContent Contenuti memorizzati nella cache. Puoi utilizzare i contenuti memorizzati nella cache nelle richieste che includono contenuti ripetuti.

contents

Il tipo di dati strutturati di base che include i contenuti in più parti di un messaggio.

Questa classe è composta da due proprietà principali: role e parts. La proprietà role indica la persona che ha prodotto i contenuti, mentre la proprietà parts contiene più elementi, ognuno dei quali rappresenta un segmento di dati all'interno di un messaggio.

Parametri
role	Facoltativo: string L'identità dell'entità che crea il messaggio. Sono supportati i seguenti valori: user: indica che il messaggio è stato inviato da una persona reale, di solito un messaggio generato dall'utente. model: indica che il messaggio è generato dal modello. Il valore model viene utilizzato per inserire messaggi dal modello nella conversazione durante le conversazioni in più passaggi. Per le conversazioni che non prevedono più passaggi, questo campo può essere lasciato vuoto o non essere impostato.
parts	Part Un elenco di parti ordinate che compongono un singolo messaggio. Parti diverse possono avere tipi MIME IANA diversi. Per i limiti degli input, come il numero massimo di token o il numero di immagini, consulta le specifiche del modello nella pagina Modelli Google. Per calcolare il numero di token nella richiesta, consulta Recuperare il conteggio dei token.

parts

Un tipo di dati contenente contenuti multimediali che fanno parte di un messaggio Content in più parti.

Parametri
text	Facoltativo: string Un prompt di testo o uno snippet di codice.
inline_data	Facoltativo: Blob Dati incorporati in byte non elaborati. Per gemini-1.0-pro-vision, puoi specificare al massimo un'immagine mediante inlineData.Per specificare fino a 16 immagini, utilizza file_data.
file_data	Facoltativo: fileData Dati archiviati in un file.
function_call	Facoltativo: FunctionCall. Contiene una stringa che rappresenta il campo FunctionDeclaration.name e un oggetto JSON strutturato contenente eventuali parametri per la chiamata di funzione prevista dal modello. Vedi Chiamate di funzione.
function_response	Facoltativo: FunctionResponse. L'output del risultato di un FunctionCall contenente una stringa che rappresenta il campo FunctionDeclaration.name e un oggetto JSON strutturato contenente qualsiasi output della chiamata di funzione. Viene utilizzato come contesto del modello. Vedi Chiamate di funzione.
video_metadata	Facoltativo: VideoMetadata Per l'input video, gli offset di inizio e fine del video nel formato Durata. Ad esempio, per specificare un clip di 10 secondi che inizia alle 1:00, imposta "start_offset": { "seconds": 60 } e "end_offset": { "seconds": 70 }. È necessario specificare i metadati solo mentre i dati del video sono presentati in inline_data o file_data.

blob

Blob di contenuti. Se possibile, invia come testo anziché byte non elaborati.

Parametri
mime_type	string Il tipo di supporto del file specificato nei campi data o fileUri. I valori accettati sono: Fai clic per espandere i tipi MIME application/pdf audio/mpeg audio/mp3 audio/wav image/png image/jpeg text/plain video/mov video/mpeg video/mp4 video/mpg video/avi video/wmv video/mpegps video/flv Per gemini-1.0-pro-vision, la durata massima del video è 2 minuti. Per Gemini 1.5 Pro e Gemini 1.5 Flash, la durata massima di un file audio è 8,4 ore, mentre la durata massima di un file video (senza audio) è un'ora. Per maggiori informazioni, vedi Requisiti per i contenuti multimediali di Gemini 1.5 Pro. I file di testo devono avere codifica UTF-8. I contenuti del file di testo vengono conteggiati ai fini del limite di token. Non esiste un limite alla risoluzione delle immagini.
data	bytes La codifica base64 dell'immagine, del PDF o del video da includere in linea nel prompt. Quando vengono inclusi elementi multimediali in linea, devi specificare anche il tipo di elemento multimediale (mimeType) dei dati. Dimensioni massime: 20 MB

CachedContent

Utilizzato per l'aggiornamento quando scade una cache di contesto. Devi specificare ttl o expire_time quando aggiorni CachedContent, ma non puoi specificare entrambi. Per maggiori informazioni, consulta Utilizzare la memorizzazione nella cache di contesto.

Parametri
ttl	TTL Utilizzato per specificare il numero di secondi e nanosecondi dopo la creazione o l'aggiornamento di una cache di contesto che risiede prima della scadenza.
expire_time	Timestamp Un timestamp che specifica quando scade una cache di contesto.

TTL

La durata, o durata, dopo la creazione o l'aggiornamento di una cache contestuale prima che scada.

Parametri
seconds	float Il componente secondi della durata prima della scadenza di una cache di contesto dopo la creazione. Il valore predefinito è 3600 secondi.
nano	Facoltativo: float Il componente in nanosecondi della durata prima della scadenza di una cache di contesto dopo la creazione.

FileData

dati basati su URI.

Parametri
mime_type	string Tipo MIME IANA dei dati.
file_uri	string L'URI Cloud Storage del file da includere nel prompt. L'oggetto del bucket deve essere leggibile pubblicamente o risiedere nello stesso progetto Google Cloud che invia la richiesta. Devi anche specificare il tipo di supporto (mimeType) del file. Per gemini-1.5-pro e gemini-1.5-flash, il limite di dimensioni è 2 GB. Per gemini-1.0-pro-vision, il limite di dimensioni è 20 MB.

functionCall

Un valore functionCall previsto restituito dal modello che contiene una stringa che rappresenta functionDeclaration.name e un oggetto JSON strutturato contenente i parametri e i relativi valori.

Parametri
name	string Il nome della funzione da chiamare.
args	Struct I parametri e i valori della funzione in formato oggetto JSON. Per i dettagli dei parametri, consulta Chiamate di funzione.

functionResponse

L'output risultante da un FunctionCall che contiene una stringa che rappresenta FunctionDeclaration.name. Contiene anche un oggetto JSON strutturato con l'output della funzione (e lo utilizza come contesto per il modello). Dovrebbe contenere il risultato di un valore FunctionCall realizzato in base alla previsione del modello.

Parametri
name	string Il nome della funzione da chiamare.
response	Struct La risposta della funzione in formato oggetto JSON.

videoMetadata

Metadati che descrivono i contenuti video di input.

Parametri
start_offset	Facoltativo: google.protobuf.Duration L'offset iniziale del video.
end_offset	Facoltativo: google.protobuf.Duration L'offset finale del video.

safetySetting

Impostazioni di sicurezza.

Parametri
category	Facoltativo: HarmCategory La categoria di sicurezza per cui configurare una soglia. I valori accettabili includono: Fai clic per espandere le categorie di sicurezza HARM_CATEGORY_SEXUALLY_EXPLICIT HARM_CATEGORY_HATE_SPEECH HARM_CATEGORY_HARASSMENT HARM_CATEGORY_DANGEROUS_CONTENT
threshold	Facoltativo: HarmBlockThreshold La soglia per il blocco delle risposte che potrebbero appartenere alla categoria di sicurezza specificata in base alla probabilità. BLOCK_NONE BLOCK_LOW_AND_ABOVE BLOCK_MED_AND_ABOVE BLOCK_ONLY_HIGH
max_influential_terms	Facoltativo: int Il numero massimo di termini influenti che contribuiscono maggiormente ai punteggi di sicurezza, che potrebbero causare potenziali blocchi.
method	Facoltativo: HarmBlockMethod Specifica se la soglia viene utilizzata per il punteggio di probabilità o gravità. Se non specificata, la soglia viene utilizzata per il punteggio di probabilità.

harmCategory

Categorie HR che bloccano i contenuti.

Parametri
HARM_CATEGORY_UNSPECIFIED	La categoria dei contenuti dannosi non è specificata.
HARM_CATEGORY_HATE_SPEECH	La categoria di contenuti dannosi è l'incitamento all'odio.
HARM_CATEGORY_DANGEROUS_CONTENT	La categoria di contenuti dannosi include contenuti pericolosi.
HARM_CATEGORY_HARASSMENT	La categoria dei contenuti dannosi è molestie.
HARM_CATEGORY_SEXUALLY_EXPLICIT	La categoria di contenuti dannosi è costituita da contenuti sessualmente espliciti.

harmBlockThreshold

Livelli delle soglie di probabilità utilizzate per bloccare una risposta.

Parametri
HARM_BLOCK_THRESHOLD_UNSPECIFIED	Soglia di blocco dei danni non specificata.
BLOCK_LOW_AND_ABOVE	Blocca una soglia bassa e più alta (ad esempio, blocca un numero maggiore).
BLOCK_MEDIUM_AND_ABOVE	Blocca soglia media e superiore.
BLOCK_ONLY_HIGH	Blocca solo la soglia alta (ad esempio, blocca meno).
BLOCK_NONE	Nessun blocco.

harmBlockMethod

Una soglia di probabilità che blocca una risposta in base a una combinazione di probabilità e gravità.

Parametri
HARM_BLOCK_METHOD_UNSPECIFIED	Il metodo di blocco dei danni non è specificato.
SEVERITY	Il metodo di blocco dei danni utilizza punteggi sia di probabilità che di gravità.
PROBABILITY	Il metodo di blocco dei danni utilizza il punteggio di probabilità.

generationConfig

Impostazioni di configurazione utilizzate durante la generazione della richiesta.

Parametri
temperature	Facoltativo: float La temperatura viene utilizzata per il campionamento durante la generazione della risposta, che si verifica quando vengono applicati topP e topK. La temperatura controlla il grado di casualità nella selezione dei token. Le temperature più basse sono ideali per prompt che richiedono una risposta meno aperta o creativa, mentre le temperature più alte possono portare a risultati più diversificati o creativi. Una temperatura pari a 0 significa che vengono sempre selezionati i token con la probabilità più alta. In questo caso, le risposte a una determinata richiesta sono per lo più deterministiche, ma è comunque possibile una piccola variazione. Se il modello restituisce una risposta troppo generica, troppo breve o fornisce una risposta di riserva, prova ad aumentare la temperatura. Intervallo per gemini-1.5-pro: 0.0 - 2.0 (valore predefinito: 1.0) Intervallo per gemini-1.0-pro-vision: 0.0 - 1.0 (valore predefinito: 0.4) Intervallo per gemini-1.0-pro-002: 0.0 - 2.0 (valore predefinito: 1.0) Intervallo per gemini-1.0-pro-001: 0.0 - 1.0 (valore predefinito: 0.9)
top_p	Facoltativo: float Se specificato, viene utilizzato il campionamento del nucleo. Top-P cambia il modo in cui il modello seleziona i token per l'output. I token vengono selezionati dal più probabile (vedi top-K) al meno probabile finché la somma delle probabilità non raggiunge il valore di top-P. Ad esempio, se i token A, B e C hanno una probabilità di 0,3, 0,2 e 0,1 e il valore di top-P è 0.5, il modello seleziona A o B come token successivo utilizzando la temperatura ed esclude C come candidato. Specifica un valore più basso per risposte meno casuali e un valore più alto per risposte più casuali. Intervallo: 0.0 - 1.0 gemini-1.5-pro: 0.94 Impostazione predefinita per gemini-1.0-pro: 1 Impostazione predefinita per gemini-1.0-pro-vision: 1
top_k	(Facoltativo) Top-K cambia il modo in cui il modello seleziona i token per l'output. Un top-K di 1 indica che il token successivo selezionato è il più probabile tra tutti i token nel vocabolario del modello (chiamato anche decodifica greedy), mentre un valore top-K pari a 3 indica che il token successivo viene selezionato tra i tre token più probabili utilizzando la temperatura. Per ogni fase di selezione dei token, vengono campionati i token top-K con le probabilità più alte. Quindi i token vengono ulteriormente filtrati in base a top-P e il token finale viene selezionato utilizzando il campionamento con temperatura. Specifica un valore più basso per risposte meno casuali e un valore più alto per risposte più casuali. Intervallo: 1-40 gemini-1.0-pro e gemini-1.5-pro non supportano topK Impostazione predefinita per gemini-1.0-pro-vision: 32
candidate_count	Facoltativo: int Il numero di varianti della risposta da restituire. Questo valore deve essere 1.
max_output_tokens	Facoltativo: int Numero massimo di token che possono essere generati nella risposta. Un token equivale a circa quattro caratteri. 100 token corrispondono a circa 60-80 parole. Specifica un valore più basso per risposte più brevi e un valore più alto per risposte potenzialmente più lunghe.
stop_sequences	Facoltativo: List[string] Specifica un elenco di stringhe che indica al modello di interrompere la generazione di testo se viene rilevata una delle stringhe nella risposta. Se una stringa appare più volte nella risposta, la risposta viene troncata nel punto in cui viene rilevata per la prima volta. Le stringhe sono sensibili alle maiuscole. Ad esempio, se la seguente è la risposta restituita quando stopSequences non è specificato: public static string reverse(string myString) La risposta restituita con stopSequences impostato su ["Str", "reverse"] è: public static string Massimo 5 elementi nell'elenco.
presence_penalty	Facoltativo: float Sanzioni positive. I valori positivi penalizzano i token già presenti nel testo generato, aumentando la probabilità di generare contenuti più diversificati. Il valore massimo per presencePenalty è fino a 2.0 (escluso). Il suo valore minimo è -2.0.
frequency_penalty	Facoltativo: float I valori positivi penalizzano i token che appaiono ripetutamente nel testo generato, diminuendo la probabilità di contenuti ripetuti. Questo valore massimo per frequencyPenalty è fino a 2.0, escluso. Il suo valore minimo è -2.0.
response_mime_type	Facoltativo: string (enum) Disponibile per gemini-1.5-pro Tipo MIME della risposta di output del testo candidato generato. Tipi MIME supportati: text/plain: (predefinito) output di testo. application/json: risposta JSON nei candidati. Al modello deve essere richiesto di inviare il tipo di risposta appropriato, altrimenti il comportamento non è definito. Questa è una funzionalità in anteprima.

Corpo della risposta

{
  "candidates": [
    {
      "content": {
        "parts": [
          {
            "text": string
          }
        ]
      },
      "finishReason": enum (FinishReason),
      "safetyRatings": [
        {
          "category": enum (HarmCategory),
          "probability": enum (HarmProbability),
          "blocked": boolean
        }
      ],
      "citationMetadata": {
        "citations": [
          {
            "startIndex": integer,
            "endIndex": integer,
            "uri": string,
            "title": string,
            "license": string,
            "publicationDate": {
              "year": integer,
              "month": integer,
              "day": integer
            }
          }
        ]
      }
    }
  ],
  "usageMetadata": {
    "promptTokenCount": integer,
    "candidatesTokenCount": integer,
    "totalTokenCount": integer
  }
}

Elemento risposta	Descrizione
text	Il testo generato.
finishReason	Il motivo per cui il modello ha smesso di generare token. Se vuoto, il modello non ha smesso di generare i token. Poiché la risposta utilizza il prompt per contesto, non è possibile modificare il comportamento del modo in cui il modello interrompe la generazione di token. FINISH_REASON_UNSPECIFIED Il motivo del completamento non è specificato. FINISH_REASON_STOP Punto di interruzione naturale del modello o sequenza di interruzione fornita. FINISH_REASON_MAX_TOKENS È stato raggiunto il numero massimo di token specificato nella richiesta. FINISH_REASON_SAFETY La generazione del token è stata interrotta perché la risposta è stata segnalata per motivi di sicurezza. Tieni presente che Candidate.content è vuoto se i filtri dei contenuti bloccano l'output. FINISH_REASON_RECITATION La generazione del token è stata interrotta perché la risposta è stata segnalata per citazioni non autorizzate. FINISH_REASON_OTHER Tutti gli altri motivi che hanno interrotto il token
category	La categoria di sicurezza per cui configurare una soglia. I valori accettati sono: Fai clic per espandere le categorie di sicurezza HARM_CATEGORY_SEXUALLY_EXPLICIT HARM_CATEGORY_HATE_SPEECH HARM_CATEGORY_HARASSMENT HARM_CATEGORY_DANGEROUS_CONTENT
probability	I livelli di probabilità di danno nei contenuti. HARM_PROBABILITY_UNSPECIFIED NEGLIGIBLE LOW MEDIUM HIGH
blocked	Un flag booleano associato a un attributo di sicurezza che indica se l'input o l'output del modello è stato bloccato.
startIndex	Un numero intero che specifica dove inizia una citazione in content.
endIndex	Un numero intero che specifica il punto in cui termina una citazione in content.
url	L'URL della fonte della citazione. Esempi di fonti URL possono essere un sito web di notizie o un repository GitHub.
title	Il titolo della fonte di una citazione. Esempi di titoli di fonti potrebbero essere quelli di un articolo o di un libro.
license	La licenza associata a una citazione.
publicationDate	La data di pubblicazione di una citazione. I formati validi sono YYYY, YYYY-MM e YYYY-MM-DD.
promptTokenCount	Numero di token nella richiesta.
candidatesTokenCount	Numero di token nelle risposte.
totalTokenCount	Numero di token nella richiesta e nelle risposte.

Esempi

Risposta testuale non in streaming

Genera una risposta del modello non in modalità flusso da un input di testo.

REST

Prima di utilizzare i dati della richiesta, effettua le seguenti sostituzioni:

• PROJECT_ID: il tuo ID progetto.
• LOCATION: la regione in cui elaborare la richiesta.
• TEXT: le istruzioni testuali da includere nel prompt.

Metodo HTTP e URL:

POST https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/publishers/google/models/MODEL_ID:generateContent

Corpo JSON della richiesta:

{
  "contents": [{
    "role": "user",
    "parts": [{
      "text": "TEXT"
    }]
  }]
}'

Per inviare la richiesta, scegli una delle seguenti opzioni:

curl

Nota: il comando seguente presuppone che tu abbia eseguito l'accesso all'interfaccia a riga di comando gcloud con il tuo account utente eseguendo gcloud init o gcloud auth login oppure utilizzando Cloud Shell, che ti fa accedere automaticamente all'interfaccia a riga di comando di gcloud. . Puoi controllare l'account attualmente attivo eseguendo gcloud auth list.

Salva il corpo della richiesta in un file denominato request.json ed esegui questo comando:

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/publishers/google/models/MODEL_ID:generateContent"

PowerShell

Nota: il comando seguente presuppone che tu abbia eseguito l'accesso all'interfaccia a riga di comando di gcloud con il tuo account utente eseguendo gcloud init o gcloud auth login . Puoi controllare l'account attualmente attivo eseguendo gcloud auth list.

Salva il corpo della richiesta in un file denominato request.json ed esegui questo comando:

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/publishers/google/models/MODEL_ID:generateContent" | Select-Object -Expand Content

Python

import vertexai
from vertexai.generative_models import GenerativeModel

# TODO(developer): Update and un-comment below line
# project_id = "PROJECT_ID"

vertexai.init(project=project_id, location="us-central1")

model = GenerativeModel(model_name="gemini-1.5-flash-001")

response = model.generate_content(
    "What's a good name for a flower shop that specializes in selling bouquets of dried flowers?"
)

print(response.text)

NodeJS

const {VertexAI} = require('@google-cloud/vertexai');

/**
 * TODO(developer): Update these variables before running the sample.
 */
async function generate_from_text_input(projectId = 'PROJECT_ID') {
  const vertexAI = new VertexAI({project: projectId, location: 'us-central1'});

  const generativeModel = vertexAI.getGenerativeModel({
    model: 'gemini-1.5-flash-001',
  });

  const prompt =
    "What's a good name for a flower shop that specializes in selling bouquets of dried flowers?";

  const resp = await generativeModel.generateContent(prompt);
  const contentResponse = await resp.response;
  console.log(JSON.stringify(contentResponse));
}

Java

import com.google.cloud.vertexai.VertexAI;
import com.google.cloud.vertexai.api.GenerateContentResponse;
import com.google.cloud.vertexai.generativeai.GenerativeModel;
import com.google.cloud.vertexai.generativeai.ResponseHandler;

public class QuestionAnswer {

  public static void main(String[] args) throws Exception {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "your-google-cloud-project-id";
    String location = "us-central1";
    String modelName = "gemini-1.5-flash-001";

    String output = simpleQuestion(projectId, location, modelName);
    System.out.println(output);
  }

  // Asks a question to the specified Vertex AI Gemini model and returns the generated answer.
  public static String simpleQuestion(String projectId, String location, String modelName)
      throws Exception {
    // Initialize client that will be used to send requests.
    // This client only needs to be created once, and can be reused for multiple requests.
    try (VertexAI vertexAI = new VertexAI(projectId, location)) {
      String output;
      GenerativeModel model = new GenerativeModel(modelName, vertexAI);
      // Send the question to the model for processing.
      GenerateContentResponse response = model.generateContent("Why is the sky blue?");
      // Extract the generated text from the model's response.
      output = ResponseHandler.getText(response);
      return output;
    }
  }
}

Go

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

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

func generateContentFromText(w io.Writer, projectID string) error {
	location := "us-central1"
	modelName := "gemini-1.5-flash-001"

	ctx := context.Background()
	client, err := genai.NewClient(ctx, projectID, location)
	if err != nil {
		return fmt.Errorf("error creating client: %w", err)
	}
	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)
	if err != nil {
		return fmt.Errorf("error generating content: %w", err)
	}
	// See the JSON response in
	// https://pkg.go.dev/cloud.google.com/go/vertexai/genai#GenerateContentResponse.
	rb, err := json.MarshalIndent(resp, "", "  ")
	if err != nil {
		return fmt.Errorf("json.MarshalIndent: %w", err)
	}
	fmt.Fprintln(w, string(rb))
	return nil
}

C#

using Google.Cloud.AIPlatform.V1;
using System;
using System.Threading.Tasks;

public class TextInputSample
{
    public async Task<string> TextInput(
        string projectId = "your-project-id",
        string location = "us-central1",
        string publisher = "google",
        string model = "gemini-1.5-flash-001")
    {

        var predictionServiceClient = new PredictionServiceClientBuilder
        {
            Endpoint = $"{location}-aiplatform.googleapis.com"
        }.Build();
        string prompt = @"What's a good name for a flower shop that specializes in selling bouquets of dried flowers?";

        var generateContentRequest = new GenerateContentRequest
        {
            Model = $"projects/{projectId}/locations/{location}/publishers/{publisher}/models/{model}",
            Contents =
            {
                new Content
                {
                    Role = "USER",
                    Parts =
                    {
                        new Part { Text = prompt }
                    }
                }
            }
        };

        GenerateContentResponse response = await predictionServiceClient.GenerateContentAsync(generateContentRequest);

        string responseText = response.Candidates[0].Content.Parts[0].Text;
        Console.WriteLine(responseText);

        return responseText;
    }
}

REST (OpenAI)

Puoi chiamare l'API Inference utilizzando la libreria OpenAI. Per maggiori informazioni, vedi Chiamare Gemini utilizzando la libreria OpenAI.

Prima di utilizzare i dati della richiesta, effettua le seguenti sostituzioni:

• PROJECT_ID: il tuo ID progetto.
• LOCATION: la regione in cui elaborare la richiesta.
• MODEL_ID: il nome del modello da utilizzare.

Metodo HTTP e URL:

POST https://LOCATION-aiplatform.googleapis.com/v1beta1/projects/PROJECT_ID/locations/LOCATION/endpoints/openapi/chat/completions

Corpo JSON della richiesta:

{
  "model": "google/MODEL_ID",
  "messages": [{
    "role": "user",
    "content": "Write a story about a magic backpack."
  }]
}

Per inviare la richiesta, scegli una delle seguenti opzioni:

curl

Nota: il comando seguente presuppone che tu abbia eseguito l'accesso all'interfaccia a riga di comando gcloud con il tuo account utente eseguendo gcloud init o gcloud auth login oppure utilizzando Cloud Shell, che ti fa accedere automaticamente all'interfaccia a riga di comando di gcloud. . Puoi controllare l'account attualmente attivo eseguendo gcloud auth list.

Salva il corpo della richiesta in un file denominato request.json ed esegui questo comando:

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://LOCATION-aiplatform.googleapis.com/v1beta1/projects/PROJECT_ID/locations/LOCATION/endpoints/openapi/chat/completions"

PowerShell

Nota: il comando seguente presuppone che tu abbia eseguito l'accesso all'interfaccia a riga di comando di gcloud con il tuo account utente eseguendo gcloud init o gcloud auth login . Puoi controllare l'account attualmente attivo eseguendo gcloud auth list.

Salva il corpo della richiesta in un file denominato request.json ed esegui questo comando:

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://LOCATION-aiplatform.googleapis.com/v1beta1/projects/PROJECT_ID/locations/LOCATION/endpoints/openapi/chat/completions" | Select-Object -Expand Content

Python (OpenAI)

Puoi chiamare l'API Inference utilizzando la libreria OpenAI. Per maggiori informazioni, vedi Chiamare Gemini utilizzando la libreria OpenAI.

import vertexai
import openai

from google.auth import default, transport

# TODO(developer): Update and un-comment below lines
# project_id = "PROJECT_ID"
# location = "us-central1"

vertexai.init(project=project_id, location=location)

# Programmatically get an access token
credentials, _ = default(scopes=["https://www.googleapis.com/auth/cloud-platform"])
auth_request = transport.requests.Request()
credentials.refresh(auth_request)

# # OpenAI Client
client = openai.OpenAI(
    base_url=f"https://{location}-aiplatform.googleapis.com/v1beta1/projects/{project_id}/locations/{location}/endpoints/openapi",
    api_key=credentials.token,
)

response = client.chat.completions.create(
    model="google/gemini-1.5-flash-001",
    messages=[{"role": "user", "content": "Why is the sky blue?"}],
)

print(response)

Risposta multimodale non in streaming

Generare una risposta del modello non in modalità flusso da un input multimodale, come testo e un'immagine.

REST

Prima di utilizzare i dati della richiesta, effettua le seguenti sostituzioni:

• PROJECT_ID: il tuo ID progetto.
• LOCATION: la regione in cui elaborare la richiesta.
• TEXT: le istruzioni testuali da includere nel prompt.
• FILE_URI: l'URI Cloud Storage del file in cui sono archiviati i dati.
• MIME_TYPE: il tipo MIME TIANA dei dati.

Metodo HTTP e URL:

POST https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/publishers/google/models/MODEL_ID:generateContent

Corpo JSON della richiesta:

{
"contents": [{
  "role": "user",
  "parts": [
    {
      "text": "TEXT"
    },
    {
      "file_data": {"file_uri": "FILE_URI", "MIME_TYPE"}
    },
    {
      "file_data": {"file_uri": "FILE_URI", "MIME_TYPE"}
    }
  ]
}]
}

Per inviare la richiesta, scegli una delle seguenti opzioni:

curl

Nota: il comando seguente presuppone che tu abbia eseguito l'accesso all'interfaccia a riga di comando gcloud con il tuo account utente eseguendo gcloud init o gcloud auth login oppure utilizzando Cloud Shell, che ti fa accedere automaticamente all'interfaccia a riga di comando di gcloud. . Puoi controllare l'account attualmente attivo eseguendo gcloud auth list.

Salva il corpo della richiesta in un file denominato request.json ed esegui questo comando:

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/publishers/google/models/MODEL_ID:generateContent"

PowerShell

Nota: il comando seguente presuppone che tu abbia eseguito l'accesso all'interfaccia a riga di comando di gcloud con il tuo account utente eseguendo gcloud init o gcloud auth login . Puoi controllare l'account attualmente attivo eseguendo gcloud auth list.

Salva il corpo della richiesta in un file denominato request.json ed esegui questo comando:

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/publishers/google/models/MODEL_ID:generateContent" | Select-Object -Expand Content

Python

# Copyright 2023 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#    https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.


def generate_text(project_id: str) -> str:
    import vertexai

    from vertexai.generative_models import GenerativeModel, Part

    # TODO(developer): Update and un-comment below line
    # project_id = "PROJECT_ID"

    vertexai.init(project=project_id, location="us-central1")

    model = GenerativeModel(model_name="gemini-1.5-flash-001")

    response = model.generate_content(
        [
            Part.from_uri(
                "gs://cloud-samples-data/generative-ai/image/scones.jpg",
                mime_type="image/jpeg",
            ),
            "What is shown in this image?",
        ]
    )

    print(response.text)

    return response.text

NodeJS

const {VertexAI} = require('@google-cloud/vertexai');

/**
 * TODO(developer): Update these variables before running the sample.
 */
async function createNonStreamingMultipartContent(
  projectId = 'PROJECT_ID',
  location = 'us-central1',
  model = 'gemini-1.5-flash-001',
  image = 'gs://generativeai-downloads/images/scones.jpg',
  mimeType = 'image/jpeg'
) {
  // Initialize Vertex with your Cloud project and location
  const vertexAI = new VertexAI({project: projectId, location: location});

  // Instantiate the model
  const generativeVisionModel = vertexAI.getGenerativeModel({
    model: model,
  });

  // For images, the SDK supports both Google Cloud Storage URI and base64 strings
  const filePart = {
    fileData: {
      fileUri: image,
      mimeType: mimeType,
    },
  };

  const textPart = {
    text: 'what is shown in this image?',
  };

  const request = {
    contents: [{role: 'user', parts: [filePart, textPart]}],
  };

  console.log('Prompt Text:');
  console.log(request.contents[0].parts[1].text);

  console.log('Non-Streaming Response Text:');
  // Create the response stream
  const responseStream =
    await generativeVisionModel.generateContentStream(request);

  // Wait for the response stream to complete
  const aggregatedResponse = await responseStream.response;

  // Select the text from the response
  const fullTextResponse =
    aggregatedResponse.candidates[0].content.parts[0].text;

  console.log(fullTextResponse);
}

Java

import com.google.cloud.vertexai.VertexAI;
import com.google.cloud.vertexai.api.GenerateContentResponse;
import com.google.cloud.vertexai.generativeai.ContentMaker;
import com.google.cloud.vertexai.generativeai.GenerativeModel;
import com.google.cloud.vertexai.generativeai.PartMaker;
import com.google.cloud.vertexai.generativeai.ResponseHandler;

public class Multimodal {
  public static void main(String[] args) throws Exception {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "your-google-cloud-project-id";
    String location = "us-central1";
    String modelName = "gemini-1.5-flash-001";

    String output = nonStreamingMultimodal(projectId, location, modelName);
    System.out.println(output);
  }

  // Ask a simple question and get the response.
  public static String nonStreamingMultimodal(String projectId, String location, String modelName)
      throws Exception {
    // Initialize client that will be used to send requests.
    // This client only needs to be created once, and can be reused for multiple requests.
    try (VertexAI vertexAI = new VertexAI(projectId, location)) {
      GenerativeModel model = new GenerativeModel(modelName, vertexAI);

      String videoUri = "gs://cloud-samples-data/video/animals.mp4";
      String imgUri = "gs://cloud-samples-data/generative-ai/image/character.jpg";

      // Get the response from the model.
      GenerateContentResponse response = model.generateContent(
          ContentMaker.fromMultiModalData(
              PartMaker.fromMimeTypeAndData("video/mp4", videoUri),
              PartMaker.fromMimeTypeAndData("image/jpeg", imgUri),
              "Are this video and image correlated?"
          ));

      // Extract the generated text from the model's response.
      String output = ResponseHandler.getText(response);
      return output;
    }
  }
}

Go

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

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

func tryGemini(w io.Writer, projectID string, location string, modelName string) error {
	// location := "us-central1"
	// modelName := "gemini-1.5-flash-001"

	ctx := context.Background()
	client, err := genai.NewClient(ctx, projectID, location)
	if err != nil {
		return fmt.Errorf("error creating client: %w", err)
	}
	gemini := client.GenerativeModel(modelName)

	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)
	}
	rb, err := json.MarshalIndent(resp, "", "  ")
	if err != nil {
		return fmt.Errorf("json.MarshalIndent: %w", err)
	}
	fmt.Fprintln(w, string(rb))
	return nil
}

C#

using Google.Api.Gax.Grpc;
using Google.Cloud.AIPlatform.V1;
using System.Text;
using System.Threading.Tasks;

public class GeminiQuickstart
{
    public async Task<string> GenerateContent(
        string projectId = "your-project-id",
        string location = "us-central1",
        string publisher = "google",
        string model = "gemini-1.5-flash-001"
    )
    {
        // Create client
        var predictionServiceClient = new PredictionServiceClientBuilder
        {
            Endpoint = $"{location}-aiplatform.googleapis.com"
        }.Build();

        // Initialize content request
        var generateContentRequest = new GenerateContentRequest
        {
            Model = $"projects/{projectId}/locations/{location}/publishers/{publisher}/models/{model}",
            GenerationConfig = new GenerationConfig
            {
                Temperature = 0.4f,
                TopP = 1,
                TopK = 32,
                MaxOutputTokens = 2048
            },
            Contents =
            {
                new Content
                {
                    Role = "USER",
                    Parts =
                    {
                        new Part { Text = "What's in this photo?" },
                        new Part { FileData = new() { MimeType = "image/png", FileUri = "gs://generativeai-downloads/images/scones.jpg" } }
                    }
                }
            }
        };

        // Make the request, returning a streaming response
        using PredictionServiceClient.StreamGenerateContentStream response = predictionServiceClient.StreamGenerateContent(generateContentRequest);

        StringBuilder fullText = new();

        // Read streaming responses from server until complete
        AsyncResponseStream<GenerateContentResponse> responseStream = response.GetResponseStream();
        await foreach (GenerateContentResponse responseItem in responseStream)
        {
            fullText.Append(responseItem.Candidates[0].Content.Parts[0].Text);
        }

        return fullText.ToString();
    }
}

REST (OpenAI)

Puoi chiamare l'API Inference utilizzando la libreria OpenAI. Per maggiori informazioni, vedi Chiamare Gemini utilizzando la libreria OpenAI.

Prima di utilizzare i dati della richiesta, effettua le seguenti sostituzioni:

• PROJECT_ID: il tuo ID progetto.
• LOCATION: la regione in cui elaborare la richiesta.
• MODEL_ID: il nome del modello da utilizzare.

Metodo HTTP e URL:

POST https://LOCATION-aiplatform.googleapis.com/v1beta1/projects/PROJECT_ID/locations/LOCATION/endpoints/openapi/chat/completions

Corpo JSON della richiesta:

{
  "model": "google/MODEL_ID",
  "messages": [{
    "role": "user",
    "content": [
       {
          "type": "text",
          "text": "Describe the following image:"
       },
       {
          "type": "image_url",
          "image_url": {
             "url": "gs://generativeai-downloads/images/character.jpg"
          }
       }
     ]
  }]
}

Per inviare la richiesta, scegli una delle seguenti opzioni:

curl

Nota: il comando seguente presuppone che tu abbia eseguito l'accesso all'interfaccia a riga di comando gcloud con il tuo account utente eseguendo gcloud init o gcloud auth login oppure utilizzando Cloud Shell, che ti fa accedere automaticamente all'interfaccia a riga di comando di gcloud. . Puoi controllare l'account attualmente attivo eseguendo gcloud auth list.

Salva il corpo della richiesta in un file denominato request.json ed esegui questo comando:

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://LOCATION-aiplatform.googleapis.com/v1beta1/projects/PROJECT_ID/locations/LOCATION/endpoints/openapi/chat/completions"

PowerShell

Nota: il comando seguente presuppone che tu abbia eseguito l'accesso all'interfaccia a riga di comando di gcloud con il tuo account utente eseguendo gcloud init o gcloud auth login . Puoi controllare l'account attualmente attivo eseguendo gcloud auth list.

Salva il corpo della richiesta in un file denominato request.json ed esegui questo comando:

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://LOCATION-aiplatform.googleapis.com/v1beta1/projects/PROJECT_ID/locations/LOCATION/endpoints/openapi/chat/completions" | Select-Object -Expand Content

Python (OpenAI)

Puoi chiamare l'API Inference utilizzando la libreria OpenAI. Per maggiori informazioni, vedi Chiamare Gemini utilizzando la libreria OpenAI.

import vertexai
import openai

from google.auth import default, transport

# TODO(developer): Update and un-comment below lines
# project_id = "PROJECT_ID"
# location = "us-central1"

vertexai.init(project=project_id, location=location)

# Programmatically get an access token
credentials, _ = default(scopes=["https://www.googleapis.com/auth/cloud-platform"])
auth_request = transport.requests.Request()
credentials.refresh(auth_request)

# OpenAI Client
client = openai.OpenAI(
    base_url=f"https://{location}-aiplatform.googleapis.com/v1beta1/projects/{project_id}/locations/{location}/endpoints/openapi",
    api_key=credentials.token,
)

response = client.chat.completions.create(
    model="google/gemini-1.5-flash-001",
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "Describe the following image:"},
                {
                    "type": "image_url",
                    "image_url": "gs://cloud-samples-data/generative-ai/image/scones.jpg",
                },
            ],
        }
    ],
)

print(response)

Risposta di testo in streaming

Genera una risposta di un modello in modalità flusso da un input di testo.

REST

Prima di utilizzare i dati della richiesta, effettua le seguenti sostituzioni:

• PROJECT_ID: il tuo ID progetto.
• LOCATION: la regione in cui elaborare la richiesta.
• TEXT: le istruzioni testuali da includere nel prompt.

Metodo HTTP e URL:

POST https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/publishers/google/models/MODEL_ID:streamGenerateContent

Corpo JSON della richiesta:

{
  "contents": [{
    "role": "user",
    "parts": [{
      "text": "TEXT"
    }]
  }]
}'

Per inviare la richiesta, scegli una delle seguenti opzioni:

curl

Nota: il comando seguente presuppone che tu abbia eseguito l'accesso all'interfaccia a riga di comando gcloud con il tuo account utente eseguendo gcloud init o gcloud auth login oppure utilizzando Cloud Shell, che ti fa accedere automaticamente all'interfaccia a riga di comando di gcloud. . Puoi controllare l'account attualmente attivo eseguendo gcloud auth list.

Salva il corpo della richiesta in un file denominato request.json ed esegui questo comando:

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/publishers/google/models/MODEL_ID:streamGenerateContent"

PowerShell

Nota: il comando seguente presuppone che tu abbia eseguito l'accesso all'interfaccia a riga di comando di gcloud con il tuo account utente eseguendo gcloud init o gcloud auth login . Puoi controllare l'account attualmente attivo eseguendo gcloud auth list.

Salva il corpo della richiesta in un file denominato request.json ed esegui questo comando:

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/publishers/google/models/MODEL_ID:streamGenerateContent" | Select-Object -Expand Content

Python

import vertexai

from vertexai.generative_models import GenerativeModel

vertexai.init(project=PROJECT_ID, location="us-central1")

model = GenerativeModel(MODEL_ID)
responses = model.generate_content(
    "Write a story about a magic backpack.", stream=True
)

for response in responses:
    print(response)

NodeJS

const {VertexAI} = require('@google-cloud/vertexai');

/**
 * TODO(developer): Update these variables before running the sample.
 */
async function generateContent(
  projectId = 'PROJECT_ID',
  location = 'us-central1',
  model = 'gemini-1.5-flash-001'
) {
  // 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.generateContentStream(request);
  for await (const item of result.stream) {
    console.log(item.candidates[0].content.parts[0].text);
  }
}

Java

import com.google.cloud.vertexai.VertexAI;
import com.google.cloud.vertexai.generativeai.GenerativeModel;

public class StreamingQuestionAnswer {

  public static void main(String[] args) throws Exception {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "your-google-cloud-project-id";
    String location = "us-central1";
    String modelName = "gemini-1.5-flash-001";

    streamingQuestion(projectId, location, modelName);
  }

  // Ask a simple question and get the response via streaming.
  public static void streamingQuestion(String projectId, String location, String modelName)
      throws Exception {
    // Initialize client that will be used to send requests.
    // This client only needs to be created once, and can be reused for multiple requests.
    try (VertexAI vertexAI = new VertexAI(projectId, location)) {
      GenerativeModel model = new GenerativeModel(modelName, vertexAI);

      // Stream the result.
      model.generateContentStream("Why is the sky blue?")
          .stream()
          .forEach(System.out::println);

      System.out.println("Streaming complete.");
    }
  }
}

Go

import (
	"context"
	"errors"
	"fmt"
	"io"

	"cloud.google.com/go/vertexai/genai"
	"google.golang.org/api/iterator"
)

// generateContent shows how to	send a basic streaming text prompt, writing
// the response to the provided io.Writer.
func generateContent(w io.Writer, projectID, modelName string) error {
	ctx := context.Background()

	client, err := genai.NewClient(ctx, projectID, "us-central1")
	if err != nil {
		return fmt.Errorf("unable to create client: %w", err)
	}
	defer client.Close()

	model := client.GenerativeModel(modelName)

	iter := model.GenerateContentStream(
		ctx,
		genai.Text("Write a story about a magic backpack."),
	)
	for {
		resp, err := iter.Next()
		if err == iterator.Done {
			return nil
		}
		if len(resp.Candidates) == 0 || len(resp.Candidates[0].Content.Parts) == 0 {
			return errors.New("empty response from model")
		}
		if err != nil {
			return err
		}
		fmt.Fprint(w, "generated response: ")
		for _, c := range resp.Candidates {
			for _, p := range c.Content.Parts {
				fmt.Fprintf(w, "%s ", p)
			}
		}
	}
}

REST (OpenAI)

Puoi chiamare l'API Inference utilizzando la libreria OpenAI. Per maggiori informazioni, vedi Chiamare Gemini utilizzando la libreria OpenAI.

Prima di utilizzare i dati della richiesta, effettua le seguenti sostituzioni:

• PROJECT_ID: il tuo ID progetto.
• LOCATION: la regione in cui elaborare la richiesta.
• MODEL_ID: il nome del modello da utilizzare.

Metodo HTTP e URL:

POST https://LOCATION-aiplatform.googleapis.com/v1beta1/projects/PROJECT_ID/locations/LOCATION/endpoints/openapi/chat/completions

Corpo JSON della richiesta:

{
  "model": "google/MODEL_ID",
  "stream": true,
  "messages": [{
    "role": "user",
    "content": "Write a story about a magic backpack."
  }]
}

Per inviare la richiesta, scegli una delle seguenti opzioni:

curl

Nota: il comando seguente presuppone che tu abbia eseguito l'accesso all'interfaccia a riga di comando gcloud con il tuo account utente eseguendo gcloud init o gcloud auth login oppure utilizzando Cloud Shell, che ti fa accedere automaticamente all'interfaccia a riga di comando di gcloud. . Puoi controllare l'account attualmente attivo eseguendo gcloud auth list.

Salva il corpo della richiesta in un file denominato request.json ed esegui questo comando:

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://LOCATION-aiplatform.googleapis.com/v1beta1/projects/PROJECT_ID/locations/LOCATION/endpoints/openapi/chat/completions"

PowerShell

Nota: il comando seguente presuppone che tu abbia eseguito l'accesso all'interfaccia a riga di comando di gcloud con il tuo account utente eseguendo gcloud init o gcloud auth login . Puoi controllare l'account attualmente attivo eseguendo gcloud auth list.

Salva il corpo della richiesta in un file denominato request.json ed esegui questo comando:

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://LOCATION-aiplatform.googleapis.com/v1beta1/projects/PROJECT_ID/locations/LOCATION/endpoints/openapi/chat/completions" | Select-Object -Expand Content

Python (OpenAI)

Puoi chiamare l'API Inference utilizzando la libreria OpenAI. Per maggiori informazioni, vedi Chiamare Gemini utilizzando la libreria OpenAI.

import vertexai
import openai

from google.auth import default, transport

# TODO(developer): Update and un-comment below lines
# project_id = "PROJECT_ID"
# location = "us-central1"

vertexai.init(project=project_id, location=location)

# Programmatically get an access token
credentials, _ = default(scopes=["https://www.googleapis.com/auth/cloud-platform"])
auth_request = transport.requests.Request()
credentials.refresh(auth_request)

# OpenAI Client
client = openai.OpenAI(
    base_url=f"https://{location}-aiplatform.googleapis.com/v1beta1/projects/{project_id}/locations/{location}/endpoints/openapi",
    api_key=credentials.token,
)

response = client.chat.completions.create(
    model="google/gemini-1.5-flash-001",
    messages=[{"role": "user", "content": "Why is the sky blue?"}],
    stream=True,
)
for chunk in response:
    print(chunk)

Risposta multimodale in modalità flusso

Generare una risposta di un modello in modalità flusso da un input multimodale, come testo e un'immagine.

REST

Prima di utilizzare i dati della richiesta, effettua le seguenti sostituzioni:

• PROJECT_ID: il tuo ID progetto.
• LOCATION: la regione in cui elaborare la richiesta.
• TEXT: le istruzioni testuali da includere nel prompt.
• FILE_URI: l'URI Cloud Storage del file in cui sono archiviati i dati.
• MIME_TYPE: il tipo MIME TIANA dei dati.

Metodo HTTP e URL:

POST https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/publishers/google/models/MODEL_ID:streamGenerateContent

Corpo JSON della richiesta:

{
"contents": [{
  "role": "user",
  "parts": [
    {
      "text": "TEXT"
    },
    {
      "file_data": {"file_uri": "FILE_URI", "MIME_TYPE"}
    },
    {
      "file_data": {"file_uri": "FILE_URI", "MIME_TYPE"}
    }
  ]
}]
}

Per inviare la richiesta, scegli una delle seguenti opzioni:

curl

Nota: il comando seguente presuppone che tu abbia eseguito l'accesso all'interfaccia a riga di comando gcloud con il tuo account utente eseguendo gcloud init o gcloud auth login oppure utilizzando Cloud Shell, che ti fa accedere automaticamente all'interfaccia a riga di comando di gcloud. . Puoi controllare l'account attualmente attivo eseguendo gcloud auth list.

Salva il corpo della richiesta in un file denominato request.json ed esegui questo comando:

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/publishers/google/models/MODEL_ID:streamGenerateContent"

PowerShell

Nota: il comando seguente presuppone che tu abbia eseguito l'accesso all'interfaccia a riga di comando di gcloud con il tuo account utente eseguendo gcloud init o gcloud auth login . Puoi controllare l'account attualmente attivo eseguendo gcloud auth list.

Salva il corpo della richiesta in un file denominato request.json ed esegui questo comando:

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/publishers/google/models/MODEL_ID:streamGenerateContent" | Select-Object -Expand Content

Python

import vertexai

from vertexai.generative_models import GenerativeModel, Part

vertexai.init(project=PROJECT_ID, location="us-central1")

model = GenerativeModel(MODEL_ID)
responses = model.generate_content(
    [
        Part.from_uri(
            "gs://cloud-samples-data/generative-ai/video/animals.mp4", "video/mp4"
        ),
        Part.from_uri(
            "gs://cloud-samples-data/generative-ai/image/character.jpg",
            "image/jpeg",
        ),
        "Are these video and image correlated?",
    ],
    stream=True,
)

for response in responses:
    print(response)

NodeJS

const {VertexAI} = require('@google-cloud/vertexai');

/**
 * TODO(developer): Update these variables before running the sample.
 */
async function generateContent(
  projectId = 'PROJECT_ID',
  location = 'us-central1',
  model = 'gemini-1.5-flash-001'
) {
  // Initialize Vertex AI
  const vertexAI = new VertexAI({project: projectId, location: location});
  const generativeModel = vertexAI.getGenerativeModel({model: model});

  const request = {
    contents: [
      {
        role: 'user',
        parts: [
          {
            file_data: {
              file_uri: 'gs://cloud-samples-data/video/animals.mp4',
              mime_type: 'video/mp4',
            },
          },
          {
            file_data: {
              file_uri:
                'gs://cloud-samples-data/generative-ai/image/character.jpg',
              mime_type: 'image/jpeg',
            },
          },
          {text: 'Are this video and image correlated?'},
        ],
      },
    ],
  };

  const result = await generativeModel.generateContentStream(request);

  for await (const item of result.stream) {
    console.log(item.candidates[0].content.parts[0].text);
  }
}

Java

import com.google.cloud.vertexai.VertexAI;
import com.google.cloud.vertexai.generativeai.ContentMaker;
import com.google.cloud.vertexai.generativeai.GenerativeModel;
import com.google.cloud.vertexai.generativeai.PartMaker;

public class StreamingMultimodal {
  public static void main(String[] args) throws Exception {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "your-google-cloud-project-id";
    String location = "us-central1";
    String modelName = "gemini-1.5-flash-001";

    streamingMultimodal(projectId, location, modelName);
  }

  // Ask a simple question and get the response via streaming.
  public static void streamingMultimodal(String projectId, String location, String modelName)
      throws Exception {
    // Initialize client that will be used to send requests.
    // This client only needs to be created once, and can be reused for multiple requests.
    try (VertexAI vertexAI = new VertexAI(projectId, location)) {
      GenerativeModel model = new GenerativeModel(modelName, vertexAI);

      String videoUri = "gs://cloud-samples-data/video/animals.mp4";
      String imgUri = "gs://cloud-samples-data/generative-ai/image/character.jpg";

      // Stream the result.
      model.generateContentStream(
          ContentMaker.fromMultiModalData(
              PartMaker.fromMimeTypeAndData("video/mp4", videoUri),
              PartMaker.fromMimeTypeAndData("image/jpeg", imgUri),
              "Are this video and image correlated?"
          ))
          .stream()
          .forEach(System.out::println);
    }
  }
}

Go

import (
	"context"
	"errors"
	"fmt"
	"io"

	"cloud.google.com/go/vertexai/genai"
	"google.golang.org/api/iterator"
)

func generateContent(w io.Writer, projectID, modelName string) error {
	ctx := context.Background()

	client, err := genai.NewClient(ctx, projectID, "us-central1")
	if err != nil {
		return fmt.Errorf("unable to create client: %w", err)
	}
	defer client.Close()

	model := client.GenerativeModel(modelName)
	iter := model.GenerateContentStream(
		ctx,
		genai.FileData{
			MIMEType: "video/mp4",
			FileURI:  "gs://cloud-samples-data/generative-ai/video/animals.mp4",
		},
		genai.FileData{
			MIMEType: "video/jpeg",
			FileURI:  "gs://cloud-samples-data/generative-ai/image/character.jpg",
		},
		genai.Text("Are these video and image correlated?"),
	)
	for {
		resp, err := iter.Next()
		if err == iterator.Done {
			return nil
		}
		if len(resp.Candidates) == 0 || len(resp.Candidates[0].Content.Parts) == 0 {
			return errors.New("empty response from model")
		}
		if err != nil {
			return err
		}

		fmt.Fprint(w, "generated response: ")
		for _, c := range resp.Candidates {
			for _, p := range c.Content.Parts {
				fmt.Fprintf(w, "%s ", p)
			}
		}
		fmt.Fprint(w, "\n")
	}
}

REST (OpenAI)

Puoi chiamare l'API Inference utilizzando la libreria OpenAI. Per maggiori informazioni, vedi Chiamare Gemini utilizzando la libreria OpenAI.

Prima di utilizzare i dati della richiesta, effettua le seguenti sostituzioni:

• PROJECT_ID: il tuo ID progetto.
• LOCATION: la regione in cui elaborare la richiesta.
• MODEL_ID: il nome del modello da utilizzare.

Metodo HTTP e URL:

POST https://LOCATION-aiplatform.googleapis.com/v1beta1/projects/PROJECT_ID/locations/LOCATION/endpoints/openapi/chat/completions

Corpo JSON della richiesta:

{
  "model": "google/MODEL_ID",
  "stream": true,
  "messages": [{
    "role": "user",
    "content": [
       {
          "type": "text",
          "text": "Describe the following image:"
       },
       {
          "type": "image_url",
          "image_url": {
             "url": "gs://generativeai-downloads/images/character.jpg"
          }
       }
     ]
  }]
}

Per inviare la richiesta, scegli una delle seguenti opzioni:

curl

Nota: il comando seguente presuppone che tu abbia eseguito l'accesso all'interfaccia a riga di comando gcloud con il tuo account utente eseguendo gcloud init o gcloud auth login oppure utilizzando Cloud Shell, che ti fa accedere automaticamente all'interfaccia a riga di comando di gcloud. . Puoi controllare l'account attualmente attivo eseguendo gcloud auth list.

Salva il corpo della richiesta in un file denominato request.json ed esegui questo comando:

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://LOCATION-aiplatform.googleapis.com/v1beta1/projects/PROJECT_ID/locations/LOCATION/endpoints/openapi/chat/completions"

PowerShell

Nota: il comando seguente presuppone che tu abbia eseguito l'accesso all'interfaccia a riga di comando di gcloud con il tuo account utente eseguendo gcloud init o gcloud auth login . Puoi controllare l'account attualmente attivo eseguendo gcloud auth list.

Salva il corpo della richiesta in un file denominato request.json ed esegui questo comando:

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://LOCATION-aiplatform.googleapis.com/v1beta1/projects/PROJECT_ID/locations/LOCATION/endpoints/openapi/chat/completions" | Select-Object -Expand Content

Python (OpenAI)

Puoi chiamare l'API Inference utilizzando la libreria OpenAI. Per maggiori informazioni, vedi Chiamare Gemini utilizzando la libreria OpenAI.

import vertexai
import openai

from google.auth import default, transport

# TODO(developer): Update and un-comment below lines
# project_id = "PROJECT_ID"
# location = "us-central1"

vertexai.init(project=project_id, location=location)

# Programmatically get an access token
credentials, _ = default(scopes=["https://www.googleapis.com/auth/cloud-platform"])
auth_request = transport.requests.Request()
credentials.refresh(auth_request)

# OpenAI Client
client = openai.OpenAI(
    base_url=f"https://{location}-aiplatform.googleapis.com/v1beta1/projects/{project_id}/locations/{location}/endpoints/openapi",
    api_key=credentials.token,
)

response = client.chat.completions.create(
    model="google/gemini-1.5-flash-001",
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "Describe the following image:"},
                {
                    "type": "image_url",
                    "image_url": "gs://cloud-samples-data/generative-ai/image/scones.jpg",
                },
            ],
        }
    ],
    stream=True,
)
for chunk in response:
    print(chunk)

Versioni modello

Per utilizzare la versione aggiornata automaticamente, specifica il nome del modello senza il numero di versione finale, ad esempio gemini-1.0-pro anziché gemini-1.0-pro-001.

Per saperne di più, consulta Versioni dei modelli Gemini e ciclo di vita.

Passaggi successivi

• Scopri di più sull'API Gemini.
• Scopri di più sulle chiamate di funzione.
• Scopri di più sulle risposte di grounding per i modelli Gemini.