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

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

ในโมเดล GPT, การเรียกใช้งานฟังก์ชันหมายถึงการ提供ฟังก์ชันที่อธิบายแก่โมเดลผ่าน API ที่ทำให้มันสามารถเลือกและส่งออกอ็อบเจ็กต์ JSON ที่มีพารามิเตอร์เพื่อเรียกใช้งานฟังก์ชันหรือหลาย ๆ ฟังก์ชันได้อย่างฉลาด ๆ สำคัญที่จะระบุว่า ส่วน Chat Completions API ไม่ได้เรียกใช้งานฟังก์ชันโดยตรง แต่สร้าง JSON ที่สามารถใช้เรียกใช้งานฟังก์ชันในโค้ด

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

2. การประยุกต์ใช้งานของการเรียกใช้งานฟังก์ชัน

นี่คือตัวอย่างการประยุกต์ใช้งานในการเรียกใช้งานฟังก์ชัน:

• สร้างผู้ช่วยในการตอบคำถามโดยการเรียกใช้งาน API ภายนอก เช่น การกำหนดฟังก์ชันเช่น send_email(to: string, body: string) หรือ get_current_weather(location: string, unit: 'celsius' | 'fahrenheit')
• แปลภาษาธรรมชาติเป็นการเรียกใช้งาน API เช่น การแปลว่า "Who are my top customers?" เป็น get_customers(min_revenue: int, created_before: string, limit: int) และจากนั้นทำการเรียกใช้งาน API ภายใน
• สกัดโครงสร้างข้อมูลจากข้อความ เช่น การกำหนดฟังก์ชันเช่น extract_data(name: string, birthday: string) หรือ sql_query(query: string)

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

3. โมเดลที่รองรับการเรียกใช้งานฟังก์ชัน

ไม่ทุกเวอร์ชันของโมเดลได้รับการฝึกด้วยข้อมูลการเรียกใช้งานฟังก์ชัน ในปัจจุบัน โมเดลที่รองรับการเรียกใช้งานฟังก์ชัน ได้แก่ gpt-4, gpt-4-turbo-มองสรุป, gpt-4-0125-มองสรุป, gpt-4-1106-มองสรุป, gpt-4-0613, gpt-3.5-turbo, gpt-3.5-turbo-1106, และ gpt-3.5-turbo-0613

อีกทั้ง โมเดล gpt-4-turbo-มองสรุป, gpt-4-0125-มองสรุป, gpt-4-1106-มองสรุป, และ gpt-3.5-turbo-1106 รองรับการเรียกใช้งานฟังก์ชันแบบขนานที่สามารถดำเนินการการเรียกใช้งานฟังก์ชันหลาย ๆ ฟังก์ชันพร้อมกันและสามารถจัดการการเรียกใช้งานฟังก์ชันนี้อย่างสะดวกเพื่อให้ได้ผลลัพธ์ที่มีประสิทธิภาพและมีประสิทธิภาพ

หมายเหตุ: ความเสี่ยงที่เกี่ยวข้องกับคุณสมบัติการเรียกใช้งานฟังก์ชัน อาจทำให้โมเดลสร้างพารามิเตอร์ที่ผิดพลาด (เช่น พารามิเตอร์หลอม) ดังนั้น ก่อนที่จะดำเนินการใด ๆ ที่ส่งผลต่อโลกของจริยธรรม (เช่น การส่งอีเมล, การเผยแพร่ออนไลน์, การทำการซื้อ ฯลฯ) ควรรวมกระบวนการการยืนยันผู้ใช้บนระดับผลิตภัณฑ์ ให้แน่ใจว่าฟังก์ชันจะถูกดำเนินการเท่านั้นหลังจากที่ผู้ใช้ยืนยันแล้ว

4. ตัวอย่างการเรียกใช้งานฟังก์ชัน

4.1 ตัวอย่าง Python

การประยุกต์ใช้งานการเรียกใช้งานฟังก์ชันบนแพลตฟอร์ม OpenAI มักต้องปฏิบัติตามขั้นตอนพื้นฐานตามที่อธิบายไว้ด้านล่าง ต่อไปคือรายละเอียดของขั้นตอนทั้งหมดโดยใช้ตัวอย่างโค้ด Python ซึ่งเน้นการคิวรี่สภาพอากาศ

ขั้นตอนที่ 1: เตรียมฟังก์ชันที่เรียกใช้ได้และกฎสำหรับโมเดล

