วิธีใช้ Claude Sonnet 4.6 API

สรุปสั้นๆ / คำตอบด่วน

Claude Sonnet 4.6 คือโมเดลระดับกลางล่าสุดของ Anthropic ที่รวมประสิทธิภาพการเขียนโค้ดระดับแนวหน้าเข้ากับหน้าต่างบริบท 1M โทเค็น (เวอร์ชันเบต้า) ในราคาเพียง $3/$15 ต่อล้านโทเค็นสำหรับการป้อน/ส่งออก หากต้องการเริ่มใช้ API: 1) รับ API key จาก console.anthropic.com, 2) ติดตั้ง SDK (pip install anthropic), 3) ใช้รหัสโมเดล claude-sonnet-4-6, และ 4) เปลี่ยนไปใช้ adaptive thinking (thinking: {type: "adaptive"}) เพื่อผลลัพธ์ที่ดีที่สุด ผู้ทดสอบกลุ่มแรกชอบโมเดลนี้มากกว่า Sonnet 4.5 ถึง 70% และมากกว่า Opus 4.5 ถึง 59%

บทนำ

Anthropic ได้เปิดตัว Claude Sonnet 4.6 ซึ่งได้ปรับโฉมหมวดหมู่โมเดล AI ระดับกลางทันที นี่ไม่ใช่การอัปเดตแบบค่อยเป็นค่อยไป แต่เป็นโมเดลที่เอาชนะ Opus 4.5 ซึ่งเป็นรุ่นพรีเมียมก่อนหน้านี้ ในการทดสอบแบบตัวต่อตัวถึง 59% ตามที่ผู้ใช้กลุ่มแรกระบุ โดยยังคง ราคาเดิมของ Sonnet ไว้

การเปลี่ยนแปลงที่สำคัญ: หน้าต่างบริบท 1M โทเค็นที่เข้าสู่ช่วงเบต้า, โหมด adaptive thinking ใหม่ที่มาแทนที่วิธีการ extended thinking แบบไบนารีเก่า, และชุดเครื่องมือ – การค้นหาเว็บ, การรันโค้ด, หน่วยความจำ, และการค้นหาเครื่องมือ – ที่พร้อมใช้งานทั่วไปแล้ว สำหรับนักพัฒนาที่สร้างแอปพลิเคชันแบบ Agentic, Sonnet 4.6 มอบความสามารถที่เคยสงวนไว้สำหรับโมเดลระดับแนวหน้าที่มีราคาแพงในราคาเพียงประมาณหนึ่งในสาม

การปรับปรุงด้านการเขียนโค้ดมีความชัดเจน ผู้ใช้รายงานว่าการปฏิบัติตามคำสั่งในการสร้างโค้ดดีขึ้น, การทำความเข้าใจบริบทก่อนการแก้ไขทำได้ฉลาดขึ้น, และลดการซ้ำซ้อนของโค้ดผ่านการรวมตรรกะอัตโนมัติ การใช้งานคอมพิวเตอร์มีความแม่นยำถึง 94% ในเวิร์กโฟลว์ประกันภัยที่ซับซ้อน คะแนน SWE-bench Verified อยู่ที่ 79.6%

คู่มือนี้ครอบคลุมทุกสิ่งที่คุณต้องการเพื่อเริ่มสร้างด้วย Claude Sonnet 4.6 API ได้แล้ววันนี้: การยืนยันตัวตน, ตัวอย่างโค้ดที่ใช้งานได้จริงใน Python และ JavaScript, พารามิเตอร์ adaptive thinking ใหม่, วิธีปลดล็อกหน้าต่างบริบท 1M, และวิธีทดสอบการผสานรวมของคุณด้วยไคลเอนต์ API แบบภาพของ Apidog

มีอะไรใหม่ใน Claude Sonnet 4.6

โหมด Adaptive Thinking

รูปแบบเก่า thinking: {type: "enabled", budget_tokens: N} ถูกเลิกใช้แล้วใน Sonnet 4.6 สิ่งที่มาแทนคือ adaptive thinking: thinking: {type: "adaptive"} ตอนนี้ Claude จะตัดสินใจแบบไดนามิกว่างานนั้นต้องการการให้เหตุผลมากน้อยเพียงใด

จับคู่ adaptive thinking กับพารามิเตอร์ effort (ซึ่งพร้อมใช้งานทั่วไปแล้ว) เพื่อปรับสมดุลระหว่างค่าใช้จ่ายและประสิทธิภาพ:

