Claude API実践ガイド2026：Messages API・ツール使用・ストリーミングの完全実装

# .env
ANTHROPIC_API_KEY=sk-ant-xxxxxxxxxxxx

# @anthropic-ai/[email protected]
pnpm add @anthropic-ai/sdk

// @anthropic-ai/[email protected]
import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic({
  apiKey: process.env.ANTHROPIC_API_KEY, // 省略時は環境変数から自動読み込み
});

# [email protected]
pip install anthropic==0.109.1

# [email protected]
import anthropic
import os

client = anthropic.Anthropic(
    api_key=os.environ.get("ANTHROPIC_API_KEY"),
)

// @anthropic-ai/[email protected]
import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic();

const message = await client.messages.create({
  model: "claude-opus-4-8",
  max_tokens: 1024,
  messages: [
    {
      role: "user",
      content: "TypeScriptでフィボナッチ数列を実装してください。",
    },
  ],
});

console.log(message.content[0].type === "text" ? message.content[0].text : "");

# [email protected]
import anthropic

client = anthropic.Anthropic()

message = client.messages.create(
    model="claude-opus-4-8",
    max_tokens=1024,
    messages=[
        {
            "role": "user",
            "content": "Pythonでフィボナッチ数列を実装してください。",
        }
    ],
)

print(message.content[0].text)

// @anthropic-ai/[email protected]
const message = await client.messages.create({
  model: "claude-opus-4-8",
  max_tokens: 1024,
  system: "あなたは日本語のみで回答するエキスパートエンジニアです。",
  messages: [{ role: "user", content: "Reactのベストプラクティスを教えてください。" }],
});

// @anthropic-ai/[email protected]
// トークン数を事前確認する
const tokenCount = await client.messages.countTokens({
  model: "claude-opus-4-8",
  messages: [{ role: "user", content: longDocument }],
});
console.log(`入力トークン数: ${tokenCount.input_tokens}`);

// @anthropic-ai/[email protected]
const tools: Anthropic.Tool[] = [
  {
    name: "get_weather",
    description: "指定した都市の現在の天気を取得します。",
    input_schema: {
      type: "object",
      properties: {
        city: {
          type: "string",
          description: "天気を取得する都市名（例: Tokyo）",
        },
        unit: {
          type: "string",
          enum: ["celsius", "fahrenheit"],
          description: "温度の単位",
        },
      },
      required: ["city"],
    },
  },
];

# [email protected]
tools = [
    {
        "name": "get_weather",
        "description": "指定した都市の現在の天気を取得します。",
        "input_schema": {
            "type": "object",
            "properties": {
                "city": {
                    "type": "string",
                    "description": "天気を取得する都市名（例: Tokyo）",
                },
                "unit": {
                    "type": "string",
                    "enum": ["celsius", "fahrenheit"],
                    "description": "温度の単位",
                },
            },
            "required": ["city"],
        },
    }
]

// @anthropic-ai/[email protected]
async function runWithTools(userMessage: string): Promise<string> {
  const messages: Anthropic.MessageParam[] = [
    { role: "user", content: userMessage },
  ];

  while (true) {
    const response = await client.messages.create({
      model: "claude-opus-4-8",
      max_tokens: 1024,
      tools,
      messages,
    });

    if (response.stop_reason === "end_turn") {
      const textBlock = response.content.find((b) => b.type === "text");
      return textBlock?.type === "text" ? textBlock.text : "";
    }

    if (response.stop_reason !== "tool_use") break;

    // アシスタントの応答を履歴に追加
    messages.push({ role: "assistant", content: response.content });

    // ツールを実行して結果を収集
    const toolResults: Anthropic.ToolResultBlockParam[] = [];
    for (const block of response.content) {
      if (block.type !== "tool_use") continue;
      const result = await executeToolCall(block.name, block.input);
      toolResults.push({
        type: "tool_result",
        tool_use_id: block.id,
        content: JSON.stringify(result),
      });
    }

    // ツール結果をユーザーメッセージとして追加
    messages.push({ role: "user", content: toolResults });
  }

  return "";
}

// ツール実行の実装例
async function executeToolCall(name: string, input: unknown): Promise<unknown> {
  if (name === "get_weather") {
    const { city } = input as { city: string };
    // 実際のAPI呼び出しに置き換える
    return { city, temperature: 22, condition: "晴れ" };
  }
  throw new Error(`未知のツール: ${name}`);
}

// @anthropic-ai/[email protected]
const toolUseBlocks = response.content.filter((b) => b.type === "tool_use");

// Promise.allで並列実行
const toolResults = await Promise.all(
  toolUseBlocks.map(async (block) => {
    if (block.type !== "tool_use") return null;
    const result = await executeToolCall(block.name, block.input);
    return {
      type: "tool_result" as const,
      tool_use_id: block.id,
      content: JSON.stringify(result),
    };
  })
);

// @anthropic-ai/[email protected]
const stream = await client.messages.stream({
  model: "claude-opus-4-8",
  max_tokens: 1024,
  messages: [{ role: "user", content: "Rustの所有権を説明してください。" }],
});

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

const finalMessage = await stream.finalMessage();
console.log(`\n完了 - 出力トークン: ${finalMessage.usage.output_tokens}`);

# [email protected]
import anthropic

