Halaman ini diterjemahkan oleh Cloud Translation API.

Chat teks

Model dasar PaLM 2 untuk Chat (chat-bison) adalah model bahasa besar (LLM) yang andal dalam pemahaman bahasa, pembuatan bahasa, dan percakapan. Model chat ini telah disesuaikan untuk melakukan percakapan multi-giliran yang alami, dan ideal untuk tugas teks tentang kode yang memerlukan interaksi bolak-balik.

Untuk tugas teks yang dapat diselesaikan dengan satu respons API (tanpa memerlukan percakapan bersambung), gunakan Model teks.

Untuk menjelajahi model ini di konsol, lihat kartu model PaLM 2 for Chat di Model Garden.
Buka Model Garden

Kasus penggunaan

Layanan Pelanggan: Menginstruksikan model untuk merespons sebagai agen layanan pelanggan yang hanya membahas produk perusahaan Anda
Dukungan Teknis: Menginstruksikan model untuk berinteraksi dengan pelanggan sebagai agen pusat panggilan dengan parameter khusus tentang cara merespons dan hal yang tidak boleh dikatakan
Persona dan karakter: Menginstruksikan model untuk merespons dengan gaya orang tertentu ("...dengan gaya Shakespeare")
Pendamping situs: Membuat asisten percakapan untuk belanja, perjalanan, dan kasus penggunaan lainnya

Untuk mengetahui informasi selengkapnya, lihat Mendesain perintah chat.

Permintaan HTTP

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

Untuk informasi selengkapnya, lihat metode predict.

Versi model

Untuk menggunakan versi model terbaru, tentukan nama model tanpa nomor versi, misalnya chat-bison.

Untuk menggunakan versi model stabil, tentukan nomor versi model, misalnya chat-bison@002. Setiap versi stabil tersedia selama enam bulan setelah tanggal rilis versi stabil berikutnya.

Tabel berikut berisi versi model stabil yang tersedia:

model chat-bison	Tanggal rilis	Tanggal penghentian
chat-bison@002	6 Desember 2023	9 April 2025

Untuk mengetahui informasi selengkapnya, baca Versi dan siklus proses model.

Isi permintaan

{
  "instances": [
    {
      "context":  string,
      "examples": [
        {
          "input": { "content": string },
          "output": { "content": string }
        }
      ],
      "messages": [
        {
          "author": string,
          "content": string,
        }
      ],
    }
  ],
  "parameters": {
    "temperature": number,
    "maxOutputTokens": integer,
    "topP": number,
    "topK": integer,
    "groundingConfig": string,
    "stopSequences": [ string ],
    "candidateCount": integer
    "logprobs": integer,
    "presencePenalty": float,
    "frequencyPenalty": float,
    "seed": integer
  }
}

Untuk panggilan API chat, context, examples, dan messages digabungkan untuk membentuk perintah. Tabel berikut menunjukkan parameter yang perlu Anda konfigurasi untuk Vertex AI PaLM API untuk teks:

