OpenAI模型显式Prompt缓存上线

本文由 OpenAI 的 Chris Dickens 共同撰写。

OpenAI GPT-5.6 Sol、Terra 和 Luna 现已在 Amazon Bedrock 上正式可用。通过 Amazon Bedrock 使用 GPT-5.6，你可以按 token 计费的方式使用最新一代 OpenAI 前沿模型，同时获得 AWS 安全与治理控制，并且相关用量可计入你现有的 AWS 承诺。该系列涵盖三个能力层级：GPT-5.6 Sol 面向最复杂的推理和智能体式编码工作；GPT-5.6 Terra 面向需要兼顾各方面的日常生产工作负载；GPT-5.6 Luna 面向分类和摘要等快速、高吞吐量任务。

除新模型外，GPT-5.6 还在 Amazon Bedrock 上引入了显式提示词缓存。这项新能力让你能够精确控制提示词中的哪些部分被缓存并在请求间复用。缓存输入按原价的 10% 计费（请参阅 Amazon Bedrock 定价页面），并可在 30 分钟内保持可复用状态。它在智能体式工作流中最具价值，因为系统指令、工具定义和参考文档通常会在多次调用中重复出现。

本文将介绍 GPT-5.6 在 Amazon Bedrock 上的显式提示词缓存。这项新能力让你能够控制提示词中的哪些部分被缓存并在请求间复用。我们将说明它与隐式缓存有何不同、应在何时使用每种模式，如何完成设置并验证缓存是否正常工作，以及它在智能体式工作流中的表现。我们还将介绍如何把工作负载从早期 GPT 模型迁移到 GPT-5.6，无论这些工作负载目前运行在 Amazon Bedrock 上还是其他平台上。

开始在 Amazon Bedrock 上使用 GPT-5.6

GPT-5.6 模型通过 Amazon Bedrock bedrock-mantle 端点上兼容 OpenAI 的 Responses API 提供服务。

推荐的身份验证方式是使用根据 AWS 凭证生成的短期 bearer token。安装 token 生成器以及 OpenAI SDK：

pip install openai aws-bedrock-token-generator

然后创建客户端。token 生成器使用标准 AWS 凭证链（IAM 角色、环境变量或 CLI 配置文件），因此代码中不需要保存长期密钥：

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
)

发出第一个请求

GPT-5.6 模型使用 Responses API。一个最小请求如下所示：

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)

三个模型 ID 分别为 openai.gpt-5.6-sol、openai.gpt-5.6-terra 和 openai.gpt-5.6-luna。GPT-5.6 Sol 可在美国东部（弗吉尼亚北部）和美国东部（俄亥俄）使用。Terra 和 Luna 还可在美国西部（俄勒冈）使用。有关各区域的模型可用性，请参阅 Amazon Bedrock 中“各 AWS 区域支持的模型”。

控制推理强度

GPT-5.6 支持 none、low、medium、high 和 xhigh 推理强度级别，默认值为 medium。较高的级别会为更困难的问题分配更多推理资源，而 none 则能为简单任务提供延迟最低的处理路径：

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"},
)

从 GPT-5.5 或 GPT-5.4 升级时，可以遵循一条实用准则：首先沿用当前使用的推理强度级别，然后测试降低一个级别。GPT-5.6 的 token 效率更高，许多工作负载在较低的推理强度设置下仍能保持质量。当 reasoning.effort 设置为 none 时，支持采样参数 temperature 和 top_p。在其他推理强度级别下，输出变化程度由模型的推理过程控制。

流式传输通过 SDK 的标准接口运行，并以带类型的事件形式交付输出：

with client.responses.stream(
    model="openai.gpt-5.6-terra",
    input="Write a haiku about distributed systems.",
) as stream:
    for event in stream:
        if event.type == "response.output_text.delta":
            print(event.delta, end="", flush=True)

调用工具并获取结构化输出

函数调用和严格 JSON Schema 输出的工作方式都与 OpenAI 原生 API 相同。工具定义使用 Responses API 的扁平格式：

response = client.responses.create(
    model="openai.gpt-5.6-terra",
    input="What's the weather in Seattle?",
    tools=[{
        "type": "function",
        "name": "get_weather",
        "description": "Get current weather for a city",
        "parameters": {
            "type": "object",
            "properties": {"city": {"type": "string"}},
            "required": ["city"],
        },
    }],
)
for item in response.output:
    if item.type == "function_call":
        print(item.name, item.arguments)  # get_weather {"city":"Seattle"}

