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

การเรียกใช้ฟังก์ชันช่วยให้คุณได้รับเอาต์พุตข้อมูลที่มีโครงสร้างจากโมเดล 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 จำลองที่เพียงแสดงผลค่าแสงที่ขอเท่านั้น

func setLightValues(brightness int, colorTemp string) map[string]any {
    // This mock API returns the requested lighting values
    return map[string]any{
        "brightness":       brightness,
        "colorTemperature": colorTemp}
}

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

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

lightControlTool := &genai.Tool{
    FunctionDeclarations: []*genai.FunctionDeclaration{{
        Name:        "controlLight",
        Description: "Set the brightness and color temperature of a room light.",
        Parameters: &genai.Schema{
            Type: genai.TypeObject,
            Properties: map[string]*genai.Schema{
                "brightness": {
                    Type:        genai.TypeString,
                    Description: "Light level from 0 to 100. Zero is off and"+
                        " 100 is full brightness.",
                },
                "colorTemperature": {
                    Type:        genai.TypeString,
                    Description: "Color temperature of the light fixture which" +
                        " can be `daylight`, `cool` or `warm`.",
                },
            },
            Required: []string{"currencyDate", "currencyFrom"},
        },
    }},
}

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

เมื่อต้องการใช้การเรียกฟังก์ชันกับโมเดล คุณต้องระบุการประกาศฟังก์ชันเมื่อเริ่มต้นออบเจ็กต์โมเดล คุณจะประกาศฟังก์ชันโดยการตั้งค่าพารามิเตอร์ Tools ของโมเดล ดังนี้

// ...

lightControlTool := &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{lightControlTool}

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

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

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

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

// 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, lightControlTool.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{
    "brightness":  "30",
    "colorTemperature":  "warm" }

// 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:     lightControlTool.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)
}