วิธีใช้ Function Calling กับ DeepSeek V4 Pro API

DeepSeek ได้นำ V4 Pro ออกจากการแสดงตัวอย่างเมื่อวันที่ 12 สิงหาคม 2026 และ รายงานการเปิดตัว เน้นไปที่เวิร์กโฟลว์ของเอเจนต์: การเขียนโค้ด, การใช้เครื่องมือ, และงานที่มีขอบเขตยาวนานที่เชื่อมโยงกันหลายสิบขั้นตอนโดยไม่หลุดจากเป้าหมาย ตำแหน่งนี้ทำให้คุณสมบัติ API อย่างหนึ่งมีความสำคัญมากกว่าคุณสมบัติอื่น ๆ นั่นคือ การเรียกใช้ฟังก์ชัน (function calling) และเป็นคุณสมบัติที่คู่มือในช่วงเปิดตัวยังไม่ได้กล่าวถึง บทเรียนทั้งหมดที่ผ่านมาจบลงที่การสร้างข้อความแชทเท่านั้น

บทความนี้จะลงลึกไปกว่านั้น: กำหนดสกีมาเครื่องมือ, เรียกใช้เครื่องมือครั้งแรกด้วย Python SDK `openai` มาตรฐาน, สร้างลูปเอเจนต์แบบเต็ม, จากนั้นทดสอบทั้งหมดใน Apidog ก่อนที่คุณจะนำเอเจนต์ไปใช้งาน หากคุณยังไม่มี DeepSeek API key ให้ตั้งค่าด้วยคู่มือของเราเกี่ยวกับ วิธีการใช้ DeepSeek V4 API แล้วกลับมาที่นี่อีกครั้ง

สรุป

• `deepseek-v4-pro` (GA build DeepSeek-V4-Pro-0813) รองรับการเรียกใช้ฟังก์ชันแบบ OpenAI: ส่งอาร์เรย์ `tools`, รับ `tool_calls`, ส่งคืนผลลัพธ์เป็นข้อความ `tool` SDK `openai` มาตรฐานใช้งานได้กับ `https://api.deepseek.com`
• ลูปเอเจนต์แบบเต็มใช้ Python ประมาณ 30 บรรทัด: เรียก, ประมวลผล, เพิ่ม, ทำซ้ำจนกว่าโมเดลจะหยุดร้องขอเครื่องมือ รองรับการเรียกใช้แบบขนานและเอาต์พุตที่มีโครงสร้าง; โหมดคิดเพิ่ม `reasoning_content`
• การแคชคำนำหน้าอัตโนมัติกำหนดราคาอินพุตที่ถูกแคชที่ $0.003625 ต่อล้านโทเค็น ซึ่งถูกกว่าการพลาดแคช 120 เท่า นี่คือสิ่งที่ทำให้ลูปเอเจนต์เชิงลึกมีราคาที่เอื้อมถึง
• คุณภาพการเรียกใช้เครื่องมือแตกต่างกันไปตามโครงสร้างและสกีมาของคุณ ทดสอบเครื่องมือจริงของคุณกับโมเดลที่ใช้งานอยู่ ไม่ใช่การทดสอบเปรียบเทียบ

เหตุใดการเรียกใช้เครื่องมือจึงเป็นกรณีการใช้งานหลักของ V4 Pro

DeepSeek สร้าง V4 Pro สำหรับเอเจนต์ และเอกสารข้อมูลจำเพาะอ่านเหมือนรายการตรวจสอบรันไทม์ของเอเจนต์:

แต่ละบรรทัดเชื่อมโยงกับปัญหาของเอเจนต์: หน้าต่าง 1M โทเค็นรองรับประวัติผลลัพธ์เครื่องมือทั้งหมดของเอเจนต์ขนาดใหญ่, เพดานเอาต์พุต 384K ทำให้มีพื้นที่สำหรับเพย์โหลดที่มีโครงสร้างขนาดใหญ่, และการแคชคำนำหน้าช่วยให้เศรษฐศาสตร์ของลูปทำงานได้ โมเดลนี้ถูกระบุใน OpenRouter เป็น deepseek-v4-pro-0813 สำหรับการเปรียบเทียบผู้ให้บริการ

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

การทำงานของการเรียกใช้ฟังก์ชัน DeepSeek

การเรียกใช้ฟังก์ชันไม่ได้หมายความว่าโมเดลจะประมวลผลอะไร มันตอบกลับด้วยคำขอที่มีโครงสร้างว่า “เรียก `get_order` ด้วย `{"order_id": "ORD-10442"}`” แทนที่จะเป็นข้อความ โค้ดของคุณจะรันฟังก์ชัน, คืนค่าผลลัพธ์, และโมเดลจะดำเนินการต่อด้วยข้อมูลจริง วัฏจักร:

