Claude Platform Docs
MensagensGerenciamento de contexto

Cache de prompt

Armazene em cache prefixos de prompt com cache_control para reduzir custos e latência, usando cache automático ou breakpoints explícitos com TTLs de 5 minutos ou 1 hora.

O uso varia conforme o produto

Messages API
Ative com cache_control, no nível superior ou em blocos.
Managed Agents
Sempre ativoAs entradas de cache usam um tempo de vida de 5 minutos por padrão, e as leituras e gravações de cache aparecem no uso da sessão.

O “prompt caching” (cache de prompt) otimiza o uso da API permitindo que a API retome a partir de prefixos específicos em seus prompts. Isso reduz significativamente o tempo de processamento e os custos para tarefas repetitivas ou prompts com elementos consistentes.

Há duas maneiras de habilitar o cache de prompt:

  • Cache automático: Adicione um único campo cache_control no nível superior da sua solicitação. O sistema aplica automaticamente o “cache breakpoint” (ponto de interrupção de cache) ao último bloco armazenável em cache e o move para frente à medida que as conversas crescem. Ideal para conversas de vários turnos em que o histórico crescente de mensagens deve ser armazenado em cache automaticamente.
  • Pontos de interrupção de cache explícitos: Coloque cache_control diretamente em blocos de conteúdo individuais para ter controle refinado sobre exatamente o que é armazenado em cache.

Uma maneira de começar é com o cache automático:

client = anthropic.Anthropic()

response = client.messages.create(
    model="claude-opus-5-5",
    max_tokens=1024,
    cache_control={"type": "ephemeral"},
    system="You are an AI assistant tasked with analyzing literary works. Your goal is to provide insightful commentary on themes, characters, and writing style.",
    messages=[
        {
            "role": "user",
            "content": "Analyze the major themes in 'Pride and Prejudice'.",
        }
    ],
)
print(response.usage.model_dump_json())

Com o cache automático, o sistema armazena em cache todo o conteúdo até o último bloco armazenável em cache, inclusive. Em solicitações subsequentes com o mesmo prefixo, o conteúdo em cache é reutilizado automaticamente.


Como o cache de prompt funciona

Quando você envia uma solicitação com o cache de prompt habilitado:

  1. O sistema verifica se um prefixo do prompt, até um ponto de interrupção de cache especificado, já está em cache a partir de uma consulta recente.
  2. Se encontrado, ele usa a versão em cache, reduzindo o tempo de processamento e os custos.
  3. Caso contrário, ele processa o prompt completo e armazena o prefixo em cache assim que a resposta começa.

Isso é especialmente útil para:

  • Prompts com muitos exemplos
  • Grandes quantidades de contexto ou informações de base
  • Tarefas repetitivas com instruções consistentes
  • Conversas longas de vários turnos

Por padrão, o cache tem um tempo de vida de 5 minutos. O cache é renovado sem custo adicional cada vez que o conteúdo em cache é usado.

O tempo de vida é medido a partir do início da solicitação que grava ou lê a entrada de cache, e não a partir do fim de sua resposta. O tempo gasto gerando uma resposta conta contra o tempo de vida: se uma resposta leva 4 minutos para fazer streaming, uma solicitação subsequente que reutilize o mesmo prefixo em cache deve começar em cerca de 1 minuto após a conclusão dessa resposta.

Se 5 minutos for muito pouco, você pode usar uma duração de cache de 1 hora com custo adicional (consulte Preços).

O cache de prompt abrange o prefixo completo: tools, system e messages (nessa ordem), até o bloco designado com cache_control, inclusive.


Preços

O cache de prompt tem preços próprios. A tabela a seguir mostra o preço por milhão de tokens para cada modelo suportado:

ModeloTokens baseCache de prompt
NomeEntradaSaídaGravações de 5 minGravações de 1hAcertos e renovações
Claude Fable 5.2For demanding reasoning and long-horizon agentic work
US$ 8 / MTok
US$ 40 / MTok
US$ 10 / MTok
US$ 16 / MTok
US$ 0,20 / MTok1
Claude Opus 5.5For long-running agentic coding and knowledge work
US$ 4 / MTok
US$ 20 / MTok
US$ 5 / MTok
US$ 8 / MTok
US$ 0,20 / MTok2
Claude Sonnet 5.5The best combination of speed and intelligence
US$ 2 / MTok
US$ 10 / MTok
US$ 2,50 / MTok
US$ 4 / MTok
US$ 0,10 / MTok2
Claude Haiku 5.5For high-volume, latency-sensitive tasks such as classification, extraction, and routing
US$ 0,10 / MTokpara prompts de até 100.000 tokens
US$ 0,50 / MTok
US$ 0,125 / MTok
US$ 0,20 / MTok
US$ 0,01 / MTok
US$ 0,50 / MTokpara prompts acima de 100.000 tokens
US$ 2,50 / MTok
US$ 0,625 / MTok
US$ 1 / MTok
US$ 0,05 / MTok
US$ 8 / MTok
US$ 40 / MTok
US$ 10 / MTok
US$ 16 / MTok
US$ 0,20 / MTok1
US$ 10 / MTok
US$ 50 / MTok
US$ 12,50 / MTok
US$ 20 / MTok
US$ 0,25 / MTok1
US$ 10 / MTok
US$ 50 / MTok
US$ 12,50 / MTok
US$ 20 / MTok
US$ 0,25 / MTok1
US$ 10 / MTok
US$ 50 / MTok
US$ 12,50 / MTok
US$ 20 / MTok
US$ 1 / MTok
US$ 10 / MTok
US$ 50 / MTok
US$ 12,50 / MTok
US$ 20 / MTok
US$ 1 / MTok
US$ 5 / MTok
US$ 25 / MTok
US$ 6,25 / MTok
US$ 10 / MTok
US$ 0,50 / MTok
US$ 5 / MTok
US$ 25 / MTok
US$ 6,25 / MTok
US$ 10 / MTok
US$ 0,50 / MTok
US$ 5 / MTok
US$ 25 / MTok
US$ 6,25 / MTok
US$ 10 / MTok
US$ 0,50 / MTok
US$ 5 / MTok
US$ 25 / MTok
US$ 6,25 / MTok
US$ 10 / MTok
US$ 0,50 / MTok
US$ 5 / MTok
US$ 25 / MTok
US$ 6,25 / MTok
US$ 10 / MTok
US$ 0,50 / MTok
Claude Opus 4.1
US$ 15 / MTok
US$ 75 / MTok
US$ 18,75 / MTok
US$ 30 / MTok
US$ 1,50 / MTok
Claude Opus 4
US$ 15 / MTok
US$ 75 / MTok
US$ 18,75 / MTok
US$ 30 / MTok
US$ 1,50 / MTok
US$ 2 / MTok
US$ 10 / MTok
US$ 2,50 / MTok
US$ 4 / MTok
US$ 0,20 / MTok
US$ 3 / MTok
US$ 15 / MTok
US$ 3,75 / MTok
US$ 6 / MTok
US$ 0,30 / MTok
US$ 3 / MTok
US$ 15 / MTok
US$ 3,75 / MTok
US$ 6 / MTok
US$ 0,30 / MTok
Claude Sonnet 4
US$ 3 / MTok
US$ 15 / MTok
US$ 3,75 / MTok
US$ 6 / MTok
US$ 0,30 / MTok
US$ 1 / MTok
US$ 5 / MTok
US$ 1,25 / MTok
US$ 2 / MTok
US$ 0,10 / MTok

1 Os cache hits e as atualizações de cache em Claude Fable 5.2, Claude Mythos 5.2, Claude Fable 5.1 e Claude Mythos 5.1 custam 0,025x o preço base de entrada.

2 Os cache hits e as atualizações de cache em Claude Opus 5.5 e Claude Sonnet 5.5 custam 0,05x o preço base de entrada.

Todos os outros modelos usam o multiplicador padrão de 0,1x.


Modelos suportados

O cache de prompt (tanto automático quanto explícito) é suportado em todos os modelos Claude ativos.


Cache automático

O cache automático habilita o cache de prompt com um único campo. Em vez de colocar cache_control em blocos de conteúdo individuais, adicione um único campo cache_control no nível superior do corpo da sua solicitação. O sistema aplica automaticamente o ponto de interrupção de cache ao último bloco armazenável em cache.

client = anthropic.Anthropic()

response = client.messages.create(
    model="claude-opus-5-5",
    max_tokens=1024,
    cache_control={"type": "ephemeral"},
    system="You are a helpful assistant that remembers our conversation.",
    messages=[
        {"role": "user", "content": "My name is Alex. I work on machine learning."},
        {
            "role": "assistant",
            "content": "Nice to meet you, Alex! How can I help with your ML work today?",
        },
        {"role": "user", "content": "What did I say I work on?"},
    ],
)
print(response.usage.model_dump_json())

Como o cache automático funciona em conversas de vários turnos

Com o cache automático, o ponto de cache avança automaticamente à medida que as conversas crescem. Cada nova solicitação armazena em cache tudo até o último bloco armazenável em cache, e o conteúdo anterior é lido do cache.

SolicitaçãoConteúdoComportamento do cache
Solicitação 1System
+ User(1) + Asst(1)
+ User(2) ◀ cache
Tudo gravado no cache
Solicitação 2System
+ User(1) + Asst(1)
+ User(2) + Asst(2)
+ User(3) ◀ cache
System até User(2) lidos do cache;
Asst(2) + User(3) gravados no cache
Solicitação 3System
+ User(1) + Asst(1)
+ User(2) + Asst(2)
+ User(3) + Asst(3)
+ User(4) ◀ cache
System até User(3) lidos do cache;
Asst(3) + User(4) gravados no cache

O ponto de interrupção de cache se move automaticamente para o último bloco armazenável em cache em cada solicitação, então você não precisa atualizar nenhum marcador cache_control à medida que a conversa cresce.

Suporte a TTL

Por padrão, o cache automático usa um TTL de 5 minutos. Você pode especificar um TTL de 1 hora a 2x o preço base dos tokens de entrada:

{ "cache_control": { "type": "ephemeral", "ttl": "1h" } }

Combinando com cache em nível de bloco

O cache automático é compatível com pontos de interrupção de cache explícitos. Quando usados juntos, o ponto de interrupção de cache automático usa um dos 4 slots de breakpoint disponíveis.

Isso permite combinar as duas abordagens. Por exemplo, use um breakpoint explícito para armazenar em cache seu prompt do sistema, enquanto o cache automático cuida da conversa:

{
  "model": "claude-opus-5-5",
  "max_tokens": 1024,
  "cache_control": { "type": "ephemeral" },
  "system": [
    {
      "type": "text",
      "text": "You are a helpful assistant.",
      "cache_control": { "type": "ephemeral" }
    }
  ],
  "messages": [{ "role": "user", "content": "What are the key terms?" }]
}

O que permanece igual

O cache automático usa a mesma infraestrutura de cache subjacente. Preços, limites mínimos de tokens, requisitos de ordenação de contexto e a janela de retrospecção de 20 blocos se aplicam da mesma forma que com breakpoints explícitos.

