Cache explícito de prompts para modelos OpenAI GPT-5.6 no Amazon Bedrock

GPT-5.6 no Amazon Bedrock: três modelos, uma novidade importante

A AWS anunciou que os modelos OpenAI GPT-5.6 Sol, Terra e Luna estão agora disponíveis no Amazon Bedrock. A família cobre três níveis de capacidade:

• GPT-5.6 Sol: para raciocínio complexo e trabalhos de codificação agêntica
• GPT-5.6 Terra: para cargas de trabalho de produção do dia a dia
• GPT-5.6 Luna: para tarefas rápidas e de alto volume, como classificação e sumarização

Junto com os novos modelos, o GPT-5.6 introduz o cache explícito de prompts no Amazon Bedrock — um recurso que permite controlar com precisão quais partes do prompt são armazenadas em cache e reutilizadas entre requisições. Tokens lidos do cache são cobrados com 90% de desconto (confira a página de preços do Amazon Bedrock) e ficam disponíveis por 30 minutos. O ganho é maior em fluxos de trabalho agênticos, onde instruções de sistema, definições de ferramentas e documentos de referência se repetem em muitas chamadas.

Como começar com o GPT-5.6 no Amazon Bedrock

Os modelos GPT-5.6 são servidos pela Responses API compatível com OpenAI, no endpoint bedrock-mantle. A autenticação recomendada usa tokens de curta duração gerados a partir das credenciais AWS:

pip install openai aws-bedrock-token-generator

from openai import OpenAI
from aws_bedrock_token_generator import provide_token

REGION = "us-east-2"
client = OpenAI(
    base_url=f"https://bedrock-mantle.{REGION}.api.aws/openai/v1",
    api_key=provide_token(region=REGION),  # short-term token from your AWS credentials
)

Uma requisição básica com a Responses API fica assim:

response = client.responses.create(
    model="openai.gpt-5.6-terra",
    instructions="You are a concise technical assistant.",
    input="What is Amazon Bedrock?",
    max_output_tokens=500,
)
print(response.output_text)

Os três identificadores de modelo são openai.gpt-5.6-sol, openai.gpt-5.6-terra e openai.gpt-5.6-luna. O GPT-5.6 Sol está disponível em US East (N. Virginia) e US East (Ohio). Terra e Luna também estão disponíveis em US West (Oregon). Consulte a disponibilidade completa por região em Modelos suportados por região AWS no Amazon Bedrock.

Controlando o nível de raciocínio

O GPT-5.6 suporta níveis de esforço de raciocínio: none, low, medium, high e xhigh, sendo medium o padrão. Níveis mais altos dedicam mais raciocínio a problemas complexos; none oferece menor latência para tarefas diretas:

response = client.responses.create(
    model="openai.gpt-5.6-luna",
    input="Classify this ticket as bug, feature request, or question: 'App crashes on login.'",
    reasoning={"effort": "none"},
)

Uma dica prática ao migrar do GPT-5.5 ou GPT-5.4: comece com o nível de esforço atual e teste um nível abaixo. O GPT-5.6 é mais eficiente em tokens, e muitas cargas de trabalho mantêm a qualidade com configuração menor.

Cache de prompts: implícito e explícito

O cache de prompts permite que o Amazon Bedrock evite reprocessar partes do prompt que se repetem entre requisições. No GPT-5.6, leituras do cache são cobradas com 90% de desconto em relação aos tokens de entrada sem cache, enquanto escritas no cache custam 1,25 vezes a taxa normal. O modelo é projetado para o padrão escreve uma vez, lê muitas vezes. Para taxas atuais, consulte a página de preços do Amazon Bedrock.

O GPT-5.6 suporta dois modos de cache:

• Implícito (padrão): o Amazon Bedrock posiciona automaticamente o ponto de cache e tenta maximizar a taxa de acerto. Funciona sem nenhuma mudança no código existente.
• Explícito: você marca o limite do cache com precisão, controlando exatamente onde o prefixo reutilizável termina.

Cache implícito

No modo implícito, o cache já está ativo por padrão. Um prefixo estável de pelo menos 1.024 tokens pode ser armazenado e reutilizado sem nenhuma mudança no código:

# Implicit caching: no caching parameters needed
response = client.responses.create(
    model="openai.gpt-5.6-terra",
    instructions=SYSTEM_INSTRUCTIONS,  # stable prefix, >= 1,024 tokens
    input=user_question,
)
details = response.usage.input_tokens_details
print(f"cached: {details.cached_tokens}, written: {details.cache_write_tokens}")

Cache explícito

O modo explícito oferece controle direto sobre o limite do cache. Prefixos em cache ficam disponíveis por pelo menos 30 minutos. Três parâmetros controlam o comportamento:

• prompt_cache_breakpoint: marca o fim exato do prefixo reutilizável em um bloco de conteúdo
• prompt_cache_key: identificador estável que direciona requisições ao mesmo cache
• prompt_cache_options: controla o modo (implícito ou explícito) e o TTL

response = client.responses.create(
    model="openai.gpt-5.6-terra",
    prompt_cache_key="support-app:kb-v1",  # same key across all requests
    input=[
        {
            "type": "message",
            "role": "developer",
            "content": [{
                "type": "input_text",
                "text": SYSTEM_INSTRUCTIONS,  # long, static: guidelines, KB excerpts (>= 1,024 tokens)
                "prompt_cache_breakpoint": {"mode": "explicit"},
            }],
        },
        {
            "type": "message",
            "role": "user",
            "content": [{
                "type": "input_text",
                "text": user_question,  # changes on every request
            }],
        },
    ],
    extra_body={"prompt_cache_options": {"mode": "explicit"}},
)

Verificando o comportamento do cache

Cada resposta reporta exatamente o que o cache fez, no objeto usage.input_tokens_details:

• cached_tokens: tokens lidos do cache, cobrados com 90% de desconto
• cache_write_tokens: tokens escritos no cache, cobrados a 1,25x a taxa normal

details = response.usage.input_tokens_details
print(f"cached: {details.cached_tokens}, written: {details.cache_write_tokens}")

A tabela abaixo ilustra o padrão esperado ao reutilizar um prefixo de 3.626 tokens com a mesma prompt_cache_key:

Requisição	input_tokens	cached_tokens	cache_write_tokens	Entrada nova
Primeira (fria)	3.682	0	3.626	56
Segunda	3.671	3.626	0	45
Terceira	3.662	3.626	0	36

A primeira requisição escreve o prefixo no cache. A partir da segunda, o prefixo é lido com desconto enquanto apenas a nova entrada do usuário é processada à taxa normal. Para monitoramento agregado, o endpoint bedrock-mantle publica métricas de inferência e tokens no Amazon CloudWatch sob o namespace AWS/BedrockMantle (veja Monitoramento de inferência do bedrock-mantle com métricas do CloudWatch).

Cache em um loop agêntico

Fluxos de trabalho agênticos são onde o cache explícito brilha. Em um loop de chamadas de ferramentas, o prompt de sistema e as definições de ferramentas se repetem a cada turno enquanto a conversa cresce no final — encaixe perfeito para um breakpoint após o conteúdo estático. O exemplo abaixo constrói um assistente de resposta a incidentes:

import json

SYSTEM_PROMPT = "..."  # long runbook and instructions (>= 1,024 tokens)
MAX_TURNS = 10
TOOLS = [
    {"type": "function", "name": "get_service_health", "description": "Get health status for a microservice", "parameters": {"type": "object", "properties": {"service": {"type": "string"}}, "required": ["service"]}},
    {"type": "function", "name": "get_recent_deploys", "description": "List deployments in the last N hours", "parameters": {"type": "object", "properties": {"hours": {"type": "integer"}}, "required": ["hours"]}},
]

conversation = [
    {"type": "message", "role": "developer", "content": [{"type": "input_text", "text": SYSTEM_PROMPT, "prompt_cache_breakpoint": {"mode": "explicit"}}]},
    {"type": "message", "role": "user", "content": [{"type": "input_text", "text": "Is checkout-service healthy? If not, was there a recent deploy?"}]},
]

for turn in range(MAX_TURNS):
    response = client.responses.create(
        model="openai.gpt-5.6-sol",
        prompt_cache_key="incident-agent:session-42",
        input=conversation,
        tools=TOOLS,
        extra_body={"prompt_cache_options": {"mode": "explicit", "ttl": "30m"}},
    )
    tool_calls = [o for o in response.output if o.type == "function_call"]
    if not tool_calls:
        print(response.output_text)
        break
    for call in tool_calls:
        # execute_tool is your implementation: call the real system
        # and return a JSON-serializable result
        result = execute_tool(call.name, json.loads(call.arguments))
        conversation.append({"type": "function_call", "call_id": call.call_id, "name": call.name, "arguments": call.arguments})
        conversation.append({"type": "function_call_output", "call_id": call.call_id, "output": json.dumps(result)})

O primeiro turno escreve o prefixo do prompt de sistema no cache. Cada turno seguinte lê esse prefixo com desconto enquanto processa apenas as novas chamadas de ferramentas e resultados. O TTL de 30 minutos cobre confortavelmente sessões de agente com vários minutos de duração.

Quando usar cada modo

A tabela abaixo resume a recomendação de modo conforme o tipo de carga de trabalho:

• Prompts que se repetem exatamente (análise de documentos em lote, scoring com prompt fixo): implícito funciona sem mudanças; explícito oferece o mesmo resultado com controle determinístico
• Prefixo estável + sufixo variável (assistentes de chat, RAG, loops agênticos): explícito, com um breakpoint após o conteúdo estático
• Múltiplas seções com frequências de mudança diferentes (ferramentas, prompt de sistema, documentos longos, conversa): explícito, com até 4 breakpoints para controle granular

Se não quiser usar cache de prompts no GPT-5.6+, é possível usar o modo explícito sem fornecer breakpoints explícitos. Isso desativa o comportamento de cobrança do cache, mas partes dos prompts ainda podem ser armazenadas nos sistemas do Bedrock para oferecer menor latência.

Migrando para o GPT-5.6

Ponto de partida 1: GPT-5.5 ou GPT-5.4 no Amazon Bedrock

A migração é uma simples troca de ID de modelo. O endpoint, a autenticação e o formato da Responses API permanecem idênticos. Ao trocar o ID do modelo, adicione um breakpoint explícito após o conteúdo estático e revise o nível de esforço de raciocínio — muitas cargas de trabalho mantêm a qualidade com um nível abaixo do atual.

Ponto de partida 2: Responses API em outra plataforma

São necessárias três mudanças: a URL base, a autenticação e o ID do modelo. O código de tratamento de requisições e respostas permanece igual:

from openai import OpenAI
from aws_bedrock_token_generator import provide_token

REGION = "us-east-2"
client = OpenAI(
    base_url=f"https://bedrock-mantle.{REGION}.api.aws/openai/v1",  # 1. endpoint
    api_key=provide_token(region=REGION),                            # 2. auth
)
response = client.responses.create(
    model="openai.gpt-5.6-terra",                                    # 3. model ID
    instructions=SYSTEM_PROMPT,
    input=user_input,
)

Ponto de partida 3: Chat Completions API em outra plataforma

O GPT-5.6 no Amazon Bedrock usa a Responses API, então cargas de trabalho escritas contra a Chat Completions API precisam portar o tratamento de requisições e respostas. O mapeamento é direto:

• messages=[{role, content}] → instructions="..." (sistema) + input="..."
• max_completion_tokens → max_output_tokens
• response.choices[0].message.content → response.output_text
• tools=[{"type": "function", "function": {...}}] → tools=[{"type": "function", "name": ..., ...}] (formato flat)
• response.usage.prompt_tokens / completion_tokens → response.usage.input_tokens / output_tokens

# Before: Chat Completions on another platform
response = client.chat.completions.create(
    model="gpt-5.5",
    messages=[
        {"role": "system", "content": "You are a concise assistant."},
        {"role": "user", "content": "What is Amazon Bedrock?"},
    ],
    max_completion_tokens=200,
)
print(response.choices[0].message.content)

# After: Responses API on Amazon Bedrock
response = client.responses.create(
    model="openai.gpt-5.6-terra",
    instructions="You are a concise assistant.",
    input="What is Amazon Bedrock?",
    max_output_tokens=200,
)
print(response.output_text)

Validação e rollout gradual

Independente do ponto de partida, a AWS recomenda tratar a migração como um projeto de engenharia estruturado: inventariar os modelos e APIs em uso, construir um conjunto de prompts representativos para comparação, estabelecer uma baseline de cache monitorando cached_tokens e cache_write_tokens, e aumentar o tráfego gradualmente mantendo a configuração anterior disponível para rollback.

Conclusão

O GPT-5.6 Sol, Terra e Luna trazem os modelos de fronteira mais recentes da OpenAI para o Amazon Bedrock. Com o cache explícito de prompts, equipes que operam agentes e fluxos de LLM com contexto repetido — instruções, ferramentas, documentos de referência — podem converter esse contexto de entrada com preço cheio em leituras de cache com desconto. O que é necessário: um breakpoint após o conteúdo estático, uma chave de cache consistente e dois campos de uso para monitorar.

Para saber mais, consulte o anúncio de lançamento do GPT-5.6 e a documentação de cache de prompts do Amazon Bedrock. Para detalhes de preços, acesse a página de preços do Amazon Bedrock. Para monitorar cargas de trabalho em produção, veja Monitoramento de inferência do bedrock-mantle com métricas do CloudWatch. Experimente o GPT-5.6 com seus próprios prompts no console do Amazon Bedrock e compartilhe seu feedback no AWS re:Post para Amazon Bedrock.

Fonte

Introducing explicit prompt caching for OpenAI GPT-5.6 models on Amazon Bedrock (https://aws.amazon.com/blogs/machine-learning/introducing-explicit-prompt-caching-for-openai-gpt-5-6-models-on-amazon-bedrock/)