1. คุณส่ง `messages` พร้อมกับอาร์เรย์ `tools` ที่อธิบายแต่ละฟังก์ชันใน JSON Schema
2. โมเดลตัดสินใจว่าจำเป็นต้องใช้เครื่องมือและตอบกลับด้วย `tool_calls` และ `finish_reason: "tool_calls"`
3. โค้ดของคุณแยกวิเคราะห์อาร์กิวเมนต์และรันฟังก์ชันจริง
4. คุณเพิ่มผลลัพธ์เป็นข้อความ `role: "tool"` ที่เชื่อมโยงกับ ID ของการเรียก
5. โมเดลจะร้องขอเครื่องมืออื่นหรือสร้างคำตอบสุดท้าย

หากคุณเคยทำงานกับการ เรียกใช้ฟังก์ชัน OpenAI นี่คือรูปแบบ wire format เดียวกัน; โค้ดเอเจนต์ส่วนใหญ่สามารถพอร์ตได้โดยการเปลี่ยน URL พื้นฐานและชื่อโมเดล เอกสารทางการของ DeepSeek ยังครอบคลุมถึงเอนด์พอยต์ Messages ที่เข้ากันได้กับ Anthropic และ Responses API แต่คู่มือนี้จะเน้นไปที่ส่วนที่เข้ากันได้กับ OpenAI

ขั้นตอนที่ 1: ตั้งค่าไคลเอนต์

ติดตั้ง SDK และชี้ไปยัง DeepSeek:

pip install openai
export DEEPSEEK_API_KEY="sk-..."

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["DEEPSEEK_API_KEY"],
    base_url="https://api.deepseek.com",
)

นั่นคือการตั้งค่าทั้งหมด ทุกตัวอย่างใช้ `model="deepseek-v4-pro"` ซึ่งจะแปลงเป็น GA build DeepSeek-V4-Pro-0813

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

เราจะสร้างเอเจนต์สนับสนุนสำหรับร้านค้าออนไลน์ เครื่องมือแรกของมันคือการค้นหาคำสั่งซื้อ คำจำกัดความของเครื่องมือมีสามส่วน: ชื่อ, คำอธิบาย, และ JSON Schema สำหรับพารามิเตอร์

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_order",
            "description": (
                "Look up a customer order by its ID. Returns the order status, "
                "carrier, tracking number, and estimated delivery date. Use this "
                "whenever the user asks where an order is or what state it's in."
            ),
            "parameters": {
                "type": "object",
                "properties": {
                    "order_id": {
                        "type": "string",
                        "description": "The order ID, formatted like 'ORD-10442'.",
                    }
                },
                "required": ["order_id"],
            },
        },
    }
]

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

ฟังก์ชันภายในที่สกีมาอธิบาย ซึ่งถูกจำลองไว้สำหรับบริการคำสั่งซื้อจริง:

def get_order(order_id: str) -> dict:
    """Stub for your real order service."""
    fake_db = {
        "ORD-10442": {
            "status": "shipped",
            "carrier": "DHL",
            "tracking_number": "4281337005",
            "estimated_delivery": "2026-08-15",
        },
        "ORD-10587": {
            "status": "processing",
            "estimated_ship_date": "2026-08-14",
        },
    }
    return fake_db.get(order_id, {"error": f"Unknown order ID: {order_id}"})

ขั้นตอนที่ 3: เรียกใช้เครื่องมือครั้งแรก

ส่งคำถามที่โมเดลไม่สามารถตอบได้หากไม่มีเครื่องมือ:

messages = [
    {"role": "system", "content": "You are a support agent for an online store."},
    {"role": "user", "content": "Where is my order ORD-10442?"},
]

response = client.chat.completions.create(
    model="deepseek-v4-pro",
    messages=messages,
    tools=tools,
)

message = response.choices[0].message
print(message.tool_calls[0].function.name) # get_order
print(message.tool_calls[0].function.arguments) # {"order_id": "ORD-10442"}

แทนที่จะตอบ โมเดลจะขอให้คุณรัน `get_order` เพย์โหลดการตอบกลับดิบจะมีลักษณะดังนี้:

{
  "id": "chatcmpl-8f3a1c",
  "object": "chat.completion",
  "model": "deepseek-v4-pro",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "",
        "tool_calls": [
          {
            "id": "call_0_f1c29a44",
            "type": "function",
            "function": {
              "name": "get_order",
              "arguments": "{\"order_id\": \"ORD-10442\"}"
            }
          }
        ]
      },
      "finish_reason": "tool_calls"
    }
  ],
  "usage": {
    "prompt_tokens": 312,
    "completion_tokens": 24,
    "total_tokens": 336,
    "prompt_cache_hit_tokens": 0,
    "prompt_cache_miss_tokens": 312
  }
}