Casos extremos

  • Se o último bloco já tiver um cache_control explícito com o mesmo TTL, o cache automático não tem efeito.
  • Se o último bloco tiver um cache_control explícito com um TTL diferente, a API retorna um erro 400.
  • Se já existirem 4 breakpoints explícitos em nível de bloco, a API retorna um erro 400 (não sobram slots para o cache automático).
  • Se o último bloco não for elegível como alvo de ponto de interrupção de cache automático, o sistema retrocede silenciosamente para encontrar o bloco elegível mais próximo. Se nenhum for encontrado, o cache é ignorado.

Pontos de interrupção de cache explícitos

Para ter mais controle sobre o cache, você pode colocar cache_control diretamente em blocos de conteúdo individuais. Isso é útil quando você precisa armazenar em cache seções diferentes que mudam em frequências diferentes, ou precisa de controle refinado sobre exatamente o que é armazenado em cache.

Estruturando seu prompt

Coloque o conteúdo estático (definições de ferramentas, instruções do sistema, contexto, exemplos) no início do seu prompt. Marque o fim do conteúdo reutilizável para cache usando o parâmetro cache_control.

Os prefixos de cache são criados na seguinte ordem: tools, system e depois messages. Essa ordem forma uma hierarquia em que cada nível se baseia nos anteriores.

Como funciona a verificação automática de prefixos

Você pode usar apenas um ponto de interrupção de cache no fim do seu conteúdo estático, e o sistema encontra automaticamente o prefixo mais longo que uma solicitação anterior já gravou no cache. Entender como isso funciona ajuda você a otimizar sua estratégia de cache.

Três princípios fundamentais:

  1. Gravações de cache ocorrem apenas no seu breakpoint. Marcar um bloco com cache_control grava exatamente uma entrada de cache: um hash do prefixo que termina nesse bloco. O sistema não grava entradas para nenhuma posição anterior. Como o hash é cumulativo, cobrindo tudo até o breakpoint, inclusive, alterar qualquer bloco no breakpoint ou antes dele produz um hash diferente na próxima solicitação.

  2. Leituras de cache procuram retroativamente entradas que solicitações anteriores gravaram. Em cada solicitação, o sistema calcula o hash do prefixo no seu breakpoint e verifica se há uma entrada de cache correspondente. Se não existir nenhuma, ele retrocede um bloco por vez, verificando se o hash do prefixo em cada posição anterior corresponde a algo que já está no cache. Ele procura gravações anteriores, não conteúdo estável.

  3. A janela de retrospecção é de 20 blocos. O sistema verifica no máximo 20 posições para cada breakpoint, contando o próprio breakpoint como a primeira. Se o sistema não encontrar nenhuma entrada correspondente nessa janela, a verificação para (ou é retomada a partir do próximo breakpoint explícito, se houver). Na Claude API, uma sequência de blocos tool_use consecutivos conta como uma posição, assim como uma sequência de blocos tool_result consecutivos, de modo que um turno com muitas chamadas de ferramentas paralelas não empurra sozinho a entrada da solicitação anterior para fora da janela.

Exemplo: Retrospecção em uma conversa crescente

Você adiciona novos blocos a cada turno e define cache_control no bloco final de cada solicitação:

  • Turno 1: 10 blocos, breakpoint no bloco 10. Não existem entradas de cache anteriores. O sistema grava uma entrada no bloco 10.
  • Turno 2: 15 blocos, breakpoint no bloco 15. O bloco 15 não tem entrada, então o sistema retrocede até o bloco 10 e encontra a entrada do turno 1. Acerto de cache no bloco 10. O sistema processa do zero apenas os blocos 11 a 15 e grava uma nova entrada no bloco 15.
  • Turno 3: 35 blocos, breakpoint no bloco 35. O sistema verifica 20 posições (blocos 35 a 16) e não encontra nada. A entrada do turno 2 no bloco 15 está uma posição fora da janela, então não há acerto de cache. Adicionar um segundo breakpoint no bloco 15 inicia uma segunda janela de retrospecção ali, que encontra a entrada do turno 2.

Erro comum: Breakpoint em conteúdo que muda a cada solicitação

Seu prompt tem um grande contexto de sistema estático (blocos 1 a 5) seguido por um bloco por solicitação contendo um timestamp e a mensagem do usuário (bloco 6). Você define cache_control no bloco 6:

  • Solicitação 1: Gravação de cache no bloco 6. O hash inclui o timestamp.
  • Solicitação 2: O timestamp é diferente, então o hash do prefixo no bloco 6 é diferente. A retrospecção percorre os blocos 5, 4, 3, 2 e 1, mas o sistema nunca gravou uma entrada em nenhuma dessas posições. Nenhum acerto de cache. Você paga por uma nova gravação de cache em cada solicitação e nunca obtém uma leitura.

A retrospecção não encontra conteúdo estável atrás do seu breakpoint para armazená-lo em cache. Ela encontra entradas que solicitações anteriores já gravaram, e as gravações ocorrem apenas nos breakpoints. Mova cache_control para o bloco 5, o último bloco que permanece igual entre solicitações, e cada solicitação subsequente lerá o prefixo em cache. O cache automático tem o mesmo problema: ele coloca o breakpoint no último bloco armazenável em cache, que nessa estrutura é aquele que muda a cada solicitação, então use um breakpoint explícito no bloco 5 em vez disso.