• effort: "high" (ค่าเริ่มต้น) — Claude มักจะคิดเกือบตลอดเวลา เหมาะสำหรับปัญหาที่ซับซ้อน
• effort: "medium" — แนะนำสำหรับกรณีการใช้งาน Sonnet 4.6 ส่วนใหญ่, สร้างสมดุลระหว่างความเร็วและคุณภาพ
• effort: "low" — การคิดน้อยที่สุด, การตอบสนองที่เร็วที่สุดสำหรับงานง่ายๆ

ประสิทธิภาพการเขียนโค้ดที่ดีขึ้น

Sonnet 4.6 นำเสนอการปรับปรุงที่ชัดเจนสามประการในการสร้างโค้ด:

1. การปฏิบัติตามคำสั่งที่ดีขึ้น — สร้างโค้ดที่ตรงตามข้อกำหนดได้แม่นยำยิ่งขึ้น
2. ความเข้าใจบริบท — อ่านและทำความเข้าใจโค้ดที่มีอยู่ก่อนการแก้ไข ซึ่งช่วยลดการถดถอย
3. การรวมตรรกะ — ระบุรูปแบบที่ซ้ำกันและเสนอแนวคิดเชิงนามธรรมที่ใช้ร่วมกัน

ผู้ทดสอบกลุ่มแรกที่ทำการทดสอบเกณฑ์มาตรฐานการเขียนโค้ดรายงานว่าชอบผลลัพธ์ของ Sonnet 4.6 มากกว่า Sonnet 4.5 ใน 70% ของกรณี และมากกว่า Opus 4.5 ใน 59% ของกรณี

การปรับปรุงการใช้งานคอมพิวเตอร์

ความแม่นยำในการใช้งานคอมพิวเตอร์สูงถึง 72.5% บน OSWorld-Verified (อยู่ในระยะ 0.2% ของ Opus 4.6) ซึ่งเพิ่มขึ้นอย่างมีนัยสำคัญจาก Sonnet 4.5 โมเดลแสดงความแม่นยำ 94% ในเวิร์กโฟลว์ประกันภัยที่ต้องมีการนำทาง UI, การจัดการสเปรดชีต และการกรอกแบบฟอร์มหลายขั้นตอน นอกจากนี้ยังทนทานต่อการโจมตีแบบ Prompt Injection ในระหว่างงานอัตโนมัติมากขึ้น

ความก้าวหน้าของ ARC-AGI-2

ตัวเลขเกณฑ์มาตรฐานที่น่าทึ่งที่สุด: ประสิทธิภาพ ARC-AGI-2 เพิ่มขึ้นจาก 13.6% เป็น 58.3% — เพิ่มขึ้น 4.3 เท่า ซึ่งเป็นการวัดการแก้ปัญหาใหม่ๆ ในงานที่โมเดลไม่เคยเห็นรูปแบบมาก่อน ซึ่งบ่งชี้ถึงการปรับปรุงการให้เหตุผลที่แท้จริงแทนที่จะเป็นการจดจำ

ข้อมูลจำเพาะและราคาของ API

ตัวเลือกการลดต้นทุน:

• Prompt caching: แคชส่วนคงที่ของ system prompt ของคุณและประหยัดได้สูงสุด 90%
• Batch API: ประมวลผลคำขอแบบอะซิงโครนัสเพื่อส่วนลด 50%
• ราคาบริบทแบบยาว: คำขอที่เกิน 200K โทเค็นจะใช้อัตราบริบทแบบยาวแยกต่างหาก

สำหรับงบประมาณการใช้งานจริง: การสนทนาหนึ่งล้านโทเค็นในโหมด adaptive thinking ที่ effort: "medium" มีค่าใช้จ่ายประมาณ $3 สำหรับโทเค็นการป้อนเข้า การเรียกใช้ API ครั้งเดียวส่วนใหญ่มีค่าใช้จ่ายน้อยกว่าหนึ่งเซ็นต์

เริ่มต้นใช้งาน Claude Sonnet 4.6 API

ขั้นตอนที่ 1: รับ API Key ของคุณ

1. เข้าสู่ระบบ platform.anthropic.com
2. ไปที่ API Keys ในการตั้งค่า
3. คลิก Create Key และคัดลอกค่าทันที (จะแสดงเพียงครั้งเดียว)

เก็บ API Key ของคุณไว้ในตัวแปรสภาพแวดล้อม—ห้ามฮาร์ดโค้ดเด็ดขาด:

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

ขั้นตอนที่ 2: ติดตั้ง SDK

Python:

pip install anthropic

JavaScript/Node.js:

npm install @anthropic-ai/sdk

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

import anthropic

client = anthropic.Anthropic()  # reads ANTHROPIC_API_KEY from environment

response = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    messages=[
        {"role": "user", "content": "Explain the difference between async/await and promises in JavaScript."}
    ]
)

print(response.content[0].text)

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

ตัวอย่างโค้ด Python

การสร้างข้อความพื้นฐาน

