Tutorial panggilan fungsi

Panggilan fungsi mempermudah Anda mendapatkan output data terstruktur dari model generatif. Kemudian, 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 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 kembali hasilnya untuk membantu model menangani kueri Anda.

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

Contoh API untuk kontrol pencahayaan

Bayangkan Anda memiliki sistem kontrol pencahayaan dasar dengan antarmuka pemrograman aplikasi (API) dan ingin mengizinkan pengguna mengontrol lampu melalui permintaan teks sederhana. 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 Tingkat 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: Menyiapkan project dan kunci API

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, tetapi 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:

async function setLightValues(brightness, colorTemp) {
  // This mock API returns the requested lighting values
  return {
    brightness: brightness,
    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:

// Function declaration, to pass to the model.
const controlLightFunctionDeclaration = {
  name: "controlLight",
  parameters: {
    type: "OBJECT",
    description: "Set the brightness and color temperature of a room light.",
    properties: {
      brightness: {
        type: "NUMBER",
        description: "Light level from 0 to 100. Zero is off and 100 is full brightness.",
      },
      colorTemperature: {
        type: "STRING",
        description: "Color temperature of the light fixture which can be `daylight`, `cool` or `warm`.",
      },
    },
    required: ["brightness", "colorTemperature"],
  },
};

// Executable function code. Put it in a map keyed by the function name
// so that you can call it once you get the name string from the model.
const functions = {
  controlLight: ({ brightness, colorTemp }) => {
    return setLightValues( brightness, 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:

<html>
  <body>
    <!-- ... Your HTML and CSS -->

    <script type="importmap">
      {
        "imports": {
          "@google/generative-ai": "https://esm.run/@google/generative-ai"
        }
      }
    </script>
    <script type="module">
      import { GoogleGenerativeAI } from "@google/generative-ai";

      // Fetch your API_KEY
      const API_KEY = "...";

      // Access your API key (see "Set up your API key" above)
      const genAI = new GoogleGenerativeAI(API_KEY);

      // ...

      const generativeModel = genAI.getGenerativeModel({
        // Use a model that supports function calling, like a Gemini 1.5 model
        model: "gemini-1.5-flash",

        // Specify the function declaration.
        tools: {
          functionDeclarations: [controlLightFunctionDeclaration],
        },
      });
    </script>
  </body>
</html>

Membuat panggilan fungsi

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

const chat = generativeModel.startChat();
const prompt = "Dim the lights so the room feels cozy and warm.";

// Send the message to the model.
const result = await chat.sendMessage(prompt);

// For simplicity, this uses the first function call found.
const call = result.response.functionCalls()[0];

if (call) {
  // Call the executable function named in the function call
  // with the arguments specified in the function call and
  // let it call the hypothetical API.
  const apiResponse = await functions[call.name](call.args);

  // Send the API response back to the model so it can generate
  // a text response that can be displayed to the user.
  const result = await chat.sendMessage([{functionResponse: {
    name: 'controlLight',
    response: apiResponse
  }}]);

  // Log the text response.
  console.log(result.response.text());
}