Inference API

Verwenden Sie die Inference API, um Gemini-Prompts zu generieren.

Die Gemini-Modellfamilie enthält Modelle, die mit multimodalen Prompt-Anfragen funktionieren. Der Begriff multimodal gibt an, dass Sie mehr als eine Modalität oder einen Eingabetyp in einem Prompt verwenden können. Modelle, die nicht multimodal sind, akzeptieren nur Prompts mit Text. Modalitäten können Text, Audio, Video und mehr umfassen.

Weitere Informationen finden Sie hier:

Unterstützte Modelle:

Modell Version
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

Beschränkungen:

Wenn Sie viele Bilder bereitstellen, kann die Latenz hoch sein.

Beispielsyntax

Syntax zum Generieren einer Modellantwort.

Nicht 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={...})

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)

Parameterliste

Einzelheiten zur Implementierung finden Sie in den Beispielen.

Anfragetext

Der Anfragetext enthält Daten mit den folgenden Parametern:

Parameter

contents

Erforderlich: Content

Der Inhalt der aktuellen Unterhaltung mit dem Modell.

Bei Einzelabfragen ist dies eine einzelne Instanz. Bei Mehrfachabfragen ist dies ein wiederkehrendes Feld, das den Unterhaltungsverlauf und die letzte Anfrage enthält.

system_instruction

Optional: Content

Der Nutzer hat Systemanweisungen für das Modell bereitgestellt.

Hinweis: In parts sollte nur text verwendet werden. Der Inhalt jedes part sollte in einem separaten Absatz sein.

tools

Optional. Siehe Function Calling API.

tool_config

Optional. Siehe Function Calling API.

safety_settings

Optional: SafetySetting

Einstellungen nach Anfrage zum Blockieren unsicherer Inhalte

Erzwungen am GenerateContentResponse.candidates

generation_config

Optional: GenerationConfig

Konfigurationseinstellungen für die Generierung.

Inhalt

Der Basistyp für strukturierte Daten, der mehrteilige Inhalte einer Nachricht enthält.

Diese Klasse besteht aus zwei Hauptattributen: role und parts. Das Attribut role bezeichnet die Person, die den Inhalt erzeugt, während das Attribut parts mehrere Elemente enthält, die jeweils ein Datensegment innerhalb einer Nachricht darstellen.

Parameter

role

Optional: string

Die Identität der Entität, die die Nachricht erstellt. Folgende Werte werden unterstützt:

  • user: bedeutet, dass die Nachricht von einer realen Person gesendet wurde, in der Regel eine vom Nutzer erstellte Nachricht.
  • model: Gibt an, dass die Nachricht vom Modell generiert wird.

Der Wert model wird verwendet, um Nachrichten aus dem Modell in die Unterhaltung einzufügen, die Unterhaltungen über mehrere Themen führen.

Bei Unterhaltungen, die nicht mehrere Themen enthalten, kann dieses Feld leer bleiben oder nicht festgelegt werden.

parts

Part

Eine Liste geordneter Teile einer einzelnen Nachricht. Verschiedene Teile haben möglicherweise unterschiedliche IANA-MIME-Typen.

Part

Ein Datentyp mit Medien, die Teil einer mehrteiligen Content-Nachricht sind.

Parameter

text

Optional: string

Ein Text-Prompt oder ein Code-Snippet.

inline_data

Optional: Blob

Inline-Daten in Rohbyte.

file_data

Optional: FileData

In einer Datei gespeicherte Daten.

function_call

Optional: FunctionCall.

Sie enthält einen String, der das Feld FunctionDeclaration.name und ein strukturiertes JSON-Objekt darstellt, das alle Parameter für den vom Modell vorhergesagten Funktionsaufruf enthält.

Siehe Function Calling API.

function_response

Optional: FunctionResponse.

Die Ergebnisausgabe eines FunctionCall, der einen String enthält, der das Feld FunctionDeclaration.name und ein strukturiertes JSON-Objekt darstellt, das alle Ausgaben des Funktionsaufrufs enthält. Sie wird als Kontext für das Modell verwendet.

Siehe Function Calling API.

video_metadata

Optional: VideoMetadata

Videometadaten Die Metadaten sollten nur angegeben werden, wenn die Videodaten in inline_data oder file_data dargestellt werden.

Blob

Inhalts-Blob Senden Sie ihn möglichst als Text und nicht als Rohbyte.

Parameter

mime_type

string

IANA-MIME-Typ der Daten.

data

bytes

Rohbyte.

FileData

URI-basierte Daten.

Parameter

mime_type

string

IANA-MIME-Typ der Daten.

file_uri

String

Der Cloud Storage-URI der Datei, in der die Daten gespeichert werden

FunctionCall

Ein vorhergesagter FunctionCall, der vom Modell zurückgegeben wird und einen String enthält, der FunctionDeclaration.name und ein strukturiertes JSON-Objekt enthält, das die Parameter und ihre Werte enthält.

Parameter

name

string

Der Name der aufzurufenden Funktion.

args

Struct

