Kompromisy między kosztem a opóźnieniem

Trójkąt koszt–jakość–opóźnienie

Cennik modeli rozumujących

# Rough cost estimates (2025 pricing, may change)
# Source: provider pricing pages

PRICING = {
    # (input $/1M tokens, output $/1M tokens)
    'gpt-4o-mini':       (0.15,   0.60),
    'gpt-4o':            (2.50,  10.00),
    'o3-mini':           (1.10,   4.40),
    'o3':                (10.0,  40.00),
    'claude-haiku-4-5':  (0.25,   1.25),
    'claude-sonnet-4-5': (3.00,  15.00),
    'claude-opus-4-5':   (15.0,  75.00),
}

def estimate_cost(model, input_tokens, output_tokens, thinking_tokens=0):
    inp_price, out_price = PRICING[model]
    # Thinking tokens billed as output tokens
    total_out = output_tokens + thinking_tokens
    cost = (input_tokens / 1e6 * inp_price) + (total_out / 1e6 * out_price)
    return cost

# A single hard question with 8000 thinking tokens:
cost = estimate_cost('claude-opus-4-5', 500, 300, thinking_tokens=8000)
print(f'Cost per call: ${cost:.4f}')

Narzut tokenów rozumowania

import anthropic

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

def analyze_token_breakdown(question, budget_tokens):
    response = client.messages.create(
        model='claude-opus-4-5',
        max_tokens=budget_tokens + 2000,
        thinking={'type': 'enabled', 'budget_tokens': budget_tokens},
        messages=[{'role': 'user', 'content': question}]
    )

    # Usage breakdown
    usage = response.usage
    print(f'Input tokens:  {usage.input_tokens:,}')
    print(f'Output tokens: {usage.output_tokens:,}')

    # Thinking tokens are in cache_creation_input_tokens on some APIs
    # or can be estimated from thinking block content length
    thinking_blocks = [b for b in response.content if b.type == 'thinking']
    est_thinking = sum(len(b.thinking.split()) * 1.3 for b in thinking_blocks)
    print(f'Est. thinking tokens: {int(est_thinking):,}')
    answer = next(b.text for b in response.content if b.type == 'text')
    print(f'Answer words: {len(answer.split())}')

analyze_token_breakdown(
    'Explain the trade-offs between REST and GraphQL APIs.',
    budget_tokens=5000
)

Opóźnienia: czego się spodziewać

import time
import anthropic

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

def benchmark_latency(prompt, model, budget_tokens=None):
    kwargs = {
        'model': model,
        'max_tokens': 2000,
        'messages': [{'role': 'user', 'content': prompt}]
    }
    if budget_tokens:
        kwargs['thinking'] = {'type': 'enabled', 'budget_tokens': budget_tokens}
        kwargs['max_tokens'] = budget_tokens + 2000

    start = time.time()
    response = client.messages.create(**kwargs)
    elapsed = time.time() - start
    answer = response.content[-1].text
    print(f'{model} (budget={budget_tokens}): {elapsed:.1f}s')
    return elapsed, answer

benchmark_latency('Name 3 planets', 'claude-haiku-4-5')
benchmark_latency('Solve x^2 - 5x + 6 = 0', 'claude-opus-4-5', 3000)
benchmark_latency('Design a fault-tolerant payment system', 'claude-opus-4-5', 10000)

Czas do pierwszego tokena w trybie strumieniowym

import anthropic
import time

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

def stream_with_timing(prompt):
    start = time.time()
    first_token_time = None
    full_text = ''

    with client.messages.stream(
        model='claude-opus-4-5',
        max_tokens=10000,
        thinking={'type': 'enabled', 'budget_tokens': 5000},
        messages=[{'role': 'user', 'content': prompt}]
    ) as stream:
        in_answer = False
        for text_chunk in stream.text_stream:
            if not in_answer:
                in_answer = True
                first_token_time = time.time() - start
                print(f'Time to first answer token: {first_token_time:.1f}s')
            full_text += text_chunk
            print(text_chunk, end='', flush=True)

    total_time = time.time() - start
    print(f'\nTotal time: {total_time:.1f}s')

stream_with_timing('List 5 key benefits of microservices.')

Wzorzec architektury hybrydowej

import anthropic

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

