The Claude Model Family

import anthropic

client = anthropic.Anthropic()

# Opus for complex legal analysis
response = client.messages.create(
    model="claude-opus-4-20250514",
    max_tokens=4096,
    messages=[{
        "role": "user",
        "content": """Analyze this contract clause for potential risks
        to the licensee. Consider jurisdictional variations across
        US, EU, and APAC markets. Identify any ambiguities that
        could be exploited in litigation.

        Clause: "Licensor reserves the right to modify the service
        at any time, with or without notice, and Licensee agrees
        that continued use constitutes acceptance of modifications."
        """
    }]
)

print(response.content[0].text)

import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic();

// Opus for complex legal analysis
const response = await client.messages.create({
  model: "claude-opus-4-20250514",
  max_tokens: 4096,
  messages: [{
    role: "user",
    content: `Analyze this contract clause for potential risks
    to the licensee. Consider jurisdictional variations across
    US, EU, and APAC markets. Identify any ambiguities that
    could be exploited in litigation.

    Clause: "Licensor reserves the right to modify the service
    at any time, with or without notice, and Licensee agrees
    that continued use constitutes acceptance of modifications."`
  }]
});

console.log(response.content[0].text);

import anthropic

client = anthropic.Anthropic()

# Sonnet for code generation -- fast, capable, affordable
response = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=2048,
    messages=[{
        "role": "user",
        "content": """Write a Python function that implements
        exponential backoff with jitter for API retries. Include
        type hints, docstring, and handle both timeout and
        rate-limit errors."""
    }]
)

print(response.content[0].text)

import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic();

// Sonnet for code generation -- fast, capable, affordable
const response = await client.messages.create({
  model: "claude-sonnet-4-20250514",
  max_tokens: 2048,
  messages: [{
    role: "user",
    content: `Write a TypeScript function that implements
    exponential backoff with jitter for API retries. Include
    proper types and handle both timeout and rate-limit errors.`
  }]
});

console.log(response.content[0].text);

import anthropic

client = anthropic.Anthropic()

# Haiku for fast classification -- sub-second responses
response = client.messages.create(
    model="claude-haiku-3-5-20241022",
    max_tokens=100,
    messages=[{
        "role": "user",
        "content": """Classify this support ticket into exactly one
        category: billing, technical, account, or general.

        Ticket: "I can't log in to my account. I've tried
        resetting my password but the email never arrives."

        Respond with only the category name."""
    }]
)

print(response.content[0].text)  # "account"

import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic();

// Haiku for fast classification -- sub-second responses
const response = await client.messages.create({
  model: "claude-haiku-3-5-20241022",
  max_tokens: 100,
  messages: [{
    role: "user",
    content: `Classify this support ticket into exactly one
    category: billing, technical, account, or general.

    Ticket: "I can't log in to my account. I've tried
    resetting my password but the email never arrives."

    Respond with only the category name.`
  }]
});

console.log(response.content[0].text); // "account"

claude-{tier}-{version}-{date}

import anthropic

client = anthropic.Anthropic()

# Reading a large codebase for review
with open("entire_codebase.txt", "r") as f:
    codebase = f.read()

response = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=4096,
    messages=[{
        "role": "user",
        "content": f"""Review this entire codebase for security
        vulnerabilities, focusing on SQL injection, XSS, and
        authentication bypass risks.

        {codebase}"""
    }]
)

import anthropic
from dataclasses import dataclass
from enum import Enum

class ModelTier(Enum):
    HAIKU = "claude-haiku-3-5-20241022"
    SONNET = "claude-sonnet-4-20250514"
    OPUS = "claude-opus-4-20250514"

@dataclass
class RoutingDecision:
    model: ModelTier
    reason: str
    estimated_cost_per_1k: float

