Tutorial: Panggilan fungsi dengan Gemini API

Python Node.js Go Dart (Flutter) Android Swift Web

Panggilan fungsi memudahkan Anda mendapatkan output data terstruktur dari model generatif. Anda kemudian 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.

Anda dapat memberikan deskripsi fungsi kepada model Gemini. Ini adalah fungsi yang Anda tulis dalam bahasa aplikasi (artinya, fungsi tersebut bukan Google Cloud Functions). Model ini mungkin meminta Anda untuk memanggil fungsi dan mengirim kembali hasilnya untuk membantu model menangani kueri Anda.

Jika Anda belum melakukannya, lihat Pengantar panggilan fungsi untuk mempelajari lebih lanjut.

Menyiapkan project

Sebelum memanggil Gemini API, Anda perlu menyiapkan project, yang meliputi menyiapkan kunci API, menginstal paket SDK, dan menginisialisasi model.

go get github.com/google/generative-ai-go

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()

// Use a model that supports function calling, like a Gemini 1.5 model
model := client.GenerativeModel("gemini-1.5-flash")

Menyiapkan panggilan fungsi

Untuk tutorial ini, Anda akan melihat model berinteraksi dengan API pertukaran mata uang fiktif yang mendukung parameter berikut:

Contoh permintaan API

{
  "currencyDate": "2024-04-17",
  "currencyFrom": "USD",
  "currencyTo": "SEK"
}

Contoh respons API

{
  "base": "USD",
  "date": "2024-04-17",
  "rates": {"SEK": 0.091}
}

Langkah 1: Buat fungsi yang membuat permintaan API

Jika belum melakukannya, mulailah dengan membuat fungsi yang membuat permintaan API.

Untuk tujuan demonstrasi dalam tutorial ini, daripada mengirim permintaan API yang sebenarnya, Anda akan menampilkan nilai hardcode dalam format yang sama seperti yang ditampilkan oleh API sebenarnya.

func exchangeRate(currencyDate string,
    currencyFrom string, currencyTo string) map[string]any {
    // This hypothetical API returns a JSON such as:
    // {"base":"USD","date":"2024-04-17","rates":{"SEK": 0.091}}
    return map[string]any{
        "base":  currencyFrom,
        "date":  currencyDate,
        "rates": map[string]any{currencyTo: 0.091}}
}

Langkah 2: Buat deklarasi fungsi

Buat deklarasi fungsi yang akan Anda teruskan ke model generatif (langkah berikutnya dalam tutorial ini).

Sertakan sebanyak mungkin detail dalam deskripsi fungsi dan parameter. Model generatif menggunakan informasi ini untuk menentukan fungsi yang harus dipilih dan cara memberikan nilai untuk parameter dalam panggilan fungsi.

currencyExchangeTool := &genai.Tool{
    FunctionDeclarations: []*genai.FunctionDeclaration{{
        Name:        "exchangeRate",
        Description: "Lookup currency exchange rates by date",
        Parameters: &genai.Schema{
            Type: genai.TypeObject,
            Properties: map[string]*genai.Schema{
                "currencyDate": {
                    Type:        genai.TypeString,
                    Description: "A date that must always be in YYYY-MM-DD format" +
                        " or the value 'latest' if a time period is not specified",
                },
                "currencyFrom": {
                    Type:        genai.TypeString,
                    Description: "Currency to convert from",
                },
                "currencyTo": {
                    Type:        genai.TypeString,
                    Description: "Currency to convert to",
                },
            },
            Required: []string{"currencyDate", "currencyFrom"},
        },
    }},
}

Langkah 3: Tentukan deklarasi fungsi selama inisialisasi model

Tentukan deklarasi fungsi saat menginisialisasi model generatif dengan meneruskannya ke parameter Tools model:

// ...

currencyExchangeTool := &genai.Tool{
  // ...
}

// Use a model that supports function calling, like a Gemini 1.5 model
model := client.GenerativeModel("gemini-1.5-flash")

// Specify the function declaration.
model.Tools = []*genai.Tool{currencyExchangeTool}

Langkah 4: Buat panggilan fungsi

Sekarang Anda dapat meminta model dengan fungsi yang ditentukan.

Cara yang direkomendasikan untuk menggunakan panggilan fungsi adalah melalui antarmuka chat, karena panggilan fungsi sangat cocok dengan struktur multi-putar chat.

// Start new chat session.
session := model.StartChat()

prompt := "How much is 50 US dollars worth in Swedish krona?"

// Send the message to the generative model.
resp, err := session.SendMessage(ctx, genai.Text(prompt))
if err != nil {
    log.Fatalf("Error sending message: %v\n", err)
}

// Check that you got the expected function call back.
part := resp.Candidates[0].Content.Parts[0]
funcall, ok := part.(genai.FunctionCall)
if !ok {
    log.Fatalf("Expected type FunctionCall, got %T", part)
}
if g, e := funcall.Name, currencyExchangeTool.FunctionDeclarations[0].Name; g != e {
    log.Fatalf("Expected FunctionCall.Name %q, got %q", e, g)
}
fmt.Printf("Received function call response:\n%q\n\n", part)

apiResult := map[string]any{
    "base":  "USD",
    "date":  "2024-04-17",
    "rates": map[string]any{"SEK": 0.091}}

// Send the hypothetical API result back to the generative model.
fmt.Printf("Sending API result:\n%q\n\n", apiResult)
resp, err = session.SendMessage(ctx, genai.FunctionResponse{
    Name:     currencyExchangeTool.FunctionDeclarations[0].Name,
    Response: apiResult,
})
if err != nil {
    log.Fatalf("Error sending message: %v\n", err)
}

// Show the model's response, which is expected to be text.
for _, part := range resp.Candidates[0].Content.Parts {
    fmt.Printf("%v\n", part)
}