anthropic-python · git:20260315.e77955e · 2026-03-15 · sha256 fc6ba5d810788633
anthropic-python git:20260315.e77955eA
Immutable. This exact content never changes and is served at /api/v1/blob/fc6ba5d810788633.
No tool to install first
claude plugin marketplace add https://markdownregistry.com/mp/a/art_xax6twxmu3plklip/fc6ba5d810788633f65762592c8d7c48c9b4c6f2b03a88c694cdad7195c6565c.json
Then /plugin install mdr-anthropic-python@markdownregistry-xax6twxmu3plklip in Claude Code. It installs this exact version, the one graded A here, pinned to the commit it was graded at, and leaves it there.
---
name: anthropic-python
description: |
Anthropic Python SDK for Claude API integration. Covers messages API,
streaming, tool use, vision, error handling, and best practices.
Use when building Python applications that call the Claude API.
USE WHEN: user mentions "anthropic", "claude api", "anthropic sdk",
"anthropic.Anthropic()", "client.messages.create", "claude-opus",
"claude-sonnet", "tool_use", "streaming claude", "claude python"
DO NOT USE FOR: OpenAI API, other LLM providers, JavaScript/TypeScript Anthropic SDK
allowed-tools: Read, Grep, Glob, Write, Edit
---
# Anthropic Python SDK
## Installation
```bash
pip install anthropic>=0.25.0
```
## Basic Usage
```python
import anthropic
client = anthropic.Anthropic() # reads ANTHROPIC_API_KEY from env
message = client.messages.create(
model="claude-opus-4-6",
max_tokens=1024,
messages=[
{"role": "user", "content": "Analyze this tag list and identify patterns."}
]
)
print(message.content[0].text)
```
## Model Selection
| Model | ID | Best For |
|-------|-----|---------|
| Claude Opus 4.6 | `claude-opus-4-6` | Complex analysis, expert reasoning |
| Claude Sonnet 4.6 | `claude-sonnet-4-6` | Balanced performance/cost |
| Claude Haiku 4.5 | `claude-haiku-4-5-20251001` | Fast, lightweight tasks |
## System Prompts
```python
message = client.messages.create(
model="claude-sonnet-4-6",
max_tokens=2048,
system="You are an industrial automation expert specializing in DCS engineering.",
messages=[
{"role": "user", "content": "Review this motor tag list for ISA-5.1 compliance."}
]
)
```
## Multi-Turn Conversations
```python
def chat(client: anthropic.Anthropic, history: list, user_message: str) -> tuple[str, list]:
history.append({"role": "user", "content": user_message})
response = client.messages.create(
model="claude-sonnet-4-6",
max_tokens=1024,
messages=history,
)
assistant_text = response.content[0].text
history.append({"role": "assistant", "content": assistant_text})
return assistant_text, history
```
## Streaming
```python
with client.messages.stream(
model="claude-sonnet-4-6",
max_tokens=1024,
messages=[{"role": "user", "content": "Generate a motor PRT template."}],
) as stream:
for text in stream.text_stream:
print(text, end="", flush=True)
# Or get final message after stream
with client.messages.stream(...) as stream:
message = stream.get_final_message()
```
## Tool Use (Function Calling)
```python
tools = [
{
"name": "validate_tag",
"description": "Validate an ISA-5.1 tag name and return structured info",
"input_schema": {
"type": "object",
"properties": {
"tag": {"type": "string", "description": "The tag name to validate"},
"area": {"type": "integer", "description": "Expected area code"},
},
"required": ["tag"],
},
}
]
response = client.messages.create(
model="claude-sonnet-4-6",
max_tokens=1024,
tools=tools,
messages=[{"role": "user", "content": "Validate tag 11301.FIC.056A for area 11301"}],
)
# Process tool calls
if response.stop_reason == "tool_use":
for block in response.content:
if block.type == "tool_use":
tool_name = block.name
tool_input = block.input
result = handle_tool(tool_name, tool_input)
```
## Vision (Image Input)
```python
import base64
from pathlib import Path
def encode_image(path: str) -> str:
return base64.standard_b64encode(Path(path).read_bytes()).decode("utf-8")
response = client.messages.create(
model="claude-opus-4-6",
max_tokens=1024,
messages=[
{
"role": "user",
"content": [
{
"type": "image",
"source": {
"type": "base64",
"media_type": "image/png",
"data": encode_image("p&id_diagram.png"),
},
},
{"type": "text", "text": "Identify all motor symbols and extract their tag names."},
],
}
],
)
```
## Error Handling
```python
from anthropic import APIError, APIConnectionError, RateLimitError, APIStatusError
def safe_claude_call(client: anthropic.Anthropic, prompt: str) -> str | None:
try:
message = client.messages.create(
model="claude-sonnet-4-6",
max_tokens=1024,
messages=[{"role": "user", "content": prompt}],
)
return message.content[0].text
except RateLimitError:
# Exponential backoff
import time
time.sleep(60)
return None
except APIConnectionError as e:
print(f"Connection error: {e}")
return None
except APIStatusError as e:
print(f"API error {e.status_code}: {e.message}")
return None
```
## Async Client
```python
import asyncio
import anthropic
async def analyze_batch(prompts: list[str]) -> list[str]:
client = anthropic.AsyncAnthropic()
async def call(prompt: str) -> str:
msg = await client.messages.create(
model="claude-haiku-4-5-20251001",
max_tokens=512,
messages=[{"role": "user", "content": prompt}],
)
return msg.content[0].text
return await asyncio.gather(*[call(p) for p in prompts])
```
## Usage Tracking
```python
response = client.messages.create(...)
print(response.usage.input_tokens) # tokens sent
print(response.usage.output_tokens) # tokens received
# Total cost = input_tokens * price_in + output_tokens * price_out
```
## Integration with Streamlit
```python
import streamlit as st
import anthropic
@st.cache_resource
def get_anthropic_client() -> anthropic.Anthropic:
return anthropic.Anthropic(api_key=st.secrets["anthropic"]["api_key"])
def stream_to_streamlit(prompt: str) -> str:
client = get_anthropic_client()
response_placeholder = st.empty()
full_text = ""
with client.messages.stream(
model="claude-sonnet-4-6",
max_tokens=2048,
messages=[{"role": "user", "content": prompt}],
) as stream:
for text in stream.text_stream:
full_text += text
response_placeholder.markdown(full_text + "▌")
response_placeholder.markdown(full_text)
return full_text
```
## Best Practices
| Practice | Why |
|----------|-----|
| Use `@st.cache_resource` for client | Avoid creating new client per request |
| Store API key in secrets.toml / env | Never hardcode keys |
| Set `max_tokens` explicitly | Avoid runaway costs |
| Use Haiku for classification/routing | 10x cheaper than Sonnet |
| Use Opus for complex analysis | Best reasoning quality |
| Stream long responses | Better UX, fail faster |
| Handle `RateLimitError` with backoff | API has rate limits |
| Track usage per request | Cost monitoring |