Diese Seite wurde von der Cloud Translation API übersetzt.

Codechat

Codey for Code Chat (codechat-bison) ist der Name des Modells, das Codechat unterstützt. Es ist ein Foundation Model, das auf Code spezialisierte Multi-Thread-Unterhaltungen unterstützt. Dank dem Modell können Entwickler mit einem Chatbot chatten, um Hilfe bei codebezogenen Fragen zu erhalten. Die Code-Chat-API wird für die Kommunikation mit dem Codey for Code Chat-Modell verwendet.

Codey for Code Chat ist ideal für Codeaufgaben mit abwechselnden Interaktionen, damit Sie eine kontinuierliche Unterhaltung führen können. Für Codeaufgaben, die nur eine einzelne Interaktion erfordern, verwenden Sie die API für den Codeabschluss oder die API für die Codegenerierung.

Weitere Informationen zu diesem Modell finden Sie in der Console auf der Modellkarte "Codey for Code Chat" im Model Garden.
Zum Model Garden

Anwendungsfälle

Typische Anwendungsfälle für Codechat:

Hilfe zu Code erhalten: Sie erhalten Hilfe bei Fragen zu Code, z. B. Fragen zu einer API, zur Syntax in einer unterstützten Programmiersprache oder dazu, welche Version einer Bibliothek für den Code benötigt wird, den Sie schreiben.
Debugging: Sie erhalten Hilfe bei der Fehlerbehebung von Code, der sich nicht kompilieren lässt oder einen Fehler enthält.
Dokumentation: Sie erhalten Hilfe beim Verständnis von Code, damit Sie den Code genau dokumentieren können.
Informationen zu Code: Hier erfahren Sie mehr über Code, mit dem Sie nicht vertraut sind.

HTTP-Anfrage

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

Modellversionen

Wenn Sie die neueste Modellversion verwenden möchten, geben Sie den Modellnamen ohne Versionsnummer an, z. B. codechat-bison.

Wenn Sie eine stabile Modellversion verwenden möchten, geben Sie die Modellversionsnummer an, z. B. codechat-bison@002. Stabile Versionen sind ab dem Releasedatum der nachfolgenden stabilen Version noch sechs Monate verfügbar.

Die folgende Tabelle enthält die verfügbaren stabilen Modellversionen:

Codechat-Bison-Modell	Veröffentlicht	Einstellungsdatum
codechat-bison@002	6. Dezember 2023	9. Oktober 2024
codechat-bison@001	29. Juni 2023	6. Juli 2024

Weitere Informationen finden Sie unter Modellversionen und Lebenszyklus.

Anfragetext

{
  "instances": [
    {
      "context": string,
      "messages": [
        {
          "content": string,
          "author": string
        }
      ]
    }
  ],
  "parameters":{
    "temperature": number,
    "maxOutputTokens": integer,
    "candidateCount": integer,
    "logprobs": integer,
    "presencePenalty": float,
    "frequencyPenalty": float,
    "seed": integer
  }
}

Im Folgenden finden Sie die Parameter für das Codechat-Modell namens codechat-bison. Das codechat-bison-Modell ist eines der Modelle in Codey. Mit diesen Parametern können Sie Ihre Eingabeaufforderung für eine Chatbot-Unterhaltung über Code optimieren. Weitere Informationen finden Sie in der Übersicht: Codemodelle und unter Aufforderungen zum Chatten über Code erstellen.

