สวัสดีครับ! หลายคนที่เพิ่งเริ่มใช้งาน AI API คงสงสัยว่า "Function Calling" ที่เห็นในเอกสารต่างๆ มันคืออะไร? วันนี้ผมจะมาอธิบายอย่างละเอียด เข้าใจง่าย ไม่ต้องมีพื้นฐานก็เข้าใจได้

Function Calling คืออะไร?

ลองนึกภาพว่าคุณมีล่ามอยู่ในมือ คุณสั่งว่า "อยากรู้อากาศวันพรุ่งนี้" แทนที่ล่ามจะตอบว่า "ฝนตก" มันกลับไปดูข้อมูลจริงจากเว็บไซต์อากาศมาให้คุณ การทำงานแบบนี้แหละคือ "Function Calling"

ในทางเทคนิค Function Calling คือวิธีที่ AI เรียกใช้โปรแกรมหรือฟังก์ชันที่เรากำหนดไว้ เช่น การค้นหาข้อมูล การบันทึกข้อมูล หรือการคำนวณต่างๆ แทนที่ AI จะเดาเอง (ซึ่งอาจผิดพลาด) มันจะบอกเราว่า "ควรเรียกฟังก์ชันไหนดี" แล้วเราไปทำงานนั้นจริงๆ แล้วส่งผลลัพธ์กลับไปให้ AI

ทำไมต้องเรียนรู้เรื่องนี้?

เริ่มต้นใช้งาน Function Calling กับ HolySheep AI

ก่อนจะเริ่ม คุณต้องมี API Key ก่อน ถ้ายังไม่มี สมัครที่นี่ ครับ HolySheep AI เป็นผู้ให้บริการ AI API ราคาประหยัด อัตรา ¥1=$1 ประหยัดได้มากกว่า 85% เมื่อเทียบกับเว็บอื่น รองรับการชำระเงินผ่าน WeChat และ Alipay มีความเร็วตอบสนองต่ำกว่า 50 มิลลิวินาที แถมเมื่อลงทะเบียนจะได้รับเครดิตฟรีทันที ใช้งานได้เลย!

ขั้นตอนที่ 1: ติดตั้งโปรแกรมที่จำเป็น

สำหรับการเรียนรู้ ผมแนะนำให้ใช้ Python ครับ ง่ายและเข้าใจได้เร็ว ก่อนอื่นติดตั้งโปรแกรม openai ก่อน เปิดหน้าต่าง Command Prompt หรือ Terminal แล้วพิมพ์คำสั่งนี้:

pip install openai

ขั้นตอนที่ 2: กำหนดค่าเริ่มต้น

สร้างไฟล์ใหม่ชื่อ test_function.py แล้วเขียนโค้ดสำหรับเชื่อมต่อ API ดังนี้:

import openai


ตั้งค่าการเชื่อมต่อกับ HolySheep AI

client = openai.OpenAI(
    api_key="YOUR_HOLYSHEEP_API_KEY",  # แทนที่ด้วย API Key ของคุณ
    base_url="https://api.holysheep.ai/v1"
)


ทดสอบการเชื่อมต่อ

response = client.chat.completions.create(
    model="gpt-4.1",
    messages=[{"role": "user", "content": "ทดสอบการเชื่อมต่อ ตอบว่า OK"}]
)
print(response.choices[0].message.content)

ถ้าได้ผลลัพธ์เป็น "OK" แสดงว่าเชื่อมต่อสำเร็จครับ!

การสร้าง Function แรกของคุณ

ตอนนี้เรามาลองสร้าง Function สำหรับคำนวณพื้นที่สี่เหลี่ยมกันครับ Function คือ "เครื่องมือ" ที่บอก AI ว่า "เวลาถามเรื่องพื้นที่ ให้ใช้ฟังก์ชันนี้นะ"

