Tool Calling คืออะไร? เมื่อ AI เริ่ม “หยิบเครื่องมือ” ได้เองแบบมืออาชีพ

ถ้าคุณเคยถาม AI ว่า “วันนี้อากาศเป็นอย่างไร?” แล้วได้คำตอบว่า “ขออภัย ฉันไม่มีข้อมูล real-time” — นั่นแหละคือข้อจำกัดดั้งเดิมของ AI ที่รู้แค่สิ่งที่ถูกสอนมาจนถึงวันหมดการฝึก แต่ตอนนี้ มีความสามารถใหม่ที่เรียกว่า Tool Calling (หรือบางค่ายเรียกว่า Function Calling) ที่ทำให้ AI ไม่ได้แค่ “ตอบจากความจำ” อีกต่อไป แต่สามารถออกไป หยิบข้อมูล จากโลกภายนอก เรียกใช้ API จริงๆ และส่งคำตอบที่แม่นยำกลับมาให้คุณได้

🤔 เข้าใจง่ายๆ ก่อน — ไม่ต้องเขียนโค้ดก็อ่านได้

ลองนึกภาพว่าคุณมี เลขานุการที่ฉลาดมาก — เขามีความรู้กว้างขวาง จำอะไรได้เก่ง แต่ถ้าคุณถามว่า “หุ้น Apple ปิดที่เท่าไหร่วันนี้?” เขาจะไม่ตอบเดาๆ แต่จะหยิบโทรศัพท์ขึ้นมา เปิด Bloomberg แล้วบอกตัวเลขจริงๆ ให้คุณ

Tool Calling ก็ทำงานในลักษณะเดียวกัน ตัว AI จะรู้ว่า:

• คำถามนี้ต้องใช้ข้อมูล real-time หรือไม่?
• ควรใช้ “เครื่องมือ” (tool) อะไร?
• ต้องส่งพารามิเตอร์อะไรไปด้วย?
• นำผลลัพธ์ที่ได้มาเรียบเรียงเป็นคำตอบอย่างไร?

ทั้งหมดนี้เกิดขึ้นโดยอัตโนมัติ ผู้ใช้แค่ถามตามธรรมชาติ ไม่ต้องรู้เลยว่าเบื้องหลังมี API หรือฐานข้อมูลอะไรอยู่

🔄 กระบวนการทำงาน — ทีละขั้น

เมื่อคุณส่งคำถามที่ต้องใช้ Tool Calling กระบวนการทำงานจะเป็นแบบนี้:

มาดูแต่ละขั้นให้ชัดขึ้น:

1. ผู้ใช้ส่งคำถาม — ถามตามธรรมชาติ เหมือนคุยกับคน
2. AI วิเคราะห์และตัดสินใจ — โมเดลอ่านคำถามและตัดสินใจว่า “คำถามนี้ต้องการข้อมูลภายนอก” จึงเลือก tool ที่เหมาะสม ณ จุดนี้ AI ยังไม่ตอบผู้ใช้ แต่ส่ง signal ว่าต้องการเรียก tool ก่อน
3. ส่ง Tool Call Request — ระบบ (ฝั่ง application) รับ signal นั้น แล้วเรียก function หรือ API จริงๆ พร้อมพารามิเตอร์ที่ AI กำหนดมา
4. Tool ส่งผลลัพธ์กลับ — ผลลัพธ์จาก API หรือ function ถูกส่งกลับไปยัง AI ในรูปแบบ structured data
5. AI สร้างคำตอบสุดท้าย — AI นำข้อมูลที่ได้มาเรียบเรียงเป็นประโยคภาษาธรรมชาติที่อ่านง่าย
6. ผู้ใช้ได้รับคำตอบ — ได้คำตอบที่แม่นยำ ทันเหตุการณ์ ในรูปแบบที่เข้าใจง่าย

💻 สำหรับนักพัฒนา — ตัวอย่างโค้ดกับ Anthropic API

ลองมาดูว่าเบื้องหลังทำงานอย่างไร ในฝั่ง Anthropic (Claude) เราจะ define tools เป็น JSON schema แล้วส่งไปพร้อมกับ message:

ขั้นที่ 1: กำหนด Tool และส่งคำถาม

import anthropic

client = anthropic.Anthropic()

# กำหนด tools ที่ AI สามารถเลือกใช้ได้
tools = [
    {
        "name": "get_stock_price",
        "description": "ดึงราคาหุ้น real-time จาก symbol ที่ระบุ",
        "input_schema": {
            "type": "object",
            "properties": {
                "symbol": {
                    "type": "string",
                    "description": "Stock symbol เช่น AAPL, MSFT, GOOGL"
                }
            },
            "required": ["symbol"]
        }
    }
]

# ส่งคำถามพร้อม tools
response = client.messages.create(
    model="claude-opus-4-6",
    max_tokens=1024,
    tools=tools,
    messages=[
        {"role": "user", "content": "หุ้น Apple ราคาเท่าไหร่ตอนนี้?"}
    ]
)

