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 Android, yang mencakup penyiapan kunci API, menambahkan dependensi SDK ke project Android Anda, dan menginisialisasi model tersebut.
Menyiapkan panggilan fungsi
Untuk tutorial ini, Anda akan melihat model berinteraksi dengan API pertukaran mata uang fiktif yang mendukung parameter berikut:
Parameter | Jenis | Wajib | Deskripsi |
---|---|---|---|
currencyFrom |
string | ya | Mata uang asal konversi |
currencyTo |
string | ya | Mata uang yang ingin dikonversi |
Contoh permintaan API
{
"currencyFrom": "USD",
"currencyTo": "SEK"
}
Contoh respons API
{
"base": "USD",
"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.
suspend fun makeApiRequest(
currencyFrom: String,
currencyTo: String
): JSONObject {
// This hypothetical API returns a JSON such as:
// {"base":"USD","rates":{"SEK": 0.091}}
return JSONObject().apply {
put("base", currencyFrom)
put("rates", hashMapOf(currencyTo to 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.
val getExchangeRate = defineFunction(
name = "getExchangeRate",
description = "Get the exchange rate for currencies between countries",
Schema.str("currencyFrom", "The currency to convert from."),
Schema.str("currencyTo", "The currency to convert to.")
) { from, to ->
// Call the function that you declared above
makeApiRequest(from, to)
}
Langkah 3: Tentukan deklarasi fungsi selama inisialisasi model
Tentukan deklarasi fungsi saat menginisialisasi model generatif dengan meneruskannya ke parameter tools
model:
val generativeModel = GenerativeModel(
// Use a model that supports function calling, like a Gemini 1.5 model
modelName = "gemini-1.5-flash",
// Access your API key as a Build Configuration variable (see "Set up your API key" above)
apiKey = BuildConfig.apiKey,
// Specify the function declaration.
tools = listOf(Tool(listOf(getExchangeRate)))
)
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.
val chat = generativeModel.startChat()
val prompt = "How much is 50 US dollars worth in Swedish krona?"
// Send the message to the generative model
var response = chat.sendMessage(prompt)
// Check if the model responded with a function call
response.functionCall?.let { functionCall ->
// Try to retrieve the stored lambda from the model's tools and
// throw an exception if the returned function was not declared
val matchedFunction = generativeModel.tools?.flatMap { it.functionDeclarations }
?.first { it.name == functionCall.name }
?: throw InvalidStateException("Function not found: ${functionCall.name}")
// Call the lambda retrieved above
val apiResponse: JSONObject = matchedFunction.execute(functionCall)
// Send the API response back to the generative model
// so that it generates a text response that can be displayed to the user
response = chat.sendMessage(
content(role = "function") {
part(FunctionResponsePart(functionCall.name, apiResponse))
}
)
}
// Whenever the model responds with text, show it in the UI
response.text?.let { modelResponse ->
println(modelResponse)
}