Anthropic Claude SDK - Quick Reference

When to Use

Load this skill when:

• anthropic package in requirements.txt or pyproject.toml
• @anthropic-ai/sdk in package.json dependencies
• ANTHROPIC_API_KEY environment variable present
• User mentions "Anthropic", "Claude", or Claude models

For detailed patterns: See REFERENCE.md

Table of Contents

1. Claude Models
2. Quick Start
3. Messages API Essentials
4. Streaming
5. Tool Use (Function Calling)
6. Extended Thinking
7. Vision
8. Prompt Caching
9. Error Handling
10. Platform Features
11. Further Reading

Claude Models (January 2026)

Model Selection

Simple chat/Q&A           -> claude-3-5-haiku (cheapest)
Standard tasks            -> claude-3-5-sonnet
Complex reasoning/coding  -> claude-sonnet-4 or claude-opus-4-5
Extended thinking needed  -> claude-sonnet-4 or claude-opus-4-5
Batch processing          -> Any model (50% cost savings)

Pricing (per 1M tokens)

Quick Start

Python

from anthropic import Anthropic

client = Anthropic()  # Uses ANTHROPIC_API_KEY env var

message = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Hello, Claude!"}]
)
print(message.content[0].text)

TypeScript

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

const client = new Anthropic();

const message = await client.messages.create({
  model: 'claude-sonnet-4-20250514',
  max_tokens: 1024,
  messages: [{ role: 'user', content: 'Hello, Claude!' }]
});
console.log(message.content[0].text);

Async Python

import asyncio
from anthropic import AsyncAnthropic

async def main():
    client = AsyncAnthropic()
    message = await client.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=1024,
        messages=[{"role": "user", "content": "Hello!"}]
    )
    print(message.content[0].text)

asyncio.run(main())

Messages API Essentials

With System Prompt

message = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    system="You are a helpful coding assistant. Be concise.",
    messages=[{"role": "user", "content": "Explain async/await."}]
)

Multi-Turn Conversation

messages = [
    {"role": "user", "content": "What is Python?"},
    {"role": "assistant", "content": "Python is a programming language..."},
    {"role": "user", "content": "How do I install it?"}
]

response = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    messages=messages
)

Common Parameters

Streaming

Basic Streaming

with client.messages.stream(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Write a story."}]
) as stream:
    for text in stream.text_stream:
        print(text, end="", flush=True)

Async Streaming

async with client.messages.stream(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    messages=[{"role": "user", "content": prompt}]
) as stream:
    async for text in stream.text_stream:
        print(text, end="", flush=True)

Tool Use (Function Calling)

Define Tools

tools = [{
    "name": "get_weather",
    "description": "Get weather for a location",
    "input_schema": {
        "type": "object",
        "properties": {
            "location": {"type": "string", "description": "City, e.g., San Francisco"}
        },
        "required": ["location"]
    }
}]

Tool Use Loop

def process_with_tools(user_message: str) -> str:
    messages = [{"role": "user", "content": user_message}]

    while True:
        response = client.messages.create(
            model="claude-sonnet-4-20250514",
            max_tokens=1024,
            tools=tools,
            messages=messages
        )

        if response.stop_reason == "end_turn":
            return response.content[0].text

        # Process tool calls
        tool_results = []
        for block in response.content:
            if block.type == "tool_use":
                result = execute_tool(block.name, block.input)
                tool_results.append({
                    "type": "tool_result",
                    "tool_use_id": block.id,
                    "content": json.dumps(result)
                })

        messages.append({"role": "assistant", "content": response.content})
        messages.append({"role": "user", "content": tool_results})

Extended Thinking

For complex reasoning tasks (Claude 4 models only):

response = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=16000,
    thinking={
        "type": "enabled",
        "budget_tokens": 10000  # Tokens allocated for thinking
    },
    messages=[{"role": "user", "content": "Solve this complex problem..."}]
)

for block in response.content:
    if block.type == "thinking":
        print("Thinking:", block.thinking)
    elif block.type == "text":
        print("Response:", block.text)

Budget Guidelines

Vision

Image from Base64

import base64

with open("image.jpg", "rb") as f:
    image_data = base64.standard_b64encode(f.read()).decode()

message = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    messages=[{
        "role": "user",
        "content": [
            {"type": "image", "source": {
                "type": "base64",
                "media_type": "image/jpeg",
                "data": image_data
            }},
            {"type": "text", "text": "Describe this image."}
        ]
    }]
)

Supported Types

• Images: image/jpeg, image/png, image/gif, image/webp
• Documents: application/pdf

Prompt Caching

90% cost savings for repeated content (>1024 tokens):

message = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    system=[{
        "type": "text",
        "text": long_system_prompt,
        "cache_control": {"type": "ephemeral"}
    }],
    messages=[{"role": "user", "content": "Question"}]
)

# Check cache usage
print(f"Cache read: {message.usage.cache_read_input_tokens}")

Error Handling

from anthropic import (
    Anthropic, RateLimitError, AuthenticationError, APIConnectionError
)
import time

def safe_message(messages, max_retries=3):
    for attempt in range(max_retries):
        try:
            return client.messages.create(
                model="claude-sonnet-4-20250514",
                max_tokens=1024,
                messages=messages
            )
        except AuthenticationError:
            raise  # Don't retry auth errors
        except RateLimitError:
            if attempt < max_retries - 1:
                time.sleep(2 ** attempt)
        except APIConnectionError:
            if attempt < max_retries - 1:
                time.sleep(1)
    return None

Platform Features

Further Reading

• REFERENCE.md: Full API reference, advanced patterns
• templates/: Code generation templates
• examples/: Production-ready examples
• Official Docs: https://docs.anthropic.com/