import anthropic

client = anthropic.Anthropic()

def ask_claude(question: str, system: str = None) -> str:
    """Wrapper อย่างง่ายสำหรับการสร้างข้อความด้วย Claude Sonnet 4.6"""
    messages = [{"role": "user", "content": question}]

    kwargs = {
        "model": "claude-sonnet-4-6",
        "max_tokens": 2048,
        "messages": messages,
    }
    if system:
        kwargs["system"] = system

    response = client.messages.create(**kwargs)
    return response.content[0].text

# ตัวอย่างการใช้งาน
answer = ask_claude(
    "Review this Python function for performance issues:\n\ndef find_duplicates(lst):\n    return [x for x in lst if lst.count(x) > 1]",
    system="คุณคือวิศวกร Python อาวุโส จงระบุให้ชัดเจนและให้โค้ดที่ถูกต้อง"
)
print(answer)

การตอบสนองแบบสตรีมมิ่ง

สำหรับเอาต์พุตที่ยาวหรือ UX แบบเรียลไทม์ ให้ใช้การสตรีมมิ่ง:

import anthropic

client = anthropic.Anthropic()

with client.messages.stream(
    model="claude-sonnet-4-6",
    max_tokens=4096,
    messages=[{
        "role": "user",
        "content": "Write a complete REST API handler in FastAPI for user authentication with JWT."
    }]
) as stream:
    for text in stream.text_stream:
        print(text, end="", flush=True)

# รับข้อความสุดท้ายพร้อมสถิติการใช้งานหลังจากสตรีมเสร็จสิ้น
message = stream.get_final_message()
print(f"\n\nโทเค็นที่ใช้: {message.usage.input_tokens} เข้า, {message.usage.output_tokens} ออก")

การเรียกใช้เครื่องมือ / การใช้งานฟังก์ชัน

import anthropic
import json

client = anthropic.Anthropic()

# กำหนดเครื่องมือ
tools = [
    {
        "name": "get_repository_info",
        "description": "ดึงข้อมูลเกี่ยวกับ GitHub repository รวมถึงจำนวนดาว, การ Fork, และคอมมิตล่าสุด",
        "input_schema": {
            "type": "object",
            "properties": {
                "owner": {
                    "type": "string",
                    "description": "ชื่อเจ้าของ Repository หรือองค์กร"
                },
                "repo": {
                    "type": "string",
                    "description": "ชื่อ Repository"
                }
            },
            "required": ["owner", "repo"]
        }
    }
]

response = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    tools=tools,
    messages=[{
        "role": "user",
        "content": "What can you tell me about the anthropics/anthropic-sdk-python repository?"
    }]
)

# จัดการการตอบสนองการใช้งานเครื่องมือ
for block in response.content:
    if block.type == "tool_use":
        print(f"เครื่องมือที่เรียกใช้: {block.name}")
        print(f"อาร์กิวเมนต์: {json.dumps(block.input, indent=2)}")
        # ในการใช้งานจริง ให้เรียกใช้งานของคุณที่นี่
        # result = get_repository_info(block.input["owner"], block.input["repo"])

วิชันและการวิเคราะห์ภาพ

import anthropic
import base64
from pathlib import Path

client = anthropic.Anthropic()

def analyze_image(image_path: str, question: str) -> str:
    """วิเคราะห์ภาพด้วย Claude Sonnet 4.6"""
    image_data = base64.standard_b64encode(Path(image_path).read_bytes()).decode("utf-8")

    # ตรวจจับประเภทสื่อจากนามสกุล
    ext = Path(image_path).suffix.lower()
    media_type_map = {
        ".jpg": "image/jpeg",
        ".jpeg": "image/jpeg",
        ".png": "image/png",
        ".gif": "image/gif",
        ".webp": "image/webp"
    }
    media_type = media_type_map.get(ext, "image/jpeg")

    response = client.messages.create(
        model="claude-sonnet-4-6",
        max_tokens=1024,
        messages=[{
            "role": "user",
            "content": [
                {
                    "type": "image",
                    "source": {
                        "type": "base64",
                        "media_type": media_type,
                        "data": image_data,
                    },
                },
                {
                    "type": "text",
                    "text": question
                }
            ],
        }]
    )
    return response.content[0].text

# ตัวอย่าง: วิเคราะห์ภาพหน้าจอ UI เพื่อหาปัญหาการเข้าถึง
result = analyze_image(
    "screenshot.png",
    "ระบุปัญหาการเข้าถึงในดีไซน์ UI นี้ ตรวจสอบอัตราส่วนคอนทราสต์, ตัวบ่งชี้ alt text ที่ขาดหายไป, และข้อกังวลเกี่ยวกับการนำทางด้วยคีย์บอร์ด"
)
print(result)

