降低 Amazon Bedrock AgentCore JSON 工作负载中的 token 成本与延迟
随着企业使用数十种工具和大型结构化输入构建生产级智能体,token 消耗和延迟成为获得良好用户体验的主要障碍。当这些智能体处理大型 JSON 数据时,每次额外的工具调用都会将完整负载注入大语言模型(LLM)上下文窗口,导致 token 用量和响应延迟飙升。在多轮对话中,这种压力会不断累积,推高成本并降低响应质量。在智能体系统中有效管理上下文窗口压力,是规模化实现可靠性和响应能力的关键。在本文中,我们分享为 Flightscape 构建生产级智能体时使用的三种可组合策略,该智能体可处理 20 MB+ 的 JSON 负载。你可以应用这些策略来降低 token 成本、降低延迟,并在长时间会话中保持完整的推理能力。在我们针对一个具有代表性的 23 MB 负载进行的基准测试运行中,这些优化共同将 token 消耗降低了最多 71%,并将平均延迟缩短了最多 80%。
解决方案概览
Flightscape 是一个航空运营平台,帮助航空公司规划和管理其机组人员、航班和运营。作为 Flightscape 机组管理能力的一部分,我们构建了一个 Training Schedule Optimization 智能体,用于依据业务规则验证机组培训计划分配。借助 40+ 个工具和数 MB 级的 JSON 输入,该智能体可以回答跨机组分配、排班和资源分配的复杂查询。尽管该智能体提供了所需功能,但大多数调用的平均请求延迟超过 15 秒。每次工具调用都会将其完整负载注入模型上下文,抬高 token 数量与成本。在更大的数据集上,上下文窗口在智能体完成推理之前就被填满。下图(图 1)详细展示了智能体架构和数据流:

图 1:智能体架构与数据流
在图 1 中,Optimizer 接收 Request JSON 并生成 Response JSON,随后由 Business Rules Validator 进行验证,生成 Validation Report JSON。这三份 JSON 文档都会由 AI 智能体摄取,该智能体提供对话界面,供用户查询优化结果、理解验证错误并探索排班分配。该智能体使用 LangChain 的开源框架 LangGraph 构建,并运行在 Amazon Bedrock AgentCore 上;后者是一个平台,可用任意框架或模型大规模构建、连接和优化智能体。可以应用 Amazon Bedrock Guardrails 来验证和过滤智能体的对话响应,帮助在生产部署中促进负责任 AI 实践。我们定义了自定义智能体状态,用于保存工具所需的数据:优化请求 JSON、优化响应 JSON 和验证报告 JSON。我们还在状态中添加了基本统计信息和缓存数据,以支持丰富查询。该智能体使用 Amazon Bedrock 模型进行推理,并使用 Amazon Bedrock AgentCore memory(Amazon Bedrock AgentCore 的一项能力)在多轮之间持久化聊天交互,每一轮都遵循以下流程(图 2):

图 2:智能体流程
状态结构如下所示。该状态引用 TOPT(Training Optimizer)请求和响应对象,这些对象表示机组排班输入和优化结果:
class GraphState(TypedDict):
"""LangGraph state that combines messages with application data."""
# Messages from conversation (managed by add_messages reducer)
messages: Annotated[List[BaseMessage], add_messages]
# Application-specific state - parsed domain objects
request: Optional[TOPTRequest]
responses: List[TOPTResponse]
validation_report: Optional[Dict[str, Any]]
basic_stats: Optional[Dict[str, Any]]
cache_data: Optional[Dict[str, Any]]
注意:这个状态最初把大型负载内联保存。后文会说明我们如何把大型产物移出对话上下文,以减少 token 消耗。
我们实现了三种策略,以减少让大型 JSON 负载经过模型上下文所带来的 token 成本、延迟和内存开销。下图(图 3)展示了这三种策略如何嵌入单次 agent 轮次。策略 1 在每个轮次开始时和结束时运行,策略 2 和策略 3 则在每次工具返回结果时运行。

