วิธีใช้ Claude Opus 4.7 API

สรุปโดยย่อ

Claude Opus 4.7 (claude-opus-4-7) เป็นโมเดล GA ที่มีความสามารถสูงสุดของ Anthropic รองรับหน้าต่างบริบท 1 ล้านโทเค็น, เอาต์พุตสูงสุด 128K, การคิดแบบปรับตัว (adaptive thinking), ระดับความพยายามใหม่ xhigh, งบประมาณงาน, การมองเห็นความละเอียดสูง (3.75 MP) และการใช้เครื่องมือ คู่มือนี้ครอบคลุมการตั้งค่า API, การตรวจสอบสิทธิ์ และตัวอย่างโค้ดที่ใช้งานได้จริงใน Python, TypeScript และ cURL สำหรับทุกความสามารถหลัก

บทนำ

Anthropic ได้เปิดตัว Claude Opus 4.7 เมื่อวันที่ 16 เมษายน 2026 เป็นโมเดลที่ทรงพลังที่สุดในตระกูล Claude และเป็นตัวเลือกหลักสำหรับการให้เหตุผลที่ซับซ้อน, เอเจนต์อัตโนมัติ และเวิร์กโฟลว์ที่เน้นการมองเห็น

หากคุณเคยใช้ Claude API มาก่อน อินเทอร์เฟซส่วนใหญ่จะคุ้นเคยดี แต่ Opus 4.7 ได้นำเสนอความสามารถใหม่ๆ และการเปลี่ยนแปลงที่ส่งผลกระทบซึ่งต้องมีการอัปเดตโค้ด งบประมาณการคิดแบบขยายได้ถูกยกเลิกไปแล้ว พารามิเตอร์การสุ่มตัวอย่าง (temperature, top_p, top_k) ก็ถูกยกเลิกเช่นกัน โหมดการคิดตอนนี้รองรับเฉพาะการคิดแบบปรับตัว (adaptive thinking) และจะถูกปิดใช้งานโดยค่าเริ่มต้น

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

ปุ่ม

เริ่มต้นใช้งาน

รับคีย์ API ของคุณ

1. ลงทะเบียนที่ console.anthropic.com
2. ไปที่ API Keys ในหน้าแดชบอร์ด
3. คลิก Create Key และคัดลอกคีย์
4. จัดเก็บเป็นตัวแปรสภาพแวดล้อม:

export ANTHROPIC_API_KEY="sk-ant-your-key-here"

ติดตั้ง SDK

Python:

pip install anthropic

TypeScript/Node.js:

npm install @anthropic-ai/sdk

API Endpoint

คำขอทั้งหมดจะถูกส่งไปที่:

POST https://api.anthropic.com/v1/messages

ส่วนหัวที่จำเป็น:

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

คำขอข้อความพื้นฐาน

การเรียก API ที่ง่ายที่สุด ส่งข้อความและรับการตอบกลับ

Python:

import anthropic

client = anthropic.Anthropic()

message = client.messages.create(
    model="claude-opus-4-7",
    max_tokens=1024,
    messages=[
        {"role": "user", "content": "Explain how HTTP/2 server push works in three sentences."}
    ]
)

print(message.content[0].text)

TypeScript:

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

const client = new Anthropic();

const message = await client.messages.create({
  model: "claude-opus-4-7",
  max_tokens: 1024,
  messages: [
    { role: "user", content: "Explain how HTTP/2 server push works in three sentences." }
  ],
});

console.log(message.content[0].text);

cURL:

curl https://api.anthropic.com/v1/messages \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "content-type: application/json" \
  -d '{
    "model": "claude-opus-4-7",
    "max_tokens": 1024,
    "messages": [
      {"role": "user", "content": "Explain how HTTP/2 server push works in three sentences."}
    ]
  }'

การคิดแบบปรับตัว

การคิดแบบปรับตัว (Adaptive thinking) เป็นโหมดการคิดเดียวที่รองรับบน Opus 4.7. ช่วยให้ Claude จัดสรรโทเค็นการให้เหตุผลแบบไดนามิกตามความซับซ้อนของงาน ซึ่งจะปิดอยู่โดยค่าเริ่มต้น — คุณต้องเปิดใช้งานอย่างชัดเจน

