Anthropic Provider

The Anthropic provider gives you access to Claude models, known for their strong reasoning capabilities, extended context windows, and thoughtful responses. Claude excels at complex analysis, creative writing, and following detailed instructions.

Installation

pip install agent-framework --pre
pip install agent-framework-anthropic

dotnet add package Microsoft.Agents.AI
dotnet add package Anthropic

Authentication

Anthropic supports both direct API access and Azure AI Foundry hosted models.

Direct Anthropic API

import os
from agent_framework.anthropic import AnthropicClient

# Set ANTHROPIC_API_KEY environment variable
# The client will automatically read from the environment
client = AnthropicClient()

using Anthropic;
using Microsoft.Agents.AI;

var apiKey = Environment.GetEnvironmentVariable("ANTHROPIC_API_KEY");
var client = new AnthropicClient { ApiKey = apiKey };

.env

ANTHROPIC_API_KEY=sk-ant-...
ANTHROPIC_MODEL_ID=claude-sonnet-4-20250514

Azure AI Foundry (Anthropic via Azure)

from anthropic.foundry import AnthropicFoundryClient
from anthropic.foundry import AnthropicFoundryIdentityTokenCredentials
from azure.identity import DefaultAzureCredential
from agent_framework.anthropic import AnthropicClient

# Using Azure managed identity
credential = DefaultAzureCredential()
foundry_creds = AnthropicFoundryIdentityTokenCredentials(
    credential,
    resource="your-resource-name",
    scopes=["https://ai.azure.com/.default"]
)

client = AnthropicFoundryClient(foundry_creds)

using Anthropic.Foundry;
using Azure.Identity;
using Microsoft.Agents.AI;

string resource = Environment.GetEnvironmentVariable("ANTHROPIC_RESOURCE");
string deploymentName = Environment.GetEnvironmentVariable("ANTHROPIC_CHAT_MODEL_NAME");

var client = new AnthropicFoundryClient(
    new AnthropicFoundryIdentityTokenCredentials(
        new DefaultAzureCredential(),
        resource,
        ["https://ai.azure.com/.default"]
    )
);

Never commit API keys to source control. Always use environment variables or secure secret management.

Basic Usage

import asyncio
from agent_framework.anthropic import AnthropicClient

async def main():
    # Create agent with Anthropic
    agent = AnthropicClient().as_agent(
        name="Assistant",
        instructions="You are a helpful assistant.",
    )
    
    # Non-streaming response
    result = await agent.run("What is the capital of France?")
    print(result)

asyncio.run(main())

using Anthropic;
using Microsoft.Agents.AI;

string deploymentName = Environment.GetEnvironmentVariable("ANTHROPIC_CHAT_MODEL_NAME") ?? "claude-haiku-4-5";

using var client = new AnthropicClient 
{ 
    ApiKey = Environment.GetEnvironmentVariable("ANTHROPIC_API_KEY") 
};

var agent = client.AsAIAgent(
    model: deploymentName,
    instructions: "You are a helpful assistant.",
    name: "Assistant"
);

var result = await agent.RunAsync("What is the capital of France?");
Console.WriteLine(result);

Configuration

Environment Variables
Explicit Configuration

# Direct Anthropic API
ANTHROPIC_API_KEY=sk-ant-...
ANTHROPIC_MODEL_ID=claude-sonnet-4-20250514

# Azure AI Foundry
ANTHROPIC_RESOURCE=your-resource-name
ANTHROPIC_CHAT_MODEL_NAME=claude-haiku-4-5

from agent_framework.anthropic import AnthropicClient

client = AnthropicClient(
    api_key="sk-ant-...",
    model_id="claude-sonnet-4-20250514",
    max_tokens=4096,
)

using Anthropic;

var client = new AnthropicClient 
{ 
    ApiKey = "sk-ant-...",
    DefaultRequestOptions = new RequestOptions 
    { 
        MaxTokens = 4096 
    }
};

Streaming Responses

