Anthropic Claude

Key Points

• Claude 4 family (2026): Opus (flagship), Sonnet (workhorse), Haiku (cheap+fast).
• 1M context window in select tiers — best for long documents.
• Computer use: Claude can operate a browser/computer (preview/GA).
• Strong at code generation and complex reasoning, especially long contexts.
• Prompt caching with up to 90% discount on repeated content.
• Distribution: Anthropic API, AWS Bedrock, Google Vertex AI, Cloudflare AI.

Lineup

Output ~5x input. Prompt caching: huge discount (~90%) on cached content.

Strengths

• Code generation: many devs prefer Claude for code.
• Long context: 1M token reasoning quality holds up better than competitors.
• Refusals / safety: strong at refusing dangerous content; sometimes too eager (over-refusal).
• Computer use: Claude can operate a browser/computer for agentic workflows.
• Extended thinking: reasoning mode for harder tasks.

Weaknesses

• Multimodal: vision yes; no native audio/video like Gemini.
• No image generation in same API.
• Fewer day-1 features vs OpenAI (no Assistants API, custom GPTs).
• Quotas / availability: harder to scale than Azure OpenAI for some workloads.

.NET integration

No first-party Microsoft SDK; community options:

// Anthropic.SDK community library
var client = new AnthropicClient(apiKey);
var resp = await client.Messages.GetClaudeMessageAsync(new MessageParameters
{
    Model = AnthropicModels.Claude_4_Sonnet,
    Messages = [new Message(RoleType.User, "Hello")],
    MaxTokens = 1024
});

Or via Anthropic-compatible endpoints (Bedrock, Vertex):

// AWS Bedrock
new AmazonBedrockRuntimeClient().AsChatClient("anthropic.claude-sonnet-4-20250514")

Or wrap into IChatClient:

public class AnthropicChatClient : IChatClient { /* adapter */ }
builder.Services.AddSingleton<IChatClient, AnthropicChatClient>();

Or use the OpenAI-compatible proxy that some providers offer.

Prompt caching

new MessageParameters
{
    System = [
        new TextContent("System instructions...") { CacheControl = new() { Type = "ephemeral" } }
    ],
    /* ... */
};

5-min TTL. ~90% discount on cached tokens. Massive win for chatbots with long system prompts or RAG.

Long context (1M)

Claude 4 supports 1M tokens (in Sonnet+). Reads entire codebase, contracts, books. Quality at 800K+ holds.

Caveat: pricing scales with input length; long prompts expensive.

Computer use

Claude 4 Opus can operate a browser via screenshots + action API.

[Agent] → screenshot → Claude → "click button at (x, y)" or "type 'hello'" → execute → loop

Use cases: form-filling, navigation, RPA-style automation. Risky — guard rails essential.

Vision

new Message(RoleType.User, [
    new TextContent("What's in this image?"),
    new ImageContent(base64Data, "image/jpeg")
]);

Strong OCR-like ability for documents.

Function calling

Claude has tool use:

var tools = new[] { new Tool { Name = "get_weather", InputSchema = ... } };

Mature; comparable to OpenAI's. JSON-Schema based.

Extended thinking

new MessageParameters
{
    Thinking = new() { Type = "enabled", BudgetTokens = 10_000 }
};

Claude reasons in a hidden block before answering. Better on hard tasks; more output tokens.

Distribution channels

For Azure shops: Bedrock if multi-cloud OK; otherwise OpenAI.

When choose Claude

• Long context (>200K tokens).
• Heavy code generation tasks.
• Document analysis (legal, contracts, research).
• Computer-use agents.
• Want diverse vendor (avoid OpenAI lock-in).

When skip Claude

• Need image / audio generation.
• Day-1 newest features (OpenAI/Google often lead).
• Pure cost-sensitive (Haiku competitive but Gemini Flash sometimes cheaper).

Senior considerations

• Tool use parsing: Anthropic returns structured tool_use; bind to .NET function.
• Refusal handling: Claude refuses more eagerly. Test edge cases.
• Streaming: SSE-based.
• Caching strategy: invest in stable system prompt + RAG context order for cache hits.

Cross-references

• Connecting from .NET
• IChatClient
• Pricing & Cost Engineering
• Vendor Trade-offs & Lock-In