Parameter	Deskripsi	Nilai yang dapat diterima
`context` (opsional)	Konteks menentukan bagaimana model merespons sepanjang percakapan. Misalnya, Anda dapat menggunakan konteks untuk menentukan kata-kata yang bisa atau tidak dapat digunakan model, topik yang harus difokuskan atau dihindari, atau format atau gaya respons.	Teks
`examples` (opsional)	Contoh bagi model untuk mempelajari cara merespons percakapan.	[{ "input": {"content": "provide content"}, "output": {"content": "provide content"} }]
`messages` (wajib)	Histori percakapan yang diberikan kepada model dalam formulir penulis alternatif terstruktur. Pesan muncul dalam urutan kronologis: terlama dulu, terbaru terakhir. Jika histori pesan menyebabkan input melebihi panjang maksimum, pesan yang paling lama akan dihapus hingga seluruh perintah berada dalam batas yang diizinkan.	[{ "author": "user", "content": "user message" }]
`temperature`	Suhu digunakan untuk pengambilan sampel selama pembuatan respons, yang terjadi saat `topP` dan `topK` diterapkan. Suhu mengontrol tingkat keacakan dalam pemilihan token. Suhu yang lebih rendah cocok untuk perintah yang memerlukan respons yang kurang terbuka atau kreatif, sedangkan suhu yang lebih tinggi dapat memberikan hasil yang lebih beragam atau kreatif. Suhu `0` berarti token probabilitas tertinggi selalu dipilih. Dalam hal ini, respons untuk permintaan tertentu sebagian besar deterministik, tetapi sedikit variasi masih dapat dilakukan. Jika model menampilkan respons yang terlalu umum, terlalu pendek, atau model memberikan respons pengganti, coba tingkatkan suhunya.	`0.0–1.0` `Default: 0.0`
`maxOutputTokens`	Jumlah maksimum token yang dapat dibuat dalam respons. Token terdiri dari sekitar empat karakter. 100 token setara dengan sekitar 60-80 kata. Tentukan nilai yang lebih rendah untuk respons yang lebih singkat dan nilai yang lebih tinggi untuk respons yang berpotensi lebih panjang.	`1–2048` `Default: 1024`
`topK`	Top-K mengubah cara model memilih token untuk output. Top-K `1` berarti token yang dipilih berikutnya adalah yang paling mungkin di antara semua token dalam kosakata model (juga disebut decoding greedy), sedangkan top-K `3` berarti token berikutnya dipilih di antara tiga token yang paling mungkin dengan menggunakan suhu. Untuk setiap langkah pemilihan token, token top-K dengan probabilitas tertinggi akan diambil sampelnya. Kemudian token akan difilter lebih lanjut berdasarkan top-P dengan token akhir yang dipilih menggunakan pengambilan sampel suhu. Tentukan nilai yang lebih rendah untuk respons acak yang lebih sedikit dan nilai yang lebih tinggi untuk respons acak yang lebih banyak.	`1–40` `Default: 40`
`topP`	Top-P mengubah cara model memilih token untuk output. Token dipilih dari yang paling mungkin (lihat top-K) hingga yang paling tidak mungkin sampai jumlah probabilitasnya sama dengan nilai top-P. Misalnya, jika token A, B, dan C memiliki probabilitas 0,3, 0,2, dan 0,1 dengan nilai top-P `0.5`, model akan memilih A atau B sebagai token berikutnya dengan menggunakan suhu dan mengecualikan C sebagai kandidat. Tentukan nilai yang lebih rendah untuk respons acak yang lebih sedikit dan nilai yang lebih tinggi untuk respons acak yang lebih banyak.	`0.0–1.0` `Default: 0.95`
`stopSequences`	Menentukan daftar string yang memberi tahu model untuk berhenti menghasilkan teks jika salah satu string ditemukan dalam respons. Jika string muncul beberapa kali dalam respons, respons akan dipotong di tempatnya pertama kali ditemukan. String peka huruf besar/kecil. Misalnya, jika respons berikut adalah respons yang ditampilkan saat `stopSequences` tidak ditentukan: `public static string reverse(string myString)` Kemudian respons yang ditampilkan dengan `stopSequences` ditetapkan ke `["Str", "reverse"]` adalah: `public static string`	`default: []`
`groundingConfig`	Pembumian memungkinkan Anda mereferensikan data tertentu saat menggunakan model bahasa. Saat Anda mendasari model, model tersebut dapat mereferensikan data internal, rahasia, dan data spesifik lainnya dari repositori Anda dan menyertakan data dalam respons. Hanya penyimpanan data dari Vertex AI Search yang didukung.	Jalur harus mengikuti format: `projects/{project_id}/locations/global/collections/{collection_name}/dataStores/{DATA_STORE_ID}`
`candidateCount`	Jumlah variasi respons yang akan ditampilkan. Untuk setiap permintaan, Anda dikenai biaya untuk token output dari semua kandidat, tetapi hanya dikenai biaya satu kali untuk token input. Menentukan beberapa kandidat adalah fitur Pratinjau yang berfungsi dengan `generateContent` (`streamGenerateContent` tidak didukung). Model berikut didukung: Gemini 1.5 Flash: `1`-`8`, default: `1` Gemini 1.5 Pro: `1`-`8`, default: `1` Gemini 1.0 Pro: `1`-`8`, default: `1`	`1–4` `Default: 1`
`logprobs`	Menampilkan log probabilitas token kandidat teratas pada setiap langkah pembuatan. Token yang dipilih model mungkin tidak sama dengan token kandidat teratas di setiap langkah. Tentukan jumlah kandidat yang akan ditampilkan menggunakan nilai bilangan bulat dalam rentang `1`-`5`.	`0-5`
`frequencyPenalty`	Nilai positif akan menghukum token yang berulang kali muncul dalam teks yang dihasilkan, sehingga mengurangi kemungkinan konten berulang. Nilai minimumnya adalah `-2.0`. Nilai maksimumnya adalah hingga, tetapi tidak termasuk, `2.0`.	`Minimum value: -2.0` `Maximum value: 2.0`
`presencePenalty`	Nilai positif akan menghukum token yang sudah muncul dalam teks yang dihasilkan, sehingga meningkatkan probabilitas untuk menghasilkan konten yang lebih beragam. Nilai minimumnya adalah `-2.0`. Nilai maksimumnya adalah hingga, tetapi tidak termasuk, `2.0`.	`Minimum value: -2.0` `Maximum value: 2.0`
`seed`	Jika seed ditetapkan ke nilai tertentu, model akan berusaha sebaik mungkin untuk memberikan respons yang sama untuk permintaan berulang. Output deterministik tidak dijamin. Selain itu, mengubah setelan model atau parameter, seperti suhu, dapat menyebabkan variasi respons meskipun Anda menggunakan nilai seed yang sama. Secara default, nilai seed acak akan digunakan. Ini adalah fitur pratinjau.	`Optional`

