Anfragen für Text-Prompts senden

Mit Vertex AI können Sie Prompts mit Vertex AI Studio in der Google Cloud Console, der Vertex AI API und dem Vertex AI SDK für Python testen. Auf dieser Seite erfahren Sie, wie Sie Textaufforderungen über eine dieser Schnittstellen testen.

Weitere Informationen zum Design der Eingabeaufforderung für Text finden Sie unter Textaufforderungen.

Text-Prompts testen

Wählen Sie eine der folgenden Methoden, um Textprompts zu testen.

REST

Senden Sie zum Testen eines Text-Prompts mit der Vertex AI API eine POST-Anfrage an den Endpunkt des Publisher-Modells.

Ersetzen Sie diese Werte in den folgenden Anfragedaten:

  • PROJECT_ID: Ihre Projekt-ID.
  • PROMPT: Ein Prompt ist eine Anfrage in natürlicher Sprache, die an ein Sprachmodell gesendet wird, um eine Antwort zu erhalten. Eingabeaufforderungen können Fragen, Anleitungen, Kontextinformationen, Beispiele und Text enthalten, die das Modell fertigstellen oder fortsetzen soll. (Hier keine Anführungszeichen um die Eingabeaufforderung hinzufügen.)
  • TEMPERATURE: Die Temperatur wird für die Probenahme während der Antwortgenerierung verwendet. Dies passiert, wenn topP und topK angewendet werden. Die Temperatur bestimmt den Grad der Zufälligkeit bei der Tokenauswahl. Niedrigere Temperaturen eignen sich gut für Prompts, die eine weniger offene oder kreative Antwort erfordern, während höhere Temperaturen zu vielfältigeren oder kreativeren Ergebnissen führen können. Eine Temperatur von 0 bedeutet, dass immer die Tokens mit der höchsten Wahrscheinlichkeit ausgewählt werden. In diesem Fall sind die Antworten auf einen bestimmten Prompt größtenteils deterministisch, aber eine gewisse Variation ist dennoch möglich.

    Wenn das Modell eine zu allgemeine oder zu kurze Antwort zurückgibt, oder wenn das Modell eine Fallback-Antwort ausgibt, versuchen Sie, die Temperatur zu erhöhen.

  • MAX_OUTPUT_TOKENS: Maximale Anzahl an Tokens, die in der Antwort generiert werden können. Ein Token besteht aus etwa vier Zeichen. 100 Tokens entsprechen etwa 60–80 Wörtern.

    Geben Sie kürzere Werte für kürzere Antworten und höhere Werte für längere Antworten an.

  • TOP_P_ Der Wert „Top-P“ ändert, wie das Modell Tokens für die Ausgabe auswählt. Die Tokens werden von den wahrscheinlichsten (siehe „Top-K“) bis zu den unwahrscheinlichsten Werten ausgewählt, bis die Summe ihrer Wahrscheinlichkeiten dem „Top-P“-Wert entspricht. Beispiel: Wenn die Tokens A, B und C eine Wahrscheinlichkeit von 0,3, 0,2 und 0,1 haben und der „Top-P“-Wert 0.5 ist, wählt das Modell anhand der Temperatur entweder A oder B als das nächste Token und C als Kandidaten ausschließen.

    Geben Sie einen niedrigeren Wert für weniger zufällige Antworten und einen höheren Wert für zufälligere Antworten an.

  • TOP_K: Der Wert „Top-K“ ändert, wie das Modell Tokens für die Ausgabe auswählt. Ein „Top-K“ von 1 bedeutet, dass das nächste ausgewählte Token unter den Tokens im Modell-Vokabular (auch als gierige Decodierung bezeichnet) am wahrscheinlichsten ist, während ein „Top-K“ von3 bedeutet, dass das nächste Token mithilfe der Temperatur aus den drei wahrscheinlichsten Tokens ausgewählt wird.

    Für jeden Tokenauswahlschritt werden die „Top-K“-Tokens mit den höchsten Wahrscheinlichkeiten abgetastet. Anschließend werden Tokens weiter auf der Grundlage von „Top-P“ gefiltert, wobei das endgültige Token mithilfe von Temperaturproben ausgewählt wird.

    Geben Sie einen niedrigeren Wert für weniger zufällige Antworten und einen höheren Wert für zufälligere Antworten an.

