Mastering Claude’s API: A Practical Guide to Features, Tools, and Context Management

Claude’s API surface is organized into five key areas: model capabilities, tools, tool infrastructure, context management, and files and assets. Whether you’re building a simple chatbot or a complex agent, understanding these building blocks will help you get the most out of Claude.

This guide covers each area with practical advice and code examples. If you’re new, start with model capabilities and tools, then return to the other sections when you’re ready to optimize cost, latency, or scale.

---

1. Model Capabilities: Steering Claude’s Reasoning and Output

Model capabilities let you control how Claude thinks and what it produces. Key features include:

• Extended thinking – Claude can reason step-by-step before responding.
• Adaptive thinking – Claude dynamically decides when and how much to think (recommended for Opus 4.7).
• Structured outputs – Enforce JSON or other structured response formats.
• Citations – Ground responses in source documents with exact sentence references.
• Streaming – Receive tokens as they’re generated for low-latency UX.
• Batch processing – Send large volumes of requests asynchronously at 50% lower cost.

Example: Using Adaptive Thinking with the Effort Parameter

import anthropic
client = anthropic.Anthropic()
response = client.messages.create(
    model="claude-opus-4-20250514",
    max_tokens=1024,
    system="You are a helpful assistant that reasons carefully.",
    messages=[
        {"role": "user", "content": "Explain the difference between quantum and classical computing in simple terms."}
    ],
    thinking={
        "type": "enabled",
        "budget_tokens": 2048,
        "effort": "high"  # Options: "low", "medium", "high"
    }
)
print(response.content)

Feature Availability Quick Reference

Note: Features marked as Beta may have limited availability, require sign-up, or change without notice. Always check the Availability column in the official docs before building production workflows.

---

2. Tools: Letting Claude Act on the Web and in Your Environment

Tools extend Claude’s capabilities beyond text generation. You can give Claude access to:

• Web search – Fetch real-time information from the internet.
• Web fetch – Retrieve content from specific URLs.
• Code execution – Run Python or JavaScript in a sandbox.
• Computer use – Control a virtual desktop (beta).
• Memory – Store and recall information across sessions.
• Bash – Execute shell commands.
• Text editor – Read and write files.
• Advisor – Get guidance on complex tasks.

Example: Defining a Custom Tool and Handling Tool Calls

import anthropic
client = anthropic.Anthropic()
Define a simple weather tool
weather_tool = {
    "name": "get_weather",
    "description": "Get the current weather for a given city.",
    "input_schema": {
        "type": "object",
        "properties": {
            "city": {"type": "string", "description": "City name"}
        },
        "required": ["city"]
    }
}
response = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    tools=[weather_tool],
    messages=[
        {"role": "user", "content": "What's the weather in Tokyo?"}
    ]
)
Check if Claude wants to use a tool
if response.stop_reason == "tool_use":
    tool_call = response.content[-1]
    print(f"Tool requested: {tool_call.name}")
    print(f"Input: {tool_call.input}")
    # Here you would execute the tool and return the result

Tool Infrastructure: Discovery and Orchestration at Scale

When you have many tools, use tool search and fine-grained tool streaming to manage them efficiently. The Tool Runner (SDK) helps orchestrate complex tool chains, and strict tool use ensures Claude only calls tools you explicitly allow.

---

3. Context Management: Keeping Long Sessions Efficient

Claude supports context windows up to 1 million tokens, but managing that context is critical for cost and performance.

Key Features

• Context windows – Set the maximum tokens Claude can “see” in a conversation.
• Compaction – Summarize or prune older messages to stay within limits.
• Prompt caching – Cache repeated system prompts or large documents to reduce latency and cost.
• Token counting – Estimate token usage before sending a request.

Example: Using Prompt Caching

import anthropic
client = anthropic.Anthropic()
response = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    system=[
        {
            "type": "text",
            "text": "You are a customer support agent for Acme Corp.\n\nHere is our full product catalog...",
            "cache_control": {"type": "ephemeral"}
        }
    ],
    messages=[
        {"role": "user", "content": "Tell me about the Pro plan."}
    ]
)
Check caching status
print(f"Cache read tokens: {response.usage.cache_read_input_tokens}")
print(f"Cache creation tokens: {response.usage.cache_creation_input_tokens}")

Tip: Use prompt caching for static context like instructions, FAQs, or document corpora that you reuse across many requests.

---

4. Files and Assets: Working with Documents and Images

Claude can process a variety of file types, including:

• PDFs – Extract text and layout.
• Images – Analyze photos, diagrams, and screenshots.
• Code files – Understand and modify source code.
• Spreadsheets – Read CSV and Excel data.

Example: Sending a PDF for Analysis

import anthropic
import base64
client = anthropic.Anthropic()
with open("report.pdf", "rb") as f:
    pdf_data = base64.b64encode(f.read()).decode("utf-8")
response = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "document",
                    "source": {
                        "type": "base64",
                        "media_type": "application/pdf",
                        "data": pdf_data
                    }
                },
                {
                    "type": "text",
                    "text": "Summarize the key findings from this report."
                }
            ]
        }
    ]
)
print(response.content[0].text)

Citations: Grounding Responses in Source Documents

When you need verifiable outputs, enable Citations. Claude will return exact sentence references from your source documents.

response = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "document",
                    "source": {
                        "type": "text",
                        "media_type": "text/plain",
                        "data": "Claude was created by Anthropic. It launched in March 2023."
                    }
                },
                {
                    "type": "text",
                    "text": "When was Claude created?"
                }
            ]
        }
    ],
    citations=True
)
print(response.content[0].text)
Output includes citation markers like [1] referencing the source

---

5. Feature Lifecycle: Understanding Availability Classifications

Not all features are ready for production. The Claude Platform uses these classifications:

Always check the Availability column in the official docs before building a production system.

---

Key Takeaways

• Start with model capabilities and tools – they give you the most immediate control over Claude’s behavior.
• Use adaptive thinking and structured outputs to steer reasoning depth and response format reliably.
• Leverage prompt caching and context compaction to keep long-running sessions cost-effective and fast.
• Enable citations for document-grounded tasks to produce verifiable, trustworthy outputs.
• Check feature availability – Beta features can change without notice; use GA features for production workloads.

--- Ready to build? Dive into the Claude API Quickstart to start coding.