Python:

message = client.messages.create(
    model="claude-opus-4-7",
    max_tokens=16384,
    thinking={
        "type": "adaptive",
        "display": "summarized"  # optional: see thinking output
    },
    messages=[
        {"role": "user", "content": "Analyze this algorithm's time complexity and suggest optimizations:\n\ndef find_pairs(arr, target):\n    result = []\n    for i in range(len(arr)):\n        for j in range(i+1, len(arr)):\n            if arr[i] + arr[j] == target:\n                result.append((arr[i], arr[j]))\n    return result"}
    ]
)

for block in message.content:
    if block.type == "thinking":
        print("Thinking:", block.thinking)
    elif block.type == "text":
        print("Response:", block.text)

ประเด็นสำคัญ:

• "type": "adaptive" เปิดใช้งานการคิด ห้ามตั้งค่า budget_tokens — มิฉะนั้นจะเกิดข้อผิดพลาด 400
• "display": "summarized" ทำให้เนื้อหาการคิดปรากฏให้เห็นในการตอบกลับ ค่าเริ่มต้นคือ "omitted"
• ใช้ร่วมกับพารามิเตอร์ effort เพื่อควบคุมความลึกของการให้เหตุผล

การใช้พารามิเตอร์ Effort

message = client.messages.create(
    model="claude-opus-4-7",
    max_tokens=16384,
    thinking={"type": "adaptive"},
    output_config={"effort": "xhigh"},  # xhigh | high | medium | low
    messages=[
        {"role": "user", "content": "Review this pull request for security vulnerabilities..."}
    ]
)

ระดับความพยายามสำหรับ Opus 4.7:

การมองเห็นความละเอียดสูง

Opus 4.7 รองรับรูปภาพที่มีความยาวด้านยาวสูงสุด 2,576 พิกเซล (3.75 เมกะพิกเซล) พิกัดจะจับคู่แบบ 1:1 กับพิกเซลจริง

Python — วิเคราะห์รูปภาพจาก URL:

message = client.messages.create(
    model="claude-opus-4-7",
    max_tokens=4096,
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "image",
                    "source": {
                        "type": "url",
                        "url": "https://example.com/architecture-diagram.png"
                    }
                },
                {
                    "type": "text",
                    "text": "Describe this architecture diagram. List every service and the connections between them."
                }
            ]
        }
    ]
)

print(message.content[0].text)

Python — วิเคราะห์รูปภาพในเครื่องด้วย base64:

import base64

with open("screenshot.png", "rb") as f:
    image_data = base64.standard_b64encode(f.read()).decode("utf-8")

message = client.messages.create(
    model="claude-opus-4-7",
    max_tokens=4096,
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "image",
                    "source": {
                        "type": "base64",
                        "media_type": "image/png",
                        "data": image_data
                    }
                },
                {
                    "type": "text",
                    "text": "What UI bugs do you see in this screenshot?"
                }
            ]
        }
    ]
)

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

การใช้เครื่องมือ (Function Calling)

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

Python:

import json

tools = [
    {
        "name": "get_weather",
        "description": "Get current weather for a city. Returns temperature, conditions, and humidity.",
        "input_schema": {
            "type": "object",
            "properties": {
                "city": {
                    "type": "string",
                    "description": "City name, e.g. 'San Francisco'"
                },
                "units": {
                    "type": "string",
                    "enum": ["celsius", "fahrenheit"],
                    "description": "Temperature unit"
                }
            },
            "required": ["city"]
        }
    }
]

messages = [
    {"role": "user", "content": "What's the weather like in Tokyo right now?"}
]

# First call — Claude requests a tool
response = client.messages.create(
    model="claude-opus-4-7",
    max_tokens=1024,
    tools=tools,
    messages=messages,
)

