anthropic sdk
**Anthropic SDK** is the **official Python and TypeScript client library for the Claude API — providing type-safe access to Claude's text generation, vision, tool use, and extended context capabilities** — with synchronous, asynchronous, and streaming interfaces that make integrating Claude models into production applications straightforward and reliable.
**What Is the Anthropic SDK?**
- **Definition**: The official Python (`anthropic` package) and TypeScript/Node (`@anthropic-ai/sdk` package) client libraries maintained by Anthropic for accessing Claude models via their Messages API.
- **Messages API**: Claude uses a "Messages" format with alternating user and assistant turns — strictly enforced alternation ensures conversation coherence and prevents context confusion common in raw HTTP implementations.
- **Model Access**: Provides access to the full Claude model family — Claude 3.5 Sonnet (balanced speed/intelligence), Claude 3.5 Haiku (fast, cost-efficient), and Claude 3 Opus (most powerful reasoning) — with the same SDK interface across all models.
- **Vision Support**: Pass images directly in message content — `{"type": "image", "source": {"type": "base64", ...}}` — enabling document analysis, chart interpretation, and visual Q&A.
- **Tool Use**: Full function/tool calling support — define tools as JSON schemas, Claude decides when to call them, SDK returns structured tool call objects for your application to execute.
**Why the Anthropic SDK Matters**
- **Long Context Leader**: Claude models support up to 200K tokens context — the SDK handles the large payload sizes and response streaming required for processing entire books, codebases, or document collections.
- **Computer Use (Beta)**: Claude 3.5 Sonnet supports computer use — controlling a browser, terminal, and file system through the API — enabling autonomous agent workflows accessible through the same SDK.
- **Safety and Reliability**: Anthropic's Constitutional AI training produces models that refuse harmful requests more gracefully and hallucinate less on factual questions — enterprise teams choose Claude for safety-critical applications.
- **Extended Thinking**: Claude 3.7 Sonnet supports extended thinking mode — allocating additional compute to reason through complex problems before responding — accessible via the SDK with a `thinking` parameter.
- **OpenAI-Compatible Option**: Anthropic offers an OpenAI-compatible endpoint, allowing existing OpenAI SDK code to switch to Claude with minimal changes.
**Core Usage Patterns**
**Basic Message**:
```python
import anthropic
client = anthropic.Anthropic() # Uses ANTHROPIC_API_KEY env variable
message = client.messages.create(
model="claude-3-5-sonnet-20241022",
max_tokens=1024,
system="You are an expert semiconductor engineer.",
messages=[{"role": "user", "content": "Explain CMP in simple terms."}]
)
print(message.content[0].text)
```
**Streaming**:
```python
with client.messages.stream(model="claude-3-5-sonnet-20241022", max_tokens=1024, messages=[...]) as stream:
for text in stream.text_stream:
print(text, end="", flush=True)
```
**Vision (Image Input)**:
```python
import base64
image_data = base64.standard_b64encode(open("chart.png", "rb").read()).decode("utf-8")
message = client.messages.create(
model="claude-3-5-sonnet-20241022",
max_tokens=1024,
messages=[{"role": "user", "content": [
{"type": "image", "source": {"type": "base64", "media_type": "image/png", "data": image_data}},
{"type": "text", "text": "Describe this chart's key trends."}
]}]
)
```
**Tool Use**:
```python
tools = [{"name": "get_stock_price", "description": "Get current stock price", "input_schema": {
"type": "object", "properties": {"ticker": {"type": "string"}}, "required": ["ticker"]
}}]
response = client.messages.create(model="claude-3-5-sonnet-20241022", max_tokens=512,
tools=tools, messages=[{"role": "user", "content": "What's the NVDA stock price?"}])
# response.stop_reason == "tool_use" signals Claude wants to call the tool
```
**Async Client**:
```python
from anthropic import AsyncAnthropic
import asyncio
async_client = AsyncAnthropic()
async def process(text):
msg = await async_client.messages.create(
model="claude-3-5-haiku-20241022", max_tokens=256,
messages=[{"role": "user", "content": text}]
)
return msg.content[0].text
```
**Key SDK Features**
**Batch API**: Process up to 10,000 requests in a single batch — 50% cost reduction, results available within 24 hours, ideal for document processing pipelines.
**Prompt Caching**: Cache frequently used prompt prefixes (system prompts, document contexts) — cached tokens cost 90% less than standard input tokens, critical for high-volume applications with repeated context.
**Extended Context**: Claude's 200K token context supports passing entire codebases or documents in a single API call — the SDK handles chunked transfer encoding for large payloads automatically.
**Anthropic SDK vs OpenAI SDK**
| Aspect | Anthropic SDK | OpenAI SDK |
|--------|--------------|-----------|
| Context window | 200K tokens | 128K tokens (GPT-4o) |
| Computer use | Yes (beta) | No |
| Prompt caching | Yes (90% discount) | Yes (50% discount) |
| Vision | Yes | Yes |
| Fine-tuning | No | Yes |
| Models | Claude 3/3.5/3.7 family | GPT-4o, GPT-4, o1 |
The Anthropic SDK is **the gateway to Claude's industry-leading long-context reasoning, safety alignment, and computer use capabilities** — for applications requiring deep document analysis, reliable instruction following, or autonomous agent behavior, the SDK provides the clean, typed interface needed to integrate Claude into production systems at any scale.