# กำหนดรายละเอียดของ Function
tools = [
    {
        "type": "function",
        "function": {
            "name": "calculate_area",
            "description": "คำนวณพื้นที่สี่เหลี่ยม",
            "parameters": {
                "type": "object",
                "properties": {
                    "width": {
                        "type": "number",
                        "description": "ความกว้าง (เมตร)"
                    },
                    "height": {
                        "type": "number",
                        "description": "ความสูง (เมตร)"
                    }
                },
                "required": ["width", "height"]
            }
        }
    }
]


ส่งคำถามไปยัง AI

user_message = "ที่ดินกว้าง 25 เมตร ยาว 40 เมตร มีพื้นที่เท่าไหร่?"

response = client.chat.completions.create(
    model="gpt-4.1",
    messages=[{"role": "user", "content": user_message}],
    tools=tools
)


ดูผลลัพธ์

print(response.choices[0].message)

เมื่อรันโค้ดนี้ คุณจะเห็นว่า AI ตอบกลับมาเป็นรูปแบบพิเศษ มี tool_calls บอกว่าควรเรียก function ชื่อ calculate_area พร้อมข้อมูล width=25 และ height=40

การอ่านผลลัพธ์จาก Function Calling

เมื่อ AI ตอบกลับมาว่าจะเรียก Function ตัวไหน ขั้นตอนต่อไปคือการอ่านข้อมูลนั้นมาประมวลผลครับ

# อ่านข้อมูลจากการตอบกลับ
message = response.choices[0].message


ตรวจสอบว่า AI ต้องการเรียก Function ไหน

if message.tool_calls:
    for tool_call in message.tool_calls:
        function_name = tool_call.function.name
        arguments = tool_call.function.arguments
        
        print(f"AI ต้องการเรียก: {function_name}")
        print(f"ข้อมูลที่ส่งมา: {arguments}")
        
        # แปลง JSON string เป็น Dictionary
        import json
        args_dict = json.loads(arguments)
        print(f"ความกว้าง: {args_dict['width']} เมตร")
        print(f"ความสูง: {args_dict['height']} เมตร")

จากโค้ดด้านบน คุณจะเห็นว่า arguments จะอยู่ในรูปแบบ JSON String ซึ่งต้องแปลงเป็น Dictionary ก่อนถึงจะใช้งานได้ วิธีนี้สำคัญมากครับ!

การประมวลผล Function และส่งผลลัพธ์กลับ

หลังจากอ่านข้อมูลได้แล้ว ต่อไปคือการทำงานจริงตาม Function แล้วส่งผลลัพธ์กลับให้ AI ครับ

# ฟังก์ชันสำหรับคำนวณพื้นที่
def calculate_area(width, height):
    return width * height


อ่านข้อมูลและประมวลผล

if message.tool_calls:
    for tool_call in message.tool_calls:
        function_name = tool_call.function.name
        arguments = json.loads(tool_call.function.arguments)
        
        # เรียกใช้ฟังก์ชันตามชื่อที่ AI บอก
        if function_name == "calculate_area":
            result = calculate_area(
                width=arguments["width"],
                height=arguments["height"]
            )
            
            # ส่งผลลัพธ์กลับไปให้ AI
            result_message = client.chat.completions.create(
                model="gpt-4.1",
                messages=[
                    {"role": "user", "content": user_message},
                    message,
                    {
                        "role": "tool",
                        "tool_call_id": tool_call.id,
                        "content": str(result)
                    }
                ],
                tools=tools
            )
            
            print("คำตอบสุดท้าย:")
            print(result_message.choices[0].message.content)

สังเกตว่าต้องส่ง messages ทั้งหมดกลับไป รวมถึงข้อความต้นทาง คำตอบของ AI และผลลัพธ์จาก Function ด้วย ถึงจะทำให้ AI ตอบได้ถูกต้อง

การจัดการข้อผิดพลาดอย่างเหมาะสม

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

import json
from openai import OpenAIError

