จะใช้โหมดการคิดใน claude 4.5 อย่างไร

“Thinking mode” (เรียกอีกอย่างว่า extended thinking, thinking หรือ thinking blocks) ใน Claude 4.5 เป็นโหมดการทำงานแบบกำหนดค่าได้อย่างชัดเจน ซึ่งสั่งให้โมเดลใช้จำนวนโทเค็นที่จัดสรรงบประมาณแยกต่างหากเพื่อสร้างการให้เหตุผลภายในแบบทีละขั้นตอน (“chain-of-thought”) ก่อนส่งคำตอบสุดท้าย โหมดนี้ถูกออกแบบมาเพื่อเพิ่มประสิทธิภาพในการให้เหตุผลหลายขั้นตอน การเขียนโค้ดซับซ้อนและเวิร์กโฟลว์เชิงเอเจนต์ รวมถึงงานวิจัย โดยแลกความหน่วงและต้นทุนโทเค็นกับการไตร่ตรองภายในที่ลึกขึ้น Claude 4.5 เปิดเผยความสามารถนี้ในระดับ Messages API ด้วยพารามิเตอร์แบบระบุชัด (เช่น thinking / budget_tokens หรือเฮดเดอร์ effort/“interleaved-thinking”) เก็บรักษาและเลือกเข้ารหัสบล็อกการคิดเพื่อการตรวจสอบภายหลังหรือใช้กับเครื่องมือ และแนะนำพฤติกรรมแคชและการคำนวณโทเค็นที่คุณต้องจัดการเมื่อสร้างเวิร์กโหลดระดับผลิตจริง

What is Claude 4.5? (And which models should I care about?)

Claude 4.5 คือชุดโมเดล Claude ล่าสุดจาก Anthropic ที่ออกเป็นอัปเดตแบบค่อยเป็นค่อยไปรุ่น “4.5” (เช่น Sonnet 4.5 และ Opus 4.5) Sonnet 4.5 ถูกวางตำแหน่งให้เป็นสมดุลที่ดีที่สุดระหว่างความฉลาด ความสามารถด้านโค้ด และประสิทธิภาพเชิงเอเจนต์สำหรับนักพัฒนาส่วนใหญ่; Opus 4.5 มุ่งเน้นการให้เหตุผลที่ใช้ความพยายามสูงมากและรักษาบล็อกการคิดเพื่อปรับปรุงความต่อเนื่องหลายรอบ โมเดลทั้งสองรองรับความสามารถ Extended Thinking แม้ว่าพฤติกรรมบางอย่าง (เช่น การคิดแบบสรุปเทียบกับแบบเต็ม) จะต่างกันไปตามโมเดล

การเพิ่มขึ้นด้านประสิทธิภาพใน Claude 4.5 โดยเฉพาะใน Sonnet 4.5 เห็นได้ชัดเจนใน benchmark SWE-bench Verified ซึ่งวัดความสามารถของ AI ในการแก้ไขปัญหา GitHub จริง

โมเดล	คะแนน SWE-bench Verified	OSWorld (การใช้งานคอมพิวเตอร์)
Claude 3.5 Sonnet	49.0%	42.2%
Claude 4.1 Opus	67.6%	55.0%
Claude 4.5 Sonnet (Thinking On)	77.2%	61.4%
GPT-5 (Medium Reasoning)	65.0%	52.0%

ตัวเลขเหล่านี้บ่งชี้ว่า Claude 4.5 ไม่ได้เก่งเพียงการเขียนโค้ดสั้น ๆ เท่านั้น แต่ยังมีความสามารถอย่างมีนัยสำคัญในการนำทางทั้งระบบไฟล์และดำเนินงานอัตโนมัติโดยไม่ต้องพึ่งมนุษย์

Why this matters

โค้ดดิ้งและเอเจนต์: Sonnet 4.5 แสดงให้เห็นถึงความก้าวหน้าที่แข็งแกร่งในงานซอฟต์แวร์โลกจริงและงานโค้ดระยะยาว—ทำให้เป็นตัวเลือกธรรมชาติสำหรับการสร้างโค้ด การแก้ไขโค้ด และเวิร์กโฟลว์เอเจนต์อัตโนมัติ
Extended thinking และคอนเท็กซ์: โมเดลตระกูล Claude 4.5 ถูกสร้างให้ให้เหตุผลด้วยสมุดบันทึกภายในขนาดใหญ่มาก (หลักหลายหมื่นโทเค็นขึ้นไป) ช่วยให้การให้เหตุผลหลายขั้นตอนลึกขึ้น นั่นส่งผลต่อวิธีการออกแบบพรอมต์ งบประมาณโทเค็น และการโต้ตอบกับเครื่องมือ

