O armazenamento em cache de contexto

Em um fluxo de trabalho típico de IA, é possível transmitir os mesmos tokens de entrada repetidamente para um modelo. A API Gemini oferece dois mecanismos de armazenamento em cache diferentes:

  • Armazenamento em cache implícito (automático, sem garantia de economia de custos)
  • Armazenamento em cache explícito (garantia manual de economia de custos)

O armazenamento em cache implícito é ativado por padrão nos modelos Gemini 2.5. Se uma solicitação contiver conteúdo que é um acerto de cache, vamos repassar automaticamente a economia de custo para você.

O armazenamento em cache explícito é útil nos casos em que você quer garantir a economia de custos, mas com um pouco mais de trabalho do desenvolvedor.

Armazenamento em cache implícito

O armazenamento em cache implícito é ativado por padrão para todos os modelos do Gemini 2.5. Transmitimos automaticamente a economia de custos se a solicitação atingir os caches. Não é necessário fazer nada para ativar esse recurso. Ela entrou em vigor em 8 de maio de 2025. A contagem mínima de tokens de entrada para o armazenamento em cache de contexto é de 1.024 para o Flash 2.5 e 2.048 para o Pro 2.5.

Para aumentar a chance de uma ocorrência de cache implícita:

  • Tente colocar conteúdos grandes e comuns no início do comando.
  • Tentar enviar solicitações com prefixo semelhante em um curto período

Você pode conferir o número de tokens que foram acertos de cache no campo usage_metadata do objeto de resposta.

Armazenamento em cache explícito

Usando o recurso de armazenamento em cache explícito da API Gemini, é possível transmitir algum conteúdo ao modelo uma vez, armazenar os tokens de entrada em cache e, em seguida, consultar os tokens em cache para solicitações subsequentes. Em alguns volumes, o uso de tokens em cache tem um custo menor do que o envio repetido do mesmo corpus de tokens.

Ao armazenar em cache um conjunto de tokens, você pode escolher por quanto tempo o cache vai existir antes que os tokens sejam excluídos automaticamente. Essa duração de armazenamento em cache é chamada de time to live (TTL). Se não for definido, o TTL será definido como 1 hora. O custo do armazenamento em cache depende do tamanho do token de entrada e de quanto tempo você quer que os tokens persistam.

Nesta seção, presumimos que você instalou um SDK do Gemini (ou o curl) e configurou uma chave de API, conforme mostrado no Guia de início rápido.

Gerar conteúdo usando um cache

O exemplo a seguir mostra como criar um cache e usá-lo para gerar conteúdo.

VídeosPDFs 
wget https://storage.googleapis.com/generativeai-downloads/data/a11.txt
echo '{
  "model": "models/gemini-2.0-flash-001",
  "contents":[
    {
      "parts":[
        {
          "inline_data": {
            "mime_type":"text/plain",
            "data": "'$(base64 $B64FLAGS a11.txt)'"
          }
        }
      ],
    "role": "user"
    }
  ],
  "systemInstruction": {
    "parts": [
      {
        "text": "You are an expert at analyzing transcripts."
      }
    ]
  },
  "ttl": "300s"
}' > request.json

curl -X POST "https://generativelanguage.googleapis.com/v1beta/cachedContents?key=$GEMINI_API_KEY" \
-H 'Content-Type: application/json' \
-d @request.json \
> cache.json

CACHE_NAME=$(cat cache.json | grep '"name":' | cut -d '"' -f 4 | head -n 1)

curl -X POST "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash-001:generateContent?key=$GEMINI_API_KEY" \
-H 'Content-Type: application/json' \
-d '{
      "contents": [
        {
          "parts":[{
            "text": "Please summarize this transcript"
          }],
          "role": "user"
        },
      ],
      "cachedContent": "'$CACHE_NAME'"
    }'

DOC_URL="https://www.nasa.gov/wp-content/uploads/static/history/alsj/a17/A17_FlightPlan.pdf"
DISPLAY_NAME="A17_FlightPlan"
SYSTEM_INSTRUCTION="You are an expert at analyzing transcripts."
PROMPT="Please summarize this transcript"
MODEL="models/gemini-2.0-flash-001"
TTL="300s"

# Download the PDF
wget -O "${DISPLAY_NAME}.pdf" "${DOC_URL}"

MIME_TYPE=$(file -b --mime-type "${DISPLAY_NAME}.pdf")
NUM_BYTES=$(wc -c < "${DISPLAY_NAME}.pdf")

echo "MIME_TYPE: ${MIME_TYPE}"
echo "NUM_BYTES: ${NUM_BYTES}"

tmp_header_file=upload-header.tmp

# Initial resumable request defining metadata.
# The upload url is in the response headers dump them to a file.
curl "${BASE_URL}/upload/v1beta/files?key=${GOOGLE_API_KEY}" \
  -D upload-header.tmp \
  -H "X-Goog-Upload-Protocol: resumable" \
  -H "X-Goog-Upload-Command: start" \
  -H "X-Goog-Upload-Header-Content-Length: ${NUM_BYTES}" \
  -H "X-Goog-Upload-Header-Content-Type: ${MIME_TYPE}" \
  -H "Content-Type: application/json" \
  -d "{'file': {'display_name': '${DISPLAY_NAME}'}}" 2> /dev/null