try:
    # ลองส่งคำขอไปยัง API
    response = client.chat.completions.create(
        model="gpt-4.1",
        messages=[{"role": "user", "content": "ทดสอบ"}],
        tools=tools
    )
    
    # ตรวจสอบว่าได้รับคำตอบหรือไม่
    if response.choices and response.choices[0].message:
        message = response.choices[0].message
        
        if message.tool_calls:
            for tool_call in message.tool_calls:
                # ลองแปลง arguments
                try:
                    arguments = json.loads(tool_call.function.arguments)
                except json.JSONDecodeError:
                    print("ข้อผิดพลาด: รูปแบบข้อมูลไม่ถูกต้อง")
                    arguments = {}
                    
except OpenAIError as e:
    # จัดการข้อผิดพลาดจาก API
    print(f"ข้อผิดพลาดจาก API: {e}")
    
except Exception as e:
    # จัดการข้อผิดพลาดอื่นๆ
    print(f"เกิดข้อผิดพลาดที่ไม่คาดคิด: {type(e).__name__}: {e}")

ข้อผิดพลาดที่พบบ่อยและวิธีแก้ไข

กรณีที่ 1: API Key ไม่ถูกต้อง

อาการ: ได้รับข้อความ error ว่า "Invalid API Key" หรือ "Authentication failed"

สาเหตุ: API Key ที่ใส่ไม่ตรงกับที่ HolySheep AI สร้างให้ หรือมีช่องว่างเกินมา

วิธีแก้ไข:

# ตรวจสอบว่า API Key ไม่มีช่องว่าง
api_key = "YOUR_HOLYSHEEP_API_KEY".strip()


ตรวจสอบว่า API Key ไม่ว่าง

if not api_key or api_key == "YOUR_HOLYSHEEP_API_KEY":
    print("กรุณาใส่ API Key ที่ถูกต้อง")
    print("ไปที่ https://www.holysheep.ai/register เพื่อสมัครและรับ API Key")
else:
    client = openai.OpenAI(
        api_key=api_key,
        base_url="https://api.holysheep.ai/v1"
    )

กรณีที่ 2: ข้อมูล Function Arguments ว่างเปล่า

อาการ: โค้ดทำงานได้บางครั้ง แต่บางครั้ง arguments ว่างเปล่า ทำให้เกิด KeyError

สาเหตุ: AI บางรุ่นอาจไม่ส่ง arguments มาให้ครบ หรือ model ที่เลือกไม่รองรับ Function Calling

วิธีแก้ไข:

# ตรวจสอบความสมบูรณ์ของ arguments ก่อนใช้งาน
if message.tool_calls:
    for tool_call in message.tool_calls:
        function_name = tool_call.function.name
        raw_arguments = tool_call.function.arguments
        
        # ตรวจสอบว่า arguments ไม่ว่าง
        if not raw_arguments:
            print(f"คำเตือน: {function_name} ไม่มีข้อมูลที่แนบมา")
            continue
            
        try:
            arguments = json.loads(raw_arguments)
            
            # ตรวจสอบว่ามี parameter ที่จำเป็นครบหรือไม่
            required_params = ["width", "height"]
            for param in required_params:
                if param not in arguments:
                    print(f"ข้อผิดพลาด: ขาดพารามิเตอร์ {param}")
                    continue
                    
        except json.JSONDecodeError:
            print("ข้อผิดพลาด: รูปแบบ JSON ไม่ถูกต้อง")

กรณีที่ 3: Rate Limit Error (เรียกใช้บ่อยเกินไป)

อาการ: ได้รับข้อผิดพลาด 429 Too Many Requests หรือ "Rate limit exceeded"

สาเหตุ: เรียกใช้ API บ่อยเกินกว่าที่กำหนดในแต่ละนาที

วิธีแก้ไข:

import time
from openai import RateLimitError

def safe_api_call(messages, tools=None, max_retries=3):
    """เรียก API อย่างปลอดภัยพร้อมรอเมื่อเกิน Rate Limit"""
    
    for attempt in range(max_retries):
        try:
            response = client.chat.completions.create(
                model="gpt-4.1",
                messages=messages,
                tools=tools
            )
            return response
            
        except RateLimitError:
            if attempt < max_retries - 1:
                wait_time = 2 ** attempt  # รอ 1, 2, 4 วินาที
                print(f"เกินขีดจำกัด รอ {wait_time} วินาที...")
                time.sleep(wait_time)
            else:
                print("ข้อผิดพลาด: เรียกใช้ API บ่อยเกินไป กรุณาลองใหม่ในภายหลัง")
                raise