ก่อนอื่นเราจำเป็นที่จะต้องกำหนดฟังก์ชันที่สามารถเรียกใช้โดยโมเดล GPT ซึ่งมักหมายถึงการเตรียมฟังก์ชันของเราเองที่สามารถดำเนินการตามกฎของพารามิเตอร์ที่ได้รับเข้ามา เช่น การสื่อสารกับ API ของลูกทีมที่สาม

import json

def get_current_weather(location, unit="fahrenheit"):
    return json.dumps({
        "location": location, 
        "temperature": "18", 
        "unit": unit
    })

ขั้นตอนที่ 2: เรียกใช้โมเดลโดยใช้พารามิเตอร์ query และ tools

ต่อมาเราจำเป็นต้องเรียกใช้โมเดล GPT ผ่าน API Chat Completion และส่งพารามิเตอร์ของผู้ใช้ (เช่น "What is the current weather") และพารามิเตอร์ tools ซึ่งรวมถึงคำอธิบายของฟังก์ชั่น get_current_weather ที่เรากำหนดไว้เพิ่มเติม

from openai import OpenAI

client = OpenAI()

tools = [{
    "type": "function",
    "function": {
        "name": "get_current_weather",
        "description": "รับข้อมูลสภาพอากาศปัจจุบันสำหรับสถานที่ที่กำหนด",
        "parameters": {
            "type": "object",
            "properties": {
                "location": {
                    "type": "string",
                    "description": "ชื่อเมือง เช่น: 'ซานฟรานซิสโก' รัฐแคลิฟอร์เนีย"
                },
                "unit": {
                    "type": "string",
                    "enum": ["เซลเซียส", "ฟาเรนไฮต์"]
                }
            },
            "required": ["location"]
        }
    }
}]

response = client.chat.completions.create(
    model="gpt-3.5-turbo",
    messages=[{"role": "user", "content": "สภาพอากาศปัจจุบันที่ซานฟรานซิสโกเป็นอย่างไร?"}],
    tools=tools
)

ขั้นตอนที่ 3: ดำเนินการฟังก์ชั่นที่เรียกใช้ในระบบ

ผลลัพธ์ที่ส่งกลับโดยโมเดลจะรวมข้อมูลเกี่ยวกับฟังก์ชันที่โมเดลต้องการเรียกใช้ ซึ่งมักจะประกอบอยู่ในพารามิเตอร์การตอบรับ tool_calls จากนั้นเราสามารถทำการดำเนินการเรียกใช้ฟังก์ชันที่เกี่ยวข้อง locally ขึ้นอยู่กับข้อมูลการเรียกใช้ฟังก์ชันที่อธิบายไว้ในพารามิเตอร์ tool_calls

tool_calls = response.choices[0].message.tool_calls

if tool_calls:
    arguments = json.loads(tool_calls[0].function.arguments)
    weather_info = get_current_weather(**arguments)
    print(weather_info) # ที่นี่เราสามารถเห็นข้อมูลสภาพอากาศที่ได้รับจากการเรียกใช้ฟังก์ชัน

ขั้นตอนที่ 4: เรียกใช้โมเดลอีกครั้งด้วยผลการคืนค่าของฟังก์ชัน

ตามนั้นเราสามารถส่งผลการคืนค่าของฟังก์ชันเป็นข้อความใหม่ให้กับโมเดล โดยที่โมเดลสามารถประมวลผลผลลัพธ์เหล่านี้และสร้างคำตอบที่เข้ากันกับผู้ใช้

follow_up_response = client.chat.completions.create(
    model="gpt-3.5-turbo",
    messages=[
        {"role": "user", "content": "สภาพอากาศปัจจุบันที่ซานฟรานซิสโกเป็นอย่างไร?"},
        {"role": "function", "name": "get_current_weather", "content": weather_info}
    ],
    tools=tools
)

อธิบาย: ในตัวอย่างข้างต้น โมเดลจะส่งเนื้อหาการคืนค่าของฟังก์ชันไปยังโมเดลผ่านข้อความฟังก์ชันดังนี้:

{"role": "function", "name": "get_current_weather", "content": weather_info}

ในการปฏิบัติจริง คุณสามารถนำเนื้อหาการคืนค่าของฟังก์ชันไปขั้นตอนโปรมต์ข้อความของระบบเพื่อให้ AI อ้างอิงเมื่อตอบคำถาม

ขั้นตอนที่ 5: รับคำตอบสุดท้ายจากโมเดล