What is Thinking Mode in Claude 4.5?

Thinking Mode (เรียกอย่างเป็นทางการว่า "Extended Thinking") เป็นความสามารถที่ให้โมเดล “แสดงวิธีทำงาน” ให้กับตัวเองก่อนส่งผลลัพธ์สุดท้าย แตกต่างจากโมเดลมาตรฐานที่ให้คำตอบทันที Claude 4.5 ใช้พื้นที่การให้เหตุผลเฉพาะเพื่อสำรวจสมมติฐานหลายแบบ ระบุข้อผิดพลาดที่อาจเกิดในตรรกะ และปรับกลยุทธ์ให้ดีขึ้น

The Anatomy of a Response

ในการโต้ตอบแบบมาตรฐาน โมเดลจะรับพรอมต์แล้วเริ่มสร้างคำตอบ ใน Thinking Mode การตอบกลับถูกแบ่งเป็นสองบล็อกที่แตกต่างกัน:

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

Key properties of thinking mode

เปิดใช้งานตามคำขอ: คุณส่งอ็อบเจ็กต์ thinking ในการเรียก API เช่น {"type":"enabled","budget_tokens":10000} เพื่อเปิดใช้งานและกำหนดงบโทเค็นภายในสำหรับการให้เหตุผล
การตั้งงบประมาณ: budget_tokens จำกัดโทเค็นการให้เหตุผลภายในของโมเดล งบมากขึ้น => ศักยภาพการให้เหตุผลลึกขึ้นแต่ต้นทุนและความหน่วงสูงขึ้น ในโมเดล Claude 4 โทเค็นการคิดจะถูกคิดค่าใช้จ่ายแม้ว่าคุณจะได้รับเพียงมุมมองแบบสรุป
การสรุปและการปิดบัง: สำหรับโมเดล Claude 4 หลายรุ่น ผู้ใช้จะเห็นเวอร์ชันสรุปของเนื้อหาการคิด; การให้เหตุผลภายในบางส่วนอาจถูกปิดบัง (เข้ารหัส) โดยระบบความปลอดภัยและส่งคืนเป็น redacted_thinking
ลายเซ็นและการตรวจสอบ: บล็อกการคิดจะมี signature ที่ทึบแสงสำหรับการตรวจสอบเมื่อส่งคืนบล็อกการคิดกลับไปยัง API (โดยเฉพาะเมื่อใช้เครื่องมือ) คุณควรปฏิบัติต่อ signature ว่าเป็นข้อมูลทึบ—อย่าพยายามแยกวิเคราะห์
การคิดแบบสอดแทรกกับเครื่องมือ: Claude 4 รองรับการสอดแทรกบล็อกการคิดกับการเรียกใช้เครื่องมือ (บางกรณีเป็นเบต้าและใช้แฟล็ก) สิ่งนี้ทรงพลังสำหรับงานเชิงเอเจนต์ (เรียกเครื่องมือ คิด เรียกอีกเครื่องมือ เป็นต้น)

สำหรับตัวอย่างเชิงปฏิบัติและพารามิเตอร์ล่าสุด เอกสาร Messages/Extended Thinking ของ Anthropic คือแหล่งอ้างอิงหลัก

How does the Messages API return thinking content

การคิดแบบสรุปเทียบกับแบบเต็ม; การเข้ารหัสและลายเซ็น

