Claude Sonnet 4.6 API 사용법

TL;DR / 빠른 답변

Claude Sonnet 4.6은 Anthropic의 최신 미드티어 모델로, 최첨단 코딩 성능과 100만 토큰 컨텍스트 창(베타)을 백만 입력/출력 토큰당 $3/$15의 저렴한 비용으로 결합했습니다. API 사용을 시작하려면: 1) console.anthropic.com에서 API 키를 받으세요. 2) SDK를 설치하세요 (pip install anthropic). 3) 모델 ID claude-sonnet-4-6을 사용하세요. 4) 최상의 결과를 위해 적응형 사고(thinking: {type: "adaptive"})로 전환하세요. 초기 테스터들은 Sonnet 4.5보다 70% 더 선호했으며, Opus 4.5보다도 59% 더 선호했습니다.

소개

Anthropic이 Claude Sonnet 4.6을 출시했으며, 이는 즉시 미드티어 AI 모델 카테고리를 재편하고 있습니다. 이는 단순한 점진적 업데이트가 아닙니다. 초기 사용자들에 따르면 이전 프리미엄 티어인 Opus 4.5를 직접 비교 테스트에서 59% 앞서는 모델이며, Sonnet의 가격대를 유지합니다.

주요 변경 사항은 다음과 같습니다: 베타 단계에 진입하는 100만 토큰 컨텍스트 창, 기존의 이진 확장 사고 방식을 대체하는 새로운 적응형 사고 모드, 그리고 웹 검색, 코드 실행, 메모리, 도구 검색과 같은 도구 모음이 일반 공급으로 전환되었습니다. 에이전트 애플리케이션을 구축하는 개발자에게 Sonnet 4.6은 이전에는 비싼 최첨단 모델에서만 가능했던 기능을 약 1/3의 비용으로 제공합니다.

코딩 개선 사항은 명확합니다. 사용자들은 코드 생성에서 더 나은 지시 따르기, 수정 전에 더 스마트한 컨텍스트 이해, 그리고 자동 로직 통합을 통한 코드 중복 감소를 보고합니다. 컴퓨터 사용은 복잡한 보험 워크플로우에서 94%의 정확도를 달성합니다. SWE-bench 검증 점수는 79.6%입니다.

이 가이드는 오늘 Claude Sonnet 4.6 API로 빌드를 시작하는 데 필요한 모든 것을 다룹니다: 인증, Python 및 JavaScript의 실제 코드 예제, 새로운 적응형 사고 매개변수, 100만 컨텍스트 창 잠금 해제 방법, 그리고 Apidog의 시각적 API 클라이언트로 통합을 테스트하는 방법.

버튼

Claude Sonnet 4.6의 새로운 기능

적응형 사고 모드

기존 thinking: {type: "enabled", budget_tokens: N} 패턴은 Sonnet 4.6에서 더 이상 사용되지 않습니다. 이를 대체하는 것은 적응형 사고: thinking: {type: "adaptive"}입니다. Claude는 이제 작업에 필요한 추론의 양을 동적으로 결정합니다.

적응형 사고를 effort 매개변수(현재 GA에서 사용 가능)와 함께 사용하여 비용 대비 성능을 조정할 수 있습니다:

• effort: "high" (기본값) — Claude가 거의 항상 사고하며, 복잡한 문제에 최적
• effort: "medium" — 대부분의 Sonnet 4.6 사용 사례에 권장되며, 속도와 품질의 균형을 이룸
• effort: "low" — 최소한의 사고로, 간단한 작업에 가장 빠른 응답

향상된 코딩 성능

Sonnet 4.6은 코드 생성에 세 가지 구체적인 개선 사항을 제공합니다:

1. 더 나은 지시 따르기 — 사양에 더 정확하게 일치하는 코드 생성
2. 컨텍스트 이해 — 기존 코드를 수정하기 전에 읽고 이해하여 회귀 감소
3. 로직 통합 — 중복 패턴을 식별하고 공유 추상화 제안

코딩 벤치마크를 수행한 초기 테스터들은 Sonnet 4.5보다 Sonnet 4.6의 출력을 70%의 경우에, Opus 4.5보다 59%의 경우에 더 선호한다고 보고했습니다.

컴퓨터 사용 개선 사항

