วิธีใช้งาน Claude Fable 5.1 API ทีละขั้นตอนพร้อม Apidog

Claude Fable 5.1 API: คู่มือเริ่มต้นใช้งานแบบลงมือทำ

Claude Fable 5.1 เปิดตัวเมื่อวันที่ 1 กันยายน 2026 โดยใช้ ID โมเดล API คือ claude-fable-5-1 ซึ่งไม่มีส่วนต่อท้ายวันที่ ราคาเท่ากับ Fable 5 คือ 10 ดอลลาร์ต่อล้านโทเค็นอินพุต และ 50 ดอลลาร์ต่อล้านโทเค็นเอาต์พุต ส่วนการอ่านแคชลดลงเหลือ 0.25 ดอลลาร์ต่อล้านโทเค็น พร้อมการเปลี่ยนแปลงสำคัญ 3 ประการที่ไม่มีใน Fable 5

ลองใช้ Apidog วันนี้

คู่มือนี้ครอบคลุมการขอคีย์ การส่งคำขอแรก การควบคุม effort การสตรีม การใช้เครื่องมือโดยไม่บังคับ tool_choice การสำรองเมื่อถูกปฏิเสธ การอัปเดตความคืบหน้า และการตรวจสอบอัตราการอ่านแคช ทุกคำขอเป็น HTTP พร้อม JSON จึงสร้างและดีบักใน Apidog ก่อนนำไปใช้ในแอปพลิเคชันได้

หากกำลังย้ายบริการ Fable 5 หรือ Opus 5 ที่มีอยู่ ให้เปิด คู่มือการย้ายข้อมูลฉบับเต็ม ควบคู่กัน สำหรับภาพรวมโมเดล โปรดอ่าน Claude Fable 5.1 คืออะไร

ก่อนเรียกใช้ครั้งแรก: 3 สิ่งที่ทำให้เกิด 400

1. การคิดไม่สามารถเปิดหรือปิดเองได้

Fable 5.1 ใช้การคิดแบบปรับตัวในการร้องขอทุกครั้ง ให้ละเว้นฟิลด์ thinking หรือส่ง:

{"type": "adaptive"}

ค่าต่อไปนี้จะทำให้เกิด 400:

{"type": "disabled"}
{"type": "enabled", "budget_tokens": N}

หากย้ายมาจาก Opus 5 ให้ลบการตั้งค่าเหล่านี้ และควบคุมการใช้จ่ายด้วย output_config.effort แทน อ่านรายละเอียดเพิ่มเติมได้จาก มีอะไรใหม่ใน Claude Fable 5.1

2. ยกเลิกการบังคับใช้เครื่องมือ

ค่าต่อไปนี้ไม่รองรับ:

{"type": "any"}
{"type": "tool", "name": "..."}

ระบบจะส่งคืนข้อความ:

tool_choice: type "tool" and "any" are not supported for this model

แนวทางแก้ไขอยู่ในหัวข้อการใช้เครื่องมือด้านล่าง

3. องค์กรต้องเปิดการเก็บรักษาข้อมูล 30 วัน

Fable 5.1 เป็นโมเดลภายใต้การคุ้มครอง (Covered Model) คำขอจากองค์กรหรือ workspace ที่ไม่มีการเก็บรักษาข้อมูล 30 วันจะส่งคืน 400 invalid_request_error โดยอาจไม่มีรายละเอียดอื่น หากคำขอแรกมีเนื้อหาถูกต้อง ให้ตรวจสอบการตั้งค่าการเก็บรักษาข้อมูลก่อน

ขั้นตอนที่ 1: ขอ API key

ลงชื่อเข้าใช้ Claude Console เปิด API keys ในการตั้งค่าองค์กร และสร้างคีย์ คีย์จะแสดงให้คัดลอกเพียงครั้งเดียว จึงควรส่งออกเป็น environment variable แทนการวางไว้ในโค้ด:

export ANTHROPIC_API_KEY="sk-ant-..."

ใน Apidog ให้จัดเก็บคีย์เป็น environment variable ชื่อ ANTHROPIC_API_KEY แล้วอ้างอิงในส่วนหัวด้วย:

{{ANTHROPIC_API_KEY}}