Permintaan sampel

REST

Untuk menguji chat teks menggunakan Vertex AI API, kirim permintaan POST ke endpoint model penayang.

Sebelum menggunakan salah satu data permintaan, lakukan penggantian berikut:

PROJECT_ID: Project ID Anda.

Untuk kolom lainnya, lihat tabel Isi permintaan di bawah.

Metode HTTP dan URL:

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

Isi JSON permintaan:

{
  "instances": [{
      "context":  "CONTEXT",
      "examples": [
       { 
          "input": {"content": "EXAMPLE_INPUT"},
          "output": {"content": "EXAMPLE_OUTPUT"}
       }],
      "messages": [
       { 
          "author": "AUTHOR",
          "content": "CONTENT",
       }],
   }],
  "parameters": {
    "temperature": TEMPERATURE,
    "maxOutputTokens": MAX_OUTPUT_TOKENS,
    "topP": TOP_P,
    "topK": TOP_K
  }
}

Untuk mengirim permintaan Anda, pilih salah satu opsi berikut:

curl

Catatan: Perintah berikut mengasumsikan bahwa Anda telah login ke gcloud CLI dengan akun pengguna Anda dengan menjalankan gcloud init atau gcloud auth login , atau dengan menggunakan Cloud Shell, yang secara otomatis membuat Anda login ke gcloud CLI . Anda dapat memeriksa akun yang saat ini aktif dengan menjalankan gcloud auth list.

Simpan isi permintaan dalam file bernama request.json, dan jalankan perintah berikut:

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

PowerShell

Catatan: Perintah berikut mengasumsikan bahwa Anda telah login ke gcloud CLI dengan akun pengguna Anda dengan menjalankan gcloud init atau gcloud auth login . Anda dapat memeriksa akun yang saat ini aktif dengan menjalankan gcloud auth list.

Simpan isi permintaan dalam file bernama request.json, dan jalankan perintah berikut:

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