import asyncio
from agent_framework.anthropic import AnthropicClient

async def main():
    agent = AnthropicClient().as_agent(
        name="Assistant",
        instructions="You are a helpful assistant.",
    )
    
    # Streaming response
    query = "Write a short story about AI agents."
    print("Agent: ", end="", flush=True)
    async for chunk in agent.run(query, stream=True):
        if chunk.text:
            print(chunk.text, end="", flush=True)
    print()

asyncio.run(main())

using Anthropic;
using Microsoft.Agents.AI;

using var client = new AnthropicClient { ApiKey = apiKey };

var agent = client.AsAIAgent(
    model: "claude-sonnet-4-20250514",
    instructions: "You are a helpful assistant.",
    name: "Assistant"
);

await foreach (var chunk in agent.RunStreamingAsync("Write a short story about AI agents."))
{
    if (chunk.Text != null)
        Console.Write(chunk.Text);
}

Function Calling (Tool Use)

Claude has excellent function calling capabilities:

import asyncio
from typing import Annotated
from agent_framework import tool
from agent_framework.anthropic import AnthropicClient

@tool(approval_mode="never_require")  # Use "always_require" in production
def get_weather(location: Annotated[str, "City name"]) -> str:
    """Get the weather for a location."""
    return f"Weather in {location}: Sunny, 72°F"

@tool(approval_mode="never_require")
def search_web(query: Annotated[str, "Search query"]) -> str:
    """Search the web for information."""
    return f"Search results for: {query}"

async def main():
    agent = AnthropicClient().as_agent(
        name="Assistant",
        instructions="You are a helpful assistant with access to tools.",
        tools=[get_weather, search_web],
    )
    
    result = await agent.run(
        "What's the weather in Seattle and find recent news about it?"
    )
    print(result)

asyncio.run(main())

using Anthropic;
using Microsoft.Agents.AI;
using Microsoft.Extensions.AI;
using System.ComponentModel;

[Description("Get the weather for a location")]
string GetWeather([Description("City name")] string location)
{
    return $"Weather in {location}: Sunny, 72°F";
}

[Description("Search the web for information")]
string SearchWeb([Description("Search query")] string query)
{
    return $"Search results for: {query}";
}

using var client = new AnthropicClient { ApiKey = apiKey };

var agent = client.AsAIAgent(
    model: "claude-sonnet-4-20250514",
    instructions: "You are a helpful assistant with access to tools.",
    name: "Assistant",
    tools: [
        AIFunctionFactory.Create(GetWeather),
        AIFunctionFactory.Create(SearchWeb)
    ]
);

var result = await agent.RunAsync(
    "What's the weather in Seattle and find recent news about it?"
);
Console.WriteLine(result);

Claude can intelligently decide when and how to use multiple tools, even calling them in parallel when appropriate.

Available Models

Anthropic offers several Claude model families:

Model	Context Window	Best For	Strengths
claude-sonnet-4-20250514	200k	Balanced performance and speed	General purpose, reasoning
claude-opus-4-20250514	200k	Highest intelligence	Complex analysis, research
claude-haiku-4-5	200k	Speed and efficiency	Quick tasks, cost-effective
claude-3-5-sonnet	200k	Previous generation	Legacy applications
claude-3-5-haiku	200k	Fast, previous generation	Quick responses

All Claude models support function calling, vision (image inputs), and extended thinking (reasoning). Context windows are 200k tokens for all current models.

Extended Thinking (Reasoning)

Claude models support extended thinking for complex reasoning tasks:

import asyncio
from agent_framework.anthropic import AnthropicClient

async def main():
    agent = AnthropicClient(
        model_id="claude-sonnet-4-20250514"
    ).as_agent(
        instructions="You are a reasoning assistant. Think step by step.",
    )
    
    result = await agent.run(
        "Solve this logic puzzle: Three people are in a room. "
        "Alice says Bob is lying. Bob says Charlie is lying. "
        "Charlie says both Alice and Bob are lying. Who is telling the truth?"
    )
    print(result)