วิธีนี้ช่วยไม่ให้คีย์ถูกบันทึกลงใน request body หรือประวัติคำขอ

ขั้นตอนที่ 2: ส่งคำขอแรก

สร้าง POST ไปยัง https://api.anthropic.com/v1/messages พร้อมส่วนหัว 3 รายการ:

• x-api-key
• anthropic-version: 2023-06-01
• content-type: application/json

curl https://api.anthropic.com/v1/messages \
  -H "x-[REDACTED CREDENTIAL] \
  -H "anthropic-version: 2023-06-01" \
  -H "content-type: application/json" \
  -d '{
    "model": "claude-fable-5-1",
    "max_tokens": 16000,
    "messages": [
      {"role": "user", "content": "Explain the difference between idempotent and safe HTTP methods, with one example each."}
    ]
  }'

การเรียกแบบเดียวกันด้วย Python SDK อย่างเป็นทางการ:

import anthropic

client = anthropic.Anthropic()

response = client.messages.create(
    model="claude-fable-5-1",
    max_tokens=16000,
    messages=[{"role": "user", "content": "Explain the difference between idempotent and safe HTTP methods, with one example each."}],
)

if response.stop_reason == "refusal":
    print("declined:", response.stop_details.category if response.stop_details else None)
else:
    for block in response.content:
        if block.type == "text":
            print(block.text)

สร้างนิสัย 2 อย่างตั้งแต่คำขอแรก:

1. ตรวจสอบ stop_reason ก่อนอ่าน content เพราะการปฏิเสธจากตัวจัดประเภทจะเป็น HTTP 200 พร้อมอาร์เรย์เนื้อหาว่าง
2. กำหนด max_tokens ให้เพียงพอ เพราะค่าดังกล่าวรวมโทเค็นการคิดและโทเค็นคำตอบ และ Fable 5.1 จะคิดเสมอ

การตอบกลับอาจมีบล็อก thinking ที่มีข้อความว่างภายใต้ค่าเริ่มต้น display: "omitted" ซึ่งเป็นพฤติกรรมที่คาดไว้ เก็บและส่งบล็อกดังกล่าวกลับโดยไม่แก้ไขในคำขอถัดไป

ขั้นตอนที่ 3: ควบคุมค่าใช้จ่ายและความลึกด้วย effort

effort เป็นตัวควบคุมหลักของ Fable 5.1 โดยอยู่ภายใน output_config ไม่ใช่ระดับบนสุด รองรับค่า low, medium, high, xhigh และ max ค่าเริ่มต้นคือ high

{
  "model": "claude-fable-5-1",
  "max_tokens": 16000,
  "output_config": {"effort": "medium"},
  "messages": [{"role": "user", "content": "Summarize this changelog in five bullets."}]
}

คำแนะนำจาก Anthropic คือเริ่มที่ high แล้วทดสอบระดับอื่นด้วยการประเมินของคุณเอง แม้จะเคยทดสอบกับ Fable 5 แล้วก็ตาม เพราะชื่อระดับไม่ได้หมายถึงปริมาณการคิดเท่ากันในทุกโมเดล

• medium มีประสิทธิภาพใกล้เคียง Fable 5 ในราคาต่ำกว่า
• low อาจแข่งขันกับ Opus และ Sonnet ได้ในแง่ต้นทุนต่อภารกิจ
• ที่ low โมเดลจะค้นหาและเรียกข้อมูลน้อยลง และพึ่งพาความจำมากขึ้น
• ที่ xhigh และ max โมเดลอาจร่างงานส่งมอบขนาดยาวในบล็อกการคิดก่อนเขียนใหม่ จึงควรตั้ง max_tokens ให้สูงพอ

รายละเอียดเพิ่มเติมอยู่ใน คู่มือพารามิเตอร์ effort และ คู่มือพารามิเตอร์ effort สำหรับ Opus 5

เปลี่ยน effort ระหว่างการสนทนา

บน Fable 5 การเปลี่ยน effort ระดับบนสุดระหว่างคำขอจะล้างคำนำหน้าที่แคชไว้ แต่ Fable 5.1 สามารถเปลี่ยน effort โดยไม่ทำลายแคชได้

ใช้ข้อความ role: "system" ที่มีเนื้อหาว่างและ output_config พร้อม beta header:

response = client.beta.messages.create(
    model="claude-fable-5-1",
    max_tokens=16000,
    output_config={"effort": "high"},
    betas=["mid-conversation-output-config-2026-07-01"],
    messages=[
        {"role": "user", "content": "Plan a migration from SQLite to PostgreSQL in three short steps."},
        {"role": "assistant", "content": "1. Export the SQLite data. 2. Create the PostgreSQL schema. 3. Import the data and verify row counts."},
        {"role": "system", "content": [], "output_config": {"effort": "low"}},
        {"role": "user", "content": "Summarize the plan in one sentence."},
    ],
)

การลด effort ด้วยวิธีนี้เชื่อถือได้ ส่วนการเพิ่ม effort ทำงานได้ดีที่สุดเมื่อกระโดดหลายระดับ เช่น low ไป xhigh

ขั้นตอนที่ 4: สตรีมการตอบกลับ

งานยากที่ใช้ effort สูงอาจใช้เวลาหลายนาที จึงควรสตรีมคำขอที่อาจใช้เวลานาน SDK กำหนดให้สตรีมเมื่อ max_tokens ใกล้ขีดจำกัด 128,000 เพื่อหลีกเลี่ยง HTTP timeout

with client.messages.stream(
    model="claude-fable-5-1",
    max_tokens=64000,
    messages=[{"role": "user", "content": "Write a test plan for a rate-limited public API."}],
) as stream:
    for text in stream.text_stream:
        print(text, end="", flush=True)
    final = stream.get_final_message()

print(final.stop_reason, final.usage.output_tokens)

ใน Apidog ผลลัพธ์จากสตรีมจะแสดงทันทีที่มาถึง ทำให้เห็นได้เร็วที่สุดว่า high-effort ใช้เวลาคิดนานเพียงใดก่อนส่งโทเค็นข้อความแรก

ขั้นตอนที่ 5: ใช้เครื่องมือโดยไม่บังคับ tool_choice

นิยามเครื่องมือเหมือนกับ Fable 5 แต่เปลี่ยนวิธีรับประกันการเรียกใช้ บน Fable 5 สามารถบังคับด้วย tool_choice: {"type": "tool", ...} ได้ แต่บน Fable 5.1 จะเกิด 400 เพราะการบังคับเรียกจะข้ามการคิด และโมเดลอาจเขียนกระบวนการทำงานลงในอาร์กิวเมนต์

ใช้ 3 ส่วนประกอบต่อไปนี้:

1. ตั้ง tool_choice เป็น auto
2. ระบุชื่อเครื่องมือในคำสั่ง
3. ตั้ง strict: true และใช้ additionalProperties: false ในสคีมา

record_summary_tool = {
    "name": "record_summary",
    "description": "Record the structured summary of the document.",
    "strict": True,
    "input_schema": {
        "type": "object",
        "properties": {"summary": {"type": "string"}},
        "required": ["summary"],
        "additionalProperties": False,
    },
}

response = client.messages.create(
    model="claude-fable-5-1",
    max_tokens=16000,
    tools=[record_summary_tool],
    tool_choice={"type": "auto"},
    messages=[{"role": "user", "content": "Summarize: The meeting moved to Thursday. Call the record_summary tool with your result."}],
)

หากต้องการ JSON เพียงอย่างเดียว ให้ใช้ structured outputs (output_config.format) แทนเครื่องมือ

หากแอปพลิเคชันต้องการเรียกเครื่องมือเฉพาะในรอบปัจจุบันของการสนทนาหลายรอบ ให้เพิ่มข้อความ role: "system" หลังการตอบกลับของผู้ใช้ล่าสุด ระบุชื่อเครื่องมือและบอกว่าการเรียกนั้นจำเป็น จากนั้นเก็บข้อความนี้ไว้ในประวัติ ค่าต่อไปนี้ยังใช้ได้สำหรับคำตอบที่ไม่ควรเรียกเครื่องมือ:

{"type": "none"}

อ่านข้อกำหนดสคีมาเพิ่มเติมได้จาก การใช้เครื่องมือแบบเข้มงวด

ลูปของเอเจนต์

ลูปยังเหมือนเดิม:

1. เมื่อ stop_reason เป็น tool_use ให้ดำเนินการ tool_use ทุกบล็อก
2. ส่ง tool_result ทั้งหมดกลับในข้อความผู้ใช้หนึ่งข้อความ
3. เพิ่มคำตอบของผู้ช่วยกลับตามที่ได้รับมาอย่างถูกต้อง รวมถึงบล็อกการคิด

ข้อสุดท้ายสำคัญกับ Fable 5.1 มากกว่าโมเดลก่อนหน้า ดูรายละเอียดใน คู่มือการคิดที่เก็บรักษาไว้

ในลูปยาวที่งานบอกเป็นนัยว่าต้องอ่านข้อมูลอิสระหลายรายการ Fable 5.1 อาจเรียกเครื่องมือเพียงรายการเดียวต่อรอบ ขณะที่ Fable 5 อาจเรียกหลายรายการพร้อมกัน ให้เพิ่มข้อความกระตุ้นต่อไปนี้หลังผลลัพธ์เครื่องมือแต่ละรายการ:

First privately list what you need next; then request every item that doesn’t depend on another’s result in this one response.

ส่งข้อความนี้เป็น system message ที่จำกัดขอบเขตรอบด้วย:

• clear_at: "next_user_message"
• beta header: mid-conversation-system-clear-at-2026-08-21

เก็บสำเนาที่มีอยู่ก่อนหน้าไว้ตามเดิม

ขั้นตอนที่ 6: จัดการการปฏิเสธด้วย fallbacks

Fable 5.1 ใช้ตัวจัดประเภทความปลอดภัย คำขอที่ถูกปฏิเสธจะส่งคืน HTTP 200 พร้อม:

• stop_reason: "refusal"
• อ็อบเจกต์ stop_details
• หมวดหมู่ cyber, bio, frontier_llm, reasoning_extraction หรือ general_harms

การปฏิเสธก่อนมีผลลัพธ์จะไม่ถูกเรียกเก็บเงิน

แนะนำให้เปิดใช้ fallbacks เป็นค่าเริ่มต้น วิธีที่ง่ายที่สุดคือ fallbacks: "default" พร้อม beta header server-side-fallback-2026-07-01 ระบบจะลองคำขอที่ถูกปฏิเสธกับโมเดลที่ Anthropic แนะนำสำหรับหมวดหมู่นั้น สำหรับ Fable 5.1 เป้าหมายที่อนุญาตคือ claude-opus-4-8 และ claude-opus-5

response = client.beta.messages.create(
    model="claude-fable-5-1",
    max_tokens=16000,
    fallbacks="default",
    betas=["server-side-fallback-2026-07-01"],
    messages=[{"role": "user", "content": "Audit this authentication middleware for logic bugs."}],
)

fallback_ran = any(
    entry.type == "fallback_message" for entry in (response.usage.iterations or [])
)
if fallback_ran and response.stop_reason != "refusal":
    print("served by", response.model)

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

ข้อจำกัด:

• fallbacks ใช้กับ Batches API ไม่ได้
• ใช้กับ Bedrock, Google Cloud หรือ Foundry ไม่ได้
• ผู้ให้บริการเหล่านี้ต้องลงทะเบียน BetaRefusalFallbackMiddleware ของ SDK บนไคลเอ็นต์แทน

อ่านเรื่องการเรียกเก็บเงิน การกำหนดเส้นทางแบบคงที่ และการลองซ้ำด้วยตนเองได้จาก คู่มือการจัดการการปฏิเสธ

ขั้นตอนที่ 7: รับอัปเดตความคืบหน้าระหว่างรอบยาว

ระหว่างการเรียกใช้เครื่องมือ Fable 5.1 จะเขียนบันทึกสั้น ๆ เกี่ยวกับสิ่งที่พบและสิ่งที่จะทำต่อไป บันทึกแต่ละรายการจะมาเป็นบล็อก thinking ของตัวเองก่อนการเรียกเครื่องมือทันที แต่ค่าเริ่มต้นจะแสดงเป็นข้อความว่าง

ตั้งค่า display: "updates" พร้อม beta header thinking-display-updates-2026-08-18:

{
  "model": "claude-fable-5-1",
  "max_tokens": 16000,
  "thinking": {"type": "adaptive", "display": "updates"},
  "tools": [...],
  "messages": [{"role": "user", "content": "Review the PRs open against our billing service."}]
}