Die Funktionsparameter und -werte im JSON-Objektformat.

Weitere Informationen zu Parametern finden Sie unter Function Calling API.

FunctionResponse

Die resultierende Ausgabe von einem FunctionCall, der einen String enthält, der FunctionDeclaration.name darstellt. Enthält außerdem ein strukturiertes JSON-Objekt mit der Ausgabe der Funktion und verwendet es als Kontext für das Modell. Dies sollte das Ergebnis eines FunctionCall enthalten, der auf der Modellvorhersage basiert.

Parameter

name

string

Der Name der aufzurufenden Funktion.

response

Struct

Die Funktionsantwort im JSON-Objektformat.

VideoMetadata

Metadaten, die den Eingabevideoinhalt beschreiben

Parameter

start_offset

Optional: google.protobuf.Duration

Der Startversatz des Videos.

end_offset

Optional: google.protobuf.Duration

Endversatz des Videos.

SafetySetting

Sicherheitseinstellungen.

Parameter

category

Optional: HarmCategory

Die Kategorie des Schadens.

threshold

Optional: HarmBlockThreshold

Der Schwellenwert für die die Schadenssperre

max_influential_terms

Optional: int

Die maximale Anzahl einflussreicher Begriffe, die am meisten zu den Sicherheitswerten beitragen. Dies kann zu einer möglichen Blockierung führen.

method

Optional: HarmBlockMethod

Geben Sie an, ob der Schwellenwert für die Wahrscheinlichkeit oder den Schweregrad verwendet wird. Wenn nicht angegeben, wird der Schwellenwert für den Wahrscheinlichkeitswert verwendet.

HarmCategory

Schadenskategorien, die Inhalte blockieren

Parameter

HARM_CATEGORY_UNSPECIFIED

Die Schadenskategorie ist nicht angegeben.

HARM_CATEGORY_HATE_SPEECH

Die Schadenskategorie ist Hassrede.

HARM_CATEGORY_DANGEROUS_CONTENT

Die Schadenskategorie ist gefährlicher Inhalt.

HARM_CATEGORY_HARASSMENT

Die Schadenskategorie ist Belästigung.

HARM_CATEGORY_SEXUALLY_EXPLICIT

Die Schadenskategorie umfasst sexuell explizite Inhalte.

HarmBlockThreshold

Wahrscheinlichkeitsschwellenwerte, die zum Blockieren einer Antwort verwendet werden.

Parameter

HARM_BLOCK_THRESHOLD_UNSPECIFIED

Unbekannter Schwellenwert für Schadenssperre.

BLOCK_LOW_AND_ABOVE

Niedrigeren Schwellenwert und höher blockieren (d. h. mehr blockieren).

BLOCK_MEDIUM_AND_ABOVE

Mittleren Grenzwert und höher blockieren.

BLOCK_ONLY_HIGH

Nur einen hohen Schwellenwert blockieren (d. h. weniger blockieren).

BLOCK_NONE

Keine blockieren.

HarmBlockMethod

Ein Wahrscheinlichkeitsschwellenwert, der eine Antwort anhand einer Kombination aus Wahrscheinlichkeit und Schweregrad blockiert.

Parameter

HARM_BLOCK_METHOD_UNSPECIFIED

Die Methode der Schadenssperre ist nicht angegeben.

SEVERITY

Die Methode der Schadenssperre verwendet Punktzahlen sowohl für die Wahrscheinlichkeit als auch den Schweregrad.

PROBABILITY

Die Methode der Schadenssperre verwendet den Wahrscheinlichkeitswert.

GenerationConfig

Konfigurationseinstellungen, die beim Generieren der Eingabeaufforderung verwendet werden.

Parameter

temperature

Optional: float

Steuert die Zufälligkeit von Vorhersagen.

top_p

Optional: float

Wenn angegeben, wird Nucleus Sampling verwendet.

top_k

Optional: Wenn dieser Wert angegeben ist, wird ein Top-K-Sampling verwendet.

candidate_count

Optional: int

Anzahl der zu generierenden Kandidaten.

max_output_tokens

Optional: int

Die maximale Anzahl von Ausgabetokens, die pro Nachricht generiert werden sollen.

stop_sequences

Optional: List[string]

Stoppsequenzen.

presence_penalty

Optional: float

Positive Strafen.

frequency_penalty

Optional: float

Strafen für die Häufigkeit.

response_mime_type

Optional: string (enum)

Ausgabeantwort-MIME-Typ des generierten Kandidatentexts.

Unterstützter MIME-Typ:

  • text/plain: (Standardeinstellung) Textausgabe.
  • application/json: JSON-Antwort in den Kandidaten.
  • Das Modell muss aufgefordert werden, den entsprechenden Antworttyp auszugeben, andernfalls ist das Verhalten nicht definiert.

Dies ist eine Funktion in der Vorabversion.

Beispiele

Nicht-Streaming-Textantwort

Generieren Sie eine Nicht-Streaming-Modellantwort aus einer Texteingabe.

REST