รุ่นโมเดล Claude ที่ต่างกันจัดการการคิดแตกต่างกัน: รุ่น Claude 4 ล่าสุด (เช่น Sonnet/Opus 4.5) มักส่งคืนมุมมองสาธารณะแบบสรุปของการให้เหตุผลภายใน ขณะที่สมุดบันทึกฉบับเต็มอาจถูกเข้ารหัสและเข้าถึงได้ผ่านฟิลด์ signature (หรือบล็อกที่ถูกปิดบัง) เมื่อมีการใช้เครื่องมือ (หรือคุณต้องรักษาสถานะภายในข้ามการเรียกเครื่องมือ) คุณต้องส่งบล็อกการคิดกลับไปยัง API หรือใช้กลไก signature ตามที่เอกสารอธิบาย กลไกนี้ช่วยปกป้องการให้เหตุผลภายในที่ละเอียดอ่อน พร้อมทั้งอนุญาตให้ดำเนินกระบวนการคิดอย่างปลอดภัยต่อเนื่องเมื่อจำเป็น

แนวทางการจัดการเชิงปฏิบัติ

การใช้เครื่องมือ / การต่อเนื่อง: หากคำขอถัดไปต้องดำเนินสถานะภายในเดียวกันต่อ (เช่น เครื่องมือทำงานจากการคิด) ให้รวมบล็อกการคิดหรือ signature ที่ส่งคืนเมื่อคุณเรียก API อีกครั้ง เพื่อให้โมเดลสามารถถอดรหัสและดำเนินต่อจากจุดเดิมได้

คำขอ: ส่ง thinking: {type: "enabled", budget_tokens: N}

การตอบกลับ: คุณอาจได้รับ (a) เอาต์พุตสาธารณะแบบสรุป, (b) signature ที่เข้ารหัสหรือบล็อก redacted_thinking, หรือ (c) ทั้งสองอย่าง

CometAPI ให้บริการ Claude 4.5 API ที่ 20% ของราคาทางการ และยังสามารถเรียกใช้ผ่าน Anthropic Messages คุณจะต้องได้รับ API key ก่อนเริ่มต้น

Example 1 — simple curl (non-streaming) enabling thinking

curl https://api.cometapi.com/v1/messages \
  -H "x-api-key: $CometAPI_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-sonnet-4-5",
    "max_tokens": 16000,
    "thinking": {
      "type": "enabled",
      "budget_tokens": 10000
    },
    "messages": [
      {"role": "user", "content": "Design a robust data validation strategy for CSV imports, show tests + code."}
    ]
  }'

การตอบกลับจะมีบล็อก content ตรวจสอบแต่ละบล็อกและให้ความสำคัญกับบล็อก text สำหรับเอาต์พุตสุดท้าย; บล็อก thinking มีสรุปการวิเคราะห์ภายในของโมเดล

Example 2 — Python: request, parse thinking and text blocks

import os, requests

API_KEY = os.environ["CometAPI_API_KEY"]
URL = "https://api.cometapi.com/v1/messages"
HEADERS = {
    "x-api-key": API_KEY,
    "anthropic-version": "2023-06-01",
    "content-type": "application/json"
}

payload = {
    "model": "claude-sonnet-4-5",
    "max_tokens": 16000,
    "thinking": {"type": "enabled", "budget_tokens": 8000},
    "messages": [{"role": "user", "content": "Explain how to do property-based testing in Python; include example code."}]
}

r = requests.post(URL, headers=HEADERS, json=payload)
r.raise_for_status()
resp = r.json()

# Parse blocks
for block in resp.get("content", []):
    if block.get("type") == "thinking":
        thinking_summary = block.get("thinking")
        print("=== THINKING (summary) ===")
        print(thinking_summary[:1000])  # truncate for logs
        print("signature:", block.get("signature")[:64], "...")
    elif block.get("type") == "text":
        print("=== FINAL TEXT ===")
        print(block.get("text"))

โค้ดนี้ดึงและพิมพ์เนื้อหาการคิดแบบสรุปและคำตอบสุดท้าย หากคุณต้องการรักษาความต่อเนื่องในการทำงานหลายรอบของเอเจนต์ ให้รวมบล็อกการคิดที่ไม่ได้แก้ไขในคำขอต่อไปในอาร์เรย์ messages (ดูตัวอย่างถัดไป)

Example 3 — reusing thinking blocks in a multi-turn flow (Python pseudo)

# After initial response (resp above):
# Add the assistant message including the thinking block back into the conversation
assistant_message = {
  "role": "assistant",
  "content": resp["content"]  # include raw content array (contains thinking + text blocks)
}