对于结构化输出，传入严格的 JSON Schema，模型便会返回符合该 Schema 的有效 JSON：

response = client.responses.create(
    model="openai.gpt-5.6-luna",
    input="Extract: 'Order #1234 shipped to Berlin on May 2.'",
    text={
        "format": {
            "type": "json_schema",
            "name": "order",
            "strict": True,
            "schema": {
                "type": "object",
                "properties": {
                    "order_id": {"type": "string"},
                    "destination": {"type": "string"},
                },
                "required": ["order_id", "destination"],
                "additionalProperties": False,
            },
        }
    },
)
print(response.output_text)  # {"destination":"Berlin","order_id":"1234"}

在 Amazon Bedrock 上为 GPT-5.6 使用提示词缓存

GPT-5.6 模型通过 Responses API 支持提示词缓存，并提供两种模式：隐式模式，由 Amazon Bedrock 自动放置缓存断点；显式模式，由你自行标记缓存边界，以实现精确控制。本节将介绍这两种模式，以及如何验证缓存行为并为工作负载选择合适的模式。

提示词缓存使 Amazon Bedrock 无需重新计算请求之间重复的提示词部分。在 GPT-5.6 上，读取缓存的费用比未缓存输入 token 低 90%，而写入缓存的费用是未缓存输入费率的 1.25 倍，因此该功能专为“一次写入、多次读取”模式而设计。由于读取缓存所节省的费用远高于写入缓存增加的费用，只要缓存读取量约占流经缓存的 token 的 20%，工作负载就能降低总体输入成本。隐式模式无需你执行任何操作即可推动工作负载达到这一水平，因为 Amazon Bedrock 会代你放置并优化断点。在显式模式下，自行标记稳定前缀通常还能进一步提高命中率，因为后续请求可以在该前缀仍处于缓存中时将其读回。有关当前费率，请参阅 Amazon Bedrock 定价页面。

从隐式提示词缓存开始

在 GPT-5.6 上，提示词缓存默认以隐式模式启用。当你发送不含任何缓存参数的请求时，Amazon Bedrock 会自动放置缓存断点并查找可复用的前缀。至少包含 1,024 个 token 的稳定前缀可以被缓存和复用，无需修改代码。

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

隐式缓存意味着现有代码从第一天起就能受益于缓存读取，无需分析提示词结构。由于断点由 Bedrock 选择，第一个请求会将前缀写入缓存，后续请求则会将其读回。对于稳定前缀之后的内容会在每次请求中发生变化的工作负载，例如聊天助手和智能体式工具循环，通过显式断点自行标记前缀可以获得更可预测的结果。下一节将介绍这种方法。

设置显式提示词缓存

显式模式让你可以直接控制缓存边界。你需要标记可复用前缀的结束位置，缓存的前缀将至少保持 30 分钟可复用状态，足以覆盖单次智能体运行所产生的一系列集中调用。GPT-5.6 使用三个请求参数控制缓存：

prompt_cache_breakpoint：放置在内容块上，用于标记可复用提示词前缀的精确结束位置。该标记块之前（包括该块）的所有内容都会被缓存，而其后的所有内容都可以自由变化，同时不会影响已缓存前缀的有效性。每个缓存前缀必须至少包含 1,024 个 token，每个请求最多可以在 input_text、input_image 和 input_file 块上设置 4 个断点。

prompt_cache_key：一个稳定的 ID，用于将请求路由到同一个缓存。在一个会话或应用程序的所有请求中，应始终使用相同的值，以便重复请求能够找到已缓存的前缀。

prompt_cache_options：用于控制缓存模式（隐式或显式，将在下一节介绍）和 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"}},
)

验证缓存行为

每个响应都会在 usage.input_tokens_details 对象中准确报告缓存执行了哪些操作。你可以在这里验证相关配置：

cached_tokens：从缓存中读取的输入 token，按原价的 10% 计费，即享受 90% 的折扣。

cache_write_tokens：写入缓存的输入 token，按未缓存费率的 1.25 倍计费。

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

注意：在 30 分钟窗口内从缓存提供的 token，不会在后续调用中重复收费。下面将对此进行详细说明。

input_tokens = cached_tokens + cache_write_tokens + non-cached remainder

