0Pricing
AI Prompt Engineering · Aula

Relações de compromisso entre custo e latência

Orçamentos de tokens para raciocínio, custos de inferência e estratégias de roteamento híbrido.

Relações de compromisso entre custo e latência é uma aula grátis de AI Prompt Engineering no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de AI Prompt Engineering, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de AI Prompt Engineering inclui 4 aulas no total.

O triângulo custo-qualidade-latência

No projeto de sistemas com LLM, existe um triângulo fundamental: custo, qualidade e latência. A cada momento, é possível otimizar no máximo dois desses três aspectos.

  • Baixo custo + Alta qualidade = Lento (modelos de raciocínio, geração lenta)
  • Baixo custo + Baixa latência = Qualidade inferior (modelos pequenos e rápidos)
  • Alta qualidade + Baixa latência = Caro (modelo de raciocínio com transmissão contínua)

Toda decisão de arquitetura envolve um compromisso dentro desse triângulo.

Preços de modelos de raciocínio

Os tokens de pensamento têm um custo adicional aos tokens padrão de entrada e saída. O custo de uma chamada a um modelo de raciocínio inclui: tokens de entrada + tokens de pensamento + tokens de saída.

Em comparação com modelos rápidos e pequenos: o3 é aproximadamente 20 vezes mais caro por token que o GPT-4o-mini; o Claude Opus com raciocínio estendido é aproximadamente 10 a 15 vezes mais caro por token de saída que o Claude Haiku.

# 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}')

Sobrecarga dos tokens de pensamento

Os tokens de pensamento costumam ser muito mais numerosos que os tokens de saída. Uma resposta concisa de 200 palavras pode ter como base de 5.000 a 15.000 tokens de pensamento. Esses tokens de pensamento custam tanto quanto os tokens de saída.

É por isso que o multiplicador de custo dos modelos de raciocínio é determinado principalmente pelos tokens de pensamento, e não pelo tamanho da resposta.

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
)

Latência: o que esperar

Faixas de latência observadas para diferentes configurações de modelo (variam significativamente conforme a carga e a dificuldade do problema):

  • Claude Haiku: 0,5 a 2 segundos
  • Claude Sonnet: 2 a 8 segundos
  • Claude Opus (sem raciocínio): 5 a 15 segundos
  • Claude Opus (raciocínio 5K): 15 a 40 segundos
  • Claude Opus (raciocínio 16K): 40 a 90 segundos
  • o3 (alto esforço): 30 a 120 segundos
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)

Tempo até o primeiro token com transmissão contínua

Embora a latência total dos modelos de raciocínio seja alta, o tempo até o primeiro token (TTFT) com transmissão contínua pode ser muito menor: o modelo começa a transmitir a resposta imediatamente depois de terminar o raciocínio. Mostre algo ao usuário rapidamente usando a transmissão contínua.

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.')

O padrão de arquitetura híbrida

Um padrão prático para produção: use primeiro um modelo padrão rápido. Se o resultado for satisfatório, verifique isso com sua métrica de qualidade e retorne-o imediatamente. Caso contrário, encaminhe a solicitação para um modelo de raciocínio. Assim, você obtém baixa latência e baixo custo médios, mantendo alta precisão nos casos difíceis.

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'

Custo em escala: fazendo as contas

Modelos de raciocínio que parecem acessíveis nos testes se tornam custos significativos em escala. Sempre projete os custos antes de escolher uma arquitetura.

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)

Armazenamento em cache de instruções para reduzir custos

Para chamadas a modelos de raciocínio com instruções de sistema ou contexto longos e repetidos, use o armazenamento em cache de instruções. Tokens armazenados em cache custam 90% menos que tokens não armazenados em cache. Isso é especialmente importante quando o mesmo contexto amplo, como documentos ou código, é enviado repetidamente.

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

Processamento em lote para obter eficiência de custos

A OpenAI e a Anthropic oferecem APIs de processamento em lote com descontos de 50% para solicitações que não são sensíveis ao tempo. Se você tiver grandes volumes de consultas que podem esperar horas pelos resultados, o processamento em lote será a opção mais econômica.

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'

Otimização do orçamento de tokens

Dimensione corretamente budget_tokens para sua classe de problema. Usar um orçamento de 16K em um problema simples desperdiça tokens e aumenta a latência. Crie uma tabela de consulta de orçamento baseada em níveis de dificuldade do problema.

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

Definição de SLAs para aplicações com LLM

Antes de escolher entre modelos padrão e modelos de raciocínio, defina os requisitos de Acordo de Nível de Serviço (SLA) da sua aplicação:

  • Latência P50: experiência típica do usuário
  • Latência P99: experiência do usuário no pior caso
  • Orçamento de tokens: custo máximo por consulta do usuário
  • Patamar mínimo de qualidade: precisão mínima aceitável no seu conjunto de testes

Os modelos de raciocínio violam facilmente os SLAs de latência P99 em aplicações interativas. Conheça suas restrições antes de finalizar as decisões de arquitetura.

Verificação de conhecimento: custos de modelos de raciocínio

Qual é o principal fator dos custos elevados ao usar modelos de raciocínio em comparação com modelos padrão?

Recapitulação: compromissos entre custo e latência

Os modelos de raciocínio são caros: os tokens de pensamento são cobrados como tokens de saída e podem ser de 10 a 50 vezes mais numerosos que a resposta visível. A latência varia de 15 a 120 segundos para problemas difíceis. Reduza esses impactos usando: o padrão híbrido, com um modelo rápido primeiro e encaminhamento apenas quando a confiança for baixa; o armazenamento em cache de instruções para contextos grandes repetidos, com desconto de 90% nos tokens armazenados; a API de processamento em lote para cargas de trabalho off-line, com desconto de 50%; e o dimensionamento correto de budget_tokens conforme a dificuldade do problema. Em escala, até mesmo pequenos custos por consulta se multiplicam e geram grandes faturas mensais. Sempre projete os custos antes de se comprometer com uma arquitetura.

Perguntas Frequentes

A aula “Relações de compromisso entre custo e latência” é grátis?

Sim — o texto completo de “Relações de compromisso entre custo e latência” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de AI Prompt Engineering, atualize para CoddyKit PRO. O curso de AI Prompt Engineering inclui 4 aulas no total.

O que vou aprender em “Relações de compromisso entre custo e latência”?

Orçamentos de tokens para raciocínio, custos de inferência e estratégias de roteamento híbrido. Você pratica AI Prompt Engineering com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar AI Prompt Engineering?

Nenhuma experiência prévia é necessária. AI Prompt Engineering no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.

Quanto tempo leva a aula “Relações de compromisso entre custo e latência”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de AI Prompt Engineering?

Sim. Cada aula de AI Prompt Engineering inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Como os modelos de raciocínio são diferentes
  2. Prompts eficazes para raciocínio prolongado
  3. Quando usar modelos de raciocínio ou modelos padrão
  4. Relações de compromisso entre custo e latência
← Voltar para AI Prompt Engineering