Anthropic Expert

Overview

anthropic-expert provides comprehensive expertise on all Anthropic products, features, and integrations. It covers 6 major product areas with complete documentation, 100+ features, code examples, and cross-product integration patterns.

Purpose: One-stop knowledge base for all Anthropic products and capabilities

Coverage (100% of Anthropic ecosystem):

• 6 Products: Claude Models, Claude API, Python SDK, Agent SDK, Claude Code, MCP
• 100+ Features: All API features, SDK capabilities, Agent concepts, Claude Code topics
• 44 Claude Code Topics: Complete CLI documentation
• All SDKs: Python + TypeScript SDKs for API and Agent development
• All Tools: 10+ built-in tools + custom tool creation
• Administration: Workspaces, usage tracking, costs, security, compliance

What's Included:

• Complete feature documentation with examples
• Code snippets for all major features (50+ examples)
• Cross-product integration patterns
• Best practices from official docs
• Searchable references (search-docs.py)
• Update tracking (maintained by anthropic-docs-updater)

The 6 Capabilities

Capability 1: Claude Models & API Expertise

What It Covers:

• All Claude models (Sonnet 4.5, Opus 4.1, Haiku 4.5, legacy models)
• Complete Messages API (endpoints, parameters, streaming)
• All API features: Prompt Caching, Extended Thinking, Citations, Memory, Vision, PDF, Context Editing
• Tools ecosystem: Bash, Code execution, Computer use, Web search, MCP connector, Memory tool
• Files API: Upload, manage, reference documents
• Skills API: Anthropic-managed skills (Office suite) + custom skills
• Message Batches: Async processing with 50% cost reduction
• Admin API: Organization, workspaces, members, API keys, usage, costs

When to Use This Capability:

• Building applications with Claude API
• Implementing API features (streaming, caching, tool use)
• Using advanced features (Extended Thinking, Citations, Memory)
• Processing images or PDFs
• Managing costs and usage
• Building RAG applications
• Integrating external tools

Quick Navigation:

• Models overview: See references/claude-api-complete.md - Models section
• Streaming: See references/claude-api-complete.md - Streaming section
• Prompt Caching: See references/claude-api-complete.md - Prompt Caching section
• Tools: See references/claude-api-complete.md - Tools section
• Admin API: See references/claude-api-complete.md - Admin API section

Key Features Quick Reference:

Capability 2: Python SDK Usage

What It Covers:

• Installation and setup (pip install anthropic)
• Sync client usage (basic patterns)
• Async client usage (asyncio integration)
• Streaming responses (server-sent events)
• Tool use integration (function calling)
• Prompt caching SDK integration
• Batch processing (async requests)
• File management (Files API via SDK)
• Error handling (exceptions, retries, timeouts)
• Configuration (API keys, settings)
• Type safety (typing support)
• 30+ code examples

When to Use This Capability:

• Python application development
• Integrating Claude into Python projects
• Async/await patterns needed
• Type-safe Claude integration
• Production Python applications

Quick Navigation:

• Installation: references/python-sdk-reference.md - Installation section
• Basic usage: references/python-sdk-reference.md - Basic Usage
• Streaming: references/python-sdk-reference.md - Streaming section
• Tool use: references/python-sdk-reference.md - Tool Use section

Quick Start Example:

import anthropic

# Initialize client
client = anthropic.Anthropic(api_key="your_api_key")

# Create message
message = client.messages.create(
    model="claude-sonnet-4-5-20250929",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Hello, Claude!"}]
)

print(message.content)

Capability 3: Agent SDK Expertise

What It Covers:

• Agent SDK overview (Python + TypeScript)
• Installation (claude-agent-sdk)
• Agents (creation, configuration, deployment)
• Subagents (.claude/agents/, composition patterns)
• Agent Skills (.claude/skills/, reusable capabilities)
• Tools (built-in ecosystem + custom tool creation)
• Sessions (multi-turn conversations, state management)
• Permissions (fine-grained access control)
• Streaming modes (single vs streaming)
• Hooks (.claude/settings.json, event-driven automation)
• Slash Commands (built-in + custom commands)
• Plugins (programmable extensions, Beta)
• System prompts (agent instructions)
• MCP integration (protocol support in agents)
• Cost tracking (expense monitoring)
• Hosting (deployment patterns)
• Use cases (coding agents, business agents)
• 25+ code examples