มีสามรายละเอียดที่สำคัญ `finish_reason` คือ `"tool_calls"` ซึ่งบอกลูปของคุณว่าโมเดลต้องการการประมวลผล การเรียกใช้แต่ละครั้งมี `id` ที่คุณต้องส่งกลับพร้อมผลลัพธ์ และ `arguments` เป็น JSON *สตริง* ที่คุณต้องแยกวิเคราะห์เอง ดังนั้นคาดว่าบางครั้งอาจมีรูปแบบที่ไม่ถูกต้อง

ขั้นตอนที่ 4: ประมวลผลฟังก์ชันและส่งคืนผลลัพธ์

รันฟังก์ชัน จากนั้นเพิ่มข้อความสองข้อความ: การตอบกลับของผู้ช่วยที่มี `tool_calls` และข้อความ `tool` ที่มีผลลัพธ์ของคุณ

import json

tool_call = message.tool_calls[0]
args = json.loads(tool_call.function.arguments)
result = get_order(args)

messages.append(message) # the assistant turn containing tool_calls
messages.append({
    "role": "tool",
    "tool_call_id": tool_call.id, # must match the id from the response
    "content": json.dumps(result),
})

final = client.chat.completions.create(
    model="deepseek-v4-pro",
    messages=messages,
    tools=tools,
)
print(final.choices[0].message.content)
# Your order ORD-10442 shipped with DHL and is estimated to arrive
# by August 15, 2026. Tracking number: 4281337005.

การเชื่อมโยง `tool_call_id` นั้นเข้มงวด: รายการ `tool_calls` ทุกรายการต้องมีข้อความ `tool` ที่ตรงกันก่อนที่จะถึงเทิร์นถัดไปของโมเดล มิฉะนั้นคำขอจะล้มเหลว

ขั้นตอนที่ 5: ลูปเอเจนต์แบบเต็ม

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

TOOLS_BY_NAME = {"get_order": get_order}

def run_agent(client, messages, tools, max_rounds=10):
    """Run the model until it produces a final answer or hits the cap."""
    for _ in range(max_rounds):
        response = client.chat.completions.create(
            model="deepseek-v4-pro",
            messages=messages,
            tools=tools,
        )
        message = response.choices[0].message
        messages.append(message)

        if not message.tool_calls: # no tool requests: we're done
            return message.content

        for tool_call in message.tool_calls:
            fn = TOOLS_BY_NAME.get(tool_call.function.name)
            try:
                if fn is None:
                    raise ValueError(f"Unknown tool: {tool_call.function.name}")
                args = json.loads(tool_call.function.arguments)
                result = fn(args)
            except Exception as exc:
                result = {"error": str(exc)} # feed failures back to the model
            messages.append({
                "role": "tool",
                "tool_call_id": tool_call.id,
                "content": json.dumps(result),
            })

    raise RuntimeError(f"Agent did not finish within {max_rounds} rounds")

เฟรมเวิร์กและ Agent SDKs เป็นการต่อยอดจากลูปนี้ ขีดจำกัด `max_rounds` จะเปลี่ยนโมเดลที่ติดอยู่กับการเรียกเครื่องมือที่ล้มเหลวซ้ำๆ ให้เป็นการล้มเหลวที่ชัดเจน แทนที่จะเป็นบิลที่ไม่มีที่สิ้นสุด

การเรียกใช้เครื่องมือแบบขนาน

ขอการค้นหาสองรายการ “เปรียบเทียบสถานะของ ORD-10442 และ ORD-10587” และ V4 Pro มักจะรวมทั้งสองรายการเป็นเทิร์นเดียว:

"tool_calls": [
  {
    "id": "call_0_a7d1",
    "type": "function",
    "function": { "name": "get_order", "arguments": "{\"order_id\": \"ORD-10442\"}" }
  },
  {
    "id": "call_1_b3e9",
    "type": "function",
    "function": { "name": "get_order", "arguments": "{\"order_id\": \"ORD-10587\"}" }
  }
]