ตัวอย่าง JavaScript/Node.js

การตั้งค่าพื้นฐานและคำขอ

import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic({
  apiKey: process.env.ANTHROPIC_API_KEY, // ค่าเริ่มต้น, แสดงอย่างชัดเจนเพื่อความเข้าใจ
});

async function askClaude(userMessage, systemPrompt = null) {
  const params = {
    model: "claude-sonnet-4-6",
    max_tokens: 2048,
    messages: [{ role: "user", content: userMessage }],
  };

  if (systemPrompt) {
    params.system = systemPrompt;
  }

  const response = await client.messages.create(params);
  return response.content[0].text;
}

// การใช้งาน
const answer = await askClaude(
  "Refactor this Express route to use async/await:\n\napp.get('/users', (req, res) => {\n  User.find({}, (err, users) => {\n    if (err) return res.status(500).send(err);\n    res.json(users);\n  });\n});",
  "คุณคือนักพัฒนา Node.js อาวุโส คืนค่าเฉพาะโค้ดที่ปรับโครงสร้างใหม่พร้อมคำอธิบายสั้นๆ"
);

console.log(answer);

การสตรีมมิ่งด้วย TypeScript

import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic();

async function streamCodeReview(codeSnippet: string): Promise<void> {
  const stream = await client.messages.stream({
    model: "claude-sonnet-4-6",
    max_tokens: 4096,
    messages: [
      {
        role: "user",
        content: `ทำการรีวิวโค้ดของฟังก์ชัน TypeScript นี้อย่างละเอียด:\n\n\`\`\`typescript\n${codeSnippet}\n\`\`\`\n\nเน้นที่: ความปลอดภัยของประเภท, กรณีขอบ, ประสิทธิภาพ, และความปลอดภัย`,
      },
    ],
  });

  // สตรีมข้อความเมื่อมาถึง
  stream.on("text", (text) => {
    process.stdout.write(text);
  });

  // รับสถิติสุดท้าย
  const finalMessage = await stream.finalMessage();
  console.log(
    `\n\n---\nโทเค็นรวม: ${finalMessage.usage.input_tokens + finalMessage.usage.output_tokens}`
  );
}

การสนทนาหลายรอบ

import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic();

class ConversationManager {
  constructor(systemPrompt = null) {
    this.messages = [];
    this.systemPrompt = systemPrompt;
  }

  async chat(userMessage) {
    this.messages.push({ role: "user", content: userMessage });

    const params = {
      model: "claude-sonnet-4-6",
      max_tokens: 2048,
      messages: this.messages,
    };

    if (this.systemPrompt) {
      params.system = this.systemPrompt;
    }

    const response = await client.messages.create(params);
    const assistantMessage = response.content[0].text;

    // รักษาประวัติการสนทนา
    this.messages.push({ role: "assistant", content: assistantMessage });

    return assistantMessage;
  }
}

// ตัวอย่าง: เซสชันการดีบั๊กหลายรอบ
const debugSession = new ConversationManager(
  "คุณคือผู้เชี่ยวชาญด้านการดีบั๊ก ถามคำถามเพื่อความชัดเจนและแก้ไขปัญหาทีละขั้นตอน"
);

console.log(await debugSession.chat("API ของฉันยังคงส่งคืนข้อผิดพลาด 401"));
console.log(await debugSession.chat("ฉันใส่ Authorization header แล้ว"));
console.log(
  await debugSession.chat("โทเค็นมาจาก localStorage หลังจากการเข้าสู่ระบบ")
);

Adaptive Thinking: Extended Thinking รูปแบบใหม่

Adaptive thinking เข้ามาแทนที่โมเดล extended thinking แบบเก่าใน Sonnet 4.6 ความแตกต่างที่สำคัญคือ: แทนที่จะกำหนดงบประมาณโทเค็นตายตัวสำหรับการคิด คุณจะกำหนดระดับ effort และ Claude จะพิจารณาว่าปัญหานั้นสมควรได้รับการให้เหตุผลมากน้อยเพียงใด

วิธีใช้งาน Adaptive Thinking

import anthropic

client = anthropic.Anthropic()

# แนะนำ: adaptive thinking ที่มี effort ระดับกลางสำหรับการใช้งานส่วนใหญ่
response = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=16000,
    thinking={"type": "adaptive"},
    effort="medium",  # ตัวเลือก: "low", "medium", "high" (ค่าเริ่มต้น: high)
    messages=[{
        "role": "user",
        "content": """
        ออกแบบสคีมาฐานข้อมูลสำหรับแพลตฟอร์ม SaaS analytics ที่ต้องการ:
        - ติดตามเหตุการณ์จากผู้ใช้หลายล้านคน
        - รองรับการสอบถามแบบเรียลไทม์ในช่วง 24 ชั่วโมงที่ผ่านมา
        - จัดเก็บข้อมูลประวัติอย่างคุ้มค่า
        - จัดการการแยก Tenant สำหรับลูกค้าองค์กร
        """
    }]
)

