บทแนะนำการเรียกใช้ฟังก์ชัน

การเรียกใช้ฟังก์ชันช่วยให้คุณได้รับเอาต์พุตข้อมูลที่มีโครงสร้างจากโมเดล Generative ได้ง่ายขึ้น จากนั้นคุณจะใช้เอาต์พุตเหล่านี้เพื่อเรียกใช้ API อื่นๆ และแสดงผลข้อมูลการตอบกลับที่เกี่ยวข้องไปยังโมเดลได้ กล่าวคือ การเรียกใช้ฟังก์ชันช่วยให้คุณเชื่อมต่อโมเดล Generative กับระบบภายนอกเพื่อให้เนื้อหาที่สร้างขึ้นมีข้อมูลที่ถูกต้องและเป็นปัจจุบันที่สุด

คุณสามารถจัดเตรียมคำอธิบายฟังก์ชันต่างๆ ให้กับโมเดล Gemini ได้ ซึ่งเป็นฟังก์ชันที่คุณเขียนในภาษาของแอป (ซึ่งไม่ใช่ Google Cloud Functions) โมเดลอาจขอให้คุณเรียกใช้ฟังก์ชันและส่งกลับผลลัพธ์เพื่อช่วยโมเดลจัดการคำค้นหาของคุณ

หากยังไม่ได้ดูข้อมูล โปรดดูข้อมูลเบื้องต้นเกี่ยวกับการเรียกใช้ฟังก์ชันเพื่อดูข้อมูลเพิ่มเติม

ตัวอย่าง API สำหรับการควบคุมแสง

สมมติว่าคุณมีระบบควบคุมแสงพื้นฐานที่มี Application Programming Interface (API) และต้องการอนุญาตให้ผู้ใช้ควบคุมแสงไฟผ่านคำขอข้อความง่ายๆ คุณสามารถใช้ฟีเจอร์การเรียกฟังก์ชันเพื่อตีความคำขอเปลี่ยนแสงจากผู้ใช้ และแปลคำขอเหล่านั้นเป็นการเรียก API เพื่อตั้งค่าแสงไฟ ระบบควบคุมแสงสมมตินี้ช่วยให้คุณควบคุมความสว่างของแสงและอุณหภูมิสีได้ โดยแบ่งเป็น 2 พารามิเตอร์แยกกัน ดังนี้

พารามิเตอร์ ประเภท จำเป็น คำอธิบาย
brightness ตัวเลข ใช่ ระดับแสงตั้งแต่ 0 ถึง 100 0 ปิดอยู่และ 100 คือความสว่างเต็ม
colorTemperature string ใช่ อุณหภูมิสีของโคมไฟอาจเป็น daylight, cool หรือ warm

เพื่อความง่าย ระบบการจัดแสงในจินตนาการนี้จึงมีไฟเพียงดวงเดียว ผู้ใช้จึงไม่จำเป็นต้องระบุห้องหรือสถานที่ นี่คือตัวอย่างคำขอ JSON ที่คุณอาจส่งไปยัง API การควบคุมแสงเพื่อเปลี่ยนระดับแสงเป็น 50% โดยใช้อุณหภูมิสีกลางวัน

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

บทแนะนำนี้จะแสดงวิธีตั้งค่าการเรียกฟังก์ชันสำหรับ Gemini API เพื่อตีความคำขอแสงไฟของผู้ใช้และแมปคำขอเหล่านั้นกับการตั้งค่า API เพื่อควบคุมค่าความสว่างและอุณหภูมิสีของหลอดไฟ

ก่อนเริ่มต้น: ตั้งค่าโปรเจ็กต์และคีย์ API

คุณต้องตั้งค่าโปรเจ็กต์และกำหนดค่าคีย์ API ก่อนที่จะเรียกใช้ Gemini API

กำหนดฟังก์ชัน API

