Membuat konten dengan Gemini API di Vertex AI

Panduan ini menunjukkan cara menggunakan metode generateContent dan streamGenerateContent Gemini API di Vertex AI untuk membuat konten. Halaman ini membahas beberapa topik berikut:

  • Mulai: Menjelaskan cara membuat akun Google Cloud untuk menggunakan API.
  • Daftar parameter: Menjelaskan parameter isi permintaan yang dapat Anda gunakan untuk mengontrol output pembuatan.
  • Isi respons: Menjelaskan struktur dan elemen respons yang Anda terima dari model.
  • Contoh: Menyediakan contoh kode untuk berbagai tugas pembuatan, termasuk teks, multimodal, dan streaming.

Diagram berikut merangkum alur kerja keseluruhan untuk membuat konten:

Gunakan generateContent atau streamGenerateContent untuk membuat konten dengan Gemini.

Metode Deskripsi Kasus Penggunaan
generateContent (Unary) Mengirim satu permintaan ke model dan menerima seluruh respons yang dihasilkan sekaligus setelah selesai. Paling cocok untuk tugas yang tidak memerlukan masukan langsung dan respons lengkap diperlukan sebelum pemrosesan, seperti membuat dokumen atau meringkas teks.
streamGenerateContent (Streaming) Mengirim permintaan dan menerima respons dalam potongan yang lebih kecil saat respons tersebut dibuat. Ideal untuk aplikasi interaktif seperti chatbot atau untuk menampilkan hasil secara progresif, sehingga memberikan pengalaman pengguna yang lebih responsif.

Serangkaian model Gemini mencakup model yang mendukung permintaan perintah multimodal. Perintah multimodal dapat mencakup lebih dari satu jenis input, atau modalitas, seperti teks, audio, dan video. Sebaliknya, model non-multimodal hanya menerima perintah teks.

Buat akun Google Cloud untuk memulai

Untuk menggunakan Gemini API di Vertex AI, Anda harus membuat akun Google Cloud terlebih dahulu.

Setelah membuat akun, Anda dapat menggunakan dokumen ini untuk mempelajari isi permintaan, parameter model, isi respons, dan contoh permintaan model Gemini.

Jika sudah siap, lihat Panduan memulai Gemini API di Vertex AI untuk mempelajari cara mengirim permintaan ke Gemini API di Vertex AI menggunakan SDK bahasa pemrograman atau REST API.

Model yang didukung

Semua model Gemini mendukung pembuatan konten.

Menambahkan banyak gambar ke satu permintaan dapat meningkatkan latensi respons.

Daftar parameter

Lihat contoh untuk mengetahui detail implementasi.

Isi permintaan

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

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

Isi permintaan berisi data dengan parameter berikut:

Parameter

cachedContent

Opsional: string

Nama konten yang di-cache yang digunakan sebagai konteks untuk menayangkan prediksi. Format: projects/{project}/locations/{location}/cachedContents/{cachedContent}

contents

Wajib: Content

Konten percakapan saat ini dengan model.

Untuk kueri sekali putaran, ini adalah satu instance. Untuk kueri multi-turn, ini adalah kolom berulang yang berisi histori percakapan dan permintaan terbaru.

systemInstruction

Opsional: Content

Tersedia untuk gemini-2.0-flash dan gemini-2.0-flash-lite.

Petunjuk untuk model untuk mengarahkannya ke performa yang lebih baik. Misalnya, "Jawab sesingkat mungkin" atau "Jangan gunakan istilah teknis dalam respons Anda".

String text dihitung dalam batas token.

Kolom role di systemInstruction diabaikan dan tidak memengaruhi performa model.

tools

Opsional. Potongan kode yang memungkinkan sistem berinteraksi dengan sistem eksternal untuk melakukan tindakan, atau serangkaian tindakan, di luar pengetahuan dan cakupan model. Lihat Pemanggilan fungsi.

toolConfig

Opsional. Lihat Pemanggilan fungsi.

safetySettings

Opsional: SafetySetting

Setelan per permintaan untuk memblokir konten tidak aman.

Diberlakukan pada GenerateContentResponse.candidates.

generationConfig

Opsional: GenerationConfig

Setelan konfigurasi pembuatan.

labels

Opsional: string

Metadata yang dapat Anda tambahkan ke panggilan API dalam format key-value pair.

contents

Parameter

role

string