# บล็อกการคิดจะปรากฏก่อนการตอบกลับข้อความ
for block in response.content:
    if block.type == "thinking":
        print(f"[การให้เหตุผลของ Claude - {len(block.thinking)} ตัวอักษร]")
    elif block.type == "text":
        print(block.text)

ระดับ Effort ในทางปฏิบัติ

ข้อควรจำในการย้ายระบบ:thinking: {type: "enabled", budget_tokens: N}thinking: {type: "adaptive"}effort

หน้าต่างบริบท 1M โทเค็น

หน้าต่างบริบท 1M โทเค็นช่วยให้คุณสามารถป้อน Claude ด้วย codebase ทั้งหมด, ชุดเอกสารจำนวนมาก, หรือประวัติการสนทนาหลายเดือนได้ ซึ่งเทียบเท่ากับประมาณ 750,000 คำ หรือ 5–10 codebase เต็มในคำขอเดียว

วิธีเปิดใช้งานบริบท 1M

ส่งส่วนหัวเบต้า context-1m-2025-08-07 ในคำขอของคุณ:

import anthropic

client = anthropic.Anthropic()

# อ่าน codebase ขนาดใหญ่ทั้งหมด
with open("large_codebase.txt", "r") as f:
    codebase_content = f.read()

response = client.beta.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=4096,
    betas=["context-1m-2025-08-07"],
    messages=[{
        "role": "user",
        "content": f"""
        นี่คือ codebase แบ็กเอนด์ทั้งหมดของเรา: \n\n{codebase_content}\n\n
        ค้นหาคำสั่งฐานข้อมูลทั้งหมดที่อาจทำให้เกิดปัญหา N+1 และเสนอแนวทางแก้ไข
        """
    }]
)

print(response.content[0].text)

// เทียบเท่า JavaScript
const response = await client.beta.messages.create({
  model: "claude-sonnet-4-6",
  max_tokens: 4096,
  betas: ["context-1m-2025-08-07"],
  messages: [
    {
      role: "user",
      content: `ตรวจสอบ codebase ทั้งหมดนี้เพื่อหาช่องโหว่ด้านความปลอดภัย:\n\n${codebaseContent}`,
    },
  ],
});

สิ่งที่ 1M โทเค็นเปิดใช้งาน

• การวิเคราะห์ codebase เต็มรูปแบบ: ส่ง repo ทั้งหมดของคุณและให้ Claude ค้นหาข้อบกพร่อง, แนะนำการปรับโครงสร้าง, หรือสร้างการทดสอบ
• การประมวลผลเอกสารขนาดยาว: วิเคราะห์สัญญาทางกฎหมายฉบับเต็ม, รายงานทางการเงิน, หรือเอกสารการวิจัย
• เซสชัน Agentic ที่ขยายออกไป: เก็บประวัติทั้งหมดของงานหลายขั้นตอนที่ยาวนานโดยไม่สูญเสียบริบท
• การติดตามการพึ่งพากันข้ามไฟล์: ค้นหาการใช้งานทั้งหมดของฟังก์ชันหรือคลาสในโปรเจกต์ขนาดใหญ่

ข้อควรทราบเรื่องราคา: คำขอที่เกิน 200K โทเค็นจะใช้ ราคาบริบทแบบยาว วางแผนให้เหมาะสมสำหรับการใช้งานปริมาณมาก

การค้นหาเว็บและการกรองแบบไดนามิก

เครื่องมือค้นหาเว็บ (web search) และดึงข้อมูลเว็บ (web fetch) รองรับ dynamic filtering ในเวอร์ชันเบต้าสาธารณะบน Sonnet 4.6 แล้ว Claude จะเขียนและรันโค้ดเพื่อกรองผลการค้นหาก่อนที่จะเข้าสู่หน้าต่างบริบท—ซึ่งจะเก็บเฉพาะข้อมูลที่เกี่ยวข้องและลดการใช้โทเค็นลงอย่างมาก

การรันโค้ด ฟรี เมื่อใช้ร่วมกับเครื่องมือค้นหาเว็บหรือดึงข้อมูลเว็บ (ไม่มีการเรียกเก็บเงินแยกต่างหาก)

การตั้งค่าการค้นหาเว็บแบบไดนามิก

import anthropic

client = anthropic.Anthropic()