input_tokens 是该请求的完整输入 token 数。cached_tokens 和 cache_write_tokens 分别表示其中有多少输入来自缓存，以及有多少输入被写入缓存；其余部分则是你每次发送的新内容，例如断点之后的用户问题。由于缓存读取和缓存写入的 token 数已包含在 input_tokens 中，而不是额外叠加，因此从缓存提供的 token 只会被统计一次，并按照缓存读取费率计费一次。你永远不会为同一个 token 支付两次费用。在下面的示例中，这些请求通过同一个 prompt_cache_key 复用了相同的 3,626-token 系统前缀。用户问题每次都会变化，因此 input_tokens 中未缓存的剩余部分也会随之变化：

第一个请求会将这个包含 3,626 个 token 的前缀写入缓存。从第二个请求开始，该前缀会以缓存读取的折扣费率从缓存中读回，只有新的用户输入（此处分别为 45 个和 36 个 token）按标准费率处理。cached_tokens 保持在较高水平，cache_write_tokens 降为零，而 input_tokens 的变化仅取决于不断变化的用户问题大小。

每个响应都会包含这两个字段。最直接的验证流程是，在应用程序中将它们与请求 ID 和 prompt_cache_key 一同记录下来。然后，在生产流量开始依赖缓存之前，通过日志确认“写入一次、多次读取”的模式。对于聚合监控，bedrock-mantle 端点会将推理和 token 指标发布到 Amazon CloudWatch 的 AWS/BedrockMantle 命名空间下（参见“使用 CloudWatch 指标监控 bedrock-mantle 推理”）。这些指标可按账户、项目和模型跟踪整体的输入与输出 token 量。每个请求的缓存明细来自相应响应中的 usage 对象，因此，在应用程序层面记录这两个字段，是构建缓存可观测性的基础。

在智能体循环中使用缓存

显式缓存尤其适合智能体工作负载。在工具调用循环中，系统提示词和工具定义会在每一轮中重复出现，而对话则不断追加到末尾，这非常适合在静态内容之后设置断点。下面的示例构建了一个事件响应助理，用于检查服务健康状况和最近的部署：

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

模型负责驱动这个循环：它决定调用哪些工具；当模型不再发起工具调用，而是返回最终响应时，循环结束。这个工具循环是智能体的最小形态，也是智能体框架代你管理的同一种循环。第一轮会将系统提示词前缀写入缓存。此后本次运行中的每一轮都会从缓存中读取该前缀，同时由模型处理新追加的工具调用及其结果；30 分钟的 TTL 足以轻松覆盖持续数分钟的智能体会话。逐轮记录这两个 usage 字段，可以清楚地展示这种模式：在第一轮进行一次缓存写入，后续每一轮都从缓存中读取。

在隐式缓存和显式缓存之间进行选择

GPT-5.6 支持两种缓存模式，由 prompt_cache_options.mode 控制：

隐式（默认模式）。Amazon Bedrock 会自动在最新消息上放置缓存断点，并尝试最大限度提高缓存命中率。你添加的任何显式断点也都会生效。使用这种模式，无需更改现有请求格式，即可自动获得缓存带来的收益。

显式。设置 "prompt_cache_options": {"mode": "explicit"} 后，你可以通过断点完全控制缓存：只有你放置的断点才会用于缓存读取和写入。

显式模式将缓存边界的控制权交给你。当提示词由稳定前缀和每次请求都会变化的内容组合而成时，这种控制最为重要。在隐式模式下，Bedrock 会替你放置断点，而开始从缓存读取之前发生的缓存写入次数可能因请求而异。如果在静态内容末尾放置一个显式断点，缓存行为便具有确定性：第一个请求只写入一次前缀，之后的每个请求都会从缓存中读取该前缀，因为变化的内容安全地位于断点之后。

如果你不想对 GPT-5.6+ 使用提示词缓存，可以采用显式缓存模式而不提供显式断点。这样做会让你退出提示词缓存计费行为（不会产生缓存写入费用），但提示词的某些部分仍可能在 Bedrock 系统中被缓存以降低延迟。无论选择哪种模式，都要在生产环境中持续监控两个使用量字段。健康的缓存模式表现为在每次写入后有明显的缓存读取。如果在隐式模式下看到缓存写入很多但读取很少，应该考虑切换到显式模式，在静态内容末尾添加显式断点，使缓存前缀具有确定性。在显式模式下，将断点移到更早的位置，使其仅覆盖在各次调用之间保持不变的内容。确保在应该共享缓存的请求中 prompt_cache_key 设置保持一致。