# Next user turn: ask follow-up and include previous assistant message
payload2 = {
  "model": "claude-opus-4-5",  # Opus preserves thinking blocks better across turns
  "max_tokens": 20000,
  "thinking": {"type": "enabled", "budget_tokens": 12000},
  "messages": [
    {"role": "user", "content": "Now adapt the validation logic for an avro pipeline."},
    assistant_message
  ]
}
r2 = requests.post(URL, headers=HEADERS, json=payload2)

การเก็บรักษาบล็อกการคิดแบบเดิมทุกประการเป็นสิ่งสำคัญเมื่อทำงานผสานเครื่องมือหรือเวิร์กโฟลว์เอเจนต์ระยะยาว Opus 4.5 มีค่าเริ่มต้นที่ดีขึ้นสำหรับการเก็บรักษาบล็อกการคิดและการแคช

How do I stream thinking outputs and show progress in a UI?

แนวทางปฏิบัติที่ดีสำหรับการสตรีม

ใช้เอ็นด์พอยต์สตรีมของ SDK (SDK ของ Python/TypeScript มีตัวช่วยสตรีม) สำหรับงานให้เหตุผลที่รันนานหรือใช้งบประมาณสูง การสตรีมช่วยหลีกเลี่ยง HTTP timeout และให้ข้อความบางส่วนระหว่างที่โมเดลคำนวณ โค้ดทั่วไปใช้ตัววนซ้ำเหนือ text_stream (Python) หรือการพาร์สอีเวนต์ (JS)
คาดหวังการสตรีมแบบสองเฟสในบางครั้ง: โมเดลอาจผลิตชิ้นส่วนการให้เหตุผลที่มองเห็นได้ก่อน แล้วจึงสรุปด้วยคำตอบ สร้าง UI ที่รองรับเนื้อหาแบบแบ่งชิ้นและแสดงสถานะ “กำลังคิด…” เทียบกับคำตอบสุดท้าย
หาก API ส่งคืน signature_delta หรือ content_block_delta ระหว่างการสตรีม ให้บันทึกและแนบไปกับคำขอถัดไปตามข้อกำหนด

หากคุณต้องการแสดงความคืบหน้าการให้เหตุผลระหว่างทางใน UI ให้สตรีมการตอบกลับ เซิร์ฟเวอร์จะส่งอีเวนต์ thinking_delta ตามด้วย text_delta

curl https://api.cometapi.com/v1/messages \
  --header "x-api-key: $CometAPI_API_KEY" \
  --header "anthropic-version: 2023-06-01" \
  --header "content-type: application/json" \
  --data '{
    "model": "claude-sonnet-4-5",
    "max_tokens": 16000,
    "stream": true,
    "thinking": { "type": "enabled", "budget_tokens": 8000 },
    "messages": [ { "role": "user", "content": "Walk me through debugging this failing unit test and propose fixes." } ]
  }'

เมื่อสตรีม ให้จัดการอีเวนต์ content_block_start, content_block_delta (ซึ่งรวม thinking_delta และ text_delta) และ content_block_stop ตามลำดับ นี่คือวิธีที่คุณสามารถแสดงการให้เหตุผลทีละขั้นตอนของโมเดลขณะดำเนินการ

How does Claude Code interact with thinking mode?(terminal + VS Code)

Claude Code เป็นเทอร์มินัลโค้ดแบบอินเทอร์แอกทีฟเชิงเอเจนต์ที่ผสาน Messages API และตัวรันเครื่องมือ ประสบการณ์ CLI/IDE แสดงการคิดในสองวิธี:

การตั้งค่าทั่วโลก/ต่อเซสชัน: Claude Code มีแผง /config สำหรับตั้งค่าพฤติกรรม (วิธีที่เอเจนต์ขออนุญาต ว่าจะเก็บรักษาบล็อกการคิดหรือไม่ ฯลฯ) ใช้ UI นั้นแทนพิมพ์ JSON ดิบ หากคุณต้องการเปลี่ยนพฤติกรรมแบบถาวร
การเลือกโมเดลและคำสั่ง CLI: คุณสามารถเลือก claude-sonnet-4-5 หรือ claude-opus-4-5 เป็นโมเดลที่ใช้งานใน REPL; เครื่องมือและพฤติกรรมการคิดจะเป็นไปตามสเปก Messages API CHANGELOG และบันทึกการเผยแพร่ระบุว่าการคิดถูกเปิดใช้โดยค่าเริ่มต้นสำหรับการปรับใช้ Opus 4.5 บางแบบ และการตั้งค่าการคิดถูกแสดงผ่าน /config