response = client.beta.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=4096,
    betas=["code-execution-web-tools-2026-02-09"],
    tools=[
        {
            "type": "web_search_20260209",  # ใช้เวอร์ชันนี้สำหรับการกรองแบบไดนามิก
            "name": "web_search",
        }
    ],
    messages=[{
        "role": "user",
        "content": "ค้นหา CVE ล่าสุดสำหรับ Apache Log4j ที่เผยแพร่ใน 30 วันที่ผ่านมาและสรุประดับความรุนแรง"
    }]
)

for block in response.content:
    if hasattr(block, "text"):
        print(block.text)

การดึงข้อมูลเว็บพร้อมการกรองแบบไดนามิก

import anthropic

client = anthropic.Anthropic()

response = client.beta.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=2048,
    betas=["code-execution-web-tools-2026-02-09"],
    tools=[
        {
            "type": "web_fetch_20260209",  # เวอร์ชันใหม่พร้อมการกรองแบบไดนามิก
            "name": "web_fetch",
        }
    ],
    messages=[{
        "role": "user",
        "content": "ดึงหน้าเว็บราคาของ Anthropic และแยกเฉพาะแถวราคาของ Claude Sonnet ออกมา"
    }]
)

print(response.content[-1].text)

ทำไมการกรองแบบไดนามิกจึงสำคัญ: หากไม่มีการกรอง การดึงข้อมูลหน้าเว็บทั้งหมดอาจใช้โทเค็น 100K สำหรับหน้าเว็บที่คุณต้องการเนื้อหาที่เกี่ยวข้องเพียง 2K โทเค็น การกรองแบบไดนามิกช่วยให้ Claude สามารถแยกวิเคราะห์หน้าเว็บด้วยโค้ดและส่งคืนเฉพาะสิ่งที่จำเป็น ซึ่งช่วยลดต้นทุนได้มากกว่า 90% ในหน้าเว็บที่มีเนื้อหามาก

Context Compaction API

Context compaction จัดการเซสชัน Agentic ที่ทำงานเป็นเวลานาน ซึ่งบริบทสะสมเกินขีดจำกัดของหน้าต่าง API จะสรุปส่วนเก่าๆ ของการสนทนาโดยอัตโนมัติที่ฝั่งเซิร์ฟเวอร์เมื่อใกล้ถึงขีดจำกัด ทำให้สามารถสนทนาได้ยาวนานอย่างไม่จำกัด

import anthropic

client = anthropic.Anthropic()

# เปิดใช้งาน context compaction ผ่านส่วนหัวเบต้า
response = client.beta.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=4096,
    betas=["interleaved-thinking-2025-05-14"],  # เปิดใช้งาน compaction ในเบต้า
    system="คุณคือเอเจนต์การพัฒนาซอฟต์แวร์ที่ทำงานเป็นเวลานาน รักษาบริบทเกี่ยวกับการเปลี่ยนแปลง codebase ที่เกิดขึ้นระหว่างเซสชันนี้",
    messages=[
        {"role": "user", "content": "เริ่มเซสชันการปรับโครงสร้างโมดูลการยืนยันตัวตนของเรา"},
        # ... การสนทนาอีกหลายรอบจะอยู่ในเซสชันจริงที่นี่
    ]
)

# ฟิลด์ compaction_details จะแสดงเวลาที่การสรุปข้อมูลเกิดขึ้น
if hasattr(response, "usage") and hasattr(response.usage, "cache_read_input_tokens"):
    print(f"โทเค็นบริบทที่บันทึกผ่านการแคช: {response.usage.cache_read_input_tokens}")

เมื่อใดควรใช้ compaction: เวิร์กโฟลว์ Agentic ใดๆ ที่ทำงานนานกว่าสองสามนาทีและมีการสะสมประวัติ—เช่น CI/CD agents, เซสชันการเขียนโค้ดที่ยาวนาน, การสนทนากับฝ่ายสนับสนุนลูกค้า, หรืองานวิจัยหลายขั้นตอน

การทดสอบ Claude Sonnet 4.6 ด้วย Apidog

ก่อนที่จะเขียนโค้ด SDK ให้ใช้ Apidog เพื่อสำรวจ Claude Sonnet 4.6 API ด้วยภาพ Apidog ช่วยเร่งความเร็วการพัฒนาโดยให้คุณกำหนดค่าส่วนหัว, สร้างเนื้อหาคำขอ, และตรวจสอบการตอบสนองแบบสตรีมมิ่งโดยไม่ต้องเขียนโค้ดเริ่มต้น

การตั้งค่า Anthropic API ใน Apidog

1. เปิด Apidog และสร้างคำขอ HTTP ใหม่
2. ตั้งค่าเมธอดเป็น POST และ URL เป็น https://api.anthropic.com/v1/messages
3. เพิ่มส่วนหัวเหล่านี้:

1. ตั้งค่าเนื้อหาคำขอเป็น JSON:

{
  "model": "claude-sonnet-4-6",
  "max_tokens": 1024,
  "messages": [
    {
      "role": "user",
      "content": "อะไรคือการปรับปรุงที่สำคัญใน Claude Sonnet 4.6?"
    }
  ]
}

การทดสอบ Adaptive Thinking

หากต้องการทดสอบโหมด adaptive thinking ใน Apidog ให้เพิ่มฟิลด์ thinking และ effort ลงในเนื้อหาคำขอของคุณ:

{
  "model": "claude-sonnet-4-6",
  "max_tokens": 8192,
  "thinking": {
    "type": "adaptive"
  },
  "effort": "medium",
  "messages": [
    {
      "role": "user",
      "content": "ออกแบบกลยุทธ์การจำกัดอัตราสำหรับ Public API ที่รองรับคำขอ 10 ล้านครั้งต่อวัน"
    }
  ]
}

การทดสอบคุณสมบัติเบต้าใน Apidog

สำหรับคุณสมบัติเบต้า (บริบท 1M, การค้นหาเว็บแบบไดนามิก, การบีบอัดบริบท) ให้เพิ่มส่วนหัวเบต้า:

หรือสำหรับการกรองแบบไดนามิกในการค้นหาเว็บ:

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

เครื่องมือใหม่พร้อมใช้งานทั่วไปแล้ว

เครื่องมือหลายอย่างที่เคยอยู่ในเวอร์ชันเบต้า ตอนนี้พร้อมใช้งานทั่วไปบน Sonnet 4.6 แล้ว ซึ่งหมายความว่าไม่จำเป็นต้องใช้ส่วนหัวเบต้าพิเศษใดๆ:

เครื่องมือรันโค้ด

import anthropic

client = anthropic.Anthropic()

response = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=4096,
    tools=[{"type": "code_execution_20250522", "name": "code_execution"}],
    messages=[{
        "role": "user",
        "content": "คำนวณดอกเบี้ยทบต้นจากเงิน $10,000 ในอัตรา 5% ต่อปี เป็นเวลา 10 ปี โดยทบต้นทุกเดือน แสดงการวิเคราะห์แบบปีต่อปี"
    }]
)

for block in response.content:
    if block.type == "tool_result":
        print("ผลลัพธ์การรัน:", block.content)
    elif hasattr(block, "text"):
        print(block.text)

เครื่องมือหน่วยความจำ

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

import anthropic

client = anthropic.Anthropic()

response = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=2048,
    tools=[{"type": "memory_20250416", "name": "memory"}],
    messages=[{
        "role": "user",
        "content": "โปรดจำไว้ว่า API base URL ของเราคือ https://api.company.com/v2 และเรากำหนดให้มีการยืนยันตัวตนด้วย Bearer token ในทุกเอนด์พอยต์"
    }]
)

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

การเรียกใช้เครื่องมือแบบโปรแกรมช่วยให้ Claude สามารถสร้างการเรียกใช้ API แบบมีโครงสร้างได้โดยตรง:

import anthropic

client = anthropic.Anthropic()

# ตอนนี้ Claude สามารถเรียกใช้เครื่องมือด้วยโปรแกรมได้โดยไม่ต้องมีการควบคุมจากมนุษย์
response = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=2048,
    tools=[
        {
            "name": "execute_sql",
            "description": "รันคำสั่ง SQL และคืนค่าผลลัพธ์",
            "input_schema": {
                "type": "object",
                "properties": {
                    "query": {"type": "string", "description": "คำสั่ง SQL ที่จะรัน"},
                    "database": {"type": "string", "description": "ชื่อฐานข้อมูล"}
                },
                "required": ["query", "database"]
            }
        }
    ],
    messages=[{
        "role": "user",
        "content": "ค้นหาผู้ใช้ทั้งหมดที่ลงทะเบียนในเดือนมกราคม 2026 และยังไม่ได้ทำการซื้อ"
    }]
)

Sonnet 4.6 เปรียบเทียบกับโมเดลรุ่นก่อนหน้า

สรุป: หากคุณใช้ Sonnet 4.5 การอัปเกรดเป็น Sonnet 4.6 เป็นสิ่งที่ควรทำอย่างยิ่ง — ราคาเท่าเดิม, ประสิทธิภาพการเขียนโค้ดดีขึ้นอย่างเห็นได้ชัด, และ adaptive thinking หากคุณใช้ Opus 4.5 ตอนนี้ Sonnet 4.6 สามารถเทียบเท่าหรือเหนือกว่าในกรณีการใช้งานส่วนใหญ่ในราคาเพียง 60% ของค่าใช้จ่าย

แนวทางปฏิบัติที่ดีที่สุดและเคล็ดลับ