วิธีใช้งาน

result = safe_api_call(
    messages=[{"role": "user", "content": "ทดสอบ"}],
    tools=tools
)

ตัวอย่างการใช้งานจริง: ระบบถามอากาศ

มาดูตัวอย่างการใช้งานจริงกันครับ ระบบนี้จะถามสภาพอากาศและแปลงอุณหภูมิให้เรา

import openai
import json


ตั้งค่าการเชื่อมต่อ

client = openai.OpenAI(
    api_key="YOUR_HOLYSHEEP_API_KEY",
    base_url="https://api.holysheep.ai/v1"
)


กำหนด Function สำหรับดูอากาศและแปลงอุณหภูมิ

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "ดูสภาพอากาศของเมือง",
            "parameters": {
                "type": "object",
                "properties": {
                    "city": {
                        "type": "string",
                        "description": "ชื่อเมืองที่ต้องการดูอากาศ"
                    }
                },
                "required": ["city"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "celsius_to_fahrenheit",
            "description": "แปลงอุณหภูมิจากเซลเซียสเป็นฟาเรนไฮต์",
            "parameters": {
                "type": "object",
                "properties": {
                    "celsius": {
                        "type": "number",
                        "description": "อุณหภูมิเป็นองศาเซลเซียส"
                    }
                },
                "required": ["celsius"]
            }
        }
    }
]


ข้อความของผู้ใช้

user_message = "อากาศที่กรุงเทพวันนี้เป็นอย่างไร? และอุณหภูมิเป็นกี่ฟาเรนไฮต์?"


ส่งคำขอครั้งแรก

response = client.chat.completions.create(
    model="gpt-4.1",
    messages=[{"role": "user", "content": user_message}],
    tools=tools
)


ตรวจสอบว่าต้องเรียก Function หรือไม่

message = response.choices[0].message

if message.tool_calls:
    # รายการข้อความทั้งหมด
    all_messages = [{"role": "user", "content": user_message}, message]
    
    for tool_call in message.tool_calls:
        function_name = tool_call.function.name
        arguments = json.loads(tool_call.function.arguments)
        
        # ทำงานตาม Function ที่ได้รับ
        if function_name == "get_weather":
            # ในงานจริงจะเรียก API อากาศ แต่ตอนนี้จำลองข้อมูล
            city = arguments.get("city", "กรุงเทพ")
            result = {"temp": 32, "condition": "แดดจัด", "humidity": 75}
            print(f"ได้รับข้อมูลอากาศ {city}: {result}")
            
        elif function_name == "celsius_to_fahrenheit":
            celsius = arguments.get("celsius", 0)
            fahrenheit = (celsius * 9/5) + 32
            result = {"fahrenheit": round(fahrenheit, 2)}
            print(f"แปลง {celsius}°C เป็น {result['fahrenheit']}°F")
        
        # ส่งผลลัพธ์กลับไปให้ AI
        all_messages.append({
            "role": "tool",
            "tool_call_id": tool_call.id,
            "content": json.dumps(result)
        })
    
    # ส่งคำขอครั้งที่สองพร้อมผลลัพธ์
    final_response = client.chat.completions.create(
        model="gpt-4.1",
        messages=all_messages,
        tools=tools
    )
    
    print("\nคำตอบสุดท้าย:")
    print(final_response.choices[0].message.content)
else:
    print("AI ตอบโดยตรง:", message.content)

สรุป

วันนี้เราได้เรียนรู้พื้นฐานของ Function Calling ใน AI API กันแล้วครับ สิ่งสำคัญที่ต้องจำคือ:

การใช้งาน API ผ่าน HolySheep AI �

แหล่งข้อมูลที่เกี่ยวข้อง

บทความที่เกี่ยวข้อง