Anda akan menerima respons JSON yang mirip seperti contoh respons.

Python

Untuk mempelajari cara menginstal atau mengupdate Vertex AI SDK untuk Python, lihat Menginstal Vertex AI SDK untuk Python. Untuk mengetahui informasi selengkapnya, lihat Dokumentasi referensi Python API.

from vertexai.language_models import ChatModel, InputOutputTextPair

chat_model = ChatModel.from_pretrained("chat-bison@002")

parameters = {
    "temperature": 0.2,
    "max_output_tokens": 256,
    "top_p": 0.95,
    "top_k": 40,
}

chat_session = chat_model.start_chat(
    context="My name is Miles. You are an astronomer, knowledgeable about the solar system.",
    examples=[
        InputOutputTextPair(
            input_text="How many moons does Mars have?",
            output_text="The planet Mars has two moons, Phobos and Deimos.",
        ),
    ],
)

response = chat_session.send_message(
    "How many planets are there in the solar system?", **parameters
)
print(response.text)
# Example response:
# There are eight planets in the solar system:
# Mercury, Venus, Earth, Mars, Jupiter, Saturn, Uranus, and Neptune.

Node.js

Sebelum mencoba contoh ini, ikuti petunjuk penyiapan Node.js di Panduan memulai Vertex AI menggunakan library klien. Untuk mengetahui informasi selengkapnya, lihat Dokumentasi referensi API Node.js Vertex AI.

Untuk melakukan autentikasi ke Vertex AI, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, baca Menyiapkan autentikasi untuk lingkungan pengembangan lokal.