print(response.stop_reason)   # → "tool_use"
print(response.content)        # → tool_use block พร้อม parameters

ขั้นที่ 2: Response ที่ได้จาก AI (JSON structure)

เมื่อ AI ตัดสินใจว่าต้องเรียก tool มันจะ หยุด และส่ง response ในรูปแบบนี้:

{
  "stop_reason": "tool_use",
  "content": [
    {
      "type": "tool_use",
      "id": "toolu_01ABC123...",
      "name": "get_stock_price",
      "input": {
        "symbol": "AAPL"
      }
    }
  ]
}

ขั้นที่ 3: เรียก function จริงๆ และส่งผลกลับ

# ฝั่ง application เรียก function จริงๆ
def get_stock_price(symbol: str) -> dict:
    # เรียก API จริงๆ ที่นี่ เช่น Yahoo Finance, Alpha Vantage
    return {"price": 189.25, "change": "+1.2%", "symbol": symbol}

# ดึง tool call จาก response
tool_use = response.content[0]
result = get_stock_price(**tool_use.input)

# ส่งผลลัพธ์กลับไปให้ AI สร้างคำตอบสุดท้าย
final_response = client.messages.create(
    model="claude-opus-4-6",
    max_tokens=1024,
    tools=tools,
    messages=[
        {"role": "user", "content": "หุ้น Apple ราคาเท่าไหร่ตอนนี้?"},
        {"role": "assistant", "content": response.content},
        {
            "role": "user",
            "content": [{
                "type": "tool_result",
                "tool_use_id": tool_use.id,
                "content": str(result)
            }]
        }
    ]
)

print(final_response.content[0].text)
# → "ขณะนี้ Apple (AAPL) อยู่ที่ $189.25 ปรับตัวขึ้น +1.2%"

🌐 AI ค่ายอื่นก็รองรับแนวคิดเดียวกัน

Tool Calling ไม่ใช่ความสามารถเฉพาะของ Anthropic แต่กลายเป็น มาตรฐานของวงการ แล้ว ทุก provider หลักรองรับ แม้จะใช้ชื่อและ syntax ต่างกันนิดหน่อย:

ตัวอย่างแบบย่อของ OpenAI และ Google Gemini เพื่อเปรียบเทียบ:

# ===== OpenAI (GPT-4o) =====
from openai import OpenAI
client = OpenAI()

response = client.chat.completions.create(
    model="gpt-4o",
    tools=[{
        "type": "function",
        "function": {
            "name": "get_stock_price",
            "description": "Get real-time stock price",
            "parameters": {
                "type": "object",
                "properties": {
                    "symbol": {"type": "string"}
                },
                "required": ["symbol"]
            }
        }
    }],
    messages=[{"role": "user", "content": "Apple stock price now?"}]
)

# ===== Google Gemini =====
import google.generativeai as genai

def get_stock_price(symbol: str) -> dict:
    """Get real-time stock price for a given symbol.
    
    Args:
        symbol: Stock ticker symbol e.g. AAPL, MSFT
    """
    return {"price": 189.25}  # replace with real API call

# Gemini สามารถรับ Python function โดยตรงได้เลย
model = genai.GenerativeModel(
    model_name="gemini-2.0-flash",
    tools=[get_stock_price]   # ← ส่ง function object ได้เลย
)
response = model.generate_content("Apple stock price now?")

จะเห็นว่าแนวคิดเหมือนกันหมด แตกต่างกันแค่ syntax เล็กน้อย ถ้าเข้าใจ Tool Calling ของค่ายหนึ่งแล้ว ค่ายอื่นๆ ก็เรียนรู้ได้เร็วมาก

✅ สรุป — ทำไม Tool Calling ถึงเปลี่ยนเกม

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

• 🎯 ข้อมูลแม่นยำ — ไม่ตอบจากความจำเก่า แต่ดึงข้อมูล real-time
• 🔒 ปลอดภัย — AI ไม่ได้เรียก API เอง นักพัฒนาควบคุมได้ 100%
• 🔧 ยืดหยุ่น — เพิ่ม tool ใหม่ได้ไม่จำกัด ไม่ต้อง train โมเดลใหม่
• 🌐 เป็นมาตรฐาน — ทุก AI ค่ายใหญ่รองรับแนวคิดเดียวกัน
• 🤖 พื้นฐาน AI Agents — Tool Calling คือ “หัวใจ” ของ AI Agent สมัยใหม่

ถ้าคุณกำลังเรียนรู้การสร้าง AI Agent — ไม่ว่าจะเป็น chatbot, automation workflow หรือ data pipeline — Tool Calling คือสิ่งแรกที่ต้องเข้าใจให้ถ่องแท้ก่อนเลย เพราะทุกอย่างต่อจากนี้ต้องการมันทั้งนั้น