Anthropic Sdk

Anthropic SDK Skill

[!CRITICAL] MANDATORY DIRECTIVE: DEFER TO DOCUMENTED MODEL CATALOG DO NOT rely on internal training knowledge for Anthropic model selection, as previous generations (Claude 3.0/3.5) are legacy/superseded. ALWAYS consult the active model catalog: Anthropic Models Catalog. The current production standard is led by the Claude 5 & Claude 4.5 series (claude-fable-5-1, claude-opus-5, claude-sonnet-5, claude-haiku-4-5) alongside claude-3-7-sonnet-20250219.

This skill provides comprehensive patterns and best practices for developing with the official Anthropic SDKs (@anthropic-ai/sdk in TypeScript/Node.js and anthropic in Python) using the Messages API.

1. Quick Reference & Setup

Package Installation

# Node.js / TypeScript
npm install @anthropic-ai/sdk

# Python
pip install anthropic

Client Initialization

TypeScript / JavaScript

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

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

Python

from anthropic import Anthropic

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

2. Currently Available Models (September 2026)

See Full Models Catalog for pricing per MTok, cache discount tiers, and deprecation notices.

3. Core Implementation Patterns

3.1 Messages API & System Prompts

import Anthropic from '@anthropic-ai/sdk';
const anthropic = new Anthropic();

const response = await anthropic.messages.create({
  model: 'claude-sonnet-5',
  max_tokens: 1024,
  system: 'You are a staff distributed systems engineer. Be concise and prioritize reliability.',
  messages: [
    { role: 'user', content: 'What are the trade-offs of Raft vs Paxos?' },
  ],
});

const textBlock = response.content.find((b) => b.type === 'text');
console.log(textBlock?.text);

3.2 Real-time Streaming (client.messages.stream)

import Anthropic from '@anthropic-ai/sdk';
const anthropic = new Anthropic();

const stream = anthropic.messages.stream({
  model: 'claude-sonnet-5',
  max_tokens: 1024,
  messages: [{ role: 'user', content: 'Write a poem about memory safety in Rust.' }],
});

stream.on('text', (textDelta) => {
  process.stdout.write(textDelta);
});

const finalMessage = await stream.finalMessage();
console.log('\nUsage:', finalMessage.usage);

3.3 Prompt Caching (Up to 90% Cost Reduction & 85% Latency Drop)

import Anthropic from '@anthropic-ai/sdk';
const anthropic = new Anthropic();

const response = await anthropic.messages.create({
  model: 'claude-sonnet-5',
  max_tokens: 2048,
  system: [
    {
      type: 'text',
      text: '...Extensive multi-thousand-token system instructions, API documentation, or domain rules...',
      cache_control: { type: 'ephemeral' },
    },
  ],
  messages: [
    {
      role: 'user',
      content: 'How should I authenticate requests based on the API docs above?',
    },
  ],
});

console.log('Cache Creation Tokens:', response.usage.cache_creation_input_tokens);
console.log('Cache Read Tokens:', response.usage.cache_read_input_tokens);

3.4 Extended & Adaptive Thinking

Claude 5 models feature native Adaptive Thinking:

import Anthropic from '@anthropic-ai/sdk';
const anthropic = new Anthropic();

const response = await anthropic.messages.create({
  model: 'claude-opus-5',
  max_tokens: 16000,
  thinking: {
    type: 'adaptive',
  },
  messages: [
    {
      role: 'user',
      content: 'Design an ACID-compliant transaction log for an in-memory database with zero disk fsync stalls.',
    },
  ],
});

for (const block of response.content) {
  if (block.type === 'thinking') {
    console.log('--- THINKING PROCESS ---');
    console.log(block.thinking);
  } else if (block.type === 'text') {
    console.log('--- FINAL ANSWER ---');
    console.log(block.text);
  }
}

3.5 Tool Use & Multi-turn Execution Loop

import Anthropic from '@anthropic-ai/sdk';
const anthropic = new Anthropic();

const tools: Anthropic.Tool[] = [
  {
    name: 'lookupUser',
    description: 'Fetch user details by ID or email',
    input_schema: {
      type: 'object',
      properties: {
        userId: { type: 'string', description: 'Unique user UUID' },
      },
      required: ['userId'],
    },
  },
];

const messages: Anthropic.MessageParam[] = [
  { role: 'user', content: 'Look up the account for user id usr_9942.' },
];

const response = await anthropic.messages.create({
  model: 'claude-sonnet-5',
  max_tokens: 1024,
  tools,
  messages,
});

if (response.stop_reason === 'tool_use') {
  messages.push({ role: 'assistant', content: response.content });

  for (const block of response.content) {
    if (block.type === 'tool_use') {
      const toolId = block.id;
      const toolArgs = block.input as { userId: string };

      const resultData = { id: toolArgs.userId, name: 'Alice Chen', tier: 'Enterprise' };

      messages.push({
        role: 'user',
        content: [
          {
            type: 'tool_result',
            tool_use_id: toolId,
            content: JSON.stringify(resultData),
          },
        ],
      });
    }
  }

  const finalResponse = await anthropic.messages.create({
    model: 'claude-sonnet-5',
    max_tokens: 1024,
    tools,
    messages,
  });

  const finalBlock = finalResponse.content.find((b) => b.type === 'text');
  console.log('Final Answer:', finalBlock?.text);
}

3.6 Multimodal Processing (Images & Documents)

import Anthropic from '@anthropic-ai/sdk';
import * as fs from 'fs';

const anthropic = new Anthropic();

const imageBase64 = fs.readFileSync('diagram.png').toString('base64');

const response = await anthropic.messages.create({
  model: 'claude-sonnet-5',
  max_tokens: 1024,
  messages: [
    {
      role: 'user',
      content: [
        {
          type: 'image',
          source: {
            type: 'base64',
            media_type: 'image/png',
            data: imageBase64,
          },
        },
        {
          type: 'text',
          text: 'Analyze the architecture diagram and identify single points of failure.',
        },
      ],
    },
  ],
});

4. References and Examples

• Active Models Catalog
• Full API Reference Cheatsheet
• TypeScript Reference Implementation
• Python Reference Implementation