/**
 * 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 = 'chat-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 = {
    context:
      'My name is Miles. You are an astronomer, knowledgeable about the solar system.',
    examples: [
      {
        input: {content: 'How many moons does Mars have?'},
        output: {
          content: 'The planet Mars has two moons, Phobos and Deimos.',
        },
      },
    ],
    messages: [
      {
        author: 'user',
        content: 'How many planets are there in the solar system?',
      },
    ],
  };
  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 chat prompt response');
  const predictions = response.predictions;
  console.log('\tPredictions :');
  for (const prediction of predictions) {
    console.log(`\t\tPrediction : ${JSON.stringify(prediction)}`);
  }
}

callPredict();

Java

Sebelum mencoba contoh ini, ikuti petunjuk penyiapan Java di Panduan memulai Vertex AI menggunakan library klien. Untuk mengetahui informasi selengkapnya, lihat Dokumentasi referensi API Java Vertex AI.

Untuk melakukan autentikasi ke Vertex AI, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, baca Menyiapkan autentikasi untuk lingkungan pengembangan lokal.


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;

// Send a Predict request to a large language model to test a chat prompt
public class PredictChatPromptSample {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String instance =
        "{\n"
            + "   \"context\":  \"My name is Ned. You are my personal assistant. My favorite movies"
            + " are Lord of the Rings and Hobbit.\",\n"
            + "   \"examples\": [ { \n"
            + "       \"input\": {\"content\": \"Who do you work for?\"},\n"
            + "       \"output\": {\"content\": \"I work for Ned.\"}\n"
            + "    },\n"
            + "    { \n"
            + "       \"input\": {\"content\": \"What do I like?\"},\n"
            + "       \"output\": {\"content\": \"Ned likes watching movies.\"}\n"
            + "    }],\n"
            + "   \"messages\": [\n"
            + "    { \n"
            + "       \"author\": \"user\",\n"
            + "       \"content\": \"Are my favorite movies based on a book series?\"\n"
            + "    }]\n"
            + "}";
    String parameters =
        "{\n"
            + "  \"temperature\": 0.3,\n"
            + "  \"maxDecodeSteps\": 200,\n"
            + "  \"topP\": 0.8,\n"
            + "  \"topK\": 40\n"
            + "}";
    String project = "YOUR_PROJECT_ID";
    String publisher = "google";
    String model = "chat-bison@001";

    predictChatPrompt(instance, parameters, project, publisher, model);
  }

  static void predictChatPrompt(
      String instance, String parameters, String project, String publisher, String model)
      throws IOException {
    PredictionServiceSettings predictionServiceSettings =
        PredictionServiceSettings.newBuilder()
            .setEndpoint("us-central1-aiplatform.googleapis.com:443")
            .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)) {
      String location = "us-central1";
      final EndpointName endpointName =
          EndpointName.ofProjectLocationPublisherModelName(project, location, publisher, model);

      Value.Builder instanceValue = Value.newBuilder();
      JsonFormat.parser().merge(instance, instanceValue);
      List<Value> instances = new ArrayList<>();
      instances.add(instanceValue.build());

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

Isi respons

{
  "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 ],
        "errors": [ int ]
      }
    }
  ],
  "metadata": {
    "tokenMetadata": {
      "input_token_count": {
        "total_tokens": integer,
        "total_billable_characters": integer
      },
      "output_token_count": {
        "total_tokens": integer,
        "total_billable_characters": integer
      }
    }
  }
}

Elemen respons	Deskripsi
`content`	Konten teks pesan chat.
`candidates`	Hasil chat yang dihasilkan dari pesan tertentu.
`categories`	Nama tampilan kategori Atribut Keamanan terkait dengan konten yang dibuat. Urutan cocok dengan Skor.
`author`	Tag penulis untuk giliran.
`scores`	Skor keyakinan setiap kategori, nilai yang lebih tinggi berarti keyakinan yang lebih tinggi.
`blocked`	Flag yang menunjukkan apakah input atau output model diblokir.
`startIndex`	Indeks dalam output prediksi tempat kutipan dimulai (inklusif). Harus >= 0 dan < end_index.
`endIndex`	Indeks dalam output prediksi tempat kutipan berakhir (eksklusif). Harus > start_index dan < len(output).
`url`	URL yang terkait dengan kutipan ini. Jika ada, URL ini akan ditautkan ke halaman web sumber kutipan ini. URL yang memungkinkan mencakup situs berita, repositori GitHub, dll.
`title`	Judul yang terkait dengan kutipan ini. Jika ada, judul tersebut merujuk pada judul sumber kutipan ini. Judul yang memungkinkan mencakup judul berita, judul buku, dll.
`license`	Lisensi yang terkait dengan kutipan ini. Jika ada, lisensi tersebut merujuk pada lisensi sumber kutipan ini. Lisensi yang memungkinkan mencakup lisensi kode, misalnya, lisensi mit.
`publicationDate`	Tanggal terbit yang terkait dengan kutipan ini. Jika ada, tanggal terbit tersebut mengacu pada tanggal sumber kutipan ini dipublikasikan. Format yang memungkinkan adalah YYYY, YYYY-MM, YYYY-MM-DD.
`safetyAttributes`	Kumpulan kategori dan skor keyakinannya yang terkait. Pemetaan 1-1 ke `candidates`.
`input_token_count`	Jumlah token input. Ini adalah jumlah total token di semua pesan, contoh, dan konteks.
`output_token_count`	Jumlah token output. Ini adalah jumlah total token di `content` untuk semua kandidat dalam respons.
`tokens`	Token sampel.
`tokenLogProbs`	Probabilitas log token sampel.
`topLogProb`	Token kandidat yang paling mungkin dan probabilitas lognya di setiap langkah.
`logprobs`	Hasil parameter `logprobs`. Pemetaan 1-1 ke `candidates`.

Contoh respons

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

Streaming respons dari model AI Generatif

Parameternya sama untuk permintaan streaming dan non-streaming ke API.

Untuk melihat contoh permintaan dan respons kode menggunakan REST API, lihat Contoh menggunakan REST API streaming.

Untuk melihat contoh permintaan dan respons kode menggunakan Vertex AI SDK untuk Python, lihat Contoh penggunaan Vertex AI SDK untuk Python untuk streaming.