Principal conclusão: Coloque cache_control no último bloco cujo prefixo é idêntico entre as solicitações que você deseja que compartilhem um cache. Em uma conversa crescente, o bloco final funciona desde que cada turno adicione menos de 20 blocos: o conteúdo anterior nunca muda, então a retrospecção da próxima solicitação encontra a gravação anterior. Para um prompt com um sufixo variável (timestamps, contexto por solicitação, a mensagem recebida), coloque o breakpoint no fim do prefixo estático, não no bloco variável.

Quando usar múltiplos breakpoints

Você pode definir até 4 pontos de interrupção de cache se quiser:

  • Armazenar em cache seções diferentes que mudam em frequências diferentes (por exemplo, as ferramentas raramente mudam, mas o contexto é atualizado diariamente)
  • Ter mais controle sobre exatamente o que é armazenado em cache
  • Garantir um acerto de cache quando uma conversa crescente empurra seu breakpoint 20 ou mais blocos além da última gravação de cache

Entendendo os custos de cache breakpoints

Os pontos de interrupção de cache em si não adicionam nenhum custo. Você só é cobrado por:

  • Gravações de cache: Quando novo conteúdo é gravado no cache (25% a mais que os tokens de entrada base para TTL de 5 minutos)
  • Leituras de cache: Quando o conteúdo em cache é usado (10% do preço base dos tokens de entrada, com exceções por modelo)
  • Tokens de entrada regulares: Para qualquer conteúdo não armazenado em cache

Adicionar mais breakpoints cache_control não aumenta seus custos; você continua pagando o mesmo valor com base no conteúdo que é realmente armazenado e lido do cache. Os breakpoints dão a você controle sobre quais seções podem ser armazenadas em cache de forma independente.


Estratégias e considerações de cache

Limitações do cache

Na Claude API, na Claude Platform on AWS, em Claude Models on Google Cloud (Google managed) e no Microsoft Foundry, o comprimento mínimo de prompt armazenável em cache é:

Esses mínimos se aplicam em cada uma dessas plataformas onde o modelo está disponível.

Prompts mais curtos não podem ser armazenados em cache, mesmo se marcados com cache_control. Quaisquer solicitações para armazenar em cache menos que esse número de tokens são processadas sem cache, e nenhum erro é retornado. Para verificar se um prompt foi armazenado em cache, observe os campos de uso da resposta: se tanto cache_creation_input_tokens quanto cache_read_input_tokens forem 0, o prompt não foi armazenado em cache (provavelmente porque não atendeu ao requisito de comprimento mínimo).

Se o seu prompt ficar um pouco abaixo do mínimo para seu modelo e plataforma, expandir o conteúdo em cache para atingir o limite geralmente vale a pena. Leituras de cache custam significativamente menos que tokens de entrada não armazenados em cache, então atingir o mínimo pode reduzir custos para prompts reutilizados com frequência.

Para solicitações simultâneas, observe que uma entrada de cache só fica disponível depois que a primeira resposta começa. Se você precisar de acertos de cache para solicitações paralelas, aguarde a primeira resposta antes de enviar as solicitações subsequentes.

ephemeral é o único tipo de cache suportado, que por padrão tem um tempo de vida de 5 minutos.

O que pode ser armazenado em cache

A maioria dos blocos da solicitação pode ser armazenada em cache. Isso inclui:

  • Ferramentas: definições de ferramentas no array tools
  • Mensagens do sistema: blocos de conteúdo no array system
  • Mensagens de texto: blocos de conteúdo no array messages.content, tanto em turnos do usuário quanto do assistente
  • Imagens e documentos: blocos de conteúdo no array messages.content, em turnos do usuário
  • Uso de ferramentas e resultados de ferramentas: blocos de conteúdo no array messages.content, tanto em turnos do usuário quanto do assistente

Cada um desses elementos pode ser armazenado em cache, automaticamente ou marcando-os com cache_control.

O que não pode ser armazenado em cache

Embora a maioria dos blocos da solicitação possa ser armazenada em cache, há algumas exceções:

  • Blocos de pensamento não podem ser armazenados em cache diretamente com cache_control. No entanto, blocos de pensamento PODEM ser armazenados em cache junto com outro conteúdo quando aparecem em turnos anteriores do assistente. Quando armazenados em cache dessa forma, eles CONTAM como tokens de entrada quando lidos do cache.

  • Blocos de subconteúdo (como citações) em si não podem ser armazenados em cache diretamente. Em vez disso, armazene em cache o bloco de nível superior.

    No caso de citações, os blocos de conteúdo de documento de nível superior que servem como material de origem para as citações podem ser armazenados em cache. Isso permite que você use o cache de prompt com citações de forma eficaz, armazenando em cache os documentos que as citações referenciam.

  • Blocos de texto vazios não podem ser armazenados em cache.

O que invalida o cache

Modificações no conteúdo em cache podem invalidar parte ou todo o cache.

Conforme descrito em Estruturando seu prompt, o cache segue a hierarquia: tools → system → messages. Alterações em cada nível invalidam esse nível e todos os níveis subsequentes.

A tabela a seguir mostra quais partes do cache são invalidadas por diferentes tipos de alterações. ✘ indica que o cache é invalidado, enquanto ✓ indica que o cache permanece válido.