Parameter	Beschreibung	Zulässige Werte
`context`	Text, der dem Modell im Voraus als Antwortbasis bereitgestellt werden sollte.	Text
`messages` (erforderlich)	Unterhaltungsverlauf, der dem Modell in einem strukturierten alternate-author-Format bereitgestellt wird. Nachrichten werden in chronologischer Reihenfolge angezeigt: älteste zuerst, neueste zuletzt. Führt der Verlauf der Nachrichten dazu, dass die Eingabe die maximale Länge überschreitet, werden die ältesten Nachrichten entfernt, bis die Eingabeaufforderung innerhalb des zulässigen Limits liegt.	List[Structured Message] "author": "user", "content": "user message"
`temperature` (optional)	: Die Temperatur wird für die Probenahme während der Antwortgenerierung verwendet. 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 Abweichung ist dennoch möglich.	`0.0–1.0` `Default: 0.2`
`maxOutputTokens` (optional)	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 potentiell längere Antworten an.	`1–2048` `Default: 1024`
`candidateCount` (optional)	Die Anzahl der zurückzugebenden Antwortvarianten.	`1-4` `Default: 1`
`logprobs` (optional)	Gibt die wahrscheinlichsten Kandidaten-Token von `logprobs` mit ihren Log-Wahrscheinlichkeiten bei jedem Generierungsschritt zurück. Die ausgewählten Tokens und ihre Logwahrscheinlichkeiten bei jedem Schritt werden immer zurückgegeben. Das ausgewählte Token befindet sich möglicherweise in den oberen `logprobs` der wahrscheinlichsten Kandidaten.	`0-5`
`frequencyPenalty` (optional)	Positive Werte nehmen Abzüge bei Tokens vor, die wiederholt im generierten Text angezeigt werden, wodurch die Wahrscheinlichkeit wiederholter Inhalte verringert wird. Akzeptable Werte sind `-2.0`–`2.0`.	`Minimum value: -2.0 Maximum value: 2.0`
`presencePenalty` (optional)	Positive Werte nehmen Abzüge bei Tokens vor, die wiederholt im generierten Text angezeigt werden, wodurch die Wahrscheinlichkeit wiederholter Inhalte verringert wird. Akzeptable Werte sind `-2.0`–`2.0`.	`Minimum value: -2.0 Maximum value: 2.0`
`seed`	Decoder generiert ein zufälliges Rauschen mit einem Pseudozufallszahlengenerator. Vor der Stichprobenerfassung wird Logits ein Temperaturrauschen* hinzugefügt. Der Pseudozufallszahlengenerator (prng) verwendet einen Seed als Eingabe, generiert dieselbe Ausgabe mit demselben Seed. Wenn das Seed nicht festgelegt wird, ist der im Decoder verwendete Seed nicht deterministisch, sodass auch das generierte Zufallsrauschen nicht deterministisch ist. Wenn das Seed festgelegt ist, ist das erzeugte zufällige Rauschen deterministisch.	`Optional`

Beispielanfrage

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.

Anfragetext

HTTP-Methode und URL:

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

JSON-Text der Anfrage:

{
  "instances": [
    {
      "messages": [
        {
          "author": "AUTHOR",
          "content": "CONTENT"
        }
      ]
    }
  ],
  "parameters": {
    "temperature": TEMPERATURE,
    "maxOutputTokens": MAX_OUTPUT_TOKENS,
    "candidateCount": CANDIDATE_COUNT
  }
}

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

curl

Hinweis: Der folgende Befehl setzt voraus, dass Sie sich mit Ihrem Nutzerkonto bei der gcloud CLI angemeldet haben. Dazu haben Sie gcloud init oder gcloud auth login ausgeführt oder die Cloud Shell genutzt, die Sie automatisch bei der gcloud CLI anmeldet. Um herauszufinden, welches Konto gerade aktiv ist, führen Sie gcloud auth list aus.

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/codechat-bison:predict"

PowerShell

Hinweis: Der folgende Befehl setzt voraus, dass Sie sich mit Ihrem Nutzerkonto bei der gcloud CLI angemeldet haben. Dazu führen Sie gcloud init oder gcloud auth login aus. Um herauszufinden, welches Konto gerade aktiv ist, führen Sie gcloud auth list aus.

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/codechat-bison:predict" | Select-Object -Expand Content

Sie sollten eine JSON-Antwort ähnlich wie die Beispielantwort erhalten.

Python

Informationen zur Installation des Vertex AI SDK for Python finden Sie unter Vertex AI SDK for Python installieren. Weitere Informationen finden Sie in der Referenzdokumentation zur Python API.

from vertexai.language_models import CodeChatModel

