O Amazon Bedrock agora oferece cache de prompt para o Claude 4.6, um recurso que pode diminuir a latência de resposta e reduzir os gastos com inferência para aplicações de IA generativa. A capacidade funciona memorizando uma parte estática de um prompt por até cinco minutos, de modo que chamadas subsequentes ignorem o custoso reprocessamento desse texto.

Como o cache se encaixa na cadeia de requisições

Quando uma requisição para o Claude 4.6 chega, duas camadas cooperam.

  • Nível do modelo – O Claude 4.6 mantém um cache de chave-valor (KV) na memória da GPU. Na primeira vez que o modelo analisa um bloco de instruções, ele armazena a representação interna resultante. Em chamadas posteriores que reutilizam o mesmo bloco, o modelo pode recuperar a representação em vez de recomputá-la.

  • Nível do Bedrock – O Bedrock computa um fingerprint do segmento estático do prompt. Se uma nova requisição contiver um fingerprint correspondente, o Bedrock a direciona diretamente para a GPU que já possui o estado em cache, ignorando a etapa de "warm-up".

Pense nisso como carregar um jogo salvo em vez de começar um novo toda vez.

Regras que mantêm o cache ativo

  1. Contagem mínima de tokens – O Claude Sonnet 4.6 exige pelo menos 1.024 tokens no segmento em cache; o Claude Opus 4.6 precisa de 4.096 tokens. Qualquer valor menor é ignorado.

  2. Tempo de vida de cinco minutos – O cache expira após cinco minutos de inatividade. Cada acesso (hit) reinicia o cronômetro, portanto, um fluxo constante de chamadas pode manter o cache vivo indefinidamente.

  3. Ordenação do prompt – O Bedrock lê o prompt sequencialmente. As instruções estáticas devem aparecer primeiro, seguidas por um marcador cachePoint, com todas as mensagens geradas pelo usuário após esse marcador. Alterar até mesmo um único caractere antes do marcador quebra o fingerprint e força uma leitura a frio (cold read).

Colocando o recurso em prática

A API Bedrock Converse é o ponto de entrada. Abaixo está um snippet minimalista em Python que demonstra a estrutura necessária.

import boto3

bedrock = boto3.client("bedrock-runtime", region_name="us-east-1")
MODEL_ID = "anthropic.claude-sonnet-4-6"

# Must be >1,024 tokens for Sonnet
BASE_SYSTEM_PROMPT = "Your long instructions here..."

system_configuration = [
    {"text": BASE_SYSTEM_PROMPT},
    {"cachePoint": {"type": "default"}}
]

conversation_history = []

def run_chat_turn(user_input):
    global conversation_history
    conversation_history.append(
        {"role": "user", "content": [{"text": user_input}]}
    )

    response = bedrock.converse(
        modelId=MODEL_ID,
        system=system_configuration,
        messages=conversation_history,
        inferenceConfig={"maxTokens": 500, "temperature": 0.4}
    )

    assistant_message = response["output"]["message"]
    conversation_history.append(assistant_message)

    metrics = response["usage"]
    print(f"Read from cache: {metrics.get('cacheReadInputTokens', 0)}")

O cachePoint informa ao Bedrock onde o segmento imutável termina. Após a primeira chamada, a métrica cacheReadInputTokens deve mostrar um valor diferente de zero, confirmando que o cache foi utilizado.

Por que os desenvolvedores devem se importar

Separar instruções estáticas de entradas dinâmicas de usuários transfere o trabalho de ciclos caros de GPU para uma etapa de roteamento leve. Para chatbots, pipelines de geração aumentada por recuperação (RAG) ou qualquer serviço que repita o mesmo prompt de sistema, o resultado são respostas mais rápidas e contagens de tokens faturáveis menores. Em cenários de alta taxa de transferência (high-throughput), mesmo uma redução modesta no tempo de computação pode se traduzir em economias de custo perceptíveis.

Limites e trade-offs

O recurso só ajuda quando o segmento do prompt atende aos mínimos de tokens e permanece inalterado. Aplicações que alteram frequentemente as instruções do sistema, ou que dependem de prompts curtos, verão pouco benefício. A janela de cinco minutos também significa que o tráfego em rajadas (bursty traffic) com longos intervalos de inatividade pode incorrer repetidamente em leituras a frio (cold reads), erodindo a vantagem de latência. Por fim, o cache reside na memória da GPU; se múltiplos modelos compartilharem o mesmo hardware, a contenção pode afetar o desempenho, embora o Bedrock não exponha esses detalhes.

O que observar a seguir

  • Dashboards de métricas – Fique de olho em cacheReadInputTokens e na latência geral para verificar se o cache está sendo usado conforme o pretendido.
  • Engenharia de prompt – Projetar prompts que satisfaçam os limites de tamanho sem inflar a requisição é uma nova disciplina para os desenvolvedores.
  • Extensões futuras – Se o Bedrock expandir a duração do cache ou flexibilizar os limites de tokens, a economia de conversas de longa duração poderá mudar ainda mais.

Resumo: O cache de prompt oferece aos usuários do Claude 4.6 uma alavanca concreta para reduzir tanto o tempo de resposta quanto os gastos, desde que consigam travar um prompt suficientemente grande e imutável e manter as chamadas dentro de uma janela curta. Para qualquer serviço de GenAI que repita as mesmas instruções de sistema, o recurso vale a pena ser testado cedo.