บล็อก thinking ที่มีข้อความจะแสดงเป็นบรรทัดสถานะได้ Fable 5.1 เขียนบล็อกเหล่านี้น้อยกว่า Fable 5 ดังนั้นหาก UI พึ่งพาคำบรรยาย ให้ลบคำสั่งที่บอกโมเดลให้เก็บผลการค้นหาไว้สำหรับคำตอบสุดท้าย

ขั้นตอนที่ 8: ตรวจสอบอัตราการอ่านแคช 0.25 ดอลลาร์

วาง cache_control บนคำนำหน้าที่คงที่ แล้วตรวจสอบการเข้าถึงผ่านอ็อบเจกต์ usage:

response = client.messages.create(
    model="claude-fable-5-1",
    max_tokens=16000,
    system=[{"type": "text", "text": LONG_STABLE_SYSTEM_PROMPT, "cache_control": {"type": "ephemeral"}}],
    messages=[{"role": "user", "content": "Which endpoints in the spec lack an error schema?"}],
)
u = response.usage
print(u.input_tokens, u.cache_creation_input_tokens, u.cache_read_input_tokens)

พฤติกรรมที่ควรเห็น:

• การส่งครั้งแรก: cache_creation_input_tokens ไม่เป็นศูนย์ และคิดค่าบริการ 12.50 ดอลลาร์ต่อล้านโทเค็นสำหรับ TTL 5 นาที
• การส่งซ้ำภายใน 5 นาที: cache_read_input_tokens ควรไม่เป็นศูนย์ และคิดค่าบริการ 0.25 ดอลลาร์ต่อล้านโทเค็น
• ขนาดคำนำหน้าที่แคชได้ขั้นต่ำคือ 512 โทเค็น

หากการอ่านแคชยังเป็นศูนย์ แสดงว่าคำนำหน้ามีการเปลี่ยนแปลง เช่น:

• มี timestamp ใน system prompt
• JSON ไม่ได้เรียงลำดับ
• อาร์เรย์เครื่องมือแตกต่างกัน

การอ่านแคชมีความสำคัญกว่าบน Fable 5.1 เพราะต้นทุน cache miss สูงกว่าการอ่านแคชถึง 40 เท่า ทั้ง effort ต่อข้อความและ system message ที่จำกัดขอบเขตการตอบกลับมีไว้ส่วนหนึ่งเพื่อให้เปลี่ยนการตั้งค่าระหว่างเซสชันได้โดยไม่รีเซ็ตแคช

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

ดูรายละเอียดเพิ่มเติมได้จาก การแคชพรอมต์ และ รายละเอียดราคา

ทดสอบและดีบักทุกขั้นตอนใน Apidog

บันทึกคำขอทั้งหมดไว้ใน Apidog collection เดียว:

• คำขอแรก
• รูปแบบ effort
• การสตรีม
• ลูปเครื่องมือ
• fallback
• การตรวจสอบแคช

ใช้ environment variable สำหรับ API key และ model เพื่อสลับทั้ง collection ระหว่าง claude-fable-5 และ claude-fable-5-1 ด้วยการแก้ไขเพียงครั้งเดียว

เพิ่ม assertions ต่อไปนี้:

• stop_reason ไม่ใช่ refusal ในพรอมต์ทดสอบที่ปลอดภัย
• usage.cache_read_input_tokens มากกว่าศูนย์ในการส่งแคชครั้งที่สอง
• ไม่มีรายการ input_transformations ที่มี reason: "prefix_binding_mismatch" เมื่อใช้ thinking-binding header

รัน collection ก่อนและหลังการเปลี่ยนแปลงทุกครั้ง สามารถ ดาวน์โหลด Apidog เพื่อสร้าง collection เดียวกัน และใช้เป็นการตรวจสอบ CI ผ่าน Apidog CLI ได้

ข้อผิดพลาดที่พบบ่อย

• 400 tool_choice: type "tool" and "any" are not supported for this model.
  
  เปลี่ยนเป็น auto ระบุชื่อเครื่องมือในคำสั่ง และใช้ strict: true

• 400 จาก thinking: {"type": "disabled"}
  
  ลบฟิลด์ดังกล่าว แล้วลด effort แทน

