Claude Opus 4.7 실전 가이드: Extended Thinking·1M 컨텍스트·에이전트 API 완전 정복

import anthropic
import json
 
client = anthropic.Anthropic()
 
def refactor_with_thinking(code: str) -> dict:
    try:
        response = client.messages.create(
            model="claude-opus-4-7",
            max_tokens=16000,
            thinking={
                "type": "enabled",
                "budget_tokens": 10000  # 추론에 허용할 최대 토큰
            },
            # task_budget: 에이전트 루프 전체 토큰 목표량 (공개 베타)
            # task_budget={"total_tokens": 50000},
            messages=[
                {
                    "role": "user",
                    "content": (
                        "아래 Python 코드를 async/await 패턴으로 리팩터링해줘. "
                        "기존 테스트가 모두 통과해야 하고, "
                        "변경한 파일 목록과 이유를 마지막에 JSON 형태로 요약해줘.\n\n"
                        f"<code>\n{code}\n</code>"
                    )
                }
            ]
        )
    except anthropic.APIStatusError as e:
        print(f"API 오류 (status={e.status_code}): {e.message}")
        raise
    except anthropic.APIConnectionError as e:
        print(f"네트워크 오류: {e}")
        raise
 
    result = {"thinking": "", "response": ""}
    for block in response.content:
        if block.type == "thinking":
            result["thinking"] = block.thinking[:300] + "..."
        elif block.type == "text":
            result["response"] = block.text
    return result
 
sample_code = """
def fetch_user(user_id):
    import requests
    r = requests.get(f"https://api.example.com/users/{user_id}")
    return r.json()
"""
 
output = refactor_with_thinking(sample_code)
print("[추론 과정 일부]", output["thinking"])
print("[최종 응답]", output["response"])

import anthropic
import base64
import json
from pathlib import Path
from typing import list
 
def analyze_ui_screenshot(image_path: str) -> list[dict]:
    client = anthropic.Anthropic()
 
    image_data = base64.standard_b64encode(
        Path(image_path).read_bytes()
    ).decode("utf-8")
 
    try:
        response = 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": (
                                "이 UI 스크린샷에서 다음을 분석해줘:\n"
                                "1. 레이아웃 깨짐 여부\n"
                                "2. 텍스트 잘림(truncation) 발생 위치\n"
                                "3. 접근성 색상 대비 문제\n"
                                '발견된 항목은 {"issue": "...", "location": "...", "severity": "high|medium|low"} '
                                "형태의 JSON 배열로만 반환해줘. 다른 설명은 포함하지 마."
                            ),
                        },
                    ],
                }
            ],
        )
    except anthropic.APIStatusError as e:
        print(f"API 오류: {e.message}")
        raise
 
    raw = response.content[0].text
    # 모델이 JSON 배열을 반환하도록 프롬프트를 지정했으므로 파싱 처리
    return json.loads(raw)
 
issues = analyze_ui_screenshot("screenshot_2576px.png")
for issue in issues:
    print(f"[{issue['severity'].upper()}] {issue['issue']} — {issue['location']}")

import Anthropic from "@anthropic-ai/sdk";
 
const client = new Anthropic();
 
interface AgentResult {
  role: string;
  output: string;
}
 
async function runParallelAgents(sourceCode: string): Promise<AgentResult[]> {
  const tasks = [
    { role: "code_reviewer", prompt: `코드 리뷰를 수행해줘:\n${sourceCode}` },
    { role: "doc_writer",    prompt: `JSDoc 주석을 생성해줘:\n${sourceCode}` },
    { role: "test_writer",   prompt: `Jest 테스트를 작성해줘:\n${sourceCode}` },
  ];
 
  const results: Anthropic.Message[] = await Promise.all(
    tasks.map(({ role, prompt }) =>
      client.messages.create({
        model: "claude-opus-4-7",
        max_tokens: 8192,
        system: `당신은 ${role} 전문가입니다.`,
        messages: [{ role: "user", content: prompt }],
      })
    )
  );
 
  return results.map((res, i) => {
    const firstBlock = res.content[0];
    return {
      role: tasks[i].role,
      output: firstBlock?.type === "text" ? firstBlock.text : "",
    };
  });
}