asyncio.run(main())

using Anthropic;
using Microsoft.Agents.AI;

using var client = new AnthropicClient { ApiKey = apiKey };

var agent = client.AsAIAgent(
    model: "claude-sonnet-4-20250514",
    instructions: "You are a reasoning assistant. Think step by step.",
    name: "Reasoner"
);

var result = await agent.RunAsync(
    "Solve this logic puzzle: Three people are in a room. " +
    "Alice says Bob is lying. Bob says Charlie is lying. " +
    "Charlie says both Alice and Bob are lying. Who is telling the truth?"
);
Console.WriteLine(result);

Claude models automatically engage extended thinking for complex problems. You can encourage this behavior by prompting the model to “think step by step” or “analyze carefully.”

Vision Capabilities

All Claude models support image inputs:

import asyncio
from agent_framework import Message
from agent_framework.anthropic import AnthropicClient

async def main():
    agent = AnthropicClient().as_agent(
        instructions="You analyze images in detail.",
    )
    
    message = Message(
        role="user",
        text="What's in this image? Describe it in detail.",
        images=["https://example.com/image.jpg"],
    )
    
    result = await agent.run(message)
    print(result)

asyncio.run(main())

using Anthropic;
using Microsoft.Agents.AI;
using Microsoft.Extensions.AI;

using var client = new AnthropicClient { ApiKey = apiKey };

var agent = client.AsAIAgent(
    model: "claude-sonnet-4-20250514",
    instructions: "You analyze images in detail.",
    name: "VisionAgent"
);

var message = new ChatMessage(
    ChatRole.User,
    [
        new TextContent("What's in this image? Describe it in detail."),
        new ImageContent(new Uri("https://example.com/image.jpg"))
    ]
);

var result = await agent.RunAsync([message]);
Console.WriteLine(result);

Claude models have excellent vision capabilities and can analyze charts, diagrams, documents, photos, and screenshots with high accuracy.

Long Context

Claude models have 200k token context windows, enabling:

Processing entire books or codebases
Analyzing lengthy documents
Maintaining long conversations
Handling extensive research materials

import asyncio
from agent_framework.anthropic import AnthropicClient

async def main():
    agent = AnthropicClient().as_agent(
        instructions="You analyze long documents.",
    )
    
    # Claude can handle very long inputs
    with open("long_document.txt", "r") as f:
        document = f.read()  # Could be 100k+ tokens
    
    result = await agent.run(
        f"Summarize this document and identify key themes:\n\n{document}"
    )
    print(result)

asyncio.run(main())

using Anthropic;
using Microsoft.Agents.AI;

using var client = new AnthropicClient { ApiKey = apiKey };

var agent = client.AsAIAgent(
    model: "claude-sonnet-4-20250514",
    instructions: "You analyze long documents.",
    name: "Analyzer"
);

// Claude can handle very long inputs
var document = await File.ReadAllTextAsync("long_document.txt");  // Could be 100k+ tokens

var result = await agent.RunAsync(
    $"Summarize this document and identify key themes:\n\n{document}"
);
Console.WriteLine(result);

Claude maintains strong performance even with very long contexts, making it ideal for document analysis and research tasks.

Best Practices

Choose the Right Model

Use claude-haiku-4-5 for quick, cost-effective tasks
Use claude-sonnet-4 for balanced performance (most use cases)
Use claude-opus-4 when maximum intelligence is critical
All models support function calling and vision

Leverage Long Context

Claude’s 200k context window is a key advantage:

Process entire documents without chunking
Maintain long conversation history
Analyze multiple related documents together
Keep extensive context for better coherence

Optimize Prompts

Claude responds well to clear, structured prompts:

Be explicit about desired output format
Use XML-style tags for structure (Claude is trained on XML)
Provide examples when possible
Break complex tasks into steps
Use “think step by step” for reasoning tasks

Handle Rate Limits