ลูป `run_agent` จัดการสิ่งนี้อยู่แล้ว: `for` ภายในจะตอบการเรียกแต่ละครั้งด้วย `tool_call_id` ของตัวเอง (ทุกการเรียกจำเป็นต้องมีผลลัพธ์ที่ตรงกันก่อนเทิร์นถัดไป) และคุณสามารถประมวลผลชุดการเรียกเหล่านั้นพร้อมกันได้ มันเป็นปรัชญาที่แตกต่างจากการ เรียกใช้เครื่องมือแบบโปรแกรมของ GPT-5.6 ซึ่งโมเดลเขียนโค้ดการจัดการในแซนด์บ็อกซ์; DeepSeek เก็บการประมวลผลและขอบเขตความน่าเชื่อถือไว้ในรันไทม์ของคุณ

โหมดการคิดพร้อมเครื่องมือ

V4 Pro มาพร้อมกับโหมดการคิดสามโหมด ดังนั้นคุณสามารถเพิ่มความพยายามในการให้เหตุผลสำหรับการวางแผนที่ซับซ้อน และข้ามไปสำหรับการค้นหาตามปกติ (ดู เอกสารทางการ สำหรับชื่อโหมดและค่าเริ่มต้น) เมื่อเปิดใช้งานการคิด API จะส่งคืนร่องรอยการทำงานของโมเดลเป็น `reasoning_content` พร้อมกับการเรียกใช้เครื่องมือใดๆ:

response = client.chat.completions.create(
    model="deepseek-v4-pro",
    messages=messages,
    tools=tools,
    extra_body={"thinking": {"type": "enabled"}},
)

message = response.choices[0].message
print(message.reasoning_content) # the planning trace
print(message.tool_calls) # the calls it settled on

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

การจัดการข้อผิดพลาด: เมื่อโมเดลเรียกใช้ผิดพลาด

การเรียกใช้เครื่องมือที่มีรูปแบบผิดพลาดนั้นหายาก แต่ลูปเอเจนต์จะขยายทุกโหมดความล้มเหลว รูปแบบที่สำคัญ: อย่าทำให้ระบบล่มจากการเรียกที่ไม่ถูกต้อง, ส่งคืนปัญหาเป็นผลลัพธ์ของเครื่องมือ, และให้โมเดลลองใหม่ สิ่งนี้ครอบคลุมถึงอาร์กิวเมนต์ที่ล้มเหลวในการ `json.loads` รวมถึงค่าที่ขัดกับกฎทางธุรกิจของคุณ:

from jsonschema import ValidationError, validate

schema = tools[0]["function"]["parameters"]

try:
    args = json.loads(tool_call.function.arguments)
    validate(instance=args, schema=schema)
    result = get_order(**args)
except (json.JSONDecodeError, ValidationError) as exc:
    result = {
        "error": f"Invalid arguments: {exc}",
        "hint": "Call get_order again with an order_id string like 'ORD-10442'.",
    }

ฟิลด์ `hint` มีความสำคัญ: การแก้ไขเพียงบรรทัดเดียวมักจะนำไปสู่การลองใหม่ที่แก้ไขได้ในรอบถัดไป ควรพิจารณาข้อผิดพลาดของเอเจนต์เป็นเหตุการณ์ด้านความปลอดภัยด้วย โมเดลที่ถูกชักจูงให้เรียก `delete_order` ด้วยอาร์กิวเมนต์ที่ผู้โจมตีให้มานั้นอันตรายพอๆ กับคีย์ที่อยู่เบื้องหลัง ซึ่งเป็นกรณีสำหรับการใช้ API key ที่มีสิทธิ์น้อยที่สุดสำหรับ AI agents จำกัดขอบเขตของข้อมูลประจำตัวเพื่อไม่ให้การเรียกที่ผิดพลาดกลายเป็นเหตุการณ์

ทดสอบและดีบักการเรียกใช้เครื่องมือด้วย Apidog ก่อนที่คุณจะนำไปใช้งาน

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

1. ออกแบบ API ที่รองรับก่อน กำหนด `GET /orders/{order_id}` เป็นสเปกใน Apidog’s visual designer; JSON Schema ของเครื่องมือของคุณจะมาจากสเปกโดยตรง ดังนั้นทั้งสองจะไม่แยกจากกันโดยไม่รู้ตัว
2. จำลองการทำงานก่อนที่แบ็คเอนด์จะถูกสร้างขึ้น Mock อัจฉริยะของ Apidog จะให้บริการการตอบสนองที่สมจริงจากสกีมา ดังนั้นลูปเอเจนต์จะทำงานกับ `get_order` ในขณะที่บริการจริงยังคงอยู่ระหว่างการพัฒนา
3. ตรวจสอบเพย์โหลดดิบ ส่ง `messages` + `tools` body เดียวกันไปยัง `https://api.deepseek.com` จาก Apidog และอ่าน `tool_calls` JSON ดิบโดยตรง `properties` ที่ซ้อนผิดพลาดหรืออาร์กิวเมนต์ที่ถูกเข้ารหัสสองครั้งจะปรากฏขึ้นในการตรวจสอบครั้งเดียว
4. เปลี่ยนการสนทนาให้เป็นสถานการณ์ทดสอบ ตรวจสอบ `finish_reason` และรูปแบบอาร์กิวเมนต์ และรันชุดทดสอบทุกครั้งที่มีการเปลี่ยนแปลงสกีมา; เมื่อพิจารณาจากความไวของโครงสร้างที่รายงานใน Hacker News ชุดทดสอบการถดถอยบนสกีมาจริงของคุณคือเกณฑ์มาตรฐานที่คาดการณ์การผลิต ดู การเชื่อมต่อ AI agent เข้ากับ Apidog test harness สำหรับรูปแบบที่ลึกซึ้งยิ่งขึ้น