upload_url=$(grep -i "x-goog-upload-url: " "${tmp_header_file}" | cut -d" " -f2 | tr -d "\r")
rm "${tmp_header_file}"

# Upload the actual bytes.
curl "${upload_url}" \
  -H "Content-Length: ${NUM_BYTES}" \
  -H "X-Goog-Upload-Offset: 0" \
  -H "X-Goog-Upload-Command: upload, finalize" \
  --data-binary "@${DISPLAY_NAME}.pdf" 2> /dev/null > file_info.json

file_uri=$(jq ".file.uri" file_info.json)
echo "file_uri: ${file_uri}"

# Clean up the downloaded PDF
rm "${DISPLAY_NAME}.pdf"

# Create the cached content request
echo '{
  "model": "'$MODEL'",
  "contents":[
    {
      "parts":[
        {"file_data": {"mime_type": "'$MIME_TYPE'", "file_uri": '$file_uri'}}
      ],
    "role": "user"
    }
  ],
  "system_instruction": {
    "parts": [
      {
        "text": "'$SYSTEM_INSTRUCTION'"
      }
    ],
    "role": "system"
  },
  "ttl": "'$TTL'"
}' > request.json

# Send the cached content request
curl -X POST "${BASE_URL}/v1beta/cachedContents?key=$GOOGLE_API_KEY" \
-H 'Content-Type: application/json' \
-d @request.json \
> cache.json

CACHE_NAME=$(cat cache.json | grep '"name":' | cut -d '"' -f 4 | head -n 1)
echo "CACHE_NAME: ${CACHE_NAME}"
# Send the generateContent request using the cached content
curl -X POST "${BASE_URL}/${MODEL}:generateContent?key=$GOOGLE_API_KEY" \
-H 'Content-Type: application/json' \
-d '{
      "contents": [
        {
          "parts":[{
            "text": "'$PROMPT'"
          }],
          "role": "user"
        }
      ],
      "cachedContent": "'$CACHE_NAME'"
    }' > response.json

cat response.json

echo jq ".candidates[].content.parts[].text" response.json

Listar caches

Não é possível recuperar ou visualizar o conteúdo armazenado em cache, mas é possível recuperar metadados de cache (name, model, displayName, usageMetadata, createTime, updateTime e expireTime).

curl "https://generativelanguage.googleapis.com/v1beta/cachedContents?key=$GEMINI_API_KEY"

Atualizar um cache

É possível definir um novo ttl ou expireTime para um cache. Não é possível mudar qualquer outra coisa sobre o cache.

O exemplo a seguir mostra como atualizar o ttl de um cache.

curl -X PATCH "https://generativelanguage.googleapis.com/v1beta/$CACHE_NAME?key=$GEMINI_API_KEY" \
 -H 'Content-Type: application/json' \
 -d '{"ttl": "600s"}'

Excluir um cache

O serviço de cache oferece uma operação de exclusão para remover manualmente o conteúdo do cache. O exemplo a seguir mostra como excluir um cache.

curl -X DELETE "https://generativelanguage.googleapis.com/v1beta/$CACHE_NAME?key=$GEMINI_API_KEY"

Cache explícito usando a biblioteca OpenAI

Se você estiver usando uma biblioteca da OpenAI, ative o armazenamento em cache explícito usando a propriedade cached_content em extra_body.

Quando usar o armazenamento em cache explícito

O armazenamento em cache de contexto é particularmente adequado para cenários em que um contexto inicial substancial é referenciado repetidamente por solicitações mais curtas. Use armazenamento em cache de contexto para casos de uso como estes:

  • Chatbots com instruções do sistema extensas
  • Análise repetitiva de arquivos de vídeo longos
  • Consultas recorrentes em grandes conjuntos de documentos
  • Análise frequente do repositório de código ou correção de bugs

Como o armazenamento em cache explícito reduz custos

O armazenamento em cache de contexto é um recurso pago projetado para reduzir os custos operacionais gerais. O faturamento é baseado nos seguintes fatores:

  1. Contagem de tokens de cache: o número de tokens de entrada armazenados em cache, faturados com uma taxa reduzida quando incluído nos comandos subsequentes.
  2. Duração do armazenamento:o tempo de armazenamento e cobrança dos tokens em cache (TTL), faturado com base na duração do TTL da contagem de tokens em cache. Não há limites mínimos ou máximos no TTL.
  3. Outros fatores: outras cobranças se aplicam, como tokens de entrada não armazenados em cache e tokens de saída.

Para detalhes atualizados sobre preços, consulte a página de preços da API Gemini. Para saber como contar tokens, consulte o guia de tokens.

Outras considerações

Considere as seguintes considerações ao usar o armazenamento em cache de contexto:

  • A contagem de tokens de entrada mínima para o armazenamento em cache de contexto é de 1.024 para o Flash 2.5 e 2.048 para o Pro 2.5. O máximo é igual ao máximo do modelo especificado. Para saber mais sobre a contagem de tokens, consulte o guia de tokens.
  • O modelo não faz distinção entre tokens em cache e tokens de entrada normais. O conteúdo armazenado em cache é um prefixo do comando.
  • Não há taxas ou limites de uso especiais no armazenamento em cache de contexto. Os limites de taxa padrão para GenerateContent são aplicados, e os limites de token incluem tokens em cache.
  • O número de tokens em cache é retornado no usage_metadata das operações de criação, acesso e listagem do serviço de cache e também em GenerateContent ao usar o cache.