HTTP-Methode und URL:

POST https://us-central1-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/us-central1/publishers/google/models/text-bison:predict

JSON-Text der Anfrage:

{
  "instances": [
    { "prompt": "PROMPT"}
  ],
  "parameters": {
    "temperature": TEMPERATURE,
    "maxOutputTokens": MAX_OUTPUT_TOKENS,
    "topP": TOP_P,
    "topK": TOP_K
  }
}

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://us-central1-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/us-central1/publishers/google/models/text-bison:predict"

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://us-central1-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/us-central1/publishers/google/models/text-bison:predict" | Select-Object -Expand Content

Sie sollten eine JSON-Antwort ähnlich wie diese erhalten:

Beispiel für einen text-bison-curl-Befehl

MODEL_ID="text-bison"
PROJECT_ID=PROJECT_ID

curl \
-X POST \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
-H "Content-Type: application/json" \
https://us-central1-aiplatform.googleapis.com/v1/projects/${PROJECT_ID}/locations/us-central1/publishers/google/models/${MODEL_ID}:predict -d \
$'{
  "instances": [
    { "prompt": "Give me ten interview questions for the role of program manager." }
  ],
  "parameters": {
    "temperature": 0.2,
    "maxOutputTokens": 256,
    "topK": 40,
    "topP": 0.95
  }
}'

Python

Informationen zum Installieren oder Aktualisieren von Python finden Sie unter Vertex AI SDK für Python installieren. Weitere Informationen finden Sie in der Referenzdokumentation zur Python API. 

import vertexai
from vertexai.language_models import TextGenerationModel

def interview(
    temperature: float,
    project_id: str,
    location: str,
) -> str:
    """Ideation example with a Large Language Model"""

    vertexai.init(project=project_id, location=location)
    # TODO developer - override these parameters as needed:
    parameters = {
        "temperature": temperature,  # Temperature controls the degree of randomness in token selection.
        "max_output_tokens": 256,  # Token limit determines the maximum amount of text output.
        "top_p": 0.8,  # Tokens are selected from most probable to least until the sum of their probabilities equals the top_p value.
        "top_k": 40,  # A top_k of 1 means the selected token is the most probable among all tokens.
    }

    model = TextGenerationModel.from_pretrained("text-bison@002")
    response = model.predict(
        "Give me ten interview questions for the role of program manager.",
        **parameters,
    )
    print(f"Response from Model: {response.text}")

    return response.text

Go

Bevor Sie dieses Beispiel anwenden, folgen Sie den Go-Einrichtungsschritten in der Vertex AI-Kurzanleitung zur Verwendung von Clientbibliotheken. Weitere Informationen finden Sie in der Referenzdokumentation zur Vertex AI Go API.

Richten Sie zur Authentifizierung bei Vertex AI Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten. 


import (
	"context"
	"fmt"
	"io"

	aiplatform "cloud.google.com/go/aiplatform/apiv1beta1"
	"cloud.google.com/go/aiplatform/apiv1beta1/aiplatformpb"
	"google.golang.org/api/option"
	"google.golang.org/protobuf/types/known/structpb"
)