แนวทางปฏิบัติใน Claude Code:

เริ่มโปรเจ็กต์ใน REPL
ใช้ /config เพื่อตรวจสอบแฟล็กที่เกี่ยวกับการคิด (การเก็บรักษา ระดับความละเอียด ฯลฯ)
ขอให้เอเจนต์รันงานยาว—มันจะสร้างเนื้อหาการคิด และหากจำเป็นจะขออนุญาตรันขั้นตอน bash เฉพาะ เก็บรักษาบล็อกการคิดเมื่อคุณต้องการตรวจสอบหรือเรียกใช้การตัดสินใจซ้ำภายหลัง

Installation and Setup

Claude Code ต้องการ Node.js และสามารถติดตั้งแบบ global ได้

# Install Claude Code CLI
npm install -g @anthropic/claude-code

# Authenticate
claude-code --init

Activating Thinking in the Terminal

Claude Code รองรับแฟล็กต่าง ๆ และทริกเกอร์แบบภาษาธรรมชาติเพื่อควบคุมความลึกของการให้เหตุผล

คำสั่ง/ทริกเกอร์	คำอธิบาย
claude-code --think	เริ่มเซสชันโดยเปิดใช้งาน extended thinking เป็นค่าเริ่มต้น
claude-code --model sonnet-4.5	ระบุโมเดลแนวหน้ารุ่นล่าสุด
/think <task>	คำสั่งสแลชใน CLI เพื่อเรียกงานที่ต้องใช้การคิดอย่างหนักเฉพาะกิจ
"ultrathink"	คีย์เวิร์ดภาษาธรรมชาติที่สั่งให้ Claude ใช้งบประมาณการให้เหตุผลสูงสุดเท่าที่ทำได้

เคล็ดลับ:

ใช้ think/think harder เมื่อคุณต้องการให้เอเจนต์สำรวจทางเลือกการทำงานหลายแบบ
เมื่อ Claude Code เรียกใช้เครื่องมือ (รันเทสต์ ทำงานกับ git) ให้เก็บรักษาบล็อก thinking หาก CLI/เอเจนต์ส่งคืน มิฉะนั้นเอเจนต์อาจสูญเสียคอนเท็กซ์ระหว่างขั้นตอน

Benefits of Interleaved Thinking and Block Preservation

สำหรับเวิร์กโฟลว์เอเจนต์ขั้นสูง Claude 4.5 แนะนำสองฟีเจอร์เบต้าที่ช่วยเพิ่มการโต้ตอบหลายรอบและการใช้เครื่องมือ: Interleaved Thinking และ Thinking Block Preservation

Interleaved Thinking (Beta)

โดยปกติการให้เหตุผลจะเกิดขึ้นครั้งเดียวก่อนเอาต์พุต Interleaved Thinking (เปิดใช้ผ่านเฮดเดอร์ interleaved-thinking-2025-05-14) อนุญาตให้ Claude “คิด” ระหว่างการเรียกเครื่องมือ

ลองจินตนาการว่า Claude กำลังดีบักเซิร์ฟเวอร์:

Think: "ฉันควรตรวจสอบล็อกก่อน"
Tool Call: read_file(logs.txt)
Think: "ล็อกแสดง timeout ของฐานข้อมูล ตอนนี้ฉันต้องตรวจการตั้งค่า connection pool"
Tool Call: read_file(db_config.yml)

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

Thinking Block Preservation

ในการสนทนาหลายรอบ โดยเฉพาะที่เกี่ยวข้องกับการใช้เครื่องมือ การส่งต่อบล็อก thinking ก่อนหน้าไปยัง API เป็นสิ่งสำคัญ

