# Anthropic Sdk

> Official guide for developing with the Anthropic SDK (@anthropic-ai/sdk on npm and anthropic on PyPI) and Claude Messages API. Use when implementing, upgrading, or debugging Anthropic API calls, Claude 3.7 Sonnet, Claude 3.5 Sonnet/Haiku, prompt caching, extended thinking, streaming, tool use/function calling, token counting, message batches, or multimodal processing.

- Skill: `matthewtaormina/anthropic-sdk` (Agent Skill, multi-file: 5 files)
- Install (CLI): `npx skillmds@latest add matthewtaormina/anthropic-sdk`
- Raw SKILL.md: https://api.skillmd.com/api/skills/matthewtaormina/anthropic-sdk/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: AI & ML
- Author: MatthewTaormina (https://skillmd.com/u/matthewtaormina)
- Updated: 2026-09-22
- Page: https://skillmd.com/skills/matthewtaormina/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](./references/models.md).**
> 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

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

# Python
pip install anthropic
```

### Client Initialization

#### TypeScript / JavaScript
```typescript
import Anthropic from '@anthropic-ai/sdk';

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

#### Python
```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](./references/models.md) for pricing per MTok, cache discount tiers, and deprecation notices.*

| Model | API Identifier | Context | Max Output | Best For |
| :--- | :--- | :--- | :--- | :--- |
| **Claude Fable 5.1** | `claude-fable-5-1` | 1,000,000 | 128,000 | Frontier multi-day agentic execution, heavy scientific research |
| **Claude Opus 5** | `claude-opus-5` | 1,000,000 | 128,000 | Enterprise workhorse, complex architecture, deep code synthesis |
| **Claude Sonnet 5** | `claude-sonnet-5` | 1,000,000 | 128,000 | Everyday workloads, optimal balance of intelligence and cost |
| **Claude Haiku 4.5** | `claude-haiku-4-5` | 200,000 | 64,000 | High-volume speed, lightweight agents, sub-second responses |
| **Claude 3.7 Sonnet**| `claude-3-7-sonnet-20250219` | 200,000 | 64,000 | Established hybrid reasoning baseline with extended thinking |

---

## 3. Core Implementation Patterns

### 3.1 Messages API & System Prompts

```typescript
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`)

```typescript
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)

```typescript
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**:

```typescript
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

```typescript
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)

```typescript
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**](./references/models.md)
* [Full API Reference Cheatsheet](./references/api-reference.md)
* [TypeScript Reference Implementation](./examples/typescript-examples.ts)
* [Python Reference Implementation](./examples/python-examples.py)