client = anthropic.Anthropic()

with client.messages.stream(
    model="claude-opus-4-8",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Rustの所有権を説明してください。"}],
) as stream:
    for text in stream.text_stream:
        print(text, end="", flush=True)

final_message = stream.get_final_message()
print(f"\n完了 - 出力トークン: {final_message.usage.output_tokens}")

// @anthropic-ai/[email protected]
const stream = await client.messages.stream({
  model: "claude-opus-4-8",
  max_tokens: 1024,
  tools,
  messages: [{ role: "user", content: "東京の天気を教えてください。" }],
});

for await (const chunk of stream) {
  switch (chunk.type) {
    case "content_block_delta":
      if (chunk.delta.type === "text_delta") {
        process.stdout.write(chunk.delta.text);
      }
      break;
    case "message_stop":
      console.log("\nストリーム完了");
      break;
  }
}

// @anthropic-ai/[email protected]
const conversationHistory: Anthropic.MessageParam[] = [];

async function chat(userInput: string): Promise<string> {
  conversationHistory.push({ role: "user", content: userInput });

  const response = await client.messages.create({
    model: "claude-opus-4-8",
    max_tokens: 1024,
    messages: conversationHistory,
  });

  const assistantText =
    response.content[0].type === "text" ? response.content[0].text : "";

  conversationHistory.push({ role: "assistant", content: assistantText });

  return assistantText;
}

// @anthropic-ai/[email protected]
const MAX_HISTORY_TURNS = 20; // 直近20ターンのみ保持

function trimHistory(
  history: Anthropic.MessageParam[]
): Anthropic.MessageParam[] {
  if (history.length <= MAX_HISTORY_TURNS * 2) return history;
  // user/assistantのペアを保持するため偶数でスライス
  return history.slice(-MAX_HISTORY_TURNS * 2);
}

// @anthropic-ai/[email protected]
const largeSystemPrompt = `
あなたは詳細なドキュメントを持つ専門家アシスタントです。
[...数千トークンのコンテキスト...]
`;

const response = await client.messages.create({
  model: "claude-opus-4-8",
  max_tokens: 1024,
  system: [
    {
      type: "text",
      text: largeSystemPrompt,
      cache_control: { type: "ephemeral", ttl: "1h" }, // 1時間キャッシュ
    },
  ],
  messages: [{ role: "user", content: "このドキュメントを要約してください。" }],
});

# [email protected]
response = client.messages.create(
    model="claude-opus-4-8",
    max_tokens=1024,
    system=[
        {
            "type": "text",
            "text": large_system_prompt,
            "cache_control": {"type": "ephemeral", "ttl": "1h"},
        }
    ],
    messages=[{"role": "user", "content": "このドキュメントを要約してください。"}],
)

// @anthropic-ai/[email protected]
console.log("キャッシュ書き込みトークン:", response.usage.cache_creation_input_tokens);
console.log("キャッシュ読み取りトークン:", response.usage.cache_read_input_tokens);
console.log("通常入力トークン:", response.usage.input_tokens);

// @anthropic-ai/[email protected]
import Anthropic from "@anthropic-ai/sdk";

const RETRYABLE_STATUS_CODES = new Set([429, 500, 529]);
const MAX_RETRIES = 5;
const BASE_DELAY_MS = 1000;

async function createMessageWithRetry(
  params: Anthropic.MessageCreateParamsNonStreaming
): Promise<Anthropic.Message> {
  for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
    try {
      return await client.messages.create(params);
    } catch (error) {
      if (!(error instanceof Anthropic.APIError)) throw error;
      if (!RETRYABLE_STATUS_CODES.has(error.status)) throw error;
      if (attempt === MAX_RETRIES - 1) throw error;

      const delay = BASE_DELAY_MS * Math.pow(2, attempt);
      const jitter = Math.random() * delay * 0.1;
      console.warn(`リトライ ${attempt + 1}/${MAX_RETRIES} - ${delay + jitter}ms後`);
      await new Promise((resolve) => setTimeout(resolve, delay + jitter));
    }
  }
  throw new Error("最大リトライ回数を超えました");
}

# [email protected]
import time
import random
import anthropic

RETRYABLE_STATUS_CODES = {429, 500, 529}
MAX_RETRIES = 5
BASE_DELAY = 1.0


def create_message_with_retry(client: anthropic.Anthropic, **kwargs) -> anthropic.types.Message:
    for attempt in range(MAX_RETRIES):
        try:
            return client.messages.create(**kwargs)
        except anthropic.APIStatusError as e:
            if e.status_code not in RETRYABLE_STATUS_CODES:
                raise
            if attempt == MAX_RETRIES - 1:
                raise

            delay = BASE_DELAY * (2 ** attempt)
            jitter = random.uniform(0, delay * 0.1)
            print(f"リトライ {attempt + 1}/{MAX_RETRIES} - {delay + jitter:.1f}秒後")
            time.sleep(delay + jitter)

    raise RuntimeError("最大リトライ回数を超えました")

// @anthropic-ai/[email protected]
const client = new Anthropic({
  timeout: 60_000, // 60秒タイムアウト
  maxRetries: 3,
});

# [email protected]
client = anthropic.Anthropic(
    timeout=60.0,  # 60秒タイムアウト
    max_retries=3,
)