Identitas entitas yang membuat pesan. Nilai-nilai berikut didukung:

  • user: Ini menunjukkan bahwa pesan dikirim oleh orang sungguhan, biasanya pesan yang dibuat pengguna.
  • model: Ini menunjukkan bahwa pesan dibuat oleh model.

Nilai model digunakan untuk menyisipkan pesan dari model ke dalam percakapan selama percakapan multi-giliran.

parts

Part

Daftar bagian yang diurutkan yang membentuk satu pesan. Bagian yang berbeda mungkin memiliki jenis MIME IANA yang berbeda.

Untuk mengetahui batas pada input, seperti jumlah maksimum token atau jumlah gambar, lihat spesifikasi model di halaman Model Google.

Untuk menghitung jumlah token dalam permintaan Anda, lihat Mendapatkan jumlah token.

parts

Jenis data yang berisi media yang merupakan bagian dari pesan Content multi-bagian. Anda dapat memberikan data media ke model dengan salah satu dari dua cara: dengan meneruskan byte mentah data secara langsung dalam permintaan, atau dengan mereferensikan file yang disimpan di Cloud Storage.

Opsi Deskripsi Kelebihan Kekurangan / Batasan
inlineData Menyematkan byte mentah media berenkode base64 secara langsung dalam isi permintaan JSON. Sederhana untuk file yang lebih kecil; tidak memerlukan penyimpanan eksternal. Meningkatkan ukuran payload permintaan. Dibatasi hingga 20 MB per bagian permintaan.
fileData Menyediakan URI Cloud Storage (gs://...) yang mengarah ke file media. Model mengambil file langsung dari bucket. Ideal untuk file besar. Mempertahankan payload permintaan tetap kecil. Memerlukan file untuk diupload ke Cloud Storage. Akun layanan yang digunakan harus memiliki izin untuk membaca file.
Parameter

text

Opsional: string

Perintah teks atau cuplikan kode.

inlineData

Opsional: Blob

Data inline dalam byte mentah.

Untuk gemini-2.0-flash-lite dan gemini-2.0-flash, Anda dapat menentukan hingga 3.000 gambar menggunakan inlineData.

fileData

Opsional: fileData

Data yang disimpan dalam file.

functionCall

Opsional: FunctionCall.

Objek ini berisi string yang merepresentasikan kolom FunctionDeclaration.name dan objek JSON terstruktur yang berisi parameter apa pun untuk panggilan fungsi yang diprediksi oleh model.

Lihat Pemanggilan fungsi.

functionResponse

Opsional: FunctionResponse.

Output hasil FunctionCall yang berisi string yang merepresentasikan kolom FunctionDeclaration.name dan objek JSON terstruktur yang berisi output apa pun dari panggilan fungsi. Bagian ini digunakan sebagai konteks untuk model.

Lihat Pemanggilan fungsi.

videoMetadata

Opsional: VideoMetadata

Untuk input video, selisih waktu mulai dan berakhir video dalam format Durasi, dan kecepatan frame video. Misalnya, untuk menentukan klip 10 detik yang dimulai pada 1:00 dengan kecepatan frame 10 frame per detik, tetapkan hal berikut:

  • "startOffset": { "seconds": 60 }
  • "endOffset": { "seconds": 70 }
  • "fps": 10.0

Metadata hanya boleh ditentukan saat data video ditampilkan di inlineData atau fileData.

blob

Mewakili blob konten. Jika memungkinkan, kirim data sebagai teks, bukan byte mentah.

Parameter

mimeType

string

Jenis media file yang ditentukan di kolom data atau fileUri. Nilai yang dapat diterima mencakup hal berikut:

Klik untuk meluaskan jenis MIME

  • application/pdf
  • audio/mpeg
  • audio/mp3
  • audio/wav
  • image/png
  • image/jpeg
  • image/webp
  • text/plain
  • video/mov
  • video/mpeg
  • video/mp4
  • video/mpg
  • video/avi
  • video/wmv
  • video/mpegps
  • video/flv

Untuk gemini-2.0-flash-lite dan gemini-2.0-flash, durasi maksimum file audio adalah 8,4 jam dan durasi maksimum file video (tanpa audio) adalah satu jam. Untuk mengetahui informasi selengkapnya, lihat persyaratan audio dan video Gemini.

File teks harus berenkode UTF-8. Isi file teks dihitung dalam batas token.

Tidak ada batasan pada resolusi gambar.

data

bytes

Encoding base64 gambar, PDF, atau video untuk disertakan secara inline dalam perintah. Saat menyertakan media secara inline, Anda juga harus menentukan jenis media (mimeType) data.

Batas ukuran: 20 MB

FileData

Data URI atau web-URL.

Parameter

mimeType

string

Jenis MIME IANA data.

fileUri

string

URI atau URL file yang akan disertakan dalam perintah. Nilai yang dapat diterima mencakup hal berikut:

  • URI bucket Cloud Storage: Objek harus dapat dibaca secara publik atau berada di project Google Cloud yang sama dengan yang mengirim permintaan. Untuk gemini-2.0-flash dan gemini-2.0-flash-lite, batas ukuran adalah 2 GB.
  • URL HTTP: URL file harus dapat dibaca secara publik. Anda dapat menentukan satu file video, satu file audio, dan hingga 10 file gambar per permintaan. Ukuran file audio, file video, dan dokumen tidak boleh lebih dari 15 MB.
  • URL video YouTube:Video YouTube harus dimiliki oleh akun yang Anda gunakan untuk login ke konsol Google Cloud atau bersifat publik. Hanya satu URL video YouTube yang didukung per permintaan.

Saat menentukan fileURI, Anda juga harus menentukan jenis media (mimeType) file. Jika Kontrol Layanan VPC diaktifkan, penentuan URL file media untuk fileURI tidak didukung.

functionCall

functionCall yang diprediksi dan ditampilkan dari model yang berisi string yang merepresentasikan functionDeclaration.name dan objek JSON terstruktur yang berisi parameter dan nilainya.

Parameter

name

string

Nama fungsi yang akan dipanggil.

args

Struct

Parameter dan nilai fungsi dalam format objek JSON.

Lihat Panggilan fungsi untuk mengetahui detail parameter.

functionResponse

Output yang dihasilkan dari FunctionCall yang berisi string yang merepresentasikan FunctionDeclaration.name. Juga berisi objek JSON terstruktur dengan output dari fungsi (dan menggunakannya sebagai konteks untuk model). Kolom ini harus berisi hasil FunctionCall yang dibuat berdasarkan prediksi model.

Parameter

name

string

Nama fungsi yang akan dipanggil.

response

Struct

Respons fungsi dalam format objek JSON.

videoMetadata

Metadata yang mendeskripsikan konten video input.

Parameter

startOffset

Opsional: google.protobuf.Duration

Offset awal video.

endOffset

Opsional: google.protobuf.Duration

Offset akhir video.

fps

Opsional: double

Kecepatan frame video yang dikirim ke model. Nilai defaultnya adalah 1.0 jika tidak ditentukan. Nilai minimum yang diterima serendah 0.0, tetapi tidak termasuk. Nilai maksimumnya adalah 24.0.

safetySetting

Setelan keamanan.

Parameter

category

Opsional: HarmCategory

Kategori keamanan untuk mengonfigurasi batas. Nilai yang dapat diterima mencakup hal berikut:

Klik untuk meluaskan kategori keamanan

  • HARM_CATEGORY_SEXUALLY_EXPLICIT
  • HARM_CATEGORY_HATE_SPEECH
  • HARM_CATEGORY_HARASSMENT
  • HARM_CATEGORY_DANGEROUS_CONTENT

threshold

Opsional: HarmBlockThreshold

Nilai minimum untuk memblokir respons yang mungkin termasuk dalam kategori keamanan yang ditentukan berdasarkan probabilitas.

  • OFF
  • BLOCK_NONE
  • BLOCK_LOW_AND_ABOVE
  • BLOCK_MEDIUM_AND_ABOVE
  • BLOCK_ONLY_HIGH

method

Opsional: HarmBlockMethod

Tentukan apakah nilai minimum digunakan untuk skor probabilitas atau keparahan. Jika tidak ditentukan, nilai minimum digunakan untuk skor probabilitas.

harmCategory

Kategori bahaya yang memblokir konten.

Parameter

HARM_CATEGORY_UNSPECIFIED

Kategori bahaya tidak ditentukan.

HARM_CATEGORY_HATE_SPEECH

Kategori bahaya adalah ujaran kebencian.

HARM_CATEGORY_DANGEROUS_CONTENT

Kategori bahayanya adalah konten berbahaya.

HARM_CATEGORY_HARASSMENT

Kategori bahaya adalah pelecehan.

HARM_CATEGORY_SEXUALLY_EXPLICIT

Kategori bahayanya adalah konten seksual vulgar.

harmBlockThreshold

Tingkat nilai minimum probabilitas yang digunakan untuk memblokir respons.

Parameter

HARM_BLOCK_THRESHOLD_UNSPECIFIED

Batas blokir bahaya tidak ditentukan.

BLOCK_LOW_AND_ABOVE

Blokir batas rendah dan lebih tinggi (yaitu, blokir lebih banyak).

BLOCK_MEDIUM_AND_ABOVE

Blokir konten dengan batas sedang dan lebih tinggi.

BLOCK_ONLY_HIGH

Ambang batas Block only high (yaitu, blokir lebih sedikit).

BLOCK_NONE

Tidak memblokir apa pun.

OFF

Menonaktifkan keamanan jika semua kategori dinonaktifkan

harmBlockMethod

Nilai minimum probabilitas yang memblokir respons berdasarkan kombinasi probabilitas dan tingkat keparahan.

Parameter

HARM_BLOCK_METHOD_UNSPECIFIED

Metode pemblokiran bahaya tidak ditentukan.

SEVERITY

Metode pemblokiran bahaya menggunakan skor probabilitas dan tingkat keparahan.

PROBABILITY

Metode pemblokiran bahaya menggunakan skor probabilitas.

generationConfig

Setelan konfigurasi yang digunakan saat membuat perintah.

Parameter

temperature

Opsional: float

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.

  • Rentang untuk gemini-2.0-flash-lite: 0.0 - 2.0 (default: 1.0)
  • Rentang untuk gemini-2.0-flash: 0.0 - 2.0 (default: 1.0)

Untuk mengetahui informasi selengkapnya, lihat Parameter pembuatan konten.

topP

Opsional: float

Jika ditentukan, pengambilan sampel inti akan digunakan.

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.

  • Rentang: 0.0 - 1.0
  • Default untuk gemini-2.0-flash-lite: 0.95
  • Default untuk gemini-2.0-flash: 0.95

candidateCount

Opsional: int

Jumlah variasi respons yang akan ditampilkan. Untuk setiap permintaan, Anda dikenai biaya untuk token output 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-2.0-flash-lite: 1-8, default: 1
  • gemini-2.0-flash: 1-8, default: 1

maxOutputTokens

Opsional: int

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 potensi respons yang lebih panjang.

Untuk mengetahui informasi selengkapnya, lihat Parameter pembuatan konten.

stopSequences

Opsional: List[string]

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

Maksimum 5 item dalam daftar.

Untuk mengetahui informasi selengkapnya, lihat Parameter pembuatan konten.

presencePenalty

Opsional: float

Penalti positif.

Nilai positif menghukum token yang sudah muncul dalam teks yang dihasilkan, sehingga meningkatkan probabilitas pembuatan konten yang lebih beragam.

Nilai maksimum untuk presencePenalty adalah hingga, tetapi tidak termasuk, 2.0. Nilai minimumnya adalah -2.0.

frequencyPenalty

Opsional: float

Nilai positif menghukum token yang berulang kali muncul dalam teks yang dihasilkan, sehingga mengurangi kemungkinan pengulangan konten.

Nilai maksimum untuk frequencyPenalty ini adalah hingga, tetapi tidak termasuk, 2.0. Nilai minimumnya adalah -2.0.

responseMimeType

Opsional: string (enum)

Jenis MIME respons output dari teks kandidat yang dihasilkan.

Jenis MIME berikut didukung:

  • application/json: Respons JSON dalam kandidat.
  • text/plain (default): Output teks biasa.
  • text/x.enum: Untuk tugas klasifikasi, tampilkan nilai enum seperti yang ditentukan dalam skema respons.

Tentukan jenis respons yang sesuai untuk menghindari perilaku yang tidak diinginkan. Misalnya, jika Anda memerlukan respons berformat JSON, tentukan application/json, bukan text/plain.

text/plain tidak didukung untuk digunakan dengan responseSchema.

responseSchema

Opsional: schema

Skema yang menghasilkan teks kandidat harus diikuti. Untuk mengetahui informasi selengkapnya, lihat Mengontrol output yang dihasilkan.

Untuk menggunakan parameter ini, Anda harus menentukan jenis MIME yang didukung selain text/plain untuk parameter responseMimeType.

seed

Opsional: int

Jika seed ditetapkan ke nilai tertentu, model akan berupaya 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 dalam respons meskipun Anda menggunakan nilai awal yang sama. Secara default, nilai awal acak akan digunakan.

responseLogprobs

Opsional: boolean

Jika benar, menampilkan probabilitas log token yang dipilih oleh model di setiap langkah. Secara default, parameter ini ditetapkan ke false.

logprobs

Opsional: int

Menampilkan probabilitas log token kandidat teratas di setiap langkah pembuatan. Token yang dipilih model mungkin tidak sama dengan token kandidat teratas di setiap langkah. Tentukan jumlah kandidat yang akan ditampilkan dengan menggunakan nilai bilangan bulat dalam rentang 1-20.

Anda harus mengaktifkan responseLogprobs untuk menggunakan parameter ini.

audioTimestamp

Opsional: boolean

Tersedia untuk model berikut:

  • Gemini 2.0 Flash-Lite
  • Gemini 2.0 Flash

Mengaktifkan pemahaman stempel waktu untuk file khusus audio.

Ini adalah fitur pratinjau.

Isi respons

{
  "candidates": [
    {
      "content": {
        "parts": [
          {
            "text": string
          }
        ]
      },
      "finishReason": enum (FinishReason),
      "safetyRatings": [
        {
          "category": enum (HarmCategory),
          "probability": enum (HarmProbability),
          "blocked": boolean
        }
      ],
      "citationMetadata": {
        "citations": [
          {
            "startIndex": integer,
            "endIndex": integer,
            "uri": string,
            "title": string,
            "license": string,
            "publicationDate": {
              "year": integer,
              "month": integer,
              "day": integer
            }
          }
        ]
      },
      "avgLogprobs": double,
      "logprobsResult": {
        "topCandidates": [
          {
            "candidates": [
              {
                "token": string,
                "logProbability": float
              }
            ]
          }
        ],
        "chosenCandidates": [
          {
            "token": string,
            "logProbability": float
          }
        ]
      }
    }
  ],
  "usageMetadata": {
    "promptTokenCount": integer,
    "candidatesTokenCount": integer,
    "totalTokenCount": integer
  },
  "modelVersion": string
}
Elemen respons Deskripsi
modelVersion Model dan versi yang digunakan untuk pembuatan. Contoh: gemini-2.0-flash-001.
text Teks yang dihasilkan.
finishReason

Alasan model berhenti menghasilkan token. Jika kosong, model belum berhenti menghasilkan token. Karena respons menggunakan perintah untuk konteks, perilaku cara model berhenti membuat token tidak dapat diubah.

  • FINISH_REASON_STOP: Titik berhenti alami model atau urutan berhenti yang diberikan.
  • FINISH_REASON_MAX_TOKENS: Jumlah maksimum token seperti yang ditentukan dalam permintaan telah tercapai.
  • FINISH_REASON_SAFETY: Model berhenti membuat token karena respons ditandai karena alasan keamanan. Perhatikan bahwa Candidate.content kosong jika filter konten memblokir output.
  • FINISH_REASON_RECITATION: Model berhenti membuat token karena respons ditandai karena kutipan yang tidak sah.
  • FINISH_REASON_BLOCKLIST: Model berhenti membuat token karena respons mencakup istilah yang diblokir.
  • FINISH_REASON_PROHIBITED_CONTENT: Model berhenti membuat token karena respons ditandai sebagai konten terlarang, seperti materi pelecehan seksual terhadap anak-anak (CSAM).
  • FINISH_REASON_SPII: Model berhenti membuat token karena respons ditandai sebagai berisi informasi identitas pribadi yang sensitif (SPII).
  • FINISH_REASON_MALFORMED_FUNCTION_CALL: Model memblokir kandidat karena panggilan fungsi yang salah bentuk dan tidak dapat diuraikan.
  • FINISH_REASON_OTHER: Semua alasan lain yang menghentikan token
  • FINISH_REASON_UNSPECIFIED: Alasan penyelesaian tidak ditentukan.
category Kategori keamanan untuk mengonfigurasi batas. Nilai yang dapat diterima mencakup hal berikut:

Klik untuk meluaskan kategori keamanan

  • HARM_CATEGORY_SEXUALLY_EXPLICIT
  • HARM_CATEGORY_HATE_SPEECH
  • HARM_CATEGORY_HARASSMENT
  • HARM_CATEGORY_DANGEROUS_CONTENT
probability

Tingkat probabilitas bahaya dalam konten.

  • HARM_PROBABILITY_UNSPECIFIED
  • NEGLIGIBLE
  • LOW
  • MEDIUM
  • HIGH
blocked Flag boolean yang terkait dengan atribut keamanan yang menunjukkan apakah input atau output model diblokir.
startIndex Bilangan bulat yang menentukan tempat kutipan dimulai dalam content. startIndex dalam byte dan dihitung dari respons yang dienkode dalam UTF-8.
endIndex Bilangan bulat yang menentukan tempat kutipan diakhiri dalam content. endIndex dalam byte dan dihitung dari respons yang dienkode dalam UTF-8.
url URL sumber kutipan. Contoh sumber URL dapat berupa situs berita atau repositori GitHub.
title Judul sumber kutipan. Contoh judul sumber mungkin dari artikel berita atau buku.
license Lisensi yang terkait dengan kutipan.
publicationDate Tanggal penerbitan kutipan. Formatnya yang valid adalah YYYY, YYYY-MM, dan YYYY-MM-DD.
avgLogprobs Probabilitas log rata-rata kandidat.
logprobsResult Menampilkan token kandidat teratas (topCandidates) dan token yang sebenarnya dipilih (chosenCandidates) di setiap langkah.
token Model AI generatif menguraikan data teks menjadi token untuk diproses, yang dapat berupa karakter, kata, atau frasa.
logProbability Nilai probabilitas log yang menunjukkan keyakinan model untuk token tertentu.
promptTokenCount Jumlah token dalam permintaan.
candidatesTokenCount Jumlah token dalam respons.
totalTokenCount Jumlah token dalam permintaan dan respons.

Contoh

Contoh berikut menunjukkan cara mengirim permintaan ke model menggunakan Gen AI SDK for Python bawaan atau library OpenAI, yang dapat dikonfigurasi untuk bekerja dengan endpoint Vertex AI.

Library Deskripsi Kasus Penggunaan
Gen AI SDK untuk Python Library resmi Google untuk berinteraksi dengan model Gemini. SDK ini terintegrasi sepenuhnya dengan layanan Google Cloud dan menyediakan akses ke semua fitur terbaru. Direkomendasikan untuk project baru dan developer yang ingin memanfaatkan kemampuan penuh Vertex AI.
Library OpenAI Library pihak ketiga yang populer untuk berinteraksi dengan model bahasa besar. Anda dapat mengonfigurasinya untuk mengirim permintaan ke endpoint Vertex AI. Berguna bagi developer yang memigrasikan aplikasi yang ada dari platform OpenAI atau lebih memilih menggunakan struktur OpenAI API.

Pembuatan Teks

Menghasilkan respons teks dari input teks.

Gen AI SDK untuk Python

from google import genai
from google.genai.types import HttpOptions

client = genai.Client(http_options=HttpOptions(api_version="v1"))
response = client.models.generate_content(
    model="gemini-2.5-flash",
    contents="How does AI work?",
)
print(response.text)
# Example response:
# Okay, let's break down how AI works. It's a broad field, so I'll focus on the ...
#
# Here's a simplified overview:
# ...

Python (OpenAI)

Anda dapat memanggil Inference API menggunakan library OpenAI. Untuk mengetahui informasi selengkapnya, lihat Memanggil model Vertex AI menggunakan library OpenAI. 

from google.auth import default
import google.auth.transport.requests

import openai

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

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

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

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

print(response)

Go 

import (
	"context"
	"fmt"
	"io"

	"google.golang.org/genai"
)

// generateWithText shows how to generate text using a text prompt.
func generateWithText(w io.Writer) error {
	ctx := context.Background()

	client, err := genai.NewClient(ctx, &genai.ClientConfig{
		HTTPOptions: genai.HTTPOptions{APIVersion: "v1"},
	})
	if err != nil {
		return fmt.Errorf("failed to create genai client: %w", err)
	}

	resp, err := client.Models.GenerateContent(ctx,
		"gemini-2.5-flash",
		genai.Text("How does AI work?"),
		nil,
	)
	if err != nil {
		return fmt.Errorf("failed to generate content: %w", err)
	}

	respText := resp.Text()

	fmt.Fprintln(w, respText)
	// Example response:
	// That's a great question! Understanding how AI works can feel like ...
	// ...
	// **1. The Foundation: Data and Algorithms**
	// ...

	return nil
}

Menggunakan perintah multimodal

Membuat respons teks dari input multimodal, seperti teks dan gambar.

Gen AI SDK untuk Python

from google import genai
from google.genai.types import HttpOptions, Part

client = genai.Client(http_options=HttpOptions(api_version="v1"))
response = client.models.generate_content(
    model="gemini-2.5-flash",
    contents=[
        "What is shown in this image?",
        Part.from_uri(
            file_uri="gs://cloud-samples-data/generative-ai/image/scones.jpg",
            mime_type="image/jpeg",
        ),
    ],
)
print(response.text)
# Example response:
# The image shows a flat lay of blueberry scones arranged on parchment paper. There are ...

Python (OpenAI)

Anda dapat memanggil Inference API menggunakan library OpenAI. Untuk mengetahui informasi selengkapnya, lihat Memanggil model Vertex AI menggunakan library OpenAI. 


from google.auth import default
import google.auth.transport.requests

import openai

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

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

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

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

print(response)

Go 

import (
	"context"
	"fmt"
	"io"

	genai "google.golang.org/genai"
)

// generateWithTextImage shows how to generate text using both text and image input
func generateWithTextImage(w io.Writer) error {
	ctx := context.Background()

	client, err := genai.NewClient(ctx, &genai.ClientConfig{
		HTTPOptions: genai.HTTPOptions{APIVersion: "v1"},
	})
	if err != nil {
		return fmt.Errorf("failed to create genai client: %w", err)
	}

	modelName := "gemini-2.5-flash"
	contents := []*genai.Content{
		{Parts: []*genai.Part{
			{Text: "What is shown in this image?"},
			{FileData: &genai.FileData{
				// Image source: https://storage.googleapis.com/cloud-samples-data/generative-ai/image/scones.jpg
				FileURI:  "gs://cloud-samples-data/generative-ai/image/scones.jpg",
				MIMEType: "image/jpeg",
			}},
		},
			Role: "user"},
	}

	resp, err := client.Models.GenerateContent(ctx, modelName, contents, nil)
	if err != nil {
		return fmt.Errorf("failed to generate content: %w", err)
	}

	respText := resp.Text()

	fmt.Fprintln(w, respText)

	// Example response:
	// The image shows an overhead shot of a rustic, artistic arrangement on a surface that ...

	return nil
}

Respons teks streaming

Menghasilkan respons model streaming dari input teks.

Gen AI SDK untuk Python

from google import genai
from google.genai.types import HttpOptions

client = genai.Client(http_options=HttpOptions(api_version="v1"))

for chunk in client.models.generate_content_stream(
    model="gemini-2.5-flash",
    contents="Why is the sky blue?",
):
    print(chunk.text, end="")
# Example response:
# The
#  sky appears blue due to a phenomenon called **Rayleigh scattering**. Here's
#  a breakdown of why:
# ...

Python (OpenAI)

Anda dapat memanggil Inference API menggunakan library OpenAI. Untuk mengetahui informasi selengkapnya, lihat Memanggil model Vertex AI menggunakan library OpenAI. 

from google.auth import default
import google.auth.transport.requests

import openai

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

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

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

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

Go 

import (
	"context"
	"fmt"
	"io"

	genai "google.golang.org/genai"
)

// generateWithTextStream shows how to generate text stream using a text prompt.
func generateWithTextStream(w io.Writer) error {
	ctx := context.Background()

	client, err := genai.NewClient(ctx, &genai.ClientConfig{
		HTTPOptions: genai.HTTPOptions{APIVersion: "v1"},
	})
	if err != nil {
		return fmt.Errorf("failed to create genai client: %w", err)
	}

	modelName := "gemini-2.5-flash"
	contents := genai.Text("Why is the sky blue?")

	for resp, err := range client.Models.GenerateContentStream(ctx, modelName, contents, nil) {
		if err != nil {
			return fmt.Errorf("failed to generate content: %w", err)
		}

		chunk := resp.Text()

		fmt.Fprintln(w, chunk)
	}

	// Example response:
	// The
	//  sky is blue
	//  because of a phenomenon called **Rayleigh scattering**. Here's the breakdown:
	// ...

	return nil
}

Versi model

Untuk menggunakan versi yang diupdate otomatis, tentukan nama model tanpa nomor versi di belakang, misalnya gemini-2.0-flash, bukan gemini-2.0-flash-001.

Untuk mengetahui informasi selengkapnya, lihat Versi dan siklus proses model Gemini.

Langkah berikutnya