O que mudaCache de ferramentasCache do sistemaCache de mensagensImpacto
Definições de ferramentas✘✘✘Modificar definições de ferramentas (nomes, descrições, parâmetros) invalida o cache inteiro
Ativação da pesquisa na web✓✘✘Ativar/desativar a pesquisa na web modifica o prompt do sistema
Ativação de citações✓✘✘Ativar/desativar citações modifica o prompt do sistema
Configuração de velocidade✓✘✘Alternar entre speed: "fast" e a velocidade padrão invalida os caches do sistema e de mensagens
Escolha de ferramenta✓✓✘Alterações no parâmetro tool_choice afetam apenas os blocos de mensagens
Imagens✓✓✘Adicionar/remover imagens em qualquer lugar do prompt afeta os blocos de mensagens
Parâmetros de pensamentoEspecífico do modeloEspecífico do modelo✘A configuração de pensamento (modo e budget_tokens no modo estendido) é renderizada no prompt, então alterá-la sempre invalida os blocos de mensagens; os caches de ferramentas e do sistema também são invalidados em modelos que renderizam a configuração antes deles. Consulte Pensamento e cache de prompt.
Configuração de esforçoEspecífico do modeloEspecífico do modelo✘Alterar o valor de output_config.effort pode invalidar os blocos de mensagens e, em alguns modelos, também os caches de ferramentas e do sistema (consulte Pensamento e cache de prompt). Definir o esforço explicitamente como o padrão do modelo equivale a omiti-lo e não invalida. Em modelos que suportam esforço por mensagem, uma alteração de esforço transmitida em uma mensagem role: "system" dentro de messages mantém o prefixo em cache intacto.
Resultados que não são de ferramentas passados para solicitações com pensamento✓✓Específico do modeloNo Claude Opus 4.5 e em modelos Opus posteriores, no Claude Sonnet 4.6 e em modelos Sonnet posteriores, no Claude Haiku 5.5 e em todos os modelos Claude Fable e Claude Mythos, os blocos de pensamento são preservados por padrão, então o cache permanece válido (✓). Em outros modelos, todos os blocos de pensamento previamente armazenados em cache são removidos do contexto, e quaisquer mensagens que sigam esses blocos de pensamento são removidas do cache (✘). Para mais detalhes, consulte Cache com blocos de pensamento.
Blocos de pensamento descartados✓✓✘Quando a API descarta um bloco de pensamento que não é preservado naquela solicitação, o prefixo em cache muda a partir da posição desse bloco naquela solicitação. Blocos que o modelo receptor consegue ler, devolvidos sem alteração, mantêm o cache intacto.

Em modelos que suportam alterações de ferramentas no meio da conversa, o cabeçalho beta inline-tools-2026-09-15 permite adicionar uma ferramenta, ou alterar a definição de uma ferramenta, no meio de uma conversa sem editar tools. Envie a definição em um bloco tool_addition em uma mensagem do sistema no meio da conversa e mantenha tools exatamente como você o enviou inicialmente. O prefixo em cache continua correspondendo, então apenas a mensagem adicionada é processada como nova entrada. A única exceção é um array tools sem nenhuma ferramenta não adiada, em que a primeira ferramenta definida dessa forma custa uma falha de cache completa naquela solicitação. Consulte Definir ferramentas em uma mensagem.

Acompanhando o desempenho do cache

Monitore o desempenho do cache usando estes campos de resposta da API, dentro de usage na resposta (ou no evento message_start se estiver usando streaming):

  • cache_creation_input_tokens: Número de tokens gravados no cache ao criar uma nova entrada
  • cache_read_input_tokens: Número de tokens recuperados do cache para esta solicitação
  • input_tokens: Número de tokens de entrada que não foram lidos do cache nem usados para criar um cache (ou seja, tokens após o último ponto de interrupção de cache)

Cache com blocos de pensamento

Ao usar pensamento com cache de prompt, os blocos de pensamento têm um comportamento especial:

Cache automático junto com outro conteúdo: Embora os blocos de pensamento não possam ser marcados explicitamente com cache_control, eles são armazenados em cache como parte do conteúdo da solicitação quando você faz chamadas subsequentes à API com resultados de ferramentas. Isso ocorre comumente durante o uso de ferramentas, quando você devolve os blocos de pensamento para continuar a conversa.

Contagem de tokens de entrada: Quando os blocos de pensamento são lidos do cache, eles contam como tokens de entrada nas suas métricas de uso. Isso é importante para o cálculo de custos e o orçamento de tokens.

Padrões de invalidação do cache:

  • O cache permanece válido quando apenas resultados de ferramentas são fornecidos como mensagens do usuário.
  • No Claude Opus 4.5 e em modelos Opus posteriores, no Claude Sonnet 4.6 e em modelos Sonnet posteriores, no Claude Haiku 5.5 e em todos os modelos Claude Fable e Claude Mythos, os blocos de pensamento são preservados por padrão mesmo quando conteúdo de usuário que não é resultado de ferramenta é adicionado, então o cache permanece válido.
  • Em outros modelos, adicionar conteúdo de usuário que não é resultado de ferramenta invalida o cache e remove todos os blocos de pensamento anteriores do contexto.
  • Esse comportamento de cache ocorre mesmo sem marcadores cache_control explícitos.

Para mais detalhes sobre a invalidação do cache, consulte O que invalida o cache.

Exemplo com uso de ferramentas:

Request 1: User: "What's the weather in Paris?"
Response: [thinking_block_1] + [tool_use block 1]

Request 2:
User: ["What's the weather in Paris?"],
Assistant: [thinking_block_1] + [tool_use block 1],
User: [tool_result_1, cache=True]
Response: [thinking_block_2] + [text block 2]
# Request 2 caches its request content (not the response)
# The cache includes: user message, thinking_block_1, tool_use block 1, and tool_result_1