OSWorld-Verified에서 컴퓨터 사용 정확도가 72.5%(Opus 4.6의 0.2% 이내)에 도달했으며, Sonnet 4.5보다 크게 향상되었습니다. 이 모델은 UI 탐색, 스프레드시트 조작 및 다단계 양식 완료를 요구하는 보험 워크플로우에서 94%의 정확도를 보입니다. 또한 자동화된 작업 중 프롬프트 주입 공격에 더 강합니다.

ARC-AGI-2 돌파구

가장 눈에 띄는 벤치마크 수치: ARC-AGI-2 성능이 13.6%에서 58.3%로 4.3배 향상되었습니다. 이는 모델이 패턴을 본 적 없는 작업에 대한 새로운 문제 해결 능력을 측정하며, 암기보다는 진정한 추론 능력 향상을 시사합니다.

API 사양 및 가격

비용 절감 옵션:

• 프롬프트 캐싱: 시스템 프롬프트의 정적 부분을 캐싱하여 최대 90% 절감
• 배치 API: 비동기적으로 요청을 처리하여 50% 할인
• 장문 컨텍스트 가격: 20만 토큰을 초과하는 요청은 별도의 장문 컨텍스트 요율을 사용

프로덕션 예산의 경우: effort: "medium"으로 적응형 사고 모드에서 100만 토큰 대화는 입력 토큰으로 약 $3의 비용이 듭니다. 대부분의 단일 API 호출은 1센트 미만입니다.

Claude Sonnet 4.6 API 시작하기

1단계: API 키 받기

1. platform.anthropic.com에 로그인하세요.
2. 설정에서 API 키로 이동하세요.
3. 키 생성을 클릭하고 값을 즉시 복사하세요 (한 번만 표시됩니다).

키를 환경 변수로 저장하세요. 절대 하드코딩하지 마세요:

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": "JavaScript에서 async/await와 Promise의 차이점을 설명해 주세요."}
    ]
)

print(response.content[0].text)

이것이 최소한의 실행 가능한 호출입니다. 응답 객체에는 사용 통계(입력 토큰, 출력 토큰), 중단 이유 및 모델 버전이 포함됩니다.

Python 코드 예제

기본 텍스트 생성

import anthropic

client = anthropic.Anthropic()

def ask_claude(question: str, system: str = None) -> str:
    """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(
    "이 Python 함수에서 성능 문제를 검토하세요:\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": "JWT를 이용한 사용자 인증을 위한 FastAPI REST API 핸들러를 완전히 작성하세요."
    }]
) 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 리포지토리에 대한 정보를 가져옵니다.",
        "input_schema": {
            "type": "object",
            "properties": {
                "owner": {
                    "type": "string",
                    "description": "리포지토리 소유자 또는 조직 이름"
                },
                "repo": {
                    "type": "string",
                    "description": "리포지토리 이름"
                }
            },
            "required": ["owner", "repo"]
        }
    }
]

response = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    tools=tools,
    messages=[{
        "role": "user",
        "content": "anthropics/anthropic-sdk-python 리포지토리에 대해 무엇을 알려줄 수 있나요?"
    }]
)

# 도구 사용 응답 처리
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 텍스트 표시기 및 키보드 탐색 관련 문제를 확인하세요."
)
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(
  "이 Express 라우트를 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 헤더를 포함하고 있습니다."));
console.log(
  await debugSession.chat("토큰은 로그인 후 localStorage에서 가져옵니다.")
);

적응형 사고: 새로운 확장 사고

적응형 사고는 Sonnet 4.6의 이전 확장 사고 모델을 대체합니다. 주요 차이점: 사고를 위한 고정 토큰 예산을 설정하는 대신, effort 수준을 설정하고 Claude가 문제가 실제로 얼마나 많은 추론을 필요로 하는지 결정합니다.

적응형 사고 사용 방법

import anthropic

client = anthropic.Anthropic()

# 권장: 대부분의 사용 사례에 중간 노력으로 적응형 사고
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 분석 플랫폼의 데이터베이스 스키마를 설계하세요:
        - 수백만 사용자의 이벤트 추적
        - 지난 24시간 동안의 실시간 쿼리 지원
        - 기록 데이터를 비용 효율적으로 보관
        - 기업 고객을 위한 테넌트 격리 처리
        """
    }]
)