图 3:单次 agent 轮次中三种优化策略的概览
在轮次开始时,hydrate_state() 函数从 AgentCore memory 恢复轻量的会话状态。当工具返回超大的列表或字典时,agent 会把完整结果存入 Amazon Simple Storage Service(Amazon S3),并向模型传入带有句柄的紧凑摘要。模型随后可以用 get_result_page_tool() 获取更多细节。在轮次结束时,dehydrate_state() 函数把大型负载写入 S3ArtifactStore,只将引用保存到 AgentCore memory。以下各节将详细介绍每种策略。
前提条件
要实施这些策略,请确保以下条件已具备:
- 一个可访问 Amazon Bedrock 及受支持模型的 AWS 账户。
- 一个用于存储产物的 Amazon S3 桶。
- 已启用 Amazon Bedrock AgentCore memory 以进行会话状态持久化的 Amazon Bedrock AgentCore。
- 一个基于 LangGraph 的 agent(或等效的图编排框架),并支持工具调用。
- 一个 Python 3.12+ 环境,包含 boto3、langchain-core 和 langgraph。
优化策略
配套代码可在该 GitHub 仓库中获取。
策略 1:持久化轻量会话状态,卸载大型产物
我们的第一项优化是改变持久化会话状态的方式。最初,大型负载被存放在了离对话状态过近的位置。因此,我们把大型产物(request JSON、response JSON、验证数据以及其他大型派生负载)迁移到了 Amazon S3。随后 AgentCore memory 只持久化指向这些对象的稳定引用,从而保持会话状态轻量。
为此,我们引入了一个专用的持久化状态 schema,只保留轻量字段和产物引用。实时图状态仍包含解析后的领域对象以供工具执行,但持久化现在写入的是脱水形式。在运行时,工具通过这些引用按需水合大型负载,而不是在每个轮次都加载全部内容。
下面这个 PersistedState schema 就是写入 AgentCore Memory 的内容:
class PersistedState(TypedDict, total=False):
"""Serialized session state for AgentCore Memory.
降低 Amazon Bedrock AgentCore JSON 工作负载中的 token 成本和延迟
Heavy fields (request, responses) are stored in S3 and referenced by key. Lightweight fields are stored inline. """ messages: List[Any] # LangChain-serialized messages request_ref: Optional[str] # S3 key for raw request JSON responses_ref: Optional[str] # S3 key for raw responses JSON list cache_data_ref: Optional[str] # S3 key for cache_data payload validation_report_ref: Optional[str] # S3 key for validation_report payload basic_stats_ref: Optional[str] # S3 key for basic_stats payload
更新后的 GraphState 将这些引用与实时域对象并列保存:
class GraphState(TypedDict): """LangGraph state that combines messages with application data.""" messages: Annotated[List[BaseMessage], add_messages]
... (same domain fields as original graph state)
Artifact references for persistence
request_ref: Optional[str] # S3 key reference for raw request JSON responses_ref: Optional[str] # S3 key reference for raw responses JSON list cache_data_ref: Optional[str] # S3 key ref for cache_data payload validation_report_ref: Optional[str] # S3 key ref for validation_report payload basic_stats_ref: Optional[str] # S3 key ref for basic_stats payload
dehydrate_state 函数从实时状态中剥离重型负载,并返回轻量级的持久化形式以及要上传的产物:
def dehydrate_state(state: GraphState) -> Tuple[PersistedState, Dict[str, Any]]: persisted: PersistedState = { "messages": [dumpd(m) for m in state.get("messages") or []], "request_ref": state.get("request_ref"), "responses_ref": state.get("responses_ref"),
... (remaining ref fields)
} artifacts: Dict[str, Any] = {} if state.get("request_raw") is not None: artifacts["request_ref"] = state["request_raw"]
... (see GitHub repository for full implementation)
return persisted, artifacts
再水合(Rehydration)会逆转这一过程。当会话恢复时,我们会重建实时图状态:反序列化 LangChain 消息,将原始负载重新解析为域对象,并恢复每个引用键,以便后续轮次能够定位其产物:
def hydrate_state( persisted: PersistedState, request_raw: Optional[Dict[str, Any]] = None, responses_raw: Optional[List[Dict[str, Any]]] = None, ) -> GraphState: """Reconstruct a live GraphState from its persisted form.""" messages = [load(m, allowed_objects="messages") for m in persisted.get("messages") or []] request = TOPTRequest.from_dict(request_raw) if request_raw else None responses = [TOPTResponse.from_dict(r) for r in (responses_raw or [])] return { "messages": messages, "request": request, "responses": responses,
... (remaining fields restored from persisted refs, see GitHub repository)
}
脱水(dehydration)和再水合都依赖产物存储为每个负载返回一致的引用。我们不再生成随机键,而是从负载本身推导引用。这种方法称为内容寻址(content addressing),它使用排序的键和紧凑分隔符序列化 JSON,并将这些字节的 SHA-256 摘要用作引用。
_content_hash 辅助函数从可 JSON 序列化的负载生成确定性的 SHA-256 引用:
def _content_hash(payload: Any) -> str: return hashlib.sha256(_canonical_bytes(payload)).hexdigest()
内容寻址使写入具备幂等性。相同的负载映射到相同的键,因此重新序列化未变更的请求 JSON 的轮次会复用桶中已有的对象,而不是再次上传它。基于 S3 的存储提供 put_json 和 get_json 接口。它还维护一个小的进程内缓存,因此当前调用期间已经读取或写入的负载不需要第二次 S3 往返。
S3ArtifactStore 类用进程内缓存和内容寻址键封装了 put_json/get_json 接口:
class S3ArtifactStore: """Content-addressed artifact store backed by Amazon S3.""" def __init__(self, bucket=None, prefix=None, region=None) -> None: self.bucket = bucket or os.getenv("SESSION_STATE_BUCKET") self.prefix = (prefix or os.getenv("ARTIFACT_STORE_PREFIX", "artifacts")).strip("/")
... (boto3 session setup, see GitHub repository)
self._cache: Dict[str, Any] = {}
def put_json(self, payload: Any) -> str: ref = _content_hash(payload) with self._lock: if ref in self._cache: return ref # Identical content already uploaded, skip PUT self._s3.put_object(Bucket=self.bucket, Key=self._key(ref), Body=_canonical_bytes(payload))
... (cache update)
return ref
def get_json(self, ref: str) -> Any: with self._lock: if ref in self._cache: return self._cache[ref]
... (S3 fetch and cache, see GitHub repository)
artifact_store = S3ArtifactStore()
将重型工件卸载到 S3 并仅持久化轻量引用,降低了每轮延迟以及存储在 AgentCore memory 中的数据量。由于重型有效载荷不再以内联方式持久化,工具调用响应成为上下文 token 的主要消耗者,促使我们引入结果分页。
## 策略 2:按需对大型结果列表分页
即使将重型有效载荷持久化迁移到 Amazon S3 之后,我们在工具响应时仍存在一个主要 token 瓶颈。许多工具结果过大,造成两个问题。第一,即使模型只需要一小部分,我们也把完整列表发送给模型,使每轮更慢、更昂贵。第二,这些完整列表有效载荷被注入上下文,在多轮对话中很快消耗上下文窗口。
在某些情况下,单个工具响应超过 80,000 个 token,并且随着用户继续与 agent 交互,成本会叠加。我们希望在默认不发送全部内容的情况下保留完整数据访问能力。为解决这个问题,我们引入了针对大型工具输出的按需结果分页。工具现在不再返回完整列表,而是返回一个紧凑有效载荷,其中包含总数、一个小样本和一个结果句柄。
当工具结果超过样本大小阈值时,完整列表存储在 S3 中,只向模型返回紧凑摘要:
if len(result) > _LLM_SAMPLE_SIZE: handle = artifact_store.put_json(result) return json.dumps( { "_oversized": True, "_result_handle": handle, "total": len(result), "sample": result[:_LLM_SAMPLE_SIZE], }, default=str, )
句柄指向存储在 S3 中的完整结果。当 agent 需要更多细节时,它使用句柄调用分页工具,并且只请求所需的切片,例如使用 offset 和 limit。
get_result_page_tool 函数让模型通过 handle、offset 和 limit 检索已存储结果的更多切片:
def get_result_page_tool(handle: str, field: Optional[str] = None, offset: int = 0, limit: int = 50): payload = artifact_store.get_json(handle) if isinstance(payload, list): return { "handle": handle, "offset": offset, "limit": limit, "total": len(payload), "items": payload[offset: offset + limit], }
... (dict field extraction, see GitHub repository)
按需分页将完整列表保留在 S3 中,并且每轮只提供请求的切片,从而控制上下文增长并显著减少 token 使用量。然而,并非所有超大输出都是列表。有些工具返回大型字典,需要不同的压缩方法。
## 策略 3:压缩超大字典输出
降低 Amazon Bedrock AgentCore JSON 工作负载中的 token 成本与延迟
与列表不同,字典输出包含深度嵌套的结构化数据,这些数据对推理很有用,但通常过于昂贵,无法在每一轮中逐字包含。我们需要一种紧凑的表示形式,既能保留结构线索,又能大幅削减 token 占用。
为解决这个问题,我们为超大的字典输出引入了基于描述符的压缩。我们不再完整返回超大的字典,而是返回一个紧凑的描述符:
- 列表字段由计数和样本表示。
- 嵌套字典按键的数量进行概括。
- 标量值在有意义时保持内联。
完整的负载存储在 artifact store 中,响应中包含一个结果句柄。当 agent 需要更深入的细节时,它使用该句柄只获取所需的数据。这种响应格式对模型来说仍然可导航,同时显著减少了不必要的 token 使用。
_oversized_descriptor 函数构建字典负载的紧凑结构摘要,保留字段类型和样本数据,但不包含完整内容:
def _oversized_descriptor(payload: Dict[str, Any], handle: str) -> Dict[str, Any]: fields: Dict[str, Any] = {} for key, value in payload.items(): if key.startswith("_"): continue if isinstance(value, list): fields[key] = {"type": "list", "count": len(value), "sample": value[:5]} elif isinstance(value, dict): fields[key] = {"type": "dict", "keys": len(value)} else: fields[key] = {"type": "scalar", "value": value} return {"_oversized": True, "_result_handle": handle, "fields": fields}
如果序列化后的输出仍然超过字符限制,回退逻辑会存储完整负载,并用其描述符替换响应:
content = json.dumps(llm_view, default=str) if len(content) > _MAX_TOOL_CONTENT_CHARS: if handle is None: handle = artifact_store.put_json(full_view) content = json.dumps(_oversized_descriptor(full_view, handle), default=str) return content
借助轻量级持久化状态、按需分页和字典压缩,token 增长变得可预测,即使面对数兆字节的数据集,agent 也能保持响应。
结果
为了验证这三种策略的影响,我们在同一数据集上针对优化前和优化后的 agent 版本运行了同一组问题。然后我们在 Amazon Bedrock AgentCore Observability(AgentCore 的一项能力)中比较了 token 使用量和延迟,并观察到成本和响应性两方面都有明显改善。
在一次 5 个问题的对话运行中,总 token 使用量下降了约 71%,从约 289,500 降至约 82,900 个 token,而平均 trace 延迟降低了近 80%,从 15.4 秒降至 3.1 秒(图 4)。在 100 个样本问题中(图 5),总 token 从 23.6 M 降至 8.5 M(64%),平均 trace 延迟从 7,930 ms 降至 2,461 ms(69%)。