ในท้ายที่สุด เราสามารถเรียกข้อมูลคำตอบสุดท้ายจากโมเดลและนำมาทำให้เป็นข้อมูลที่เข้าใจและนำให้กับผู้ใช้ ในขั้นตอนนี้ โมเดลจะสร้างคำตอบที่เข้ากันกับผู้ใช้โดยขึ้นอยู่กับข้อมูลสภาพอากาศที่เราได้นำเข้า

final_output = follow_up_response.choices[0].message.content
print(final_output) # ผลลัพธ์ที่ได้คือข้อมูลสภาพอากาศที่เราต้องการแสดงให้กับผู้ใช้

ตามขั้นตอนข้างต้น เราได้ทำการตัวอย่างการสอบถามสภาพอากาศโดยใช้โมเดล GPT และการเรียกใช้ฟังก์ชันเสร็จสมบูรณ์แล้ว

4.2 อภิปรายการฟังก์ชันการเรียกใช้ฟังก์ชัน

4.2.1 ความหมายของฟิลด์พารามิเตอร์ 'เครื่องมือ'

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

1. ประเภท: ฟิลด์นี้แทนประเภทของเครื่องมือ ในการเรียกใช้ฟังก์ชัน ฟิลด์นี้ควรถูกตั้งค่าเป็น "function"
2. ฟังก์ชัน: ฟิลด์นี้ประกอบด้วยข้อมูลรายละเอียดเกี่ยวกับฟังก์ชัน และเป็นออบเจ็กต์ที่ประกอบด้วยฟิลด์ที่เฉพาะเจาะจงต่อไปนี้:
   • ชื่อ: ชื่อของฟังก์ชันซึ่งเป็นสตริง
   • คำอธิบาย: คำอธิบายเกี่ยวกับวัตถุประสงค์ของฟังก์ชัน ซึ่งสามารถช่วยให้โมเดลสร้างพารามิเตอร์ที่ตรงกับความคาดหวังของผู้ใช้ได้
   • พารามิเตอร์: อธิบายการกำหนดพารามิเตอร์ของฟังก์ชันและเป็นออบเจ็กต์ที่ประกอบด้วยเซ็ตฟิลด์ย่อยต่อไปนี้:
     • ประเภท: กำหนดประเภทของพารามิเตอร์ ซึ่งควรถูกตั้งค่าเป็น "object" โดยส่วนมาก
     • คุณสมบัติ: นิยามหรือบอกความสำคัญของแต่ละพารามิเตอร์ของฟังก์ชัน โดยที่นิยามของแต่ละพารามิเตอร์เป็นออบเจ็กต์ที่มักจะประกอบด้วยฟิลด์ย่อยต่อไปนี้:
       • ประเภท: ประเภทข้อมูลของพารามิเตอร์ (เช่น "string", "integer", "boolean" เป็นต้น)
       • คำอธิบาย: คำอธิบายของพารามิเตอร์เพื่อช่วยโมเดลเข้าใจวัตถุประสงค์
       • enum (ทางเลือก): ในกรณีที่ ประเภท เป็น "string" ฟิลด์ enum สามารถระบุอาร์เรย์ของสตริงที่แทนชุดของค่าที่ถูกต้อง
     • required: อาร์เรย์ของสตริงที่ประกอบด้วยชื่อของพารามิเตอร์ที่จำเป็นต้องระบุ

4.2.2 ตัวอย่างการนิยามเครื่องมือ

ตอนนี้เราจะให้ตัวอย่างของการนิยามเครื่องมือเพื่อช่วยให้เข้าใจวิธีการใช้ฟิลด์แต่ละตัวได้ดียิ่งขึ้น

ตัวอย่างที่ 1: ข้อมูลสภาพอากาศปัจจุบัน

{
    "type": "function",
    "function": {
        "name": "get_current_weather",
        "description": "รับข้อมูลสภาพอากาศปัจจุบันสำหรับทำเครื่องหมายสถานที่ที่กำหนด",
        "parameters": {
            "type": "object",
            "properties": {
                "location": {
                    "type": "string",
                    "description": "เมืองที่ต้องการสอบถามสภาพอากาศ เช่น 'ซานฟรานซิสโก, แคลิฟอร์เนีย'"
                },
                "unit": {
                    "type": "string",
                    "enum": ["เซลเซียส", "ฟาเรนไฮต์"],
                    "description": "หน่วยอุณหภูมิ 'เซลเซียส' สำหรับเซลเซียส, 'ฟาเรนไฮต์' สำหรับฟาเรนไฮต์"
                }
            },
            "required": ["location", "unit"]
        }
    }
}