• 400 invalid_request_error ทั้งที่เนื้อหาถูกต้อง
  
  ตรวจสอบว่าองค์กรหรือ workspace เปิดการเก็บรักษาข้อมูล 30 วัน

• 400 Invalid signature in thinking block. The block is bound to a different conversation.
  
  โค้ดอาจแก้ไขคำตอบก่อนหน้า system prompt หรืออาร์เรย์เครื่องมือ อ่าน คู่มือการคิดที่เก็บรักษาไว้

• บล็อกการคิดว่างเปล่า
  
  เป็นพฤติกรรมปกติภายใต้ display: "omitted" ใช้ summarized หรือ updates หากต้องการแสดงผล

• การอ่านแคชเป็นศูนย์
  
  ตรวจสอบ timestamp และอ็อบเจกต์ที่ไม่ได้เรียงลำดับในคำนำหน้า

• คำขอ Priority Tier ล้มเหลว
  
  Fable 5.1 ไม่รองรับ Priority Tier แต่ Fable 5 รองรับ

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

ID โมเดลสำหรับ Claude Fable 5.1 API คืออะไร?

ใช้ claude-fable-5-1

• Amazon Bedrock: anthropic.claude-fable-5-1
• Google Cloud, Microsoft Foundry และ Claude Platform บน AWS: claude-fable-5-1

จำเป็นต้องมี beta header หรือไม่?

ไม่จำเป็น โมเดลพื้นฐาน การคิดแบบปรับตัว effort เครื่องมือ และการแคชทำงานด้วยส่วนหัวมาตรฐาน:

anthropic-version: 2023-06-01

Beta header จำเป็นเฉพาะสำหรับ:

• effort ต่อข้อความ
• system message ที่จำกัดขอบเขตการตอบกลับ
• การอัปเดตความคืบหน้า
• server-side fallbacks
• การควบคุม thinking-binding

บังคับให้ Claude Fable 5.1 เรียกเครื่องมือได้หรือไม่?

ไม่ได้ tool_choice แบบ any และ tool จะส่งคืน 400 ให้ใช้ auto ระบุชื่อเครื่องมือในพรอมต์ และตั้ง strict: true สำหรับอาร์กิวเมนต์ที่ตรงตามสคีมา หรือใช้ structured outputs เพื่อดึง JSON

เอาต์พุตสูงสุดของ Claude Fable 5.1 API เท่าไร?

Messages API รองรับสูงสุด 128,000 โทเค็น ควรสตรีมคำขอขนาดใหญ่ ส่วน Batch API เบต้า 300,000 โทเค็นยังไม่ได้ระบุว่าสนับสนุน Fable 5.1

จะดูการอ่านแคชในอัตราที่ถูกกว่าได้อย่างไร?

ตรวจสอบ usage.cache_read_input_tokens ในคำขอซ้ำ โทเค็นเหล่านี้คิดค่าบริการ:

• Fable 5.1: 0.25 ดอลลาร์ต่อล้านโทเค็น
• Fable 5: 1 ดอลลาร์ต่อล้านโทเค็น
• Opus 5: 0.50 ดอลลาร์ต่อล้านโทเค็น

คู่มือ Fable 5 API ยังใช้ได้หรือไม่?

ส่วนใหญ่ยังใช้ได้ เพราะครอบคลุม endpoint เดียวกัน แต่ตัวอย่างการบังคับใช้เครื่องมือจะทำให้เกิด 400 บน Fable 5.1 และคู่มือเดิมยังไม่มีรายละเอียดเรื่อง effort ต่อข้อความและการอัปเดตความคืบหน้า

ลิงก์อ้างอิง

• มีอะไรใหม่ใน Claude Fable 5.1
• พารามิเตอร์ effort
• การใช้เครื่องมือแบบเข้มงวด
• การแคชพรอมต์
• คู่มือการย้ายข้อมูลฉบับเต็ม
• Claude Fable 5.1 คืออะไร
• คู่มือพารามิเตอร์ effort สำหรับ Opus 5
• คู่มือการคิดที่เก็บรักษาไว้
• คู่มือการจัดการการปฏิเสธ
• ดาวน์โหลด Apidog
• รายละเอียดราคา
• คู่มือ Fable 5 API