// textPredict generates text from prompt and configurations provided.
func textPredict(w io.Writer, prompt, projectID, location, publisher, model string, parameters map[string]interface{}) error {
	ctx := context.Background()

	apiEndpoint := fmt.Sprintf("%s-aiplatform.googleapis.com:443", location)

	client, err := aiplatform.NewPredictionClient(ctx, option.WithEndpoint(apiEndpoint))
	if err != nil {
		fmt.Fprintf(w, "unable to create prediction client: %v", err)
		return err
	}
	defer client.Close()

	// PredictRequest requires an endpoint, instances, and parameters
	// Endpoint
	base := fmt.Sprintf("projects/%s/locations/%s/publishers/%s/models", projectID, location, publisher)
	url := fmt.Sprintf("%s/%s", base, model)

	// Instances: the prompt to use with the text model
	promptValue, err := structpb.NewValue(map[string]interface{}{
		"prompt": prompt,
	})
	if err != nil {
		fmt.Fprintf(w, "unable to convert prompt to Value: %v", err)
		return err
	}

	// Parameters: the model configuration parameters
	parametersValue, err := structpb.NewValue(parameters)
	if err != nil {
		fmt.Fprintf(w, "unable to convert parameters to Value: %v", err)
		return err
	}

	// PredictRequest: create the model prediction request
	req := &aiplatformpb.PredictRequest{
		Endpoint:   url,
		Instances:  []*structpb.Value{promptValue},
		Parameters: parametersValue,
	}

	// PredictResponse: receive the response from the model
	resp, err := client.Predict(ctx, req)
	if err != nil {
		fmt.Fprintf(w, "error in prediction: %v", err)
		return err
	}

	fmt.Fprintf(w, "text-prediction response: %v", resp.Predictions[0])
	return nil
}

Java

Bevor Sie dieses Beispiel anwenden, folgen Sie den Java-Einrichtungsschritten in der Vertex AI-Kurzanleitung zur Verwendung von Clientbibliotheken. Weitere Informationen finden Sie in der Referenzdokumentation zur Vertex AI Java API.

Richten Sie zur Authentifizierung bei Vertex AI Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten. 


import com.google.cloud.aiplatform.v1beta1.EndpointName;
import com.google.cloud.aiplatform.v1beta1.PredictResponse;
import com.google.cloud.aiplatform.v1beta1.PredictionServiceClient;
import com.google.cloud.aiplatform.v1beta1.PredictionServiceSettings;
import com.google.protobuf.Value;
import com.google.protobuf.util.JsonFormat;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

public class PredictTextPromptSample {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    // Details of designing text prompts for supported large language models:
    // https://cloud.google.com/vertex-ai/docs/generative-ai/text/text-overview
    String instance =
        "{ \"prompt\": " + "\"Give me ten interview questions for the role of program manager.\"}";
    String parameters =
        "{\n"
            + "  \"temperature\": 0.2,\n"
            + "  \"maxOutputTokens\": 256,\n"
            + "  \"topP\": 0.95,\n"
            + "  \"topK\": 40\n"
            + "}";
    String project = "YOUR_PROJECT_ID";
    String location = "us-central1";
    String publisher = "google";
    String model = "text-bison@001";

    predictTextPrompt(instance, parameters, project, location, publisher, model);
  }

  // Get a text prompt from a supported text model
  public static void predictTextPrompt(
      String instance,
      String parameters,
      String project,
      String location,
      String publisher,
      String model)
      throws IOException {
    String endpoint = String.format("%s-aiplatform.googleapis.com:443", location);
    PredictionServiceSettings predictionServiceSettings =
        PredictionServiceSettings.newBuilder().setEndpoint(endpoint).build();

    // 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 (PredictionServiceClient predictionServiceClient =
        PredictionServiceClient.create(predictionServiceSettings)) {
      final EndpointName endpointName =
          EndpointName.ofProjectLocationPublisherModelName(project, location, publisher, model);

      // Initialize client that will be used to send requests. This client only needs to be created
      // once, and can be reused for multiple requests.
      Value.Builder instanceValue = Value.newBuilder();
      JsonFormat.parser().merge(instance, instanceValue);
      List<Value> instances = new ArrayList<>();
      instances.add(instanceValue.build());

      // Use Value.Builder to convert instance to a dynamically typed value that can be
      // processed by the service.
      Value.Builder parameterValueBuilder = Value.newBuilder();
      JsonFormat.parser().merge(parameters, parameterValueBuilder);
      Value parameterValue = parameterValueBuilder.build();

      PredictResponse predictResponse =
          predictionServiceClient.predict(endpointName, instances, parameterValue);
      System.out.println("Predict Response");
      System.out.println(predictResponse);
    }
  }
}