ความต่อเนื่องของการให้เหตุผล: เมื่อได้รับความคิดก่อนหน้า Claude รักษาคอนเท็กซ์เชิงตรรกะของการเดินทางไว้ได้
การปรับให้เหมาะสมใน Opus 4.5: ใน Claude Opus 4.5 พฤติกรรมนี้เป็นแบบอัตโนมัติ โมเดลจะเก็บรักษาบล็อกการคิดก่อนหน้าทั้งหมดในคอนเท็กซ์โดยค่าเริ่มต้น ช่วยให้แม้ในเซสชันที่ยาวกว่า 30 ชั่วโมง โมเดลก็ไม่ “ลืม” ว่าทำไมจึงตัดสินใจเชิงสถาปัตยกรรมบางอย่างหลายรอบก่อนหน้า

Best practices for using THINKING mode with Claude 4.5

เลือกโมเดลและงบประมาณให้เหมาะกับงาน:

ใช้ Sonnet 4.5 สำหรับการโค้ดและเวิร์กโฟลว์เชิงเอเจนต์ ที่ต้องการสมดุลที่ดีที่สุดระหว่างความเร็ว ต้นทุน และความสามารถด้านโค้ดที่แข็งแรง; ใช้ Opus 4.5 สำหรับการให้เหตุผลที่ลึกที่สุดและหน้าต่างคอนเท็กซ์ที่ใหญ่ที่สุด หรือเมื่อคุณวางแผนรันเซสชันอัตโนมัติยาว ๆ ทั้งสองรองรับ extended thinking กำหนด budget_tokens ตามความซับซ้อนของงาน (เริ่มต่ำเพื่อทดลอง; เพิ่มงบเฉพาะเมื่อเห็นการปรับคุณภาพที่เป็นสาระสำคัญ)

เฝ้าระวังและควบคุมต้นทุนและความหน่วง

คุณจะถูกคิดค่าใช้จ่ายสำหรับโทเค็นการคิดทั้งหมดที่ Claude สร้าง ไม่ใช่เฉพาะเอาต์พุตแบบสรุปที่คุณได้รับ นั่นหมายความว่าการไตร่ตรองภายในที่ยาวขึ้นเพิ่มต้นทุนแม้ว่าคุณจะเห็นเพียงสรุปสั้น ๆ ติดตามการใช้โทเค็นและพิจารณาปรับทีละน้อย (เช่น: 2k → 8k → 32k) เมื่อย้ายจากการสำรวจไปสู่ระบบผลิตจริง

เก็บรักษาบล็อกการคิดเฉพาะเมื่อจำเป็น

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

เมื่อใดควรสตรีมการคิดให้ผู้ใช้เห็น

การสตรีมการคิดเหมาะอย่างยิ่งสำหรับเครื่องมือพัฒนาซอฟต์แวร์และ UI เชิงการศึกษา (แสดง “กำลังทำงาน” ระหว่างที่โมเดลไตร่ตรอง) อย่าสตรีมการคิดดิบให้ผู้ใช้ปลายทางของแอปผู้บริโภคในระบบผลิตจริงโดยไม่คำนึงถึงความปลอดภัยและการปิดบัง: การคิดแบบสรุปมีอยู่เพื่อเหตุผลนี้ หากจะสตรีม ให้จัด UI เพื่อระบุการให้เหตุผลภายใน (เช่น “Assistant reasoning — internal”) และควบคุมว่าผู้ใช้สุดท้ายจะเห็นการคิดแบบสรุปหรือแบบเต็ม

การใช้เครื่องมือและการสอดแทรก

เมื่อผสมผสานการคิดกับเครื่องมือ (การรันโค้ด การดึงเว็บ กระบวนการภายในเครื่อง) ใช้ดีไซน์ interleaved thinking เมื่อคุณต้องการให้โมเดลเลือกเครื่องมือ รันมัน และให้เหตุผลกับผลลัพธ์ภายในรอบเดียว การสอดแทรกเพิ่มความซับซ้อน (และอาจต้องใช้แฟล็กฟีเจอร์) แต่ทรงพลังสำหรับระบบอัตโนมัติเชิงเอเจนต์ ระบุให้ชัดเจนว่าคุณจะเก็บรักษาการคิดอะไร และทดสอบว่าโมเดลเลือกเครื่องมืออย่างไรภายใต้การรันที่เปิดใช้งานการคิด

Practical troubleshooting and operational notes

ข้อผิดพลาดทั่วไปและความหมาย