def hybrid_query(question, quality_threshold=0.7):
    # Step 1: Try fast model first
    r_fast = client.messages.create(
        model='claude-haiku-4-5',
        max_tokens=300,
        messages=[{'role': 'user', 'content': question}]
    )
    fast_answer = r_fast.content[0].text

    # Step 2: Quick confidence check
    confidence_check = client.messages.create(
        model='claude-haiku-4-5',
        max_tokens=20,
        messages=[{
            'role': 'user',
            'content': (
                f'Q: {question}\nA: {fast_answer}\n'
                f'Rate answer quality 0.0-1.0. Number only:'
            )
        }]
    )
    try:
        quality = float(confidence_check.content[0].text.strip())
    except ValueError:
        quality = 0.5

    if quality >= quality_threshold:
        return fast_answer, 'fast'

    # Step 3: Escalate to reasoning model
    r_slow = client.messages.create(
        model='claude-opus-4-5',
        max_tokens=8000,
        thinking={'type': 'enabled', 'budget_tokens': 6000},
        messages=[{'role': 'user', 'content': question}]
    )
    return next(b.text for b in r_slow.content if b.type == 'text'), 'reasoning'

Koszt w dużej skali: obliczenia

def project_monthly_cost(daily_queries, model_config):
    """
    Project monthly API costs for different configurations.
    model_config: dict with 'cost_per_query' key
    """
    monthly_queries = daily_queries * 30
    monthly_cost = monthly_queries * model_config['cost_per_query']

    print(f'Daily queries: {daily_queries:,}')
    print(f'Monthly queries: {monthly_queries:,}')
    print(f'Cost per query: ${model_config["cost_per_query"]:.4f}')
    print(f'Monthly cost: ${monthly_cost:,.2f}')
    return monthly_cost

# Compare configurations at 10,000 queries/day
configs = [
    {'name': 'All Haiku', 'cost_per_query': 0.0005},
    {'name': 'All Sonnet', 'cost_per_query': 0.015},
    {'name': 'All Opus+Thinking', 'cost_per_query': 0.85},
    {'name': 'Hybrid (90% Haiku, 10% Opus)', 'cost_per_query': 0.9*0.0005 + 0.1*0.85},
]

for config in configs:
    print(f'\n--- {config["name"]} ---')
    project_monthly_cost(10_000, config)

Buforowanie promptów w celu obniżenia kosztów

import anthropic

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

LONG_CONTEXT = 'A' * 50000  # Simulated large document

# With prompt caching: mark large context as cacheable
response = client.messages.create(
    model='claude-opus-4-5',
    max_tokens=10000,
    thinking={'type': 'enabled', 'budget_tokens': 6000},
    system=[
        {
            'type': 'text',
            'text': f'You are analyzing this document: {LONG_CONTEXT}',
            'cache_control': {'type': 'ephemeral'}  # Cache this prefix
        }
    ],
    messages=[{
        'role': 'user',
        'content': 'What are the main themes in this document?'
    }]
)

usage = response.usage
print(f'Cache read tokens: {getattr(usage, "cache_read_input_tokens", 0):,}')
print(f'Cache creation tokens: {getattr(usage, "cache_creation_input_tokens", 0):,}')
# Second call with same system content costs ~90% less on cached tokens

Przetwarzanie wsadowe w celu obniżenia kosztów

import anthropic
import json

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

# Batch API: 50% cheaper, 24-hour turnaround
requests = [
    {
        'custom_id': f'query_{i}',
        'params': {
            'model': 'claude-opus-4-5',
            'max_tokens': 1024,
            'messages': [{'role': 'user', 'content': f'Analyze dataset row {i}'}]
        }
    }
    for i in range(100)  # 100 queries in one batch
]

# Submit batch
batch = client.messages.batches.create(requests=requests)
print(f'Batch ID: {batch.id}')
print(f'Status: {batch.processing_status}')
print(f'Requests: {batch.request_counts}')
# Poll batch.id for results when processing_status == 'ended'

Optymalizacja budżetu tokenów

BUDGET_LOOKUP = {
    'simple_math':        1000,   # Arithmetic, basic algebra
    'medium_code':        3000,   # Function implementation, debugging
    'complex_reasoning':  8000,   # System design, complex analysis
    'research_grade':    16000,   # Proofs, research-level problems
}

def budget_for_query(query):
    q_lower = query.lower()
    if any(kw in q_lower for kw in ['calculate', 'what is', 'how many', 'convert']):
        return BUDGET_LOOKUP['simple_math']
    elif any(kw in q_lower for kw in ['code', 'function', 'bug', 'implement']):
        return BUDGET_LOOKUP['medium_code']
    elif any(kw in q_lower for kw in ['design', 'architecture', 'analyze', 'strategy']):
        return BUDGET_LOOKUP['complex_reasoning']
    else:
        return BUDGET_LOOKUP['medium_code']  # Safe default

print(budget_for_query('What is 15% of 340?'))       # 1000
print(budget_for_query('Implement a trie in Python')) # 3000
print(budget_for_query('Design a CDC pipeline'))      # 8000

Ustalanie umów SLA dla aplikacji LLM

Sprawdzenie wiedzy: koszty modeli rozumujących

Podsumowanie: kompromisy między kosztem a opóźnieniem