Node.js

Bevor Sie dieses Beispiel anwenden, folgen Sie den Node.js-Einrichtungsschritten in der Vertex AI-Kurzanleitung zur Verwendung von Clientbibliotheken. Weitere Informationen finden Sie in der Referenzdokumentation zur Vertex AI Node.js API.

Richten Sie zur Authentifizierung bei Vertex AI Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten. 

/**
 * TODO(developer): Uncomment these variables before running the sample.\
 * (Not necessary if passing values as arguments)
 */
// const project = 'YOUR_PROJECT_ID';
// const location = 'YOUR_PROJECT_LOCATION';
const aiplatform = require('@google-cloud/aiplatform');

// Imports the Google Cloud Prediction service client
const {PredictionServiceClient} = aiplatform.v1;

// Import the helper module for converting arbitrary protobuf.Value objects.
const {helpers} = aiplatform;

// Specifies the location of the api endpoint
const clientOptions = {
  apiEndpoint: 'us-central1-aiplatform.googleapis.com',
};

const publisher = 'google';
const model = 'text-bison@001';

// Instantiates a client
const predictionServiceClient = new PredictionServiceClient(clientOptions);

async function callPredict() {
  // Configure the parent resource
  const endpoint = `projects/${project}/locations/${location}/publishers/${publisher}/models/${model}`;

  const prompt = {
    prompt:
      'Give me ten interview questions for the role of program manager.',
  };
  const instanceValue = helpers.toValue(prompt);
  const instances = [instanceValue];

  const parameter = {
    temperature: 0.2,
    maxOutputTokens: 256,
    topP: 0.95,
    topK: 40,
  };
  const parameters = helpers.toValue(parameter);

  const request = {
    endpoint,
    instances,
    parameters,
  };

  // Predict request
  const response = await predictionServiceClient.predict(request);
  console.log('Get text prompt response');
  console.log(response);
}

callPredict();

C#

Bevor Sie dieses Beispiel anwenden, folgen Sie den C#-Einrichtungsschritten in der Vertex AI-Kurzanleitung zur Verwendung von Clientbibliotheken. Weitere Informationen finden Sie in der Referenzdokumentation zur Vertex AI C# API.

Richten Sie zur Authentifizierung bei Vertex AI Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten. 


using Google.Cloud.AIPlatform.V1;
using System;
using System.Collections.Generic;
using System.Linq;
using Value = Google.Protobuf.WellKnownTypes.Value;

public class PredictTextPromptSample
{
    public string PredictTextPrompt(
        string projectId = "your-project-id",
        string locationId = "us-central1",
        string publisher = "google",
        string model = "text-bison@001"
    )
    {
        // Initialize client that will be used to send requests.
        // This client only needs to be created
        // once, and can be reused for multiple requests.
        var client = new PredictionServiceClientBuilder
        {
            Endpoint = $"{locationId}-aiplatform.googleapis.com"
        }.Build();

        // Configure the parent resource
        var endpoint = EndpointName.FromProjectLocationPublisherModel(projectId, locationId, publisher, model);

        // Initialize request argument(s)
        var prompt = "Give me ten interview questions for the role of program manager.";

        var instanceValue = Value.ForStruct(new()
        {
            Fields =
            {
                ["prompt"] = Value.ForString(prompt)
            }
        });

        var instances = new List<Value>
        {
            instanceValue
        };

        var parameters = Value.ForStruct(new()
        {
            Fields =
            {
                { "temperature", new Value { NumberValue = 0.2 } },
                { "maxOutputTokens", new Value { NumberValue = 256 } },
                { "topP", new Value { NumberValue = 0.95 } },
                { "topK", new Value { NumberValue = 40 } }
            }
        });

        // Make the request
        var response = client.Predict(endpoint, instances, parameters);

        // Parse and return the content.
        var content = response.Predictions.First().StructValue.Fields["content"].StringValue;
        Console.WriteLine($"Content: {content}");
        return content;
    }
}