ในตัวอย่างข้างต้น เราได้กำหนดฟังก์ชันที่ชื่อว่า get_current_weather เพื่อให้ได้ข้อมูลสภาพอากาศปัจจุบันของสถานที่ที่กำหนด พารามิเตอร์ประกอบด้วย location และ unit โดยที่ unit มีค่าที่ถูกต้อง 2 ค่าคือ "เซลเซียส" (เซลเซียส) และ "ฟาเรนไฮต์" (ฟาเรนไฮต์)

ตัวอย่างที่ 2: ค้นหาอัลบั้มสำหรับศิลปินที่ระบุ

{
    "type": "function",
    "function": {
        "name": "find_artist_albums",
        "description": "ค้นหาอัลบั้มทั้งหมดสำหรับศิลปินที่กำหนด",
        "parameters": {
            "type": "object",
            "properties": {
                "artist_name": {
                    "type": "string",
                    "description": "ชื่อของศิลปิน"
                }
            },
            "required": ["artist_name"]
        }
    }
}

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

4.3 ตัวอย่างการเรียกใช้ฟังก์ชันผ่าน HTTP Request

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

4.3.1. ขั้นตอนที่ 1: เรียกใช้โมเดลด้วยคำถามของผู้ใช้และการประกาศฟังก์ชัน

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

ในตัวอย่างต่อไปนี้ เราแจ้งให้ GPT ทราบว่าเรามีฟังก์ชัน get_current_weather ที่สามารถใช้เพื่อสอบถามข้อมูลสภาพอากาศปัจจุบันสำหรับเมืองที่กำหนดไว้

curl --location 'https://api.aiproxy.io/v1/chat/completions' \
--header 'Content-Type: application/json' \
--header 'Authorization: Bearer {OPENAI_KEY}' \
--data '{
    "model": "gpt-3.5-turbo",
    "messages": [
        {
            "role": "user",
            "content": "สภาพอากาศเป็นอย่างไรในเซี่ยงไฮ้วันนี้?"
        }
    ],
    "tools": [
        {
            "type": "function",
            "function": {
                "name": "get_current_weather",
                "description": "รับข้อมูลสภาพอากาศปัจจุบันสำหรับสถานที่ที่ระบุ",
                "parameters": {
                    "type": "object",
                    "properties": {
                        "location": {
                            "type": "string",
                            "description": "เมืองที่ต้องการสอบถามสภาพอากาศ เช่น 'ซานฟรานซิสโก, แคลิฟอร์เนีย'"
                        },
                        "unit": {
                            "type": "string",
                            "enum": [
                                "เซลเซียส",
                                "ฟาเรนไฮต์"
                            ],
                            "description": "หน่วยอุณหภูมิ 'เซลเซียส' หมายถึง เซลเซียส, 'ฟาเรนไฮต์' หมายถึง ฟาเรนไฮต์"
                        }
                    },
                    "required": [
                        "location",
                        "unit"
                    ]
                }
            }
        }
    ]
}'

คำอธิบายพารามิเตอร์คำขอ:

{
    "model": "gpt-3.5-turbo", // โมเดล GPT ที่จะเรียกใช้
    "messages": [ // นี้คือรายการของข้อความสำหรับ GPT ซึ่งรวมถึงคำถามของผู้ใช้
        {
            "role": "user",
            "content": "สภาพอากาศเป็นอย่างไรในเซี่ยงไฮ้วันนี้?"
        }
    ],
    "tools": [
	  // นี่คือการกำหนดฟังก์ชันของคุณ ที่แจ้งให้ GPT ทราบถึงฟังก์ชันที่พร้อมที่ใช้งาน
    ]
}

ที่หน้า 4.2.2 สำหรับคำจำกัดคำของพารามิเตอร์ tools.

ในการประมวลผลโดยปกติโดยโมเดล GPT คุณจะได้รับการตอบกลับ API ที่คล้ายกับต่อไปนี้:

