Tutorial ini menunjukkan cara mengakses Gemini API untuk aplikasi Go Anda menggunakan Google AI Go SDK.
Dalam tutorial ini, Anda akan mempelajari cara melakukan hal berikut:
- Menyiapkan project Anda, termasuk kunci API Anda
- Membuat teks dari input hanya teks
- Membuat teks dari input teks dan gambar (multimodal)
- Membuat percakapan bolak-balik (chat)
- Gunakan streaming untuk interaksi yang lebih cepat
Selain itu, tutorial ini berisi bagian tentang kasus penggunaan lanjutan (seperti embeddings dan penghitungan token) serta opsi untuk mengontrol pembuatan konten.
Prasyarat
Tutorial ini mengasumsikan bahwa Anda sudah memahami cara membangun aplikasi dengan Go.
Untuk menyelesaikan tutorial ini, pastikan lingkungan pengembangan Anda memenuhi persyaratan berikut:
- Go 1.20+
Menyiapkan project
Sebelum memanggil Gemini API, Anda perlu menyiapkan project, yang mencakup menyiapkan kunci API, menginstal paket SDK, dan menginisialisasi model.
Menyiapkan kunci API
Untuk menggunakan Gemini API, Anda memerlukan kunci API. Jika Anda belum memilikinya, buat kunci di Google AI Studio.
Mengamankan kunci API Anda
Anda sebaiknya tidak memeriksa kunci API di sistem kontrol versi. Sebagai gantinya, Anda harus menggunakan penyimpanan secret untuk kunci API Anda.
Semua cuplikan dalam tutorial ini mengasumsikan bahwa Anda mengakses kunci API sebagai variabel lingkungan.
Menginstal paket SDK
Untuk menggunakan Gemini API di aplikasi Anda sendiri, Anda harus melakukan get
paket Go SDK
dalam direktori modul Anda:
go get github.com/google/generative-ai-go
Melakukan inisialisasi model generatif
Sebelum dapat melakukan panggilan API, Anda harus mengimpor dan menginisialisasi model generatif.
import "github.com/google/generative-ai-go/genai"
import "google.golang.org/api/option"
ctx := context.Background()
// Access your API key as an environment variable (see "Set up your API key" above)
client, err := genai.NewClient(ctx, option.WithAPIKey(os.Getenv("API_KEY")))
if err != nil {
log.Fatal(err)
}
defer client.Close()
// The Gemini 1.5 models are versatile and work with most use cases
model := client.GenerativeModel("gemini-1.5-flash")
Saat menentukan model, perhatikan hal-hal berikut:
Gunakan model yang dikhususkan untuk kasus penggunaan Anda (misalnya,
gemini-1.5-flash
untuk input multimodal). Dalam panduan ini, petunjuk untuk setiap penerapan mencantumkan model yang direkomendasikan untuk setiap kasus penggunaan.
Mengimplementasikan kasus penggunaan umum
Setelah project siap, Anda dapat mempelajari penggunaan Gemini API untuk menerapkan berbagai kasus penggunaan:
- Membuat teks dari input hanya teks
- Membuat teks dari input teks dan gambar (multimodal)
- Membuat percakapan bolak-balik (chat)
- Gunakan streaming untuk interaksi yang lebih cepat
Di bagian kasus penggunaan lanjutan, Anda dapat menemukan informasi tentang Gemini API dan embeddings.
Membuat teks dari input hanya teks
Jika input perintah hanya menyertakan teks, gunakan model Gemini 1.5 atau
model Gemini 1.0 Pro dengan generateContent
untuk menghasilkan output teks:
ctx := context.Background()
// Access your API key as an environment variable (see "Set up your API key" above)
client, err := genai.NewClient(ctx, option.WithAPIKey(os.Getenv("API_KEY")))
if err != nil {
log.Fatal(err)
}
defer client.Close()
// The Gemini 1.5 models are versatile and work with both text-only and multimodal prompts
model := client.GenerativeModel("gemini-1.5-flash")
resp, err := model.GenerateContent(ctx, genai.Text("Write a story about a magic backpack."))
if err != nil {
log.Fatal(err)
}
Membuat teks dari input teks dan gambar (multimodal)
Gemini menyediakan berbagai model yang dapat menangani input multimodal (model Gemini 1.5) sehingga Anda dapat memasukkan teks dan gambar. Pastikan Anda meninjau persyaratan gambar untuk perintah.
Saat input perintah menyertakan teks dan gambar, gunakan model Gemini 1.5
dengan metode generateContent
untuk menghasilkan output teks:
ctx := context.Background()
// Access your API key as an environment variable (see "Set up your API key" above)
client, err := genai.NewClient(ctx, option.WithAPIKey(os.Getenv("API_KEY")))
if err != nil {
log.Fatal(err)
}
defer client.Close()
// The Gemini 1.5 models are versatile and work with both text-only and multimodal prompts
model := client.GenerativeModel("gemini-1.5-flash")
imgData1, err := os.ReadFile(pathToImage1)
if err != nil {
log.Fatal(err)
}
imgData2, err := os.ReadFile(pathToImage1)
if err != nil {
log.Fatal(err)
}
prompt := []genai.Part{
genai.ImageData("jpeg", imgData1),
genai.ImageData("jpeg", imgData2),
genai.Text("What's different between these two pictures?"),
}
resp, err := model.GenerateContent(ctx, prompt...)
if err != nil {
log.Fatal(err)
}
Membuat percakapan bolak-balik (chat)
Dengan Gemini, Anda dapat membangun percakapan berformat bebas dalam beberapa giliran. SDK
menyederhanakan proses dengan mengelola status percakapan. Jadi, tidak seperti
GenerateContent
, Anda tidak perlu menyimpan histori percakapan
sendiri.
Untuk membuat percakapan multi-giliran (seperti chat), gunakan model Gemini 1.5 atau
model Gemini 1.0 Pro, lalu inisialisasi percakapan dengan memanggil startChat()
.
Kemudian, gunakan sendMessage()
untuk mengirim pesan pengguna baru, yang juga akan menambahkan
pesan dan respons ke histori chat.
Ada dua kemungkinan opsi untuk role
yang terkait dengan konten dalam
percakapan:
user
: peran yang memberikan perintah. Nilai ini adalah default untuk panggilanSendMessage
.model
: peran yang memberikan respons. Peran ini dapat digunakan saat memanggilStartChat()
denganhistory
yang ada.
ctx := context.Background()
// Access your API key as an environment variable (see "Set up your API key" above)
client, err := genai.NewClient(ctx, option.WithAPIKey(os.Getenv("API_KEY")))
if err != nil {
log.Fatal(err)
}
defer client.Close()
// The Gemini 1.5 models are versatile and work with multi-turn conversations (like chat)
model := client.GenerativeModel("gemini-1.5-flash")
// Initialize the chat
cs := model.StartChat()
cs.History = []*genai.Content{
&genai.Content{
Parts: []genai.Part{
genai.Text("Hello, I have 2 dogs in my house."),
},
Role: "user",
},
&genai.Content{
Parts: []genai.Part{
genai.Text("Great to meet you. What would you like to know?"),
},
Role: "model",
},
}
resp, err := cs.SendMessage(ctx, genai.Text("How many paws are in my house?"))
if err != nil {
log.Fatal(err)
}
Gunakan streaming untuk interaksi yang lebih cepat
Secara default, model akan menampilkan respons setelah menyelesaikan seluruh proses pembuatan. Anda dapat mencapai interaksi yang lebih cepat dengan tidak menunggu seluruh hasil, dan sebagai gantinya menggunakan streaming untuk menangani hasil parsial.
Contoh berikut menunjukkan cara mengimplementasikan streaming dengan
metode GenerateContentStream
untuk membuat teks dari prompt input
teks dan gambar.
ctx := context.Background()
// Access your API key as an environment variable (see "Set up your API key" above)
client, err := genai.NewClient(ctx, option.WithAPIKey(os.Getenv("API_KEY")))
if err != nil {
log.Fatal(err)
}
defer client.Close()
// The Gemini 1.5 models are versatile and work with both text-only and multimodal prompts
model := client.GenerativeModel("gemini-1.5-flash")
imageBytes, err := os.ReadFile(pathToImage)
img := genai.ImageData("jpeg", imageBytes)
prompt := genai.Text("Tell me a story about this animal")
iter := model.GenerateContentStream(ctx, img, prompt)
for {
resp, err := iter.Next()
if err == iterator.Done {
break
}
if err != nil {
log.Fatal(err)
}
// ... print resp
}
Anda dapat menggunakan pendekatan serupa untuk kasus penggunaan chat dan input hanya teks.
prompt := genai.Text("Tell me a story about a lumberjack and his giant ox")
iter := model.GenerateContentStream(ctx, prompt)
prompt := genai.Text("And how do you feel about that?")
iter := cs.SendMessageStream(ctx, prompt)
Mengimplementasikan kasus penggunaan lanjutan
Kasus penggunaan umum yang dijelaskan di bagian sebelumnya dalam tutorial ini membantu Anda memahami Gemini API. Bagian ini menjelaskan beberapa kasus penggunaan yang mungkin dianggap lebih lanjut.
Menggunakan embedding
Embedding adalah teknik yang digunakan untuk menampilkan informasi sebagai daftar angka floating point dalam array. Dengan Gemini, Anda dapat merepresentasikan teks (kata, kalimat, dan blok teks) dalam bentuk vektor, sehingga mempermudah untuk membandingkan dan membedakan embedding. Misalnya, dua teks yang memiliki materi pokok atau sentimen yang serupa harus memiliki embedding serupa, yang dapat diidentifikasi melalui teknik perbandingan matematis seperti kemiripan kosinus.
Gunakan model embedding-001
dengan metode EmbedContent
(atau
metode BatchEmbedContent
) untuk menghasilkan penyematan. Contoh berikut
menghasilkan embedding untuk satu string:
ctx := context.Background()
// Access your API key as an environment variable (see "Set up your API key" above)
client, err := genai.NewClient(ctx, option.WithAPIKey(os.Getenv("API_KEY")))
if err != nil {
log.Fatal(err)
}
defer client.Close()
// For embeddings, use the embedding-001 model
em := client.EmbeddingModel("embedding-001")
res, err := em.EmbedContent(ctx, genai.Text("The quick brown fox jumps over the lazy dog."))
if err != nil {
panic(err)
}
fmt.Println(res.Embedding.Values)
Panggilan fungsi
Panggilan fungsi memudahkan Anda mendapatkan output data terstruktur dari model generatif. Selanjutnya, Anda dapat menggunakan output ini untuk memanggil API lain dan menampilkan data respons yang relevan ke model. Dengan kata lain, panggilan fungsi membantu Anda menghubungkan model generatif ke sistem eksternal sehingga konten yang dihasilkan berisi informasi terbaru dan akurat. Pelajari lebih lanjut di tutorial panggilan fungsi.
Hitung token
Saat menggunakan perintah panjang, sebaiknya hitung token sebelum mengirim konten apa pun ke model. Contoh berikut menunjukkan cara menggunakan CountTokens()
untuk berbagai kasus penggunaan:
// For text-only input
text := "Parrots can be green and live a long time."
resp, err := model.CountTokens(ctx, genai.Text(text))
if err != nil {
log.Fatal(err)
}
fmt.Println(resp.TotalTokens)
// For text-and-image input (multimodal)
text := "Parrots can be green and live a long time."
imageBytes, err := os.ReadFile(pathToImage)
if err != nil {
log.Fatal(err)
}
resp, err := model.CountTokens(
ctx,
genai.Text(text),
genai.ImageData("png", imageBytes))
if err != nil {
log.Fatal(err)
}
fmt.Println(resp.TotalTokens)
Opsi untuk mengontrol pembuatan konten
Anda dapat mengontrol pembuatan konten dengan mengonfigurasi parameter model dan menggunakan setelan keamanan.
Mengonfigurasi parameter model
Setiap perintah yang Anda kirim ke model akan menyertakan parameter value yang mengontrol cara model menghasilkan respons. Model ini dapat memberikan hasil yang berbeda untuk parameter value yang berbeda. Pelajari Parameter model lebih lanjut. Konfigurasi ini dipertahankan sepanjang waktu instance model Anda.
// ...
// The Gemini 1.5 models are versatile and work with most use cases
model := client.GenerativeModel("gemini-1.5-flash")
// Configure model parameters by invoking Set* methods on the model.
model.SetTemperature(0.9)
model.SetTopK(1)
// ...
Gunakan setelan keamanan
Anda dapat menggunakan setelan keamanan untuk menyesuaikan kemungkinan mendapatkan respons yang mungkin dianggap berbahaya. Secara default, setelan keamanan akan memblokir konten dengan probabilitas sedang dan/atau tinggi yang berisi konten yang tidak aman di semua dimensi. Pelajari Setelan keamanan lebih lanjut.
Berikut ini cara menetapkan satu setelan keamanan:
// ...
// The Gemini 1.5 models are versatile and work with most use cases
model := client.GenerativeModel("gemini-1.5-flash")
model.SafetySettings = []*genai.SafetySetting{
{
Category: genai.HarmCategoryHarassment,
Threshold: genai.HarmBlockOnlyHigh,
},
}
// ...
Anda juga dapat menetapkan lebih dari satu setelan keamanan:
// ...
// The Gemini 1.5 models are versatile and work with most use cases
model := client.GenerativeModel("gemini-1.5-flash")
model.SafetySettings = []*genai.SafetySetting{
{
Category: genai.HarmCategoryHarassment,
Threshold: genai.HarmBlockOnlyHigh,
},
{
Category: genai.HarmCategoryHateSpeech,
Threshold: genai.HarmBlockMediumAndAbove,
},
}
// ...
Langkah selanjutnya
Desain prompt adalah proses pembuatan prompt yang mendapatkan respons yang diinginkan dari model bahasa. Menulis dialog yang terstruktur dengan baik adalah bagian penting untuk memastikan respons yang akurat dan berkualitas tinggi dari model bahasa. Pelajari praktik terbaik untuk menulis perintah.
Gemini menawarkan beberapa variasi model untuk memenuhi kebutuhan berbagai kasus penggunaan, seperti jenis input dan kompleksitas, implementasi untuk chat atau tugas bahasa dialog lainnya, serta batasan ukuran. Pelajari model Gemini yang tersedia.