Ersetzen Sie dabei folgende Werte für die Anfragedaten:

  • PROJECT_ID: Ihre Projekt-ID.
  • LOCATION: Die Region, in der die Anfrage verarbeitet werden soll.
  • TEXT: Die Textanleitung, die in den Prompt eingefügt werden soll.

HTTP-Methode und URL:

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

JSON-Text der Anfrage:

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

Wenn Sie die Anfrage senden möchten, wählen Sie eine der folgenden Optionen aus:

curl

Speichern Sie den Anfragetext in einer Datei mit dem Namen request.json und führen Sie den folgenden Befehl aus: 

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

Speichern Sie den Anfragetext in einer Datei mit dem Namen request.json und führen Sie den folgenden Befehl aus: 

$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.0-pro-002")

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;
import java.io.IOException;

public class TextInput {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "your-google-cloud-project-id";
    String location = "us-central1";
    String modelName = "gemini-1.0-pro-002";
    String textPrompt =
        "What's a good name for a flower shop that specializes in selling bouquets of"
            + " dried flowers?";

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

  // Passes the provided text input to the Gemini model and returns the text-only response.
  // For the specified textPrompt, the model returns a list of possible store names.
  public static String textInput(
      String projectId, String location, String modelName, String textPrompt) throws IOException {
    // 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);

      GenerateContentResponse response = model.generateContent(textPrompt);
      String 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.0-pro-vision-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;
    }
}

Multimodale Nicht-Streaming-Antwort

Generieren Sie eine Nicht-Streaming-Modellantwort aus einer multimodalen Eingabe, z. B. Text und einem Bild.

REST

Ersetzen Sie dabei folgende Werte für die Anfragedaten:

  • PROJECT_ID: Ihre Projekt-ID.
  • LOCATION: Die Region, in der die Anfrage verarbeitet werden soll.
  • TEXT: Die Textanleitung, die in den Prompt eingefügt werden soll.
  • FILE_URI: Der Cloud Storage-URI der Datei, in der die Daten gespeichert werden
  • MIME_TYPE: Der TIANA-MIME-Typ der Daten.

HTTP-Methode und URL:

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

JSON-Text der Anfrage:

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

Wenn Sie die Anfrage senden möchten, wählen Sie eine der folgenden Optionen aus:

curl

Speichern Sie den Anfragetext in einer Datei mit dem Namen request.json und führen Sie den folgenden Befehl aus: 

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

Speichern Sie den Anfragetext in einer Datei mit dem Namen request.json und führen Sie den folgenden Befehl aus: 

$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.0-pro-vision-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.0-pro-vision-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 java.io.IOException;

public class Quickstart {

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

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

  // Analyzes the provided Multimodal input.
  public static String quickstart(String projectId, String location, String modelName)
      throws IOException {
    // 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 imageUri = "gs://cloud-samples-data/vertex-ai/llm/prompts/landmark1.png";

      GenerativeModel model = new GenerativeModel(modelName, vertexAI);
      GenerateContentResponse response = model.generateContent(ContentMaker.fromMultiModalData(
          PartMaker.fromMimeTypeAndData("image/png", imageUri),
          "What's in this photo"
      ));

      return response.toString();
    }
  }
}

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.0-pro-vision-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.0-pro-vision"
    )
    {
        // 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();
    }
}

Streaming-Textantwort

Generieren Sie eine Antwort eines Streamingmodells aus einer Texteingabe.

REST

Ersetzen Sie dabei folgende Werte für die Anfragedaten:

  • PROJECT_ID: Ihre Projekt-ID.
  • LOCATION: Die Region, in der die Anfrage verarbeitet werden soll.
  • TEXT: Die Textanleitung, die in den Prompt eingefügt werden soll.

HTTP-Methode und URL:

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

JSON-Text der Anfrage:

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

Wenn Sie die Anfrage senden möchten, wählen Sie eine der folgenden Optionen aus:

curl

Speichern Sie den Anfragetext in einer Datei mit dem Namen request.json und führen Sie den folgenden Befehl aus: 

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

Speichern Sie den Anfragetext in einer Datei mit dem Namen request.json und führen Sie den folgenden Befehl aus: 

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

Multimodale Streamingantworten

Generieren Sie eine Streamingmodellantwort aus einer multimodalen Eingabe wie Text und einem Bild.

REST

Ersetzen Sie dabei folgende Werte für die Anfragedaten:

  • PROJECT_ID: Ihre Projekt-ID.
  • LOCATION: Die Region, in der die Anfrage verarbeitet werden soll.
  • TEXT: Die Textanleitung, die in den Prompt eingefügt werden soll.

HTTP-Methode und URL:

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

JSON-Text der Anfrage:

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

Wenn Sie die Anfrage senden möchten, wählen Sie eine der folgenden Optionen aus:

curl

Speichern Sie den Anfragetext in einer Datei mit dem Namen request.json und führen Sie den folgenden Befehl aus: 

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

Speichern Sie den Anfragetext in einer Datei mit dem Namen request.json und führen Sie den folgenden Befehl aus: 

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

Nächste Schritte