# 사고 블록은 텍스트 응답 전에 나타납니다
for block in response.content:
    if block.type == "thinking":
        print(f"[Claude의 추론 - {len(block.thinking)} 문자]")
    elif block.type == "text":
        print(block.text)

실제 노력 수준

마이그레이션 참고:thinking: {type: "enabled", budget_tokens: N}effortthinking: {type: "adaptive"}

100만 토큰 컨텍스트 창

100만 토큰 컨텍스트 창을 통해 Claude에게 전체 코드베이스, 광범위한 문서 세트 또는 몇 달간의 대화 기록을 제공할 수 있습니다. 이는 약 75만 단어 또는 단일 요청으로 5~10개의 전체 코드베이스에 해당합니다.

100만 컨텍스트 활성화 방법

요청 시 context-1m-2025-08-07 베타 헤더를 전달하세요:

import anthropic

client = anthropic.Anthropic()

# 전체 대규모 코드베이스 읽기
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"""
        다음은 전체 백엔드 코드베이스입니다:\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: `이 전체 코드베이스에서 보안 취약점을 검토하세요:\n\n${codebaseContent}`,
    },
  ],
});

100만 토큰이 가능하게 하는 것

• 전체 코드베이스 분석: 전체 리포지토리를 보내 Claude에게 버그를 찾거나, 리팩토링을 제안하거나, 테스트를 생성하도록 요청
• 긴 문서 처리: 전체 법률 계약, 재무 보고서 또는 연구 논문 분석
• 확장된 에이전트 세션: 컨텍스트를 잃지 않고 긴 다단계 작업의 전체 기록 유지
• 파일 간 종속성 추적: 대규모 프로젝트에서 함수 또는 클래스의 모든 사용법 찾기

가격 참고: 20만 토큰을 초과하는 요청은 장문 컨텍스트 가격을 사용합니다. 대용량 사용에 맞춰 계획하세요.

웹 검색 및 동적 필터링

웹 검색 및 웹 가져오기 도구는 이제 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": "지난 30일 동안 게시된 Apache Log4j의 최신 CVE를 찾아 심각도 수준을 요약하세요."
    }]
)

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)

동적 필터링이 중요한 이유: 필터링 없이 전체 웹 페이지를 가져오면 필요한 관련 콘텐츠가 2천 토큰에 불과한 페이지에 대해 10만 토큰을 소비할 수 있습니다. 동적 필터링을 통해 Claude는 코드로 페이지를 파싱하고 필요한 것만 반환하여 콘텐츠가 많은 페이지에서 비용을 90% 이상 절감할 수 있습니다.

컨텍스트 압축 API

컨텍스트 압축은 컨텍스트가 창 제한을 초과하여 누적되는 장기 실행 에이전트 세션을 처리합니다. API는 제한에 가까워지면 대화의 오래된 부분을 서버 측에서 자동으로 요약하여 사실상 무제한의 대화 길이를 가능하게 합니다.

import anthropic

client = anthropic.Anthropic()

# 베타 헤더를 통해 컨텍스트 압축 활성화
response = client.beta.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=4096,
    betas=["interleaved-thinking-2025-05-14"],  # 베타에서 압축 활성화
    system="당신은 장기 실행 소프트웨어 개발 에이전트입니다. 이 세션 동안 이루어진 코드베이스 변경 사항에 대한 컨텍스트를 유지하세요.",
    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}")

압축 사용 시기: 몇 분 이상 실행되고 기록이 누적되는 모든 에이전트 워크플로우—CI/CD 에이전트, 긴 코딩 세션, 고객 지원 스레드 또는 다단계 연구 작업.

Apidog로 Claude Sonnet 4.6 테스트하기

SDK 코드를 작성하기 전에 Apidog를 사용하여 Claude Sonnet 4.6 API를 시각적으로 탐색하세요. Apidog는 상용구 없이 헤더를 구성하고, 요청 본문을 구축하고, 스트리밍 응답을 검사할 수 있도록 하여 개발 속도를 높여줍니다.

Apidog에서 Anthropic API 설정하기

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의 주요 개선 사항은 무엇인가요?"
    }
  ]
}

적응형 사고 테스트

Apidog에서 적응형 사고 모드를 테스트하려면 요청 본문에 thinking 및 effort 필드를 추가하세요:

{
  "model": "claude-sonnet-4-6",
  "max_tokens": 8192,
  "thinking": {
    "type": "adaptive"
  },
  "effort": "medium",
  "messages": [
    {
      "role": "user",
      "content": "하루 1,000만 건의 요청을 처리하는 공개 API의 속도 제한 전략을 설계하세요."
    }
  ]
}

Apidog에서 베타 기능 테스트

베타 기능(100만 컨텍스트, 동적 웹 검색, 컨텍스트 압축)의 경우 베타 헤더를 추가하세요:

또는 웹 검색 동적 필터링의 경우:

Apidog를 사용하면 이러한 구성을 사전 설정으로 저장하고 팀과 공유하여 모든 사람이 일관된 API 테스트 환경을 가질 수 있습니다.

버튼

이제 GA로 제공되는 새로운 도구

이전에 베타였던 여러 도구가 이제 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": "연 5% 이자율로 10년 동안 월 복리 10,000달러에 대한 복리 이자를 계산하세요. 연도별 세부 내역을 보여주세요."
    }]
)

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 기본 URL은 https://api.company.com/v2이며 모든 엔드포인트에 Bearer 토큰 인증이 필요하다는 것을 기억하세요."
    }]
)

프로그래밍 방식 도구 호출

프로그래밍 방식 도구 호출을 통해 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년 1월에 가입했지만 구매하지 않은 모든 사용자를 찾으세요."
    }]
)

Sonnet 4.6 대 이전 모델

결론: Sonnet 4.5를 사용하고 있다면 Sonnet 4.6으로 업그레이드하는 것은 당연한 선택입니다. 동일한 가격에 훨씬 향상된 코딩 성능과 적응형 사고를 제공합니다. Opus 4.5를 사용하고 있다면 Sonnet 4.6이 이제 대부분의 사용 사례에서 Opus 4.5와 동등하거나 능가하며, 비용은 60%에 불과합니다.

모범 사례 및 팁

1. 기본적으로 중간 노력으로 적응형 사고 사용

대부분의 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. 1천 토큰을 초과하는 출력에는 스트리밍 사용

큰 응답은 HTTP 시간 초과를 방지하고 사용자에게 더 빠른 응답 시간을 제공하기 위해 스트리밍을 통해 이점을 얻습니다:

# 길 것으로 예상되는 모든 응답에 대해
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. 반복되는 시스템 프롬프트에 대해 프롬프트 캐싱 활성화

동일한 시스템 프롬프트를 여러 호출에 걸쳐 사용하는 경우, 이를 캐싱하여 최대 90%를 절약하세요:

response = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    system=[
        {
            "type": "text",
            "text": "여기에 긴 시스템 프롬프트...",
            "cache_control": {"type": "ephemeral"}  # 이 블록 캐싱
        }
    ],
    messages=[{"role": "user", "content": user_input}]
)

4. 속도 제한을 유연하게 처리

Sonnet 4.6은 관대한 속도 제한을 가지고 있지만, 프로덕션 시스템은 지수 백오프를 구현해야 합니다:

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. Sonnet 4.6에서 선행 채우기(Prefill) 사용 중단

어시스턴트 메시지 선행 채우기(마지막 턴 선행 채우기)는 Claude 4.6 모델에서 지원되지 않습니다. 대신 구조화된 출력을 사용하세요:

# 이전 접근 방식 (Claude 4.6에서 작동하지 않음):
# messages = [
#     {"role": "user", "content": "Give me JSON..."},
#     {"role": "assistant", "content": "{"}  # 선행 채우기
# ]

# 새로운 접근 방식: 구조화된 출력 사용
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 지정

규정 준수 요구 사항이 미국 내 추론만 필요로 하는 경우, inference_geo 매개변수를 사용하세요:

response = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    inference_geo="us",  # 미국 데이터 센터에서 추론 실행 보장
    messages=[...]
)

미국 내 추론은 Sonnet 4.6에서 표준 요율의 1.1배로 책정됩니다.

Claude Sonnet 4.6으로 빌드할 준비가 되셨나요? Apidog를 무료로 다운로드하여 시각적으로 API 호출을 테스트하고, 요청 구성에 대해 팀과 협업하며, SDK 코드를 자동 생성하세요. 신용카드 정보가 필요 없습니다.

버튼