การคิดไม่ถูกต้อง + บังคับเลือกเครื่องมือ: หากคุณขอให้คิดแต่บังคับโหมดการใช้เครื่องมือบางอย่างที่ไม่เข้ากันกับการคิด API จะส่งคืนข้อผิดพลาด—อย่าผสม tool_choice: {"type":"tool","name":"..."} กับการคิด
งบประมาณ > max_tokens: สำหรับสถานการณ์การคิดแบบสอดแทรก กฎโทเค็นที่ใช้จริงแตกต่างกัน—แพลตฟอร์มอธิบายเมื่อใดที่ budget_tokens สามารถมากกว่า max_tokens อ่านส่วน “interleaved thinking” ให้ละเอียดก่อนทดสอบงบประมาณขนาดใหญ่
การตรวจสอบลายเซ็น: หากคุณเก็บรักษาบล็อกการคิดเพื่อใช้ในการเรียกภายหลัง ให้รวม signature ที่ส่งคืนเพื่อให้ API ตรวจสอบว่ามาจาก Claude; สิ่งนี้ช่วยป้องกันการดัดแปลงและรักษาห่วงการตรวจสอบได้

การสังเกตและอินสตรูเมนต์

บันทึก: (1) การเลือก model, (2) thinking.budget_tokens, (3) การใช้โทเค็นการคิดจริง (คุณถูกคิดค่าใช้จ่ายสำหรับมัน), (4) ความหน่วงการสตรีม (เวลาถึง thinking_delta ครั้งแรก), และ (5) โทเค็นข้อความสุดท้าย ใช้มาตรวัดเหล่านี้เพื่อสร้างงบประมาณและ SLO สำหรับเวิร์กโฟลว์ที่เผชิญผู้ใช้

การเปิดใช้แบบค่อยเป็นค่อยไปและมนุษย์ในวงจร

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

เคล็ดลับการดีบัก

เริ่มเล็ก: เปิด budget_tokens ต่ำและค่อย ๆ เพิ่มเพื่อเข้าใจการปรับปรุงทีละขั้น
เปิดสตรีมและบันทึกอีเวนต์ content_block_delta / signature เพื่อดูว่าโมเดลผลิตบล็อกการคิดเมื่อใด
หากใช้ Claude Code: ตรวจสอบ /config และการตั้งค่าระดับโปรเจ็กต์; ดู changelog ของ Claude Code หากพฤติกรรมไม่ตรงกับค่าเริ่มต้นที่คาดไว้

Conclusion:

Claude 4.5 เมื่อรวมพลังกับ Extended Thinking และ Claude Code CLI แสดงให้เห็นถึงก้าวกระโดดด้านประสิทธิภาพของนักพัฒนาที่สำคัญที่สุดตั้งแต่การถือกำเนิดของ IDE โดยอนุญาตให้โมเดล “แสดงวิธีทำงาน” และไตร่ตรองเหนือปัญหาที่ซับซ้อน Anthropic ได้ก้าวข้ามยุค “แชทบ็อต” ไปสู่ยุค “เอเจนต์”

ไม่ว่าคุณจะผสาน Messages API เข้ากับเครื่องมือสำหรับนักพัฒนาที่กำหนดเอง หรือใช้ Claude Code เพื่อจัดการ PR รายวัน การเชี่ยวชาญ Thinking Mode เป็นสิ่งจำเป็น มันมอบความโปร่งใสที่จำเป็นต่อความเชื่อมั่นและความลึกของการให้เหตุผลที่จำเป็นต่อความเป็นเลิศ

นักพัฒนาสามารถเข้าถึงโมเดล Claude 4.5 (Claude Sonnet 4.5 , Claude Haiku 4.5, Claude Opus 4.5) ผ่าน CometAPI เพื่อเริ่มต้น สำรวจความสามารถของโมเดลของ CometAPI ใน Playground และดูคู่มือ API สำหรับคำแนะนำโดยละเอียด ก่อนเข้าถึง โปรดตรวจสอบให้แน่ใจว่าคุณได้เข้าสู่ระบบ CometAPI และได้รับ API key แล้ว Com e tAPI เสนอราคาที่ต่ำกว่าราคาทางการอย่างมากเพื่อช่วยให้คุณผสานระบบได้

Ready to Go?→ ทดลองใช้งานฟรี Claude 4.5!