Claude 3: First Look at Anthropic's New Models

claude_3_family:
  opus:
    positioning: Most capable, frontier
    use_case: Complex analysis, research, coding
    context: 200K tokens
    cost: Higher

  sonnet:
    positioning: Balanced capability and cost
    use_case: General tasks, production workloads
    context: 200K tokens
    cost: Moderate

  haiku:
    positioning: Fast and affordable
    use_case: High-volume, simple tasks
    context: 200K tokens
    cost: Lower

improvements:
  reasoning:
    - Better multi-step reasoning
    - Improved mathematical capabilities
    - More accurate analysis

  coding:
    - Better code generation
    - Improved debugging
    - Multi-file understanding

  vision:
    - Native image understanding
    - Document analysis
    - Chart interpretation

  context:
    - 200K context window
    - Better long-context performance
    - Improved retrieval within context

  safety:
    - Reduced refusals for benign requests
    - Better nuanced responses
    - Maintained safety boundaries

import anthropic

client = anthropic.Anthropic()

# Using Claude 3 Opus
response = client.messages.create(
    model="claude-3-opus-20240229",
    max_tokens=1024,
    messages=[
        {"role": "user", "content": "Analyze this code for security issues."}
    ]
)

print(response.content[0].text)

import base64

def analyze_image(image_path: str, prompt: str) -> str:
    with open(image_path, "rb") as f:
        image_data = base64.standard_b64encode(f.read()).decode()

    response = client.messages.create(
        model="claude-3-opus-20240229",
        max_tokens=1024,
        messages=[
            {
                "role": "user",
                "content": [
                    {
                        "type": "image",
                        "source": {
                            "type": "base64",
                            "media_type": "image/png",
                            "data": image_data
                        }
                    },
                    {
                        "type": "text",
                        "text": prompt
                    }
                ]
            }
        ]
    )

    return response.content[0].text

# Analyze an architecture diagram
result = analyze_image(
    "architecture.png",
    "Describe this system architecture and identify potential issues."
)

class ClaudeRouter:
    """Route requests to appropriate Claude 3 model."""

    MODELS = {
        "opus": "claude-3-opus-20240229",
        "sonnet": "claude-3-sonnet-20240229",
        "haiku": "claude-3-haiku-20240307"
    }

    def select_model(self, request: dict) -> str:
        # Opus for complex tasks
        if request.get("complexity") == "high":
            return self.MODELS["opus"]

        # Haiku for simple, high-volume
        if request.get("volume") == "high" and request.get("complexity") == "low":
            return self.MODELS["haiku"]

        # Sonnet as default
        return self.MODELS["sonnet"]

claude_3_vs_gpt4:
  claude_3_strengths:
    - Longer context (200K vs 128K)
    - Often more nuanced responses
    - Better at following complex instructions
    - More balanced safety (fewer unnecessary refusals)

  gpt4_strengths:
    - Larger ecosystem
    - More integrations
    - Established track record
    - Function calling maturity

  similar:
    - Overall capability tier
    - Vision capabilities
    - Coding ability

model_selection:
  prefer_claude_3:
    - Long document analysis
    - Nuanced writing tasks
    - Complex instruction following
    - Research and analysis

  prefer_gpt4:
    - Existing GPT integrations
    - Specific function calling needs
    - OpenAI ecosystem features
    - Established prompts that work

  use_both:
    - Test for your specific use case
    - A/B testing in production
    - Fallback redundancy

class MultiProviderLLM:
    """Support multiple LLM providers with easy switching."""

    def __init__(self):
        self.anthropic = anthropic.Anthropic()
        self.openai = openai.OpenAI()

    async def generate(
        self,
        prompt: str,
        provider: str = "anthropic",
        model: str = None
    ) -> str:
        if provider == "anthropic":
            model = model or "claude-3-sonnet-20240229"
            response = self.anthropic.messages.create(
                model=model,
                max_tokens=1024,
                messages=[{"role": "user", "content": prompt}]
            )
            return response.content[0].text
        else:
            model = model or "gpt-4-turbo"
            response = self.openai.chat.completions.create(
                model=model,
                messages=[{"role": "user", "content": prompt}]
            )
            return response.choices[0].message.content

cost_comparison_rough:
  # Approximate pricing per million tokens
  claude_3_opus:
    input: $15
    output: $75
    use: Complex, high-value tasks

  claude_3_sonnet:
    input: $3
    output: $15
    use: General production

  claude_3_haiku:
    input: $0.25
    output: $1.25
    use: High-volume, simple tasks

  gpt_4_turbo:
    input: $10
    output: $30
    use: Comparison point