人工智能
降低 Amazon Bedrock AgentCore JSON 工作负载中的 token 成本与延迟随着企业构建配备数十种工具和大型结构化输入的生产级智能体,token 消耗和延迟成为良好用户体验的主要障碍。当这些智能体处理大型 JSON 数据时,每一次额外的工具调用都会将完整负载注入大语言模型(LLM)的上下文窗口,导致 token 用量和响应延迟激增。 在多轮对话中,这种压力会不断累积,推高成本并降低响应质量。有效管理智能体系统中的上下文窗口压力,是在规模化场景下实现可靠性和响应能力的关键。在本文中,我们分享三种可组合的策略,我们曾用它们为 Flightscape 构建了一个可处理 20 MB 以上 JSON 负载的生产级智能体。 你可以应用这些策略来降低 token 成本、降低延迟,并在长时间会话中保持完整的推理能力。在我们的基准测试中,使用具有代表性的 23 MB 负载,这些优化措施合计将 token 消耗最多降低了 71%,并将平均延迟最多降低了 80%。
解决方案概述
Flightscape 是一个航空公司运营平台,帮助航空公司规划和管理其机组人员、航班和运营。作为 Flightscape 机组管理能力的一部分,我们构建了一个培训计划优化智能体,用于根据业务规则验证机组培训计划分配。该智能体拥有 40 多个工具,JSON 输入达到数兆字节,能够回答跨机组分配、排班和资源分配的复杂查询。 尽管该智能体实现了所需功能,但大多数调用的平均请求延迟超过15秒。每次工具调用都会将其完整负载注入模型上下文,从而推高token数量和成本。在较大的数据集上,上下文窗口会在智能体完成推理之前就被填满。下图(图1)详细展示了该智能体架构和数据流:
图 1:智能体架构与数据流
在图 1 中,Optimizer 接收 Request JSON 并生成 Response JSON,随后由 Business Rules Validator 进行验证,生成 Validation Report JSON。这三份 JSON 文档都会被一个 AI Agent 摄取,该 Agent 提供对话式界面,供用户查询优化结果、理解验证错误并探索排班分配。该 Agent 使用 LangGraph(LangChain 的开源框架)构建,并运行在 Amazon Bedrock AgentCore这一平台可用于大规模构建、连接和优化智能体,并支持任意框架或模型。Amazon Bedrock Guardrails 可用于验证和过滤智能体的对话响应,有助于在生产部署中促进负责任的 AI 实践。我们定义了一个自定义智能体状态,用于保存工具所需的数据:优化请求 JSON、优化响应 JSON 和验证报告 JSON。我们还在状态中添加了基本统计信息和缓存数据,以支持丰富的查询。智能体使用一个 模型进行推理,并使用 Amazon Bedrock AgentCore memory(Amazon Bedrock AgentCore 的一项能力)来跨轮次持久化聊天交互,每一轮都遵循以下流程(图 2):图 2:智能体流程状态结构如下所示。该状态引用了 TOPT(Training Optimizer)请求和响应对象,它们分别代表机组排班输入和优化结果:注意:该状态最初以内联方式保存了沉重的负载。后续章节将说明我们如何将大型工件 模型进行推理,并使用 (Amazon Bedrock AgentCore 的一项能力)(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)展示了这三种策略如何融入单个智能体轮次。策略 1 在每一轮的开头和结尾运行,策略 2 和策略 3 则在每次工具返回结果时运行。
图 3:单个智能体轮次中三种优化策略的概览
在一轮开始时, hydrate_state() 函数从 AgentCore memory 恢复轻量级会话状态。当工具返回超大列表或字典时,智能体会将完整结果存入 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 的智能体(或等效的图编排框架),支持工具调用。
- 一个 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 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
重新水合会逆转这一过程。当会话恢复时,我们会重建实时图状态:反序列化 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 memory 中的数据量。由于重型负载不再以内联方式持久化,工具调用响应成为上下文 token 的主要消耗者,这促使我们引入了结果分页。
策略 2:按需对大型结果列表进行分页
即使将重型负载的持久化迁移到 Amazon S3 之后,我们在工具响应时仍然面临严重的 token 瓶颈。许多工具结果过于庞大,由此产生了两个问题。第一,即使模型只需要一小部分数据,我们也会把完整列表发送给模型,导致每一轮都更慢、更昂贵。第二,这些完整的列表负载被注入上下文,在多轮对话中很快耗尽了上下文窗口。
在某些情况下,单个工具响应超过了 80,000 个 token,而且随着用户持续与智能体交互,成本会不断累积。我们希望在不默认发送全部内容的前提下保留完整的数据访问能力。为了解决这个问题,我们为大型工具输出引入了按需结果分页。工具不再返回完整列表,而是返回一个紧凑的负载,其中包含总数、一个小样本和一个结果句柄。
当工具结果超过样本量阈值时,完整列表会存储在 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 中的完整结果。当智能体需要更多细节时,它会用该句柄调用分页工具,并且只请求所需的切片,例如使用 offset 和 limit。
该函数允许模型通过句柄、偏移量和限制来检索已存储结果的更多切片:按需分页将完整列表保留在 S3 中,并且每轮只提供所请求的切片,从而控制上下文增长并显著减少 token 使用量。然而,并非所有超大输出都是列表。有些工具返回的是大型字典,需要采用不同的压缩方法。策略 3:压缩超大字典输出与列表不同,字典输出包含深度嵌套的结构化 get_result_page_tool 该函数允许模型通过句柄、偏移量和限制来检索已存储结果的更多切片:
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 占用。
为了解决这个问题,我们为超大字典输出引入了基于描述符的压缩方式。我们不再完整返回超大字典,而是返回一个紧凑的描述符:
- 列表字段用计数和样本表示。
- 嵌套字典按键的数量进行汇总。
- 标量值在有用时保持内联。
完整负载存储在构件存储中,响应中包含一个结果句柄。当智能体需要更详细的信息时,它会使用该句柄仅获取所需的数据。这种响应格式对模型而言仍然易于导航,同时显著减少了不必要的 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,而平均trace延迟降低了近80%,从15.4秒降至3.1秒(图4)。在100个样本问题中(图5),总token从23.6 M降至8.5 M(64%),平均trace延迟从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 展示了优化前后的相应 trace 详情。图 6:优化前 trace 详情 图 7:优化后 trace 详情 这些收益主要来自避免在每一轮都将完整负载注入模型上下文。取而代之的是,模型现在先接收紧凑摘要,仅在需要时才获取更多细节。图 8:紧凑 | 之后 | 降幅 |
| 输入 token 约 32,000 约 8,000 75% 输出 token 约 2,800 477 83% 单轮延迟 约 165 秒 9.9 秒 94% 表 1:输入、输出和延迟影响 图 6 和图 7 展示了优化前后的相应 trace 详情。图 6:优化前 trace 详情 图 7:优化后 trace 详情 这些收益主要来自避免在每一轮都将完整负载注入模型上下文。取而代之的是,模型现在先接收紧凑摘要,仅在需要时才获取更多细节。图 8:紧凑摘要事件 改进 | ~32,000 | ~8,000 | 75% |
| 输出 token | ~2,800 | 477 | 83% |
| 单轮延迟 | 约165秒 | 9.9 秒 | 94% |
表 1:输入、输出和延迟影响
图6和图7展示了优化前后的相应trace详情。
图 6:优化前 trace 详情
图 7:优化后 trace 详情
这些收益主要来自避免在每一轮都将完整负载注入模型上下文。取而代之的是,模型现在先接收紧凑摘要,仅在需要时才获取更多细节。
图 8:紧凑摘要事件
这一改进在 trace 时间线上也同样可见:优化前的单轮耗时接近 2 分 46 秒,而优化后的单轮耗时约为 15 秒(图 9)。
图 9:优化前后的时间线
这些变化还改善了较长对话中的表现。上下文增长在各轮之间变得更可预测,即使用户在大型数据集上提出后续问题时,智能体也保持响应。在实践中,这使系统从不断累积的 token 成本转变为更可控、按需驱动的访问模式。
最重要的是,这些收益并未以牺牲能力为代价。完整负载仍保留在工件存储中,只要需要更深入的检查,就可以通过句柄检索。在 Flightscape,这一模式为将对话式 AI 能力引入复杂的航空公司运营工作流奠定了基础,同时让底层 AI 体验保持可扩展且成本高效。
清理
为避免持续产生费用,请删除你为此演练创建的资源:
- 清空并可选地删除用于工件存储的 S3 存储桶,或删除工件前缀(例如 artifacts/)下的所有对象。
- 删除测试期间创建的所有 Amazon Bedrock AgentCore 智能体及关联的 AgentCore 内存会话。
- 删除 AWS Identity and Access Management (IAM)角色和策略。
- 删除 Amazon CloudWatch 由智能体运行时生成的日志组。
- 删除任何 (Amazon VPC)端点或为此演练预置的网络资源。 删除为此演练预置的任何 Amazon Virtual Private Cloud(Amazon VPC)端点或网络资源。
结论
如果你的 Amazon Bedrock AgentCore 智能体需要处理大型 JSON 数据,请先确定哪些工具输出主导了你的上下文窗口。首先从将工件卸载到 S3(策略 1)开始,因为它为其他优化奠定了基础,然后按需添加分页(策略 2)和压缩(策略 3),以改善智能体的 token 使用量和延迟。要开始使用,请克隆 GitHub 仓库 ,并根据你自己的智能体调整这些策略。要了解更多关于使用 AgentCore 和 LangGraph 构建智能体的信息,请参阅 Amazon Bedrock AgentCore 文档 以及 LangGraph 框架文档.
AI 热点