Ruby

Bevor Sie dieses Beispiel anwenden, folgen Sie den Ruby-Einrichtungsschritten in der Vertex AI-Kurzanleitung zur Verwendung von Clientbibliotheken. Weitere Informationen finden Sie in der Referenzdokumentation zur Vertex AI Ruby API.

Richten Sie zur Authentifizierung bei Vertex AI Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten. 

require "google/cloud/ai_platform/v1"

##
# Vertex AI Predict Text Prompt
#
# @param project_id [String] Your Google Cloud project (e.g. "my-project")
# @param location_id [String] Your Processor Location (e.g. "us-central1")
# @param publisher [String] The Model Publisher (e.g. "google")
# @param model [String] The Model Identifier (e.g. "text-bison@001")
#
def predict_text_prompt project_id:, location_id:, publisher:, model:
  # Create the Vertex AI client.
  client = ::Google::Cloud::AIPlatform::V1::PredictionService::Client.new do |config|
    config.endpoint = "#{location_id}-aiplatform.googleapis.com"
  end

  # Build the resource name from the project.
  endpoint = client.endpoint_path(
    project: project_id,
    location: location_id,
    publisher: publisher,
    model: model
  )

  prompt = "Give me ten interview questions for the role of program manager."

  # Initialize the request arguments
  instance = Google::Protobuf::Value.new(
    struct_value: Google::Protobuf::Struct.new(
      fields: {
        "prompt" => Google::Protobuf::Value.new(
          string_value: prompt
        )
      }
    )
  )

  instances = [instance]

  parameters = Google::Protobuf::Value.new(
    struct_value: Google::Protobuf::Struct.new(
      fields: {
        "temperature" => Google::Protobuf::Value.new(number_value: 0.2),
        "maxOutputTokens" => Google::Protobuf::Value.new(number_value: 256),
        "topP" => Google::Protobuf::Value.new(number_value: 0.95),
        "topK" => Google::Protobuf::Value.new(number_value: 40)
      }
    )
  )

  # Make the prediction request
  response = client.predict endpoint: endpoint, instances: instances, parameters: parameters

  # Handle the prediction response
  puts "Predict Response"
  puts response
end

Console