# TODO developer - override these parameters as needed:
parameters = {
    "temperature": temperature,  # Temperature controls the degree of randomness in token selection.
    "max_output_tokens": 1024,  # Token limit determines the maximum amount of text output.
}

code_chat_model = CodeChatModel.from_pretrained("codechat-bison@001")
chat = code_chat_model.start_chat()

response = chat.send_message(
    "Please help write a function to calculate the min of two numbers", **parameters
)
print(f"Response from Model: {response.text}")

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 = 'codechat-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}`;

  // Learn more about creating prompts to work with a code chat model at:
  // https://cloud.google.com/vertex-ai/docs/generative-ai/code/code-chat-prompts
  const prompt = {
    messages: [
      {
        author: 'user',
        content: 'Hi, how are you?',
      },
      {
        author: 'system',
        content: 'I am doing good. What can I help you in the coding world?',
      },
      {
        author: 'user',
        content:
          'Please help write a function to calculate the min of two numbers',
      },
    ],
  };
  const instanceValue = helpers.toValue(prompt);
  const instances = [instanceValue];

  const parameter = {
    temperature: 0.5,
    maxOutputTokens: 1024,
  };
  const parameters = helpers.toValue(parameter);

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

  // Predict request
  const [response] = await predictionServiceClient.predict(request);
  console.log('Get code chat response');
  const predictions = response.predictions;
  console.log('\tPredictions :');
  for (const prediction of predictions) {
    console.log(`\t\tPrediction : ${JSON.stringify(prediction)}`);
  }
}

callPredict();

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.v1.EndpointName;
import com.google.cloud.aiplatform.v1.PredictResponse;
import com.google.cloud.aiplatform.v1.PredictionServiceClient;
import com.google.cloud.aiplatform.v1.PredictionServiceSettings;
import com.google.protobuf.InvalidProtocolBufferException;
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 PredictCodeChatSample {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace this variable before running the sample.
    String project = "YOUR_PROJECT_ID";

    // Learn more about creating prompts to work with a code chat model at:
    // https://cloud.google.com/vertex-ai/docs/generative-ai/code/code-chat-prompts
    String instance =
        "{ \"messages\": [\n"
            + "{\n"
            + "  \"author\": \"user\",\n"
            + "  \"content\": \"Hi, how are you?\"\n"
            + "},\n"
            + "{\n"
            + "  \"author\": \"system\",\n"
            + "  \"content\": \"I am doing good. What can I help you in the coding world?\"\n"
            + " },\n"
            + "{\n"
            + "  \"author\": \"user\",\n"
            + "  \"content\":\n"
            + "     \"Please help write a function to calculate the min of two numbers.\"\n"
            + "}\n"
            + "]}";
    String parameters = "{\n" + "  \"temperature\": 0.5,\n" + "  \"maxOutputTokens\": 1024\n" + "}";
    String location = "us-central1";
    String publisher = "google";
    String model = "codechat-bison@001";

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

  // Use a code chat model to generate a code function
  public static void predictCodeChat(
      String instance,
      String parameters,
      String project,
      String location,
      String publisher,
      String model)
      throws IOException {
    final 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);

      Value instanceValue = stringToValue(instance);
      List<Value> instances = new ArrayList<>();
      instances.add(instanceValue);

      Value parameterValue = stringToValue(parameters);

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

  // Convert a Json string to a protobuf.Value
  static Value stringToValue(String value) throws InvalidProtocolBufferException {
    Value.Builder builder = Value.newBuilder();
    JsonFormat.parser().merge(value, builder);
    return builder.build();
  }
}

Antworttext

{
  "predictions": [
    {
      "candidates": [
        {
          "author": string,
          "content": string
        }
      ],
      "citationMetadata": {
        "citations": [
          {
            "startIndex": integer,
            "endIndex": integer,
            "url": string,
            "title": string,
            "license": string,
            "publicationDate": string
          }
        ]
      },
      "logprobs": {
        "tokenLogProbs": [ float ],
        "tokens": [ string ],
        "topLogProbs": [ { map<string, float> } ]
      },
      "safetyAttributes":{
        "categories": [ string ],
        "blocked": false,
        "scores": [ float ]
      },
      "score": float
    }
  ]
}

