Anthropic API Guide: Claude Integration From Authentication to Prompt Caching

pnpm add @anthropic-ai/sdk

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

const client = new Anthropic({
  apiKey: process.env.ANTHROPIC_API_KEY,
});

const response = await client.messages.create({
  model: "claude-3-5-sonnet-20241022",
  max_tokens: 1024,
  system: "You are a helpful assistant.",
  messages: [
    { role: "user", content: "What is the capital of France?" }
  ],
});

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

const messages = [
  { role: "user", content: "What is React?" },
  { role: "assistant", content: "React is a JavaScript library..." },
  { role: "user", content: "How does it differ from Vue?" },
];

const response = await client.messages.create({
  model: "claude-3-5-sonnet-20241022",
  max_tokens: 1024,
  messages,
});

const stream = client.messages.stream({
  model: "claude-3-5-sonnet-20241022",
  max_tokens: 1024,
  messages: [{ role: "user", content: "Write a haiku about TypeScript." }],
});

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

const finalMessage = await stream.finalMessage();

const tools = [
  {
    name: "get_weather",
    description: "Get the current weather for a location",
    input_schema: {
      type: "object" as const,
      properties: {
        location: { type: "string", description: "City name" },
      },
      required: ["location"],
    },
  },
];

// First request
const response = await client.messages.create({
  model: "claude-3-5-sonnet-20241022",
  max_tokens: 1024,
  tools,
  messages: [{ role: "user", content: "What is the weather in Tokyo?" }],
});

// Check if model wants to use a tool
if (response.stop_reason === "tool_use") {
  const toolUseBlock = response.content.find((b) => b.type === "tool_use");
  if (toolUseBlock && toolUseBlock.type === "tool_use") {
    const toolResult = await executeWeatherTool(toolUseBlock.input);

    // Second request with tool result
    const finalResponse = await client.messages.create({
      model: "claude-3-5-sonnet-20241022",
      max_tokens: 1024,
      tools,
      messages: [
        { role: "user", content: "What is the weather in Tokyo?" },
        { role: "assistant", content: response.content },
        {
          role: "user",
          content: [
            {
              type: "tool_result",
              tool_use_id: toolUseBlock.id,
              content: JSON.stringify(toolResult),
            },
          ],
        },
      ],
    });
  }
}

const response = await client.messages.create({
  model: "claude-3-5-sonnet-20241022",
  max_tokens: 1024,
  system: [
    {
      type: "text",
      text: "You are an expert coding assistant. Here is the full API documentation:
" +
        longDocumentationString,  // potentially thousands of tokens
      cache_control: { type: "ephemeral" },
    },
  ],
  messages: [{ role: "user", content: userQuestion }],
});

const { input_tokens } = await client.messages.countTokens({
  model: "claude-3-5-sonnet-20241022",
  system: "You are a helpful assistant.",
  messages: [{ role: "user", content: "Hello" }],
});

console.log(`This request will use ${input_tokens} input tokens`);

const batch = await client.messages.batches.create({
  requests: documents.map((doc, i) => ({
    custom_id: `doc-${i}`,
    params: {
      model: "claude-3-5-sonnet-20241022",
      max_tokens: 1024,
      messages: [{ role: "user", content: `Summarize: ${doc}` }],
    },
  })),
});

// Poll for completion
let completed = false;
while (!completed) {
  const status = await client.messages.batches.retrieve(batch.id);
  if (status.processing_status === "ended") {
    completed = true;
  }
  await new Promise((r) => setTimeout(r, 30000));  // check every 30s
}

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

try {
  const response = await client.messages.create({ /* ... */ });
} catch (error) {
  if (error instanceof Anthropic.APIError) {
    switch (error.status) {
      case 400:
        // Validation error  -  malformed request, invalid parameters
        console.error("Bad request:", error.message);
        break;
      case 429:
        // Rate limit  -  back off and retry
        const retryAfter = error.headers?.["retry-after"];
        await new Promise((r) => setTimeout(r, Number(retryAfter) * 1000));
        break;
      case 529:
        // API overloaded  -  retry with exponential backoff
        await new Promise((r) => setTimeout(r, 5000));
        break;
      case 500:
        // Server error  -  retry
        break;
    }
  }
}