Amazon Bedrock AgentCore 如何降低 JSON 负载的 token 成本与延迟
Reducing token costs and latency in Amazon Bedrock AgentCore JSON workloads
Flightscape 在 Amazon Bedrock AgentCore 上用三种策略优化处理大 JSON 的 Agent,在 23 MB 负载基准测试中 token 消耗最多降低 71%、平均延迟最多降低 80%。
随着企业构建拥有数十种工具和大型结构化输入的生产级智能体,token 消耗和延迟成为良好用户体验的主要障碍。当这些智能体处理大型 JSON 数据时,每一次额外的工具调用都会将完整载荷注入大语言模型(LLM)的上下文窗口,导致 token 用量和响应延迟激增。在多轮对话中,这种压力会不断累积,推高成本并降低响应质量。有效管理智能体系统中的上下文窗口压力,是实现大规模可靠性和响应能力的关键。在本文中,我们分享三种可组合的策略,用于为 Flightscape 构建一个可处理 20 MB 以上 JSON 载荷的生产级智能体。你可以应用这些策略来降低 token 成本、减少延迟,并在长时间会话中保持完整的推理能力。在我们针对一个具有代表性的 23 MB 载荷进行的基准测试中,这些优化措施合计将 token 消耗降低了最多 71%,并将平均延迟缩短了最多 80%。
解决方案概述
Flightscape 是一个航空运营平台,帮助航空公司规划和管理其机组人员、航班和运营。作为 Flightscape 机组管理能力的一部分,我们构建了一个培训计划优化智能体,用于根据业务规则验证机组培训计划分配。该智能体拥有 40 多种工具和数 MB 的 JSON 输入,可以回答跨机组分配、排班和资源分配的复杂查询。尽管该智能体提供了所需功能,但大多数调用的平均请求延迟超过 15 秒。每次工具调用都会将其完整载荷注入模型上下文,从而推高 token 数量和成本。在较大的数据集上,上下文窗口在智能体完成推理之前就被填满。下图(图 1)详细展示了智能体架构和数据流:
图 1:智能体架构和数据流
在图 1 中,Optimizer 接收 Request JSON 并生成 Response JSON,随后由 Business Rules Validator 进行验证以生成 Validation Report JSON。这三份 JSON 文档都会被一个 AI Agent 摄取,该智能体为用户提供对话式界面,用于查询优化结果、理解验证错误并探索排班分配。该智能体使用 LangGraph 构建,这是 LangChain 推出的开源框架,并运行在 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:持久化轻量级会话状态,卸载大型工件
我们的第一项优化是改变持久化会话状态的方式。最初,大型负载被存储得离对话状态太近。因此,我们将大型工件(请求 JSON、响应 JSON、验证数据以及其他大型派生负载)移至 Amazon S3。随后,AgentCore memory 仅持久化指向这些对象的稳定引用,从而保持会话状态轻量。
为支持这一点,我们引入了一个专用的持久化状态 schema,仅保留轻量级字段和工件引用。实时图状态仍包含用于工具执行的已解析领域对象,但持久化现在写入的是脱水形式。在运行时,工具使用这些引用按需水合大型负载,而不是在每个轮次都加载所有内容。
这个 PersistedState schema 就是写入 AgentCore Memory 的内容:
class PersistedState(TypedDict, total=False):
"""Serialized session state for AgentCore Memory.
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 payloaddehydrate_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再水合则逆转这一过程。当会话恢复时,我们重建实时图状态:反序列化 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)
}脱水和再水合都依赖工件存储为每个负载返回一致的引用。我们不是生成随机键,而是从负载本身派生引用。这种方法称为内容寻址,它使用排序键和紧凑分隔符序列化 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 内存中的数据量。由于重型负载不再内联持久化,工具调用响应成为上下文 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 函数让模型可以通过句柄、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:压缩超大字典输出
与列表不同,字典输出包含深度嵌套的结构化数据,这些数据对推理有用,但通常逐字包含在每一轮中成本过高。我们需要一种紧凑表示,既能保留结构线索,又能大幅削减 token 占用。
为解决这个问题,我们为超大字典输出引入了基于描述符的压缩。我们不再完整返回超大字典,而是返回一个紧凑描述符:
- 列表字段由计数和样本表示。
- 嵌套字典按键数量进行汇总。
- 标量值在有帮助时保持内联。
完整负载存储在工件存储中,响应中包含一个结果句柄。当 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 增长变得可预测,即使面对数兆字节的数据集,代理也能保持响应。
结果
为了验证这三种策略的效果,我们在同一数据集上针对优化前和优化后的代理版本运行了同一组问题。随后,我们在 Amazon Bedrock AgentCore Observability(AgentCore 的一项能力)中比较了 token 用量和延迟,并观察到成本和响应性均有明显改善。
在一次包含 5 个问题的对话运行中,总 token 用量下降了约 71%,从约 289,500 降至约 82,900 个 token,而平均追踪延迟下降了近 80%,从 15.4 秒降至 3.1 秒(图 4)。在 100 个样本问题中(图 5),总 token 从 23.6 M 降至 8.5 M(64%),平均追踪延迟从 7,930 毫秒降至 2,461 毫秒(69%)。
图 4:OTEL 会话比较
图 5:100 个样本问题的 OTEL 会话比较
效果在大型单轮负载上最为显著。表 1 分解了最重单次查询(列出所有验证类别中的有效机组)的每轮影响。
| 指标 | 优化前 | 优化后 | 降幅 |
| 输入 token | ~32,000 | ~8,000 | 75% |
| 输出 token | ~2,800 | 477 | 83% |
| 轮次延迟 | 约 165 秒 | 9.9 秒 | 94% |
表 1:输入、输出和延迟影响
图 6 和图 7 展示了优化前后的相应追踪详情。
图 6:优化前追踪详情
图 7:优化后追踪详情
这些收益主要来自避免在每一轮都将完整负载注入模型上下文。相反,模型现在首先接收紧凑摘要,仅在需要时获取更多细节。
图 8:紧凑摘要事件
改进也体现在追踪时间线上:优化前的轮次延长至近 2 分 46 秒,而优化后的轮次约 15 秒完成(图 9)。
图 9:优化前后时间线
这些更改还改善了较长对话中的行为。上下文增长在各轮之间变得更可预测,即使用户在大型数据集上提出后续问题,代理也能保持响应。在实践中,这将系统从复合式 token 成本转变为更可控、需求驱动的访问模式。
最重要的是,这些收益并未牺牲能力。完整负载仍保留在工件存储中,可在需要深入检查时通过句柄检索。在 Flightscape,这一模式为将对话式 AI 能力引入复杂的航空公司运营工作流奠定了基础,使底层 AI 体验保持可扩展且成本高效。
清理
为避免持续产生费用,请删除本演练中创建的资源:
- 清空并可选删除用于工件存储的 S3 桶,或删除工件前缀(例如 artifacts/)下的所有对象。
- 删除测试期间创建的任何 Amazon Bedrock AgentCore 代理及关联的 AgentCore 内存会话。
- 删除为 S3 或 Bedrock 访问创建的 AWS Identity and Access Management(IAM)角色和策略。
- 删除由 agent 运行时生成的 Amazon CloudWatch 日志组。
- 移除为本演练预置的任何 Amazon Virtual Private Cloud(Amazon VPC)端点或网络资源。
结论
如果您的 Amazon Bedrock AgentCore agent 需要处理大型 JSON 数据,请先找出哪些工具输出占据了大部分上下文窗口。首先从将产物卸载到 S3(策略 1)开始,因为它为其他优化奠定了基础;然后根据需要添加分页(策略 2)和压缩(策略 3),以改善 agent 的 token 使用量和延迟。要开始使用,请克隆 GitHub 仓库,并将这些策略适配到您自己的 agent。要了解有关使用 AgentCore 和 LangGraph 构建 agent 的更多信息,请参阅 Amazon Bedrock AgentCore 文档和 LangGraph 框架文档。
关于作者
Pallav Gupta
Pallav 是 Flightscape 的软件工程经理,他领导 Flightscape AI Labs(FLAI),该团队专注于将 AI 能力引入 Flightscape 各项解决方案的生产环境。他在软件领域拥有近二十年的经验,曾担任首席软件架构师,在 AWS 上构建可扩展且高性价比的系统。他目前的工作重点是生产级 AI agent,尤其关注可扩展性、成本效益和可靠性。他持有 AWS 和 Google Cloud 架构师认证。
Pascal Acquaah
Pascal 是 AWS 的高级解决方案架构师,他帮助 Enterprise 客户通过在 AWS 上构建和现代化架构来实现业务成果。他倡导构建强大的数据基础,以最大化 AI 竞争优势,并帮助客户在 AWS 上制定和执行其数据与 AI 战略。
来源:AWS Machine Learning Blog · aws.amazon.com