# Process tool calls
if response.stop_reason == "tool_use":
    messages.append({"role": "assistant", "content": response.content})

    tool_results = []
    for block in response.content:
        if block.type == "tool_use":
            # Execute your function here
            result = {"temperature": 22, "conditions": "Partly cloudy", "humidity": 65}

            tool_results.append({
                "type": "tool_result",
                "tool_use_id": block.id,
                "content": json.dumps(result)
            })

    messages.append({"role": "user", "content": tool_results})

    # Second call — Claude uses the tool result
    final_response = client.messages.create(
        model="claude-opus-4-7",
        max_tokens=1024,
        tools=tools,
        messages=messages,
    )
    print(final_response.content[0].text)

รูปแบบ Agentic Loop

สำหรับเอเจนต์อัตโนมัติที่เรียกใช้เครื่องมือหลายครั้งตามลำดับ:

def run_agent(system_prompt: str, tools: list, user_message: str) -> str:
    messages = [{"role": "user", "content": user_message}]

    while True:
        response = client.messages.create(
            model="claude-opus-4-7",
            max_tokens=16384,
            system=system_prompt,
            tools=tools,
            thinking={"type": "adaptive"},
            output_config={"effort": "xhigh"},
            messages=messages,
        )

        messages.append({"role": "assistant", "content": response.content})

        if response.stop_reason != "tool_use":
            return "".join(
                block.text for block in response.content
                if hasattr(block, "text")
            )

        tool_results = []
        for block in response.content:
            if block.type == "tool_use":
                result = execute_tool(block.name, block.input)
                tool_results.append({
                    "type": "tool_result",
                    "tool_use_id": block.id,
                    "content": result,
                })

        messages.append({"role": "user", "content": tool_results})

งบประมาณงาน (เบต้า)

งบประมาณงานจะให้โทเค็นแก่ Claude สำหรับลูปตัวแทนทั้งหมด โมเดลจะเห็นการนับถอยหลังและสิ้นสุดการทำงานเมื่อใช้งบประมาณหมด

response = client.beta.messages.create(
    model="claude-opus-4-7",
    max_tokens=128000,
    output_config={
        "effort": "high",
        "task_budget": {"type": "tokens", "total": 128000},
    },
    messages=[
        {"role": "user", "content": "Review the codebase and propose a refactor plan."}
    ],
    betas=["task-budgets-2026-03-13"],
)

ข้อจำกัดที่สำคัญ:

• งบประมาณขั้นต่ำ: 20,000 โทเค็น
• เป็นคำแนะนำ ไม่ใช่ขีดจำกัดสูงสุดที่เข้มงวด — Claude อาจใช้งบเกิน
• แตกต่างจาก max_tokens (เพดานสูงสุดที่โมเดลไม่สามารถมองเห็นได้)
• ต้องมีส่วนหัวเบต้า task-budgets-2026-03-13

การสตรีมการตอบสนอง

สตรีมการตอบสนองสำหรับเอาต์พุตแบบเรียลไทม์ในอินเทอร์เฟซแชท

Python:

with client.messages.stream(
    model="claude-opus-4-7",
    max_tokens=4096,
    messages=[
        {"role": "user", "content": "Write a Python function to parse CSV files with error handling."}
    ]
) as stream:
    for text in stream.text_stream:
        print(text, end="", flush=True)

TypeScript:

const stream = await client.messages.stream({
  model: "claude-opus-4-7",
  max_tokens: 4096,
  messages: [
    { role: "user", content: "Write a Python function to parse CSV files with error handling." }
  ],
});

for await (const event of stream) {
  if (event.type === "content_block_delta" && event.delta.type === "text_delta") {
    process.stdout.write(event.delta.text);
  }
}

หากคุณเปิดใช้งานการคิดแบบปรับตัวด้วย display: "summarized", บล็อกการคิดจะถูกสตรีมก่อน ตามด้วยการตอบสนองข้อความ หากไม่มี display: "summarized", ผู้ใช้จะเห็นการหยุดชั่วคราวระหว่างการคิด ตามด้วยเอาต์พุตข้อความ

การแคช Prompt

ลดค่าใช้จ่ายสำหรับบริบทที่ซ้ำกัน (system prompts, เอกสารยาวๆ) โดยการแคช