{
    "model": "gpt-3.5-turbo-0613",
    "object": "chat.completion",
    "usage": {
        "prompt_tokens": 122,
        "completion_tokens": 27,
        "total_tokens": 149
    },
    "id": "chatcmpl-8mL4hS4zNMocyR2ajKyAvSTcbNaao",
    "created": 1706531447,
    "choices": [
        {
            "index": 0,
            "delta": null,
            "message": {
                "role": "assistant",
                "tool_calls": [ // พารามิเตอร์ tool_calls แทนรายการของฟังก์ชันที่ GPT ต้องการเรียกใช้
                    {
                        "id": "call_1iF09ttX1R9ESR18Ul2nLe1R",
                        "type": "function",
                        "function": {
                            "name": "get_current_weather",  // ระบุว่า GPT ต้องการตอบคำถามของผู้ใช้โดยการเรียกใช้ฟังก์ชัน get_current_weather
                            "arguments": "{\n  \"location\": \"เซี่ยงไฮ้, จีน\",\n  \"unit\": \"เซลเซียส\"\n}" // นี่คือพารามิเตอร์ของการเรียกใช้ฟังก์ชัน get_current_weather
                        }
                    }
                ]
            },
            "finish_reason": "tool_calls"
        }
    ]
}

4.3.2. ขั้นตอนที่ 2: การเรียกใช้ฟังก์ชันภายในระบบ

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

4.3.3. ขั้นตอนที่ 3: เรียกใช้โมเดลอีกครั้งด้วยผลลัพธ์ที่ส่งกลับจากฟังก์ชัน

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

curl --location 'https://api.aiproxy.io/v1/chat/completions' \
--header 'Content-Type: application/json' \
--header 'Authorization: Bearer sk-Roc5MX1zEuVxiuaMaETV6wZ2jXcCehjUCzwP9AcNErUiwppQ' \
--data '{
    "model": "gpt-3.5-turbo",
    "messages": [
        {
            "role": "user",
            "content": "สภาพอากาศที่เซี่ยงไฮ้วันนี้เป็นอย่างไร?"
        },
        {
            "role": "function",
            "name": "get_current_weather",
            "content": "{\"city\":\"Shanghai\", \"temperature\":\"25 องศาเซลเซียส\"}"
        }
    ],
    "tools": [
        {
            "type": "function",
            "function": {
                "name": "get_current_weather",
                "description": "รับข้อมูลสภาพอากาศปัจจุบันสำหรับสถานที่ที่ระบุ",
                "parameters": {
                    "type": "object",
                    "properties": {
                        "location": {
                            "type": "string",
                            "description": "เมืองที่ต้องการสอบถามสภาพอากาศ เช่น 'ซานฟรานซิสโก, California'"
                        },
                        "unit": {
                            "type": "string",
                            "enum": [
                                "เซลเซียส",
                                "ฟาเรนไฮต์"
                            ],
                            "description": "หน่วยการวัดอุณหภูมิ 'เซลเซียส' สำหรับเซลเซียส, 'ฟาเรนไฮต์' สำหรับฟาเรนไฮต์"
                        }
                    },
                    "required": [
                        "location",
                        "unit"
                    ]
                }
            }
        }
    ]
}'

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

ข้อความของฟังก์ชันแทนความสมบูรณ์ของฟังก์ชันและอยู่ในรูปแบบดังนี้:

{
    "role": "function", // ประเภทข้อความเป็นฟังก์ชัน ทำให้เสริมค่าของฟังก์ชันที่กำลังตอบกลับ
    "name": "get_current_weather", // แจ้งให้ GPT ว่าข้อความปัจจุบันคือค่าที่ส่งกลับจากฟังก์ชัน get_current_weather
    "content": "{\"city\":\"Shanghai\", \"temperature\":\"25 องศาเซลเซียส\"}" // ข้อความที่ส่งกลับจากฟังก์ชันสามารถอยู่ในรูปแบบ JSON หรือข้อความอื่น ๆ
}

ด้านล่างคือคำตอบสุดท้ายที่สร้างขึ้นโดย GPT:

{
    "model": "gpt-3.5-turbo-0613",
    "object": "chat.completion",
    "usage": {
        "prompt_tokens": 144,
        "completion_tokens": 17,
        "total_tokens": 161
    },
    "id": "chatcmpl-8mLmvvKAjSql7rGF8fvQeddKhWYvr",
    "created": 1706534189,
    "choices": [
        {
            "index": 0,
            "delta": null,
            "message": {
                "role": "assistant",
                "content": "สภาพอากาศในเซี่ยงไฮ้วันนี้คือ 25 องศาเซลเซียส"
            },
            "finish_reason": "stop"
        }
    ]
}