ดาวน์โหลด Apidog ฟรีเพื่อทำตาม; mock server และสถานการณ์ทดสอบรวมอยู่ในแพ็กเกจฟรี

ค่าใช้จ่ายของลูปเอเจนต์ (และเหตุใดการแคชจึงเป็นตัวตัดสิน)

ลูปเอเจนต์จะอ่านบทสนทนาทั้งหมดซ้ำในทุกรอบ: เมื่อถึงรอบที่สิบ พร้อมต์ของระบบ, สกีมาของเครื่องมือ, และผลลัพธ์เก้ารอบจะถูกเรียกเก็บเงินเป็นครั้งที่สิบ การแคชคำนำหน้าอัตโนมัติของ V4 Pro ช่วยลดค่าใช้จ่ายนี้ โดยอินพุตของแต่ละรอบคือของรอบก่อนหน้าบวกกับส่วนเล็กน้อย ดังนั้นเกือบทั้งคำนำหน้าจะถูกเรียกเก็บเงินที่ $0.003625/M แทนที่จะเป็น $0.435/M การอ่านบทสนทนา 100K โทเค็นซ้ำมีค่าใช้จ่ายประมาณ $0.0435 สำหรับแบบไม่แคช แต่ประมาณ $0.0004 สำหรับแบบแคช; `prompt_cache_hit_tokens` ในบล็อกการใช้งานจะแสดงอัตราการเรียกใช้งานจริงของคุณ

เพื่อรักษาระดับอัตราการแคชให้สูง อย่าแก้ไขข้อความก่อนหน้า และรักษาสภาพอาร์เรย์ `tools` ให้คงที่ตลอดหลายรอบ บทความเบื้องต้นเกี่ยวกับ การแคชพร้อมต์ ครอบคลุมกลไกการทำงาน และหาก `deepseek-v4-flash` ที่ราคา $0.14/$0.28 ดูน่าสนใจ: มันดีสำหรับการส่งต่อเครื่องมือแบบครั้งเดียว แต่จะถดถอยเมื่อใช้งานในลูปที่เรียกใช้ 10+ ครั้ง ดังนั้นการลองใหม่จะกินเงินที่ประหยัดได้ DeepSeek Pro จึงเป็นค่าเริ่มต้นที่ปลอดภัยกว่าสำหรับเอเจนต์

คำถามที่พบบ่อย

คำจำกัดความของเครื่องมือมีค่าใช้จ่ายเป็นโทเค็นหรือไม่?

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

ฉันสามารถรวมการเรียกใช้ฟังก์ชันเข้ากับเอาต์พุตที่มีโครงสร้างได้หรือไม่?

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

สรุป

การเรียกใช้ฟังก์ชันบน DeepSeek V4 Pro นั้นตั้งใจให้ใช้งานได้ไม่น่าตื่นเต้น: สกีมาที่เข้ากันได้กับ OpenAI, อาร์เรย์ `tool_calls`, ข้อความ `tool` ที่มี ID ลูปในขั้นตอนที่ 5 คือสถาปัตยกรรมทั้งหมด และการกำหนดราคาแบบแคชสำเร็จทำให้มีราคาถูกกว่าที่ทีมส่วนใหญ่คาดหวัง สิ่งที่การทดสอบเปรียบเทียบไม่สามารถบอกคุณได้คือโมเดลทำงานอย่างไรกับสกีมาของคุณเอง จงออกแบบ API ที่รองรับอย่างตั้งใจ, จำลองการทำงานล่วงหน้า, และเก็บชุดการทดสอบการถดถอยของสถานการณ์การเรียกใช้เครื่องมือไว้ใน Apidog เพื่อที่การเปลี่ยนแปลงสกีมาจะไม่ทำให้เอเจนต์ของคุณเสียหายโดยไม่รู้ตัว