Request 3:
User: ["What's the weather in Paris?"],
Assistant: [thinking_block_1] + [tool_use block 1],
User: [tool_result_1, cache=True],
Assistant: [thinking_block_2] + [text block 2],
User: [Text response, cache=True]
# Depending on the model, this non-tool-result user block either keeps prior thinking blocks or strips them (see the next paragraph)

Nos modelos que mantêm o pensamento anterior, os blocos de pensamento anteriores permanecem no contexto por padrão e continuam sendo parte do prefixo em cache. Em outros modelos, todos os blocos de pensamento anteriores são removidos do contexto neste ponto.

Para informações mais detalhadas, consulte Pensamento e cache de prompt.

Armazenamento e compartilhamento de cache

  • Isolamento de organização e workspace: Os caches são isolados entre organizações. Organizações diferentes nunca compartilham caches, mesmo que usem prompts idênticos. Os caches também são isolados por workspace dentro de uma organização na Claude API, na Claude Platform on AWS e no Microsoft Foundry; Claude Models on Google Cloud (Google managed) e o Bedrock usam apenas isolamento em nível de organização.

  • Correspondência exata: Acertos de cache exigem segmentos de prompt 100% idênticos, incluindo todo o texto e as imagens até o bloco marcado com controle de cache, inclusive.

  • Geração de tokens de saída: O cache de prompt não tem efeito na geração de tokens de saída. A resposta que você recebe é idêntica à que você obteria se o cache de prompt não fosse usado.

Melhores práticas para um cache eficaz

Para otimizar o desempenho do cache de prompt:

  • Comece com o cache automático para conversas de vários turnos. Ele gerencia os breakpoints automaticamente.
  • Use breakpoints explícitos em nível de bloco quando precisar armazenar em cache seções diferentes com frequências de alteração diferentes.
  • Armazene em cache conteúdo estável e reutilizável, como instruções do sistema, informações de base, contextos grandes ou definições de ferramentas frequentes.
  • Coloque o conteúdo em cache no início do prompt para obter o melhor desempenho.
  • Use pontos de interrupção de cache estrategicamente para separar diferentes seções de prefixo armazenáveis em cache.
  • Coloque o breakpoint no último bloco que permanece idêntico entre solicitações. Para um prompt com um prefixo estático e um sufixo variável (timestamps, contexto por solicitação, a mensagem recebida), esse é o fim do prefixo, não o bloco variável.
  • Analise regularmente as taxas de acerto de cache e ajuste sua estratégia conforme necessário.

Otimizando para diferentes casos de uso

Adapte sua estratégia de cache de prompt ao seu cenário:

  • Agentes conversacionais: Reduza o custo e a latência de conversas estendidas, especialmente aquelas com instruções longas ou documentos enviados.
  • Assistentes de programação: Melhore o preenchimento automático e as perguntas e respostas sobre a base de código mantendo seções relevantes ou uma versão resumida da base de código no prompt.
  • Processamento de documentos grandes: Incorpore material completo de formato longo, incluindo imagens, em seu prompt sem aumentar a latência da resposta.
  • Conjuntos de instruções detalhadas: Compartilhe listas extensas de instruções, procedimentos e exemplos para ajustar as respostas do Claude. Os desenvolvedores costumam incluir um ou dois exemplos no prompt, mas com o cache de prompt você pode obter um desempenho ainda melhor incluindo mais de 20 exemplos diversos de respostas de alta qualidade.
  • Uso de ferramentas agêntico: Melhore o desempenho em cenários que envolvem múltiplas chamadas de ferramentas e alterações iterativas de código, em que cada etapa normalmente exige uma nova chamada à API.
  • Livros, artigos, documentação, transcrições de podcasts e outros conteúdos de formato longo: Torne qualquer base de conhecimento interativa incorporando o(s) documento(s) inteiro(s) no prompt e permitindo que os usuários façam perguntas sobre ele.

Solução de problemas comuns

Se você enfrentar um comportamento inesperado:

  • Certifique-se de que as seções em cache sejam idênticas entre as chamadas. Para breakpoints explícitos, verifique se os marcadores cache_control estão nos mesmos locais.
  • Verifique se as chamadas são feitas dentro do tempo de vida do cache (5 minutos por padrão).
  • Verifique se tool_choice, o uso de imagens, a configuração de pensamento e output_config.effort permanecem consistentes entre as chamadas.
  • Valide se você está armazenando em cache pelo menos o número mínimo de tokens para seu modelo e plataforma (consulte Limitações do cache).
  • Confirme se o seu breakpoint está em um bloco que permanece idêntico entre solicitações. Gravações de cache ocorrem apenas no breakpoint e, se esse bloco mudar (timestamps, contexto por solicitação, a mensagem recebida), o hash do prefixo nunca corresponde. A retrospecção não encontra conteúdo estável atrás do breakpoint; ela encontra apenas entradas que solicitações anteriores gravaram em seus próprios breakpoints.
  • Verifique se as chaves em seus blocos de conteúdo tool_use têm ordenação estável, pois algumas linguagens (por exemplo, Swift, Go) randomizam a ordem das chaves durante a conversão para JSON, quebrando os caches.
  • Use o diagnóstico de cache para que a API compare solicitações consecutivas e informe qual parte do prompt divergiu.

Duração de cache de 1 hora

Se você achar que 5 minutos é muito pouco, a Anthropic também oferece uma duração de cache de 1 hora com custo adicional (consulte Preços).

Para usar o cache estendido, inclua ttl na definição de cache_control assim:

"cache_control": {
  "type": "ephemeral",
  "ttl": "1h"
}

A resposta inclui informações detalhadas de cache como as seguintes:

Output
{
  "usage": {
    "input_tokens": 2048,
    "cache_read_input_tokens": 1800,
    "cache_creation_input_tokens": 248,
    "output_tokens": 503,

    "cache_creation": {
      "ephemeral_5m_input_tokens": 148,
      "ephemeral_1h_input_tokens": 100
    }
  }
}

O campo cache_creation_input_tokens é igual à soma dos valores no objeto cache_creation.

Se você vir gravações ephemeral_5m_input_tokens que não solicitou ao usar ferramentas de servidor, como a pesquisa na web, consulte Resultados de ferramentas de servidor são armazenados em cache automaticamente.

Quando usar o cache de 1 hora

Se você usa um prompt em uma cadência regular (por exemplo, um prompt do sistema que você envia com mais frequência do que a cada 5 minutos), continue usando o cache de 5 minutos, pois ele continua sendo renovado sem custo adicional.

O cache de 1 hora é mais bem utilizado nos seguintes cenários:

  • Quando você tem prompts que provavelmente são usados com menos frequência do que a cada 5 minutos, mas com mais frequência do que a cada hora. Por exemplo, quando um agente secundário agêntico leva mais de 5 minutos, ou ao armazenar uma longa conversa de chat com um usuário e você geralmente espera que esse usuário possa não responder nos próximos 5 minutos.
  • Quando a latência é importante e seus prompts de acompanhamento podem ser enviados após 5 minutos.
  • Quando você deseja melhorar a utilização do seu limite de taxa, pois acertos de cache não são deduzidos do seu limite de taxa.

Combinando TTLs diferentes

Você pode usar controles de cache de 1 hora e de 5 minutos na mesma solicitação, mas com uma restrição importante: entradas de cache com TTL mais longo devem aparecer antes das com TTLs mais curtos (ou seja, uma entrada de cache de 1 hora deve aparecer antes de quaisquer entradas de cache de 5 minutos).

Ao combinar TTLs, a Claude API determina três locais de cobrança no seu prompt:

  1. Posição A: A contagem de tokens no último acerto de cache no seu prompt (ou 0 se não houver acertos).
    • Um acerto em uma entrada armazenada em cache com TTL de 5 minutos não é aceito como acerto se um bloco cache_control com TTL de 1 hora, posicionado depois dessa entrada, for uma falha de cache.
    • Uma solicitação que lê uma entrada armazenada em cache com TTL de 5 minutos reinicia o tempo de vida de 5 minutos dessa entrada, mesmo que a solicitação atual defina "ttl": "1h".
  2. Posição B: A contagem de tokens no último bloco cache_control de 1 hora posicionado após A (ou igual a A se não existir nenhum).
  3. Posição C: A contagem de tokens no último bloco cache_control.

Você é cobrado por:

  1. Tokens de leitura de cache para A.
  2. Tokens de escrita de cache de 1 hora para (B - A).
  3. Tokens de escrita de cache de 5 minutos para (C - B).

Aqui estão três solicitações de exemplo, cada uma com diferentes acertos e falhas de cache. Cada uma tem um preço calculado diferente, mostrado nas caixas.

Leitura de cache
Escrita de cache de ⁠1h
Escrita de cache de ⁠5m
Restante do prompt
Acerto de ⁠1h
(A)
Falha de ⁠1h
Falha de ⁠1h
Falha de ⁠1h
(B)
Falha de ⁠5m
(C)
Escrita de cache de ⁠1h
Escrita de cache de ⁠5m
Restante do prompt
(A é zero)
Falha de ⁠1h
Falha de ⁠1h
Falha de ⁠1h
Falha de ⁠1h
(B)
Falha de ⁠5m
(C)
Leitura de cache
Restante do prompt
Falha de ⁠1h
Acerto de ⁠5m
(A, B, C)

Pré-aquecendo o cache

O pré-aquecimento do cache permite carregar seu prompt do sistema ou definições de ferramentas no cache de prompt antes que um usuário acione uma solicitação real. Isso pode reduzir a penalidade de latência por falha de cache na primeira interação do usuário, diminuindo o “time-to-first-token” (tempo até o primeiro token), ou TTFT, para aplicações sensíveis à latência.

Como funciona

Defina max_tokens: 0 na sua solicitação. A API lê seu prompt no modelo e escreve o cache em qualquer ponto de interrupção cache_control, e então retorna imediatamente sem gerar nenhuma saída. A resposta tem um array content vazio, stop_reason: "max_tokens" e um bloco usage totalmente preenchido.

Coloque o ponto de interrupção cache_control no último bloco compartilhado com a solicitação subsequente (normalmente seu prompt do sistema ou definições de ferramentas), não na mensagem de usuário de preenchimento. Caso contrário, a entrada de cache fica associada ao preenchimento e a solicitação subsequente não a acertará. Use também a mesma configuração de pensamento e o mesmo output_config.effort das suas solicitações subsequentes: esses valores são renderizados no prompt (consulte O que invalida o cache), portanto um pré-aquecimento com uma configuração diferente pode escrever uma entrada que seu tráfego real nunca acerta. Isso significa usar um ponto de interrupção de cache explícito em vez do cache automático, porque o cache automático coloca o ponto de interrupção no último bloco, que aqui é o preenchimento. A mensagem de usuário de preenchimento pode ser qualquer string com conteúdo que não seja apenas espaços em branco (os exemplos aqui usam "warmup"); seu conteúdo é lido no modelo, mas nunca respondido.

client = anthropic.Anthropic()