class ModelRouter:
    """Routes requests to the optimal Claude model based on task complexity."""

    def __init__(self):
        self.client = anthropic.Anthropic()

        # Keywords that suggest different complexity levels
        self.opus_signals = [
            "analyze", "synthesize", "compare and contrast",
            "evaluate risks", "strategic", "ambiguous",
            "creative writing", "architectural review",
            "security audit", "legal analysis"
        ]
        self.haiku_signals = [
            "classify", "extract", "categorize",
            "true or false", "yes or no", "pick one",
            "sentiment", "moderate", "filter", "route"
        ]

    def route(self, task_description: str,
              max_cost_tier: ModelTier = ModelTier.OPUS) -> RoutingDecision:
        """Determine the optimal model for a given task."""

        task_lower = task_description.lower()

        # Check for Opus signals
        opus_score = sum(1 for s in self.opus_signals if s in task_lower)
        haiku_score = sum(1 for s in self.haiku_signals if s in task_lower)

        # Route based on signals
        if opus_score >= 2 and max_cost_tier == ModelTier.OPUS:
            return RoutingDecision(
                model=ModelTier.OPUS,
                reason=f"Complex task detected ({opus_score} complexity signals)",
                estimated_cost_per_1k=0.075
            )
        elif haiku_score >= 1:
            return RoutingDecision(
                model=ModelTier.HAIKU,
                reason=f"Simple task detected ({haiku_score} simplicity signals)",
                estimated_cost_per_1k=0.004
            )
        else:
            return RoutingDecision(
                model=ModelTier.SONNET,
                reason="Default routing to balanced model",
                estimated_cost_per_1k=0.015
            )

    def call(self, task: str, user_message: str,
             system_prompt: str = None, max_tokens: int = 2048) -> dict:
        """Route and execute an API call."""

        decision = self.route(task)

        kwargs = {
            "model": decision.model.value,
            "max_tokens": max_tokens,
            "messages": [{"role": "user", "content": user_message}]
        }
        if system_prompt:
            kwargs["system"] = system_prompt

        response = self.client.messages.create(**kwargs)

        return {
            "content": response.content[0].text,
            "model_used": decision.model.value,
            "routing_reason": decision.reason,
            "input_tokens": response.usage.input_tokens,
            "output_tokens": response.usage.output_tokens
        }

# Usage
router = ModelRouter()

# This routes to Haiku (classification task)
result = router.call(
    task="classify this email",
    user_message="Is this email spam? 'You've won a free iPhone!'"
)
print(f"Model: {result['model_used']}")  # claude-haiku-3-5-20241022

# This routes to Opus (complex analysis)
result = router.call(
    task="analyze and evaluate risks in this strategic proposal",
    user_message="Evaluate this merger proposal for regulatory risks..."
)
print(f"Model: {result['model_used']}")  # claude-opus-4-20250514

# This routes to Sonnet (general task)
result = router.call(
    task="write a product description",
    user_message="Write a description for our new wireless headphones"
)
print(f"Model: {result['model_used']}")  # claude-sonnet-4-20250514

import Anthropic from "@anthropic-ai/sdk";

enum ModelTier {
  HAIKU = "claude-haiku-3-5-20241022",
  SONNET = "claude-sonnet-4-20250514",
  OPUS = "claude-opus-4-20250514",
}

interface RoutingDecision {
  model: ModelTier;
  reason: string;
  estimatedCostPer1k: number;
}

class ModelRouter {
  private client: Anthropic;
  private opusSignals: string[];
  private haikuSignals: string[];

  constructor() {
    this.client = new Anthropic();
    this.opusSignals = [
      "analyze", "synthesize", "compare and contrast",
      "evaluate risks", "strategic", "ambiguous",
      "creative writing", "architectural review",
    ];
    this.haikuSignals = [
      "classify", "extract", "categorize",
      "true or false", "yes or no", "pick one",
      "sentiment", "moderate", "filter", "route",
    ];
  }

  route(taskDescription: string): RoutingDecision {
    const taskLower = taskDescription.toLowerCase();
    const opusScore = this.opusSignals.filter(
      s => taskLower.includes(s)
    ).length;
    const haikuScore = this.haikuSignals.filter(
      s => taskLower.includes(s)
    ).length;

    if (opusScore >= 2) {
      return {
        model: ModelTier.OPUS,
        reason: `Complex task (${opusScore} signals)`,
        estimatedCostPer1k: 0.075,
      };
    } else if (haikuScore >= 1) {
      return {
        model: ModelTier.HAIKU,
        reason: `Simple task (${haikuScore} signals)`,
        estimatedCostPer1k: 0.004,
      };
    }
    return {
      model: ModelTier.SONNET,
      reason: "Default balanced model",
      estimatedCostPer1k: 0.015,
    };
  }

  async call(task: string, userMessage: string) {
    const decision = this.route(task);

    const response = await this.client.messages.create({
      model: decision.model,
      max_tokens: 2048,
      messages: [{ role: "user", content: userMessage }],
    });

    return {
      content: response.content[0].type === "text"
        ? response.content[0].text
        : "",
      modelUsed: decision.model,
      routingReason: decision.reason,
      inputTokens: response.usage.input_tokens,
      outputTokens: response.usage.output_tokens,
    };
  }
}