When to Use This Capability:

• Building AI agents
• Creating autonomous systems
• Agent composition (subagents)
• Reusable agent capabilities (skills)
• Production agent deployment
• Custom tool integration
• Session-based applications

Quick Navigation:

• Agents: references/agent-sdk-complete.md - Agents section
• Subagents: references/agent-sdk-complete.md - Subagents section
• Skills: references/agent-sdk-complete.md - Agent Skills section
• Tools: references/agent-sdk-complete.md - Tools section
• Deployment: references/agent-sdk-complete.md - Hosting section

Key Concepts:

Capability 4: Claude Code Mastery

What It Covers (All 44 Documentation Pages):

GETTING STARTED:

• Overview (capabilities, Unix philosophy)
• Quickstart (8-step setup guide)
• Common Workflows (codebase analysis, debugging, refactoring, testing, git integration)
• Claude Code on the Web (cloud execution)

BUILD WITH CLAUDE CODE:

• Sub-agents (specialized AI agents for delegated tasks)
• Plugins (extending functionality with custom code)
• Skills (creating reusable agent capabilities)
• Output Styles (customizing response formatting)
• Hooks Guide (event-driven automation and validation)
• Headless (API-based integration without terminal UI)
• GitHub Actions (CI/CD workflow automation)

DEPLOYMENT & CI/CD:

• GitLab CI/CD (pipeline integration)
• MCP (Model Context Protocol server setup)
• Migration Guide (version upgrade instructions)
• Troubleshooting (common issues and solutions)
• Third-party Integrations (enterprise provider strategies)
• Amazon Bedrock (AWS model access)
• Google Vertex AI (GCP model setup)
• Network Config (proxy, certificate management)

ADMINISTRATION:

• LLM Gateway (LiteLLM routing configuration)
• DevContainer (containerized development)
• Sandboxing (security isolation)
• Setup (cross-platform installation)
• IAM (authentication and permissions)
• Security (threat protection, best practices)
• Data Usage (privacy policies, telemetry)
• Monitoring Usage (metrics collection)
• Costs (expense tracking and optimization)

CONFIGURATION:

• Analytics (team usage metrics)
• Plugin Marketplaces (distributing and discovering plugins)
• Settings (configuration files and precedence)
• VS Code (extension setup)
• JetBrains (IntelliJ-based IDE plugin)
• Terminal Config (shell customization)
• Model Config (model selection and caching)
• Memory (persistent context management)

REFERENCE:

• Statusline (custom status line creation)
• CLI Reference (command syntax and flags)
• Interactive Mode (keyboard shortcuts, editing)
• Slash Commands (built-in and custom commands)
• Checkpointing (session state management)
• Hooks (advanced hook configuration)

ADDITIONAL:

• Plugins Reference (plugin schema and structure)
• Legal and Compliance (licensing, BAA)

When to Use This Capability:

• Developing with Claude Code CLI
• Creating custom skills
• Building sub-agents
• Developing plugins
• CI/CD integration
• Enterprise deployment
• Configuring Claude Code
• Troubleshooting issues

Quick Navigation:

• All topics: references/claude-code-reference.md (organized by category)
• Specific feature: Use search: python scripts/search-docs.py "hooks"

Capability 5: MCP Integration

What It Covers:

• Model Context Protocol specification
• MCP server development (creating custom servers)
• MCP client integration (connecting to servers)
• Tool creation (building MCP tools)
• Security best practices (securing MCP integrations)
• Integration across products (API MCP connector, Agent SDK MCP, Claude Code MCP)
• Common MCP servers (Slack, GitHub, Google Drive, Jira, Asana)
• Custom MCP server examples

When to Use This Capability:

• Connecting Claude to external services
• Building custom MCP servers
• Integrating with enterprise tools (Slack, Jira, etc.)
• Creating custom tool ecosystems
• Extending Claude capabilities

Quick Navigation:

• MCP overview: references/mcp-integration-guide.md - Protocol Overview
• Server development: references/mcp-integration-guide.md - Server Development
• Examples: references/mcp-integration-guide.md - Examples section