response = client.messages.create(
    model="claude-opus-4-7",
    max_tokens=1024,
    system=[
        {
            "type": "text",
            "text": "You are a senior code reviewer. Review code for security vulnerabilities, performance issues, and best practices violations...",
            "cache_control": {"type": "ephemeral"}
        }
    ],
    messages=[
        {"role": "user", "content": "Review this function:\n\ndef process_user_input(data):\n    return eval(data)"}
    ]
)

ราคาแคชสำหรับ Opus 4.7:

การอ่านแคชเพียงครั้งเดียวก็คุ้มค่ากับการเขียนแคช 5 นาที การอ่านสองครั้งก็คุ้มค่ากับการเขียน 1 ชั่วโมง

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

รักษาบริบทตลอดการสนทนาโดยการเพิ่มข้อความลงในอาร์เรย์ messages

messages = []

# Turn 1
messages.append({"role": "user", "content": "I need to build a REST API for a todo app."})

response = client.messages.create(
    model="claude-opus-4-7",
    max_tokens=4096,
    messages=messages,
)

messages.append({"role": "assistant", "content": response.content})

# Turn 2
messages.append({"role": "user", "content": "Add authentication with JWT tokens."})

response = client.messages.create(
    model="claude-opus-4-7",
    max_tokens=4096,
    messages=messages,
)

การทดสอบการเรียกใช้ API ของคุณด้วย Apidog

การสร้างการผสานรวม Claude API เกี่ยวข้องกับเพย์โหลดที่ซับซ้อน: ข้อความหลายรอบ, การกำหนดเครื่องมือ, ผลลัพธ์เครื่องมือ, รูปภาพ Base64 และการสตรีมการตอบสนอง เครื่องมืออย่าง Apidog ช่วยให้การดีบักและการทดสอบง่ายขึ้น

ตั้งค่าสภาพแวดล้อมของคุณ:

1. สร้างโปรเจกต์ใหม่ใน Apidog และเพิ่ม API endpoint ของ Claude Messages
2. จัดเก็บ ANTHROPIC_API_KEY ของคุณในตัวแปรสภาพแวดล้อม
3. ตั้งค่าส่วนหัวที่จำเป็น (x-api-key, anthropic-version, content-type)

ทดสอบขั้นตอนการใช้เครื่องมือ:

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

เปรียบเทียบโมเดล:

เรียกใช้พรอมต์เดียวกันกับ claude-opus-4-6 และ claude-opus-4-7 เพื่อเปรียบเทียบจำนวนโทเค็น, คุณภาพการตอบสนอง และความหน่วง Test runner ของ Apidog ทำให้การเปรียบเทียบ A/B ทำซ้ำได้

ตรวจสอบสคีมา:

กำหนด JSON schemas สำหรับรูปแบบการตอบสนองที่คุณคาดหวัง และให้ Apidog ตรวจสอบโดยอัตโนมัติว่าการตอบสนองของ Claude ตรงกัน สิ่งนี้จะช่วยจับการถดถอยเมื่อคุณเปลี่ยนพรอมต์หรือสลับโมเดล

ปุ่ม

ข้อผิดพลาดและการแก้ไขที่พบบ่อย

ข้อมูลอ้างอิงราคา

ข้อควรทราบ: ตัวแยกวิเคราะห์โทเค็นใหม่ของ Opus 4.7 อาจใช้โทเค็นเพิ่มขึ้นถึง 35% สำหรับข้อความเดียวกันเมื่อเทียบกับ Opus 4.6 ใช้ endpoint /v1/messages/count_tokens เพื่อประเมินค่าใช้จ่ายก่อนการใช้งานจริง

บทสรุป

Claude Opus 4.7 เป็นโมเดลที่มีความสามารถสูงสุดในตระกูล Claude API ส่วนใหญ่เข้ากันได้กับ Opus 4.6 แต่การยกเลิกงบประมาณการคิดแบบขยายและพารามิเตอร์การสุ่มตัวอย่างจำเป็นต้องมีการเปลี่ยนแปลงโค้ด ความสามารถใหม่ๆ — การคิดแบบปรับตัว, ความพยายาม xhigh, งบประมาณงาน และการมองเห็นความละเอียดสูง — ช่วยให้คุณควบคุมวิธีการให้เหตุผลของโมเดลและค่าใช้จ่ายได้มากขึ้น

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

ปุ่ม