Wann Reasoning- und wann Standardmodelle einsetzen

import anthropic

client = anthropic.Anthropic(api_key='sk-ant-...')

# Multi-step math: use reasoning model
hard_math_prompt = (
    'A company has 3 factories. Factory A produces 240 units/day, '
    'Factory B produces 180 units/day, and Factory C produces 300 units/day. '
    'They operate 5 days/week. A unit sells for $47.50. Operating costs are '
    '$18,000/week for A, $14,500/week for B, and $22,000/week for C. '
    'What is the total weekly profit across all factories?'
)

response = client.messages.create(
    model='claude-opus-4-5',
    max_tokens=8000,
    thinking={'type': 'enabled', 'budget_tokens': 5000},
    messages=[{'role': 'user', 'content': hard_math_prompt}]
)
print(next(b.text for b in response.content if b.type == 'text'))

import anthropic

client = anthropic.Anthropic(api_key='sk-ant-...')

# Complex coding: use reasoning model
code_prompt = (
    'Implement a thread-safe LRU cache in Python with these requirements:\n'
    '- O(1) get and put operations\n'
    '- Thread-safe using minimal locking\n'
    '- Support a max_size parameter\n'
    '- Include full docstrings and type hints\n'
    '- Handle edge cases: empty cache, size=1, duplicate keys'
)

response = client.messages.create(
    model='claude-opus-4-5',
    max_tokens=10000,
    thinking={'type': 'enabled', 'budget_tokens': 8000},
    messages=[{'role': 'user', 'content': code_prompt}]
)
code = next(b.text for b in response.content if b.type == 'text')
print(code[:400])

import anthropic

client = anthropic.Anthropic(api_key='sk-ant-...')

# Strategic decision: reasoning model adds real value
strategy_prompt = (
    'We are a B2B SaaS startup with $2M ARR, 15% monthly churn, '
    '3 engineers, and $800K runway. We have two options:\n'
    'A) Raise a Series A now at a $10M valuation\n'
    'B) Cut costs, extend runway 18 months, raise at higher valuation\n\n'
    'Analyze the trade-offs and recommend a course of action with reasoning.'
)

response = client.messages.create(
    model='claude-opus-4-5',
    max_tokens=10000,
    thinking={'type': 'enabled', 'budget_tokens': 8000},
    messages=[{'role': 'user', 'content': strategy_prompt}]
)
print(next(b.text for b in response.content if b.type == 'text')[:400])

import anthropic

client = anthropic.Anthropic(api_key='sk-ant-...')

# Simple Q&A: standard model is just as good, much cheaper
simple_questions = [
    'What is the capital of France?',
    'Who wrote Hamlet?',
    'What year did the Berlin Wall fall?',
]

for q in simple_questions:
    # Use claude-haiku-4-5 — fast, cheap, equally accurate for factual recall
    r = client.messages.create(
        model='claude-haiku-4-5',
        max_tokens=50,
        messages=[{'role': 'user', 'content': q}]
    )
    print(f'Q: {q}\nA: {r.content[0].text}\n')

# Reasoning model would give the same answers at 50-100x the cost

import anthropic

client = anthropic.Anthropic(api_key='sk-ant-...')

# Text formatting tasks: standard model wins
formatting_tasks = [
    ('Summarize in 2 sentences: The Eiffel Tower was built in 1889...', 100),
    ('Translate to Spanish: Good morning, how are you?', 50),
    ('Convert to bullet points: We need to buy milk, eggs, and bread.', 50),
]

for prompt, max_tok in formatting_tasks:
    r = client.messages.create(
        model='claude-haiku-4-5',  # Fastest, cheapest
        max_tokens=max_tok,
        messages=[{'role': 'user', 'content': prompt}]
    )
    print(r.content[0].text, '\n')

# Reasoning model: same quality, 50-100x more expensive, 10-30x slower

import anthropic
import time

client = anthropic.Anthropic(api_key='sk-ant-...')

def latency_comparison(question):
    # Standard model: fast for real-time use
    start = time.time()
    r1 = client.messages.create(
        model='claude-haiku-4-5',
        max_tokens=200,
        messages=[{'role': 'user', 'content': question}]
    )
    t_standard = time.time() - start

    # Reasoning model: accurate but slow
    start = time.time()
    r2 = client.messages.create(
        model='claude-opus-4-5',
        max_tokens=5000,
        thinking={'type': 'enabled', 'budget_tokens': 3000},
        messages=[{'role': 'user', 'content': question}]
    )
    t_reasoning = time.time() - start

    print(f'Standard: {t_standard:.1f}s | Reasoning: {t_reasoning:.1f}s')

latency_comparison('What does API stand for?')

import anthropic

client = anthropic.Anthropic(api_key='sk-ant-...')

# Ambiguous reasoning: reasoning model handles this much better
ambiguous_prompt = (
    'Alice, Bob, and Carol are in a room. Alice says Bob is lying. '
    'Bob says Carol is lying. Carol says both Alice and Bob are lying. '
    'Who, if anyone, is telling the truth? '
    'Explain all possible consistent interpretations.'
)

# Reasoning model explores the logical space
response = client.messages.create(
    model='claude-opus-4-5',
    max_tokens=8000,
    thinking={'type': 'enabled', 'budget_tokens': 6000},
    messages=[{'role': 'user', 'content': ambiguous_prompt}]
)
print(next(b.text for b in response.content if b.type == 'text')[:400])

import anthropic

client = anthropic.Anthropic(api_key='sk-ant-...')

def classify_complexity(query):
    prompt = (
        f'Classify this query as SIMPLE or COMPLEX:\n'
        f'SIMPLE: factual, formatting, translation, short Q&A\n'
        f'COMPLEX: multi-step reasoning, analysis, code design, math\n\n'
        f'Query: {query}\n\n'
        f'Reply with only SIMPLE or COMPLEX.'
    )
    r = client.messages.create(
        model='claude-haiku-4-5',
        max_tokens=10,
        messages=[{'role': 'user', 'content': prompt}]
    )
    return r.content[0].text.strip()

def smart_query(query):
    complexity = classify_complexity(query)
    if complexity == 'SIMPLE':
        model, thinking = 'claude-haiku-4-5', None
    else:
        model = 'claude-opus-4-5'
        thinking = {'type': 'enabled', 'budget_tokens': 8000}

    kwargs = {'model': model, 'max_tokens': 2048, 'messages': [{'role': 'user', 'content': query}]}
    if thinking:
        kwargs['thinking'] = thinking
        kwargs['max_tokens'] = 10000

    r = client.messages.create(**kwargs)
    print(f'Used: {model} ({complexity})')
    return r.content[-1].text

import anthropic

client = anthropic.Anthropic(api_key='sk-ant-...')

def compare_models_on_task(task_examples, metric_fn):
    results = {'standard': [], 'reasoning': []}

    for ex in task_examples:
        # Standard model
        r_std = client.messages.create(
            model='claude-haiku-4-5',
            max_tokens=200,
            messages=[{'role': 'user', 'content': ex.question}]
        )
        results['standard'].append(
            metric_fn(ex.answer, r_std.content[0].text)
        )

        # Reasoning model
        r_rsn = client.messages.create(
            model='claude-opus-4-5',
            max_tokens=8000,
            thinking={'type': 'enabled', 'budget_tokens': 5000},
            messages=[{'role': 'user', 'content': ex.question}]
        )
        ans = next(b.text for b in r_rsn.content if b.type == 'text')
        results['reasoning'].append(metric_fn(ex.answer, ans))

    for model, scores in results.items():
        avg = sum(scores) / len(scores)
        print(f'{model}: {avg:.1%}')
    return results