MCP in Products:

• Claude API: MCP connector tool (Beta) - call MCP servers from API
• Agent SDK: Built-in MCP integration - agents can use MCP servers
• Claude Code: Native MCP support - connect to servers via config

Capability 6: Administration & Enterprise

What It Covers:

• Workspaces (create, manage, organize projects)
• API Key management (create, rotate, secure)
• Organization members (add, remove, roles, permissions)
• Usage tracking (token counts, request metrics, analytics)
• Cost management (expense tracking, optimization, budgets)
• IAM (authentication methods, permission models)
• Security (threat protection, data encryption, compliance)
• Compliance (BAA for healthcare, legal requirements)
• Admin API (programmatic management)
• Code examples for all admin operations

When to Use This Capability:

• Enterprise deployment
• Team/organization management
• Cost tracking and optimization
• Security configuration
• Compliance requirements (healthcare, financial)
• Programmatic administration

Quick Navigation:

• Complete guide: references/administration-reference.md
• Specific topic: Search: python scripts/search-docs.py "workspaces"

Admin API Quick Reference:

Integration Scenarios

Scenario 1: API Development → Production Deployment

Use Case: Develop with API, deploy as agent

Workflow:

1. Development (Claude API + Python SDK):

   • Use Python SDK for development
   • Implement with API features (streaming, caching, tools)
   • Test locally with API client

2. Agent Creation (Agent SDK):

   • Convert API application to agent
   • Use Agent SDK for deployment
   • Add session management, permissions

3. Production (Agent hosting):

   • Deploy agent with hosting patterns
   • Monitor with cost tracking
   • Manage with Admin API

Products Used: Claude API → Python SDK → Agent SDK See: references/integration-patterns.md - API to Agent Pattern

Scenario 2: Local Development → Cloud Deployment

Use Case: Develop locally with Claude Code, deploy to production

Workflow:

1. Local Development (Claude Code):

   • Use Claude Code CLI for local development
   • Create skills, sub-agents, plugins
   • Test workflows locally

2. Adaptation (Agent SDK):

   • Convert Claude Code skills to Agent SDK skills
   • Adapt sub-agents for production
   • Add production tooling

3. Deployment:

   • Deploy agent with Agent SDK hosting
   • Use MCP for external integrations
   • Monitor with Admin API

Products Used: Claude Code → Agent SDK → MCP See: references/integration-patterns.md - Claude Code to Production Pattern

Scenario 3: RAG Application

Use Case: Build retrieval-augmented generation system

Workflow:

1. Document Management (Files API):

   • Upload documents via Files API
   • Manage document library

2. Search Integration (Search Results + Citations):

   • Provide search results to Claude
   • Enable citations for grounding

3. Query Processing (Messages API):

   • Send queries with document context
   • Get cited responses

Products Used: Files API + Search Results + Citations See: references/integration-patterns.md - RAG Pipeline Pattern

Scenario 4: MCP Everywhere

Use Case: Integrate external services across all products

MCP in Claude API:

• Use MCP connector tool (Beta)
• Call MCP servers from API requests
• Example: {"type": "mcp_connector", "server": "slack"}

MCP in Agent SDK:

• Built-in MCP integration
• Agents access MCP servers directly
• Configure in agent settings

MCP in Claude Code:

• Native MCP support
• Connect via .claude/mcp-servers config
• Auto-discovered tools

Products Used: MCP across API, Agent SDK, Claude Code See: references/mcp-integration-guide.md - Integration Across Products

Best Practices

1. Choose the Right Product

Use Claude API when:

• Direct API integration needed
• Custom application development
• Maximum flexibility required
• You manage infrastructure

Use Python SDK when:

• Python applications
• Type safety desired
• Async/await patterns needed
• Simplified API access

Use Agent SDK when:

• Building autonomous agents
• Session-based applications
• Need subagents or agent composition
• Production agent deployment

Use Claude Code when:

• Terminal-based development
• Local skill/agent creation
• Quick prototyping
• Developer productivity

2. Optimize Costs

Prompt Caching (90% cost reduction):