# Dispare isto antes da chegada dos usuários para aquecer o cache compartilhado do prompt do sistema.
prewarm = client.messages.create(
    model="claude-opus-5-5",
    max_tokens=0,
    system=[
        {
            "type": "text",
            "text": "You are an expert software engineer with deep knowledge of distributed systems...",
            "cache_control": {"type": "ephemeral"},
        }
    ],
    messages=[{"role": "user", "content": "warmup"}],
)
print(prewarm.stop_reason)  # "max_tokens"
print(prewarm.content)  # []
print(prewarm.usage)

A API retorna um array content vazio:

Output
{
  "id": "msg_01XFDUDYJgAACzvnptvVoYEL",
  "type": "message",
  "role": "assistant",
  "content": [],
  "model": "claude-opus-5-5",
  "stop_reason": "max_tokens",
  "stop_sequence": null,
  "usage": {
    "input_tokens": 8,
    "cache_creation_input_tokens": 5120,
    "cache_read_input_tokens": 0,
    "cache_creation": {
      "ephemeral_5m_input_tokens": 5120,
      "ephemeral_1h_input_tokens": 0
    },
    "iterations": [
      {
        "input_tokens": 8,
        "output_tokens": 0,
        "cache_read_input_tokens": 0,
        "cache_creation_input_tokens": 5120,
        "cache_creation": {
          "ephemeral_5m_input_tokens": 5120,
          "ephemeral_1h_input_tokens": 0
        },
        "type": "message"
      }
    ],
    "output_tokens": 0,
    "service_tier": "standard",
    "inference_geo": "global"
  }
}

Padrão de uso típico

Faça uma solicitação de pré-aquecimento quando sua aplicação iniciar (ou em um intervalo programado) e, em seguida, envie solicitações reais de usuários após a conclusão do pré-aquecimento:

client = anthropic.Anthropic()

SYSTEM_PROMPT = [
    {
        "type": "text",
        "text": "You are an expert software engineer with deep knowledge of distributed systems...",
        "cache_control": {"type": "ephemeral"},
    }
]


def prewarm_cache() -> None:
    """Call this at application startup or on a scheduled interval."""
    client.messages.create(
        model="claude-opus-5-5",
        max_tokens=0,
        system=SYSTEM_PROMPT,
        messages=[{"role": "user", "content": "warmup"}],
    )


def respond(user_message: str) -> anthropic.types.Message:
    """The real user request; benefits from a warm cache."""
    return client.messages.create(
        model="claude-opus-5-5",
        max_tokens=1024,
        system=SYSTEM_PROMPT,
        messages=[{"role": "user", "content": user_message}],
    )


# Aqueça o cache antes que chegue qualquer tráfego de usuários.
prewarm_cache()

# Depois, quando o usuário envia uma mensagem, o prefixo do prompt do sistema já está em cache.
response = respond("How do I implement a binary search tree?")
for block in response.content:
    if block.type == "text":
        print(block.text)

Lembre-se de que o TTL do cache ainda se aplica. Para o cache padrão de 5 minutos, envie uma nova solicitação de pré-aquecimento pelo menos a cada 5 minutos para manter o cache aquecido. Para intervalos mais longos entre solicitações de usuários, use a duração de cache de 1 hora em vez disso.

Limitações

Uma solicitação com max_tokens: 0 é rejeitada com um invalid_request_error se qualquer um dos seguintes estiver definido, porque cada um implica uma saída que um orçamento de zero tokens não pode produzir:

max_tokens: 0 também é rejeitado dentro de uma solicitação de Message Batches. O pré-aquecimento visa o time-to-first-token, que não se aplica ao processamento em lote, e uma entrada de cache escrita durante o processamento em lote provavelmente expiraria antes da execução da solicitação subsequente.

Substituindo a solução alternativa max_tokens=1

Algumas aplicações enviam solicitações com max_tokens: 1 para aquecer o cache. Prefira max_tokens: 0 quando a solicitação permitir: nenhuma saída é produzida, portanto não há resposta de um único token para descartar, nenhum token de saída é cobrado e a intenção da solicitação é inequívoca.


Exemplos de cache de prompt

Para ajudar você a começar com o “prompt caching” (cache de prompt), a receita de cache de prompt no Claude Cookbook fornece exemplos detalhados e melhores práticas.

Os trechos de código a seguir demonstram vários padrões de cache de prompt. Esses exemplos mostram como implementar o cache em diferentes cenários, ajudando você a entender as aplicações práticas desse recurso:

Retenção de dados

O cache de prompt (tanto automático quanto explícito) é elegível para ZDR. A Anthropic não armazena o texto bruto dos seus prompts nem das respostas do Claude.

As representações do cache KV (chave-valor) e os hashes criptográficos do conteúdo em cache são mantidos apenas na memória e não são armazenados em repouso. As entradas em cache têm um tempo de vida mínimo de 5 minutos (padrão) ou 1 hora (estendido), após o qual são excluídas prontamente, embora não imediatamente. As entradas de cache são isoladas entre organizações e, na Claude API, na Claude Platform on AWS e no Microsoft Foundry, entre workspaces dentro de uma organização.


Perguntas frequentes

Disponibilidade

Cache de prompt
APIs
  • Messages API
  • Managed Agents Beta
Modelos
  • Todos os modelos

Endpoints aplicáveis

  • /v1/messages
Retenção zero de dadosElegível

Exclui Modelos cobertos

Seus prompts e as saídas do Claude não são armazenados. As representações do cache KV e os hashes criptográficos são mantidos na memória durante o TTL do cache e excluídos prontamente após a expiração. Saiba mais

HIPAAElegível

Esta página foi útil?