Antwortelement	Beschreibung
`author`	Ein `string`, der den Autor einer Chatantwort angibt.
`blocked`	Ein `boolean`-Flag, das mit einem Sicherheitsattribut verknüpft ist, das angibt, ob die Ein- oder Ausgabe des Modells blockiert wurde. Wenn `blocked` den Wert `true` hat, enthält das Feld `errors` in der Antwort einen oder mehrere Fehlercodes. Wenn `blocked` den Wert `false` hat, enthält die Antwort nicht das Feld `errors`.
`categories`	Eine Liste der Namen der Sicherheitsattribute, die den generierten Inhalten zugeordnet sind. Die Reihenfolge der Scores im `scores`-Parameter entspricht der Reihenfolge der Kategorien. Der erste Wert im `scores`-Parameter gibt beispielsweise die Wahrscheinlichkeit an, mit der die Antwort gegen die erste Kategorie in der `categories`-Liste verstößt.
`content`	Der Inhalt einer Chatantwort.
`endIndex`	Eine Ganzzahl, die angibt, wo eine Zitation in `content` endet.
`errors`	Ein Array von Fehlercodes. Das Antwortfeld `errors` ist nur in der Antwort enthalten, wenn das Feld `blocked` in der Antwort `true` ist. Informationen zum Verständnis von Fehlercodes finden Sie unter Sicherheitsfehler.
`license`	Die mit einer Zitation verknüpfte Lizenz.
`publicationDate`	Das Datum, an dem ein Zitat veröffentlicht wurde. Die gültigen Formate sind `YYYY`, `YYYY-MM` und `YYYY-MM-DD`.
`safetyAttributes`	Eine Reihe an Sicherheitsattributen. Das Array enthält für jeden Antwortkandidaten ein Sicherheitsattribut.
`score`	Ein `float`-Wert, der kleiner als null ist. Je höher der Wert für `score`, desto größer ist das Vertrauen des Modells in seine Antwort.
`scores`	Ein Array von `float`-Werten. Die einzelnen Werte sind Scores, die die Wahrscheinlichkeit angeben, dass die Antwort gegen die Sicherheitskategorie verstößt, auf die sie geprüft wird. Je niedriger der Wert ist, als desto sicherer nimmt das Modell die Antwort an. Die Reihenfolge der Scores im Array entspricht der Reihenfolge der Sicherheitsattribute im Antwortelement `categories`.
`startIndex`	Eine Ganzzahl, die angibt, wo eine Zitation im Inhalt beginnt.
`title`	Der Titel einer Zitationsquelle. Beispiele für Quelltitel sind der eines Nachrichtenartikels oder eines Buches.
`url`	Die URL einer Zitationsquelle. Beispiele für eine URL-Quelle sind beispielsweise eine Nachrichtenwebsite oder ein GitHub-Repository.
`tokens`	Die Stichprobentokens.
`tokenLogProbs`	Die Logwahrscheinlichkeit der Stichprobentokens.
`topLogProbs`	Die wahrscheinlichsten Tokens und ihre Logwahrscheinlichkeit bei jedem Schritt
`logprobs`	Ergebnisse des Parameters „logprobs”. 1:1-Zuordnung zu "Kandidaten".

Beispielantwort

{
  "predictions": [
    {
      "citationMetadata": [
        {
          "citations": []
        }
      ],
      "candidates": [
        {
          "author": "AUTHOR",
          "content": "RESPONSE"
        }
      ],
      "safetyAttributes": {
        "categories": [],
        "blocked": false,
        "scores": []
      },
      "score": -1.1161688566207886
    }
  ]
}

Streamantwort von Modellen der generativen KI.

Die Parameter für Streaming- und Nicht-Streaming-Anfragen an die APIs sind identisch.

Beispiele für die Verwendung von REST API-Beispielanfragen und -Antworten finden Sie unter Beispiele, die die Streaming-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 zum Streaming verwenden.