从早期 GPT 模型迁移到 GPT-5.6

GPT-5.6 综合了更强的性能、更好的 token 效率和可控的缓存，是一个引人注目的升级目标。迁移工作量取决于你的工作负载当前运行在哪里。我们涵盖了三个常见的起点，从改动最小到改动最大。

起点 1：Amazon Bedrock 上的 GPT-5.5 或 GPT-5.4

如果你已经在 Amazon Bedrock 上运行 OpenAI 模型，升级就是改变模型 ID。端点、身份验证和 Responses API 请求形状保持不变：

response = client.responses.create(
    model="openai.gpt-5.6-terra",  # was: openai.gpt-5.5
    instructions=SYSTEM_PROMPT,
    input=user_input,
    max_output_tokens=1000,
)

升级时需要融入两个要点：

采用显式缓存断点。在 GPT-5.5 和 GPT-5.4 上，提示词缓存是自动的：系统缓存符合条件的 1,024 token 或更长的前缀，无需额外参数，缓存写入不收费。GPT-5.6 转向上文描述的可控模式，包括 1.25 倍的缓存写入费率，适用于隐式和显式写入。一起规划这两项变更：当你切换模型 ID 时，同时在静态内容后放置显式断点。这个单一添加为结尾在每个请求中都会变化的提示词建立了一写多读模式。它还延长了你的缓存生命周期，因为 GPT-5.6 缓存前缀至少保留 30 分钟。

重新评估推理努力级别。GPT-5.6 增加了 xhigh 努力级别，在整个范围内每个 token 提供更多能力。从当前的 GPT-5.5 努力级别开始，测试低一级的设置。许多工作负载能在较低成本下保持质量标准。

起点 2：其他平台上的 Responses API

如果你的应用已经在其他平台上使用 OpenAI Responses API，迁移到 Amazon Bedrock 需要三项变更：基础 URL、身份验证和模型 ID。请求和响应处理代码保持不变：

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,
)

身份验证变更也是一次安全升级：aws-bedrock-token-generator 从 AWS 凭证派生短期 token，所以你的应用端到端使用 IAM 角色。你保持与其他 AWS 工作负载相同的身份、策略和审计模式（AWS CloudTrail）。在生产环境中，将 token 生成包装在刷新例程中，因为 token 按设计是短期的。由于此迁移通常也会将你升级到更新的模型版本，需要融入起点 1 的两项变更：在静态内容后放置显式缓存断点，并测试比当前设置低一级的推理努力级别。

起点 3：其他平台上的 Chat Completions API

Amazon Bedrock 上的 GPT-5.6 通过 Responses API 提供，所以针对 Chat Completions 编写的工作负载在迁移过程中需要迁移其请求和响应处理。映射是机械的：

前后对比：

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

Responses API 还带来了其他功能，包括服务器管理的对话状态、类型化流事件和本文涵盖的显式提示词缓存，所以这个迁移是一项投资，其价值超越了迁移本身。

验证和推出

无论你的起点如何，都应把迁移当作一个结构化的工程项目来对待：

首先清点。 列清你的应用依赖的模型、API（Responses 或 Chat Completions）、工具、流媒体使用和状态管理。这决定了上面哪个起点适用以及工作的范围。

构建黄金提示集。 从生产流量中收集代表性提示和预期行为，并在 Amazon Bedrock 上的 GPT-5.6 与当前设置之间并排回放它们。评估成功率、输出质量、token 消耗和对应用关键任务的延迟。Amazon Bedrock 评估工具或你现有的评估框架都可行。

建立缓存基线。 作为相同回放的一部分，记录 cached_tokens 和 cache_write_tokens，并在生产流量依赖它之前确认你的断点位置产生了一写多读的模式。

逐步扩大。 将一小部分流量路由到新模型，将 KPI 与基线进行比较，随着信心增长而逐步扩大，在迁移完成前保持旧配置可立即回滚。

GPT-5.6 Sol、Terra 和 Luna 将 OpenAI 最新的前沿模型带到 Amazon Bedrock。凭借显式提示词缓存，你拥有了一个精密工具来处理主导现代大语言模型（LLM）支出的工作负载：那些在每次调用时重新发送相同指令、工具和参考资料的智能体和 AI 工作负载。你只需要在静态内容后放一个断点、一个一致的缓存密钥和两个要监控的使用量字段。有了这些，你就能将那个重复