Anthropic has rate limits based on your tier:

Implement exponential backoff retry logic
Monitor usage in the Anthropic console
Consider upgrading your tier for higher limits
Batch similar requests when possible

Use Function Calling Effectively

Claude excels at tool use:

Provide clear, detailed function descriptions
Use descriptive parameter names
Claude can chain multiple tool calls intelligently
Claude can call tools in parallel when appropriate

Troubleshooting

Authentication Errors

If you see authentication errors:

Verify the API key is correct and active
Check if using Anthropic direct or Azure Foundry
For Azure: ensure managed identity has proper permissions
Verify the resource name is correct for Foundry

Rate Limit Errors

If you’re hitting rate limits:

Check your usage tier at console.anthropic.com
Implement exponential backoff
Reduce request frequency
Consider upgrading to a higher tier
Monitor concurrent requests

Model Not Available

If the model is not available:

Check if you have access to the model
Verify the model name is correct
Some newer models require API access approval
Check if using the right endpoint (Anthropic vs Azure)

Context Length Errors

If you exceed context length:

Claude has 200k token limit
Count both input and output tokens
Implement conversation pruning for long sessions
Consider summarizing older context

Cost Optimization

Anthropic pricing varies by model:

Use appropriate models: claude-haiku-4-5 is significantly cheaper than opus-4
Monitor token usage: Input and output tokens are priced differently
Optimize prompts: Shorter, clearer prompts use fewer tokens
Cache system prompts: Reuse system instructions across requests
Leverage long context: Process documents once instead of multiple chunks

Check current pricing at anthropic.com/pricing

Comparison with Other Providers

Feature	Claude	GPT-4o	Advantage
Context Window	200k	128k	Claude
Vision	✅ Excellent	✅ Excellent	Tie
Function Calling	✅ Excellent	✅ Excellent	Tie
Reasoning	✅ Extended thinking	✅ o1/o3 models	Different approaches
Cost	$	$$	Claude (generally)
Document Analysis	✅ Superior	✅ Good	Claude
Creative Writing	✅ Superior	✅ Good	Claude
Code Generation	✅ Good	✅ Superior	GPT-4o

Claude excels at document analysis, creative writing, and following complex instructions. GPT-4o may be better for code generation and certain reasoning tasks.

Next Steps

Function Tools

Learn how to add function calling to your agents

Sessions & Memory

Manage multi-turn conversations with memory

Tools

Add function calling to Claude agents

Workflows

Build multi-agent workflows with Claude

Get Started

Core Concepts

Workflows

Providers

Hosting & Deployment

Migration Guides

Anthropic

Anthropic Provider

Installation

Authentication

Direct Anthropic API

Azure AI Foundry (Anthropic via Azure)

Basic Usage

Configuration

Streaming Responses

Function Calling (Tool Use)

Available Models

Extended Thinking (Reasoning)

Vision Capabilities

Long Context

Best Practices

Troubleshooting

Cost Optimization

Comparison with Other Providers

Next Steps

Function Tools

Sessions & Memory

Tools

Workflows

​Anthropic Provider

​Installation

​Authentication

​Direct Anthropic API

​Azure AI Foundry (Anthropic via Azure)

​Basic Usage

​Configuration

​Streaming Responses

​Function Calling (Tool Use)

​Available Models

​Extended Thinking (Reasoning)

​Vision Capabilities

​Long Context

​Best Practices

​Troubleshooting

​Cost Optimization

​Comparison with Other Providers

​Next Steps

Function Tools

Sessions & Memory

Tools

Workflows

Anthropic Provider

Installation

Authentication

Direct Anthropic API

Azure AI Foundry (Anthropic via Azure)

Basic Usage

Configuration

Streaming Responses

Function Calling (Tool Use)

Available Models

Extended Thinking (Reasoning)

Vision Capabilities

Long Context

Best Practices

Troubleshooting

Cost Optimization

Comparison with Other Providers

Next Steps