Führen Sie die folgenden Schritte aus, um einen Textprompt mithilfe von Vertex AI Studio in der Google Cloud Console zu testen:

  1. Rufen Sie im Bereich „Vertex AI“ der Google Cloud Console die Seite Vertex AI Studio auf.

    Zu Vertex AI Studio

  2. Klicken Sie auf den Tab Jetzt starten.
  3. Klicken Sie auf Textprompt.

  4. Wählen Sie die Methode zum Eingeben des Prompts aus:

    • Freies Format wird für Zero-Shot-Prompts oder oder das Kopieren und Einfügen von Few-Shot-Prompts empfohlen.
    • Strukturiert wird für das Entwerfen von Few-Shot-Prompts in Vertex AI Studio empfohlen.

    Freies Format

    Geben Sie Ihren Prompt in das Textfeld Prompt ein.

    Strukturiert

    Die strukturierte Methode zur Eingabe von Prompts trennt die Komponenten eines Prompts in verschiedene Felder:

    • Kontext: Geben Sie eine Anleitung für die Aufgabe ein, die das Modell ausführen soll, und fügen Sie Kontextinformationen als Referenzmaterial für das Modell hinzu.
    • Beispiele: Fügen Sie für kurzzeitige Aufforderungen Beispiele für Eingabeausgaben hinzu, die die Verhaltensmuster des Modells imitieren. Das Hinzufügen eines Präfixes zur Beispieleingabe und -ausgabe ist optional. Wenn Sie Präfixe hinzufügen, müssen diese in allen Beispielen konsistent sein.
    • Test: Geben Sie im Feld Eingabe die Eingabe des Prompts ein, für den Sie eine Antwort erhalten möchten. Das Hinzufügen eines Präfixes für die Testeingabe und -ausgabe ist optional. Wenn Ihre Beispiele Präfixe haben, sollte der Test die gleichen Präfixe haben.

  5. Konfigurieren Sie Modell und Parameter:

    • Modell: Wählen Sie ein text-bison- oder gemini-1.0-pro-Modell aus.

    • Temperaturen: Geben Sie über den Schieberegler oder das Textfeld einen Temperaturwert ein.

      Die Temperatur wird für die Probenahme während der Antwortgenerierung verwendet. Dies passiert, wenn topP und topK angewendet werden. Die Temperatur bestimmt den Grad der Zufälligkeit bei der Tokenauswahl. Niedrigere Temperaturen eignen sich gut für Prompts, die eine weniger offene oder kreative Antwort erfordern, während höhere Temperaturen zu vielfältigeren oder kreativeren Ergebnissen führen können. Eine Temperatur von 0 bedeutet, dass immer die Tokens mit der höchsten Wahrscheinlichkeit ausgewählt werden. In diesem Fall sind die Antworten auf einen bestimmten Prompt größtenteils deterministisch, aber eine gewisse Variation ist dennoch möglich.

      Wenn das Modell eine zu allgemeine oder zu kurze Antwort zurückgibt, oder wenn das Modell eine Fallback-Antwort ausgibt, versuchen Sie, die Temperatur zu erhöhen.

    • Token-Limit: Verwenden Sie den Schieberegler oder das Textfeld, um einen Wert für das maximale Ausgabelimit einzugeben.

      Maximale Anzahl an Tokens, die in der Antwort generiert werden können. Ein Token besteht aus etwa vier Zeichen. 100 Tokens entsprechen etwa 60–80 Wörtern.

      Geben Sie kürzere Werte für kürzere Antworten und höhere Werte für längere Antworten an.

    • Top-K: Sie können den Schieberegler oder das Textfeld verwenden, um einen Wert für Top-K einzugeben.

      Der Wert „Top-K“ ändert, wie das Modell Tokens für die Ausgabe auswählt. Ein „Top-K“ von 1 bedeutet, dass das nächste ausgewählte Token unter den Tokens im Modell-Vokabular (auch als gierige Decodierung bezeichnet) am wahrscheinlichsten ist, während ein „Top-K“ von 3 bedeutet, dass das nächste Token mithilfe der Temperatur aus den drei wahrscheinlichsten Tokens ausgewählt wird.

      Für jeden Tokenauswahlschritt werden die „Top-K“-Tokens mit den höchsten Wahrscheinlichkeiten abgetastet. Anschließend werden Tokens weiter auf der Grundlage von „Top-P“ gefiltert, wobei das endgültige Token mithilfe von Temperaturproben ausgewählt wird.

      Geben Sie einen niedrigeren Wert für weniger zufällige Antworten und einen höheren Wert für zufälligere Antworten an.

    • Top-P: Verwenden Sie den Schieberegler oder das Textfeld, um einen Wert für „Top-P“ einzugeben. Tokens werden vom wahrscheinlichsten bis zum am wenigsten wahrscheinlichen Token ausgewählt, bis die Summe ihrer Wahrscheinlichkeiten dem Wert von „Top-P“ entspricht. Für die Ergebnisse der geringsten Variablen legen Sie Top-P auf 0 fest.
  6. Klicken Sie auf Senden.
  7. Optional: Klicken Sie auf Speichern, um die Eingabeaufforderung unter Meine Prompts zu speichern.
  8. Optional: Klicken Sie auf Code anzeigen, um den Python-Code oder einen curl-Befehl für die Eingabeaufforderung abzurufen.

Streamantwort vom Textmodell

Beispiele für die Verwendung von REST API-Beispielanfragen und -Antworten finden Sie unter Beispiele, die die REST-API verwenden.

Um Beispielcodeanfragen und -antworten mit dem Vertex AI SDK für Python anzuzeigen, lesen Sie Beispiele, die Vertex AI SDK für Python verwenden.

Nächste Schritte