สร้างฟังก์ชันที่สร้างคำขอ API ควรกำหนดฟังก์ชันนี้ภายในโค้ดของแอปพลิเคชัน แต่สามารถเรียกใช้บริการหรือ API นอกแอปพลิเคชันได้ Gemini API จะไม่เรียกใช้ฟังก์ชันนี้โดยตรง คุณจึงควบคุมวิธีการและเวลาที่เรียกใช้ฟังก์ชันนี้ผ่านโค้ดของแอปพลิเคชันได้ การสาธิตนี้ดูจะกำหนดฟังก์ชัน API จำลองที่เพียงแสดงผลค่าแสงที่ขอเท่านั้น

Future<Map<String, Object?>> setLightValues(
  Map<String, Object?> arguments,
) async =>
    // This mock API returns the requested lighting values
    {
      'brightness': arguments['brightness'],
      'colorTemperature': arguments['colorTemp'],
    };

สร้างการประกาศฟังก์ชัน

สร้างการประกาศฟังก์ชันที่คุณจะส่งไปยังโมเดล Generative เมื่อประกาศฟังก์ชันที่โมเดลจะใช้ คุณควรใส่รายละเอียดให้มากที่สุดเท่าที่จะทำได้ในคำอธิบายฟังก์ชันและพารามิเตอร์ โมเดล Generative ใช้ข้อมูลนี้เพื่อระบุฟังก์ชันที่จะเลือกและวิธีระบุค่าสำหรับพารามิเตอร์ในการเรียกใช้ฟังก์ชัน โค้ดต่อไปนี้แสดงวิธีประกาศฟังก์ชันการควบคุมแสง

final lightControlTool = FunctionDeclaration(
    'setLightValues',
    'Set the brightness and color temperature of a room light.',
    Schema(SchemaType.object, properties: {
      'brightness': Schema(SchemaType.number,
          description: 'Light level from 0 to 100. '
              'Zero is off and 100 is full brightness.'),
      'colorTemperature': Schema(SchemaType.string,
          description: 'Color temperature of the light fixture, '
              'which can be `daylight`, `cool` or `warm`.'),
    }, requiredProperties: [
      'brightness',
      'colorTemperature'
    ]));

ประกาศฟังก์ชันระหว่างการเริ่มต้นโมเดล

เมื่อต้องการใช้การเรียกฟังก์ชันกับโมเดล คุณต้องระบุการประกาศฟังก์ชันเมื่อเริ่มต้นออบเจ็กต์โมเดล คุณประกาศฟังก์ชันได้โดยการตั้งค่าพารามิเตอร์ tools ของโมเดล นอกจากนี้ Dart SDK ยังรองรับการประกาศฟังก์ชันเป็นอาร์กิวเมนต์ของ API ของ generateContent หรือ generateContentStream

final model = GenerativeModel(
  model: 'gemini-1.5-flash',
  apiKey: apiKey,

  // Specify the function declaration.
  tools: [
    Tool(functionDeclarations: [lightControlTool])
  ],
);

สร้างการเรียกใช้ฟังก์ชัน

เมื่อเริ่มต้นโมเดลด้วยการประกาศฟังก์ชันแล้ว คุณจะแจ้งโมเดลด้วยฟังก์ชันที่กำหนดไว้ได้ คุณควรใช้การเรียกฟังก์ชันโดยใช้พรอมต์แชท (sendMessage()) เนื่องจากการเรียกใช้ฟังก์ชันโดยทั่วไปจะได้รับประโยชน์จากบริบทของพรอมต์และคำตอบก่อนหน้า

final chat = model.startChat(); final prompt =
  'Dim the lights so the room feels cozy and warm.';

// Send the message to the generative model.
var response = await chat.sendMessage(Content.text(prompt));

final functionCalls = response.functionCalls.toList();
// When the model response with a function call, invoke the function.
if (functionCalls.isNotEmpty) {
  final functionCall = functionCalls.first;
  final result = switch (functionCall.name) {
    // Forward arguments to the hypothetical API.
    'setLightValues' => await setLightValues(functionCall.args),
    // Throw an exception if the model attempted to call a function that was
    // not declared.
    _ => throw UnimplementedError(
        'Function not implemented: ${functionCall.name}')
  };
  // Send the response to the model so that it can use the result to generate
  // text for the user.
  response = await chat
      .sendMessage(Content.functionResponse(functionCall.name, result));
}
// When the model responds with non-null text content, print it.
if (response.text case final text?) {
  print(text);
}