Tutorial panggilan fungsi

Panggilan fungsi memudahkan Anda untuk mendapatkan output data terstruktur dari model generatif. Anda kemudian dapat menggunakan output ini untuk memanggil API lain dan menampilkan data respons yang relevan dengan model. Dengan kata lain, panggilan fungsi membantu Anda menghubungkan model generatif ke sistem eksternal sehingga konten yang dihasilkan berisi informasi yang terbaru dan akurat.

Anda dapat memberikan deskripsi fungsi ke model Gemini. Berikut adalah fungsi yang Anda tulis dalam bahasa aplikasi (artinya, fungsi itu tidak Google Cloud Functions). Model mungkin meminta Anda untuk memanggil fungsi dan mengirim balik hasilnya untuk membantu model menangani kueri Anda.

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

Contoh API untuk kontrol pencahayaan

Bayangkan Anda memiliki sistem kontrol pencahayaan dasar dengan pemrograman aplikasi dan Anda ingin memungkinkan pengguna untuk mengontrol lampu melalui permintaan teks. Anda dapat menggunakan fitur Panggilan Fungsi untuk menafsirkan pencahayaan mengubah permintaan dari pengguna dan menerjemahkannya menjadi panggilan API untuk menyetel pencahayaan masing-masing. Sistem kontrol pencahayaan hipotetis ini memungkinkan Anda mengontrol kecerahan cahaya dan suhu warnanya, yang didefinisikan sebagai dua parameter:

Parameter Jenis Wajib diisi Deskripsi
brightness angka ya Level cahaya dari 0 hingga 100. Nol tidak aktif dan 100 adalah kecerahan penuh.
colorTemperature string ya Suhu warna lampu yang bisa daylight, cool, atau warm.

Untuk kesederhanaan, sistem pencahayaan imajiner ini hanya memiliki satu cahaya, sehingga pengguna tidak harus menentukan ruangan atau lokasi. Berikut adalah contoh permintaan JSON Anda bisa mengirim ke Light Control API untuk mengubah level cahaya menjadi 50% menggunakan suhu warna siang hari:

{
  "brightness": "50",
  "colorTemperature": "daylight"
}

Tutorial ini menunjukkan cara menyiapkan Panggilan Fungsi untuk Gemini API guna menafsirkan permintaan pencahayaan pengguna dan memetakannya ke setelan API untuk mengontrol kecerahan dan suhu warna lampu.

Sebelum memulai: Siapkan project dan kunci API Anda

Sebelum memanggil Gemini API, Anda perlu menyiapkan project dan mengonfigurasi kunci API Anda.

Menentukan fungsi API

Buat fungsi yang membuat permintaan API. Fungsi ini harus ditentukan dalam kode aplikasi Anda, namun dapat memanggil layanan atau API di luar aplikasi Anda. Gemini API tidak memanggil fungsi ini secara langsung, sehingga Anda dapat mengontrol bagaimana dan kapan fungsi ini dijalankan melalui aplikasi Anda pada kode sumber. Untuk tujuan demonstrasi, tutorial ini mendefinisikan fungsi API tiruan yang hanya mengembalikan nilai pencahayaan yang diminta:

suspend fun setLightValues(
    brightness: Int,
    colorTemp: String
): JSONObject {
    // This mock API returns the requested lighting values
    return JSONObject().apply {
        put("brightness", brightness)
        put("colorTemperature", colorTemp)
    }
}

Membuat deklarasi fungsi

Buat deklarasi fungsi yang akan Anda teruskan ke model generatif. Kapan Anda mendeklarasikan fungsi untuk digunakan oleh model, Anda harus menyertakan detail mungkin dalam deskripsi fungsi dan parameter. Model generatif menggunakan informasi ini untuk menentukan fungsi mana yang harus dipilih dan bagaimana menyediakan untuk parameter dalam panggilan fungsi. Kode berikut menunjukkan cara mendeklarasikan fungsi kontrol pencahayaan:

val lightControlTool = defineFunction(
  name = "setLightValues",
  description = "Set the brightness and color temperature of a room light.",
  Schema.int("brightness", "Light level from 0 to 100. Zero is off and 100" +
    " is full brightness."),
  Schema.str("colorTemperature", "Color temperature of the light fixture" +
    " which can be `daylight`, `cool` or `warm`.")
) { brightness, colorTemp ->
    // Call the function you declared above
    setLightValues(brightness.toInt(), colorTemp)
}

Mendeklarasikan fungsi selama inisialisasi model

Jika ingin menggunakan panggilan fungsi dengan model, Anda harus memasukkan deklarasi fungsi saat Anda melakukan inisialisasi objek model. Anda mendeklarasikan fungsi dengan menetapkan parameter tools model:

val generativeModel = GenerativeModel(
    modelName = "gemini-1.5-flash",

    // Access your API key as a Build Configuration variable
    apiKey = BuildConfig.apiKey,

    // Specify the function declaration.
    tools = listOf(Tool(listOf(lightControlTool)))
)

Membuat panggilan fungsi

Setelah menginisialisasi model dengan deklarasi fungsi, Anda dapat meminta model dengan fungsi yang ditentukan. Sebaiknya gunakan panggilan fungsi menggunakan prompting chat (sendMessage()), karena pemanggilan fungsi umumnya memanfaatkan memiliki konteks dari perintah dan respons sebelumnya.

val chat = generativeModel.startChat()

val prompt = "Dim the lights so the room feels cozy and warm."

// 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)
}