• Cache system prompts, long documents
• Standard: 5-min TTL (most use cases)
• Extended: 1-hour TTL (very frequent access)

Message Batches (50% cost reduction):

• Use for async/batch processing
• Ideal for background jobs, bulk operations

Model Selection:

• Haiku 4.5: Fast, cheap (simple tasks)
• Sonnet 4.5: Balanced (most use cases)
• Opus 4.1: Complex reasoning (when needed)

3. Leverage Progressive Features

Start simple, add features as needed:

1. Basic Messages API
2. Add Streaming (better UX)
3. Add Prompt Caching (cost savings)
4. Add Tool Use (external integration)
5. Add Extended Thinking (complex reasoning)
6. Add Citations (trustworthiness)
7. Add Memory (long-term context)

4. Integrate with MCP

Why MCP: Standardized integration to external services

Use Across Products:

• API: MCP connector tool
• Agent SDK: Built-in MCP integration
• Claude Code: Native MCP support

Common MCP Servers:

• Slack (team communication)
• GitHub (code management)
• Google Drive (documents)
• Jira (project management)
• Custom servers (your services)

5. Monitor Usage and Costs

Admin API Tracking:

• GET /v1/organization/usage (token metrics)
• GET /v1/organization/costs (expense data)
• Monitor by workspace for project tracking

Cost Optimization:

• Use caching aggressively
• Choose appropriate models
• Batch async work
• Monitor with Admin API

See Also

For specialized deep-dives on advanced topics:

• claude-opus-4-5-guide: Comprehensive guide to Opus 4.5, effort parameter, model selection, and benchmark comparisons
• claude-context-management: Context editing strategies (server-side clearing, client-side compaction), memory tool integration for infinite conversations
• claude-advanced-tool-use: Tool search (10,000+ tools), programmatic calling, tool use examples for production systems
• claude-cost-optimization: Cost tracking, ROI measurement, optimization patterns (caching, batching, context editing, effort tuning)

Quick Reference

Product Navigator

Feature Finder

Search Instructions

Find Anything Quickly:

# Search across all references
python scripts/search-docs.py "prompt caching"

# Search specific product
python scripts/search-docs.py "streaming" --product "Python SDK"

# Find code examples
python scripts/search-docs.py "example" --type code

Search Returns:

• Reference file name
• Section location
• Relevant excerpt
• Line numbers

Latest Models (2025)

Common Workflows

1. Simple API Call:

import anthropic
client = anthropic.Anthropic()
response = client.messages.create(
    model="claude-sonnet-4-5-20250929",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Your prompt"}]
)

2. Streaming Response:

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

3. Tool Use:

tools = [{"name": "get_weather", "description": "Get weather for location", ...}]
response = client.messages.create(
    model="claude-sonnet-4-5-20250929",
    max_tokens=1024,
    tools=tools,
    messages=[{"role": "user", "content": "What's the weather in SF?"}]
)

4. Prompt Caching:

messages = [
    {
        "role": "user",
        "content": [
            {"type": "text", "text": "System prompt...",
             "cache_control": {"type": "ephemeral"}}
        ]
    }
]

Documentation Structure

anthropic-expert/
├── SKILL.md - This file (overview, capabilities, quick ref)
├── references/
│   ├── claude-api-complete.md - Models, API, all features
│   ├── python-sdk-reference.md - Python SDK complete guide
│   ├── agent-sdk-complete.md - Agent SDK comprehensive
│   ├── claude-code-reference.md - All 44 Claude Code topics
│   ├── mcp-integration-guide.md - MCP across products
│   ├── administration-reference.md - Admin, costs, security
│   ├── integration-patterns.md - Cross-product usage
│   └── changelog.md - Version history, updates
├── scripts/
│   └── search-docs.py - Search all references
└── README.md - Quick start, navigation guide

Total Coverage: ~8,400 lines of comprehensive Anthropic expertise

Update Tracking

Last Updated: 2025-11-07 (initial build) Next Update: Use anthropic-docs-updater skill to check for and apply updates Changelog: See references/changelog.md for version history

anthropic-expert provides complete, searchable, up-to-date expertise on all Anthropic products, features, and integration patterns - your comprehensive guide to the Anthropic ecosystem.