图 4:OTEL 会话对比

图 5:100 个样本问题的 OTEL 会话对比
这一效果在大型单轮负载上最为显著。表 1 分解了最重单次查询(列出每个验证类别中的所有有效 crew)的每轮影响。
| 指标 | 优化前 | 优化后 | 降幅 |
|---|---|---|---|
| 输入 token | ~32,000 | ~8,000 | 75% |
| 输出 token | ~2,800 | 477 | 83% |
| 单轮延迟 | ~165 s | 9.9 s | 94% |
表 1:输入、输出和延迟影响
图 6 和图 7 展示了优化前后的相应跟踪详情。

图 6:优化前的跟踪详情

图 7:优化后的跟踪详情
这些收益主要来自避免在每一轮都将完整负载注入模型上下文。取而代之的是,模型现在先接收精简摘要,仅在需要时才获取更多细节。

图 8:精简摘要事件
这种改进也体现在跟踪时间线中:优化前的轮次拉长到接近 2 分 46 秒,而优化后的轮次约 15 秒完成(图 9)。

图 9:优化前后时间线
这些更改还改善了较长对话中的行为。上下文增长在各轮次之间变得更可预测,即使用户基于大型数据集追问后续问题,代理仍保持响应。在实践中,这使系统从不断累积的 token 成本转向更可控、按需驱动的访问模式。
最重要的是,这些收益并未以牺牲能力为代价。完整负载仍保留在制品存储中,并可在需要更深入检查时通过句柄检索。在 Flightscape,这种模式为将对话式 AI 能力引入复杂的航空公司运营工作流提供了基础,使底层 AI 体验保持可扩展且成本高效。
清理
为避免持续产生费用,请删除你为本演练创建的资源:
- 清空并可选删除用于制品存储的 S3 桶,或移除 artifacts/ 前缀下的所有对象(例如 artifacts/)。
- 删除测试期间创建的任何 Amazon Bedrock AgentCore 代理及关联的 AgentCore 记忆会话。
- 移除为 S3 或 Bedrock 访问创建的 AWS Identity and Access Management(IAM)角色和策略。
- 删除代理运行时生成的 Amazon CloudWatch 日志组。
- 移除为本演练预配的任何 Amazon Virtual Private Cloud(Amazon VPC)端点或网络资源。
结论
如果你的 Amazon Bedrock AgentCore 代理处理大型 JSON 数据,请先确定哪些工具输出主导了你的上下文窗口。从将制品卸载到 S3(策略 1)开始,因为它为其他优化提供了基础,然后按需添加分页(策略 2)和压缩(策略 3),以改善代理的 token 使用量和延迟。要开始使用,请克隆 GitHub 仓库,并将这些策略适配到你自己的代理。要详细了解如何使用 AgentCore 和 LangGraph 构建代理,请参阅 Amazon Bedrock AgentCore 文档和 LangGraph 框架文档。