1. ใช้ Adaptive Thinking ที่ระดับ Effort ปานกลางเป็นค่าเริ่มต้น

สำหรับการใช้งาน Sonnet 4.6 ส่วนใหญ่, effort: "medium" ให้สมดุลระหว่างค่าใช้จ่ายและประสิทธิภาพที่ดีที่สุด สงวน effort: "high" ไว้สำหรับงานที่ซับซ้อนจริงๆ เช่น การออกแบบสถาปัตยกรรม, การให้เหตุผลแบบหลายขั้นตอน, หรือการพิสูจน์ทางคณิตศาสตร์

# รูปแบบค่าเริ่มต้นที่ดีสำหรับ Sonnet 4.6
response = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=4096,
    thinking={"type": "adaptive"},
    effort="medium",  # จุดที่เหมาะสมที่สุดสำหรับงานส่วนใหญ่
    messages=[...]
)

2. ใช้การสตรีมมิ่งสำหรับเอาต์พุตที่เกิน 1K โทเค็น

การตอบสนองขนาดใหญ่ได้รับประโยชน์จากการสตรีมมิ่งเพื่อหลีกเลี่ยง HTTP timeouts และให้ผู้ใช้รู้สึกว่าการตอบสนองเร็วขึ้น:

# สำหรับการตอบสนองใดๆ ที่คาดว่าจะยาว
with client.messages.stream(
    model="claude-sonnet-4-6",
    max_tokens=8192,
    messages=[...]
) as stream:
    for text in stream.text_stream:
        print(text, end="", flush=True)

3. เปิดใช้งาน Prompt Caching สำหรับ System Prompt ที่ใช้ซ้ำ

หากคุณใช้ system prompt เดียวกันในการเรียกใช้หลายครั้ง ให้แคชเพื่อประหยัดได้สูงสุด 90%:

response = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    system=[
        {
            "type": "text",
            "text": "System prompt ที่ยาวของคุณที่นี่...",
            "cache_control": {"type": "ephemeral"}  # แคชบล็อกนี้
        }
    ],
    messages=[{"role": "user", "content": user_input}]
)

4. จัดการ Rate Limit อย่างเหมาะสม

Sonnet 4.6 มี Rate Limit ที่เอื้อเฟื้อเผื่อแผ่ แต่ระบบใน Production ควรใช้ exponential backoff:

import anthropic
import time

def create_with_retry(client, max_retries=3, **kwargs):
    for attempt in range(max_retries):
        try:
            return client.messages.create(**kwargs)
        except anthropic.RateLimitError:
            if attempt == max_retries - 1:
                raise
            wait_time = (2 ** attempt) + 1  # 2s, 3s, 5s
            time.sleep(wait_time)

5. หลีกเลี่ยงการใช้ Prefill บน Sonnet 4.6

การ prefill ข้อความของผู้ช่วย (prefill รอบสุดท้าย) ไม่รองรับในโมเดล Claude 4.6 ให้ใช้ structured outputs แทน:

# แนวทางเก่า (ใช้งานไม่ได้บน Claude 4.6):
# messages = [
#     {"role": "user", "content": "Give me JSON..."},
#     {"role": "assistant", "content": "{"}  # Prefill
# ]

# แนวทางใหม่: ใช้ structured outputs
response = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    output_config={
        "format": {
            "type": "json_schema",
            "schema": {
                "type": "object",
                "properties": {
                    "name": {"type": "string"},
                    "score": {"type": "number"}
                }
            }
        }
    },
    messages=[{"role": "user", "content": "สร้างอ็อบเจกต์ผู้ใช้ตัวอย่าง"}]
)

6. ระบุ AWS หรือ GCP สำหรับ Data Residency

หากข้อกำหนดด้านการปฏิบัติตามกฎระเบียบของคุณต้องการการอนุมานเฉพาะในสหรัฐอเมริกา ให้ใช้พารามิเตอร์ inference_geo:

response = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    inference_geo="us",  # ช่วยให้มั่นใจว่าการอนุมานจะทำงานในศูนย์ข้อมูลในสหรัฐอเมริกา
    messages=[...]
)

การอนุมานเฉพาะในสหรัฐอเมริกามีราคาที่ 1.1 เท่าของอัตรามาตรฐานบน Sonnet 4.6

พร้อมที่จะสร้างด้วย Claude Sonnet 4.6 แล้วหรือยัง? ดาวน์โหลด Apidog ฟรี เพื่อทดสอบการเรียกใช้ API ของคุณด้วยภาพ, ทำงานร่วมกับทีมของคุณในการกำหนดค่าคำขอ, และสร้างโค้ด SDK โดยอัตโนมัติ—ไม่ต้องใช้บัตรเครดิต