跳到正文
原文
AWS Machine Learning Blog· Pallav Gupta·· 33 分钟前

降低 Amazon Bedrock AgentCore JSON 工作负载的 token 成本与延迟

Reducing token costs and latency in Amazon Bedrock AgentCore JSON workloads

SI 导读

在代表性 23 MB payload 的基准运行中,三种 Amazon Bedrock AgentCore JSON 工作负载优化策略让 token 消耗最高降低 71%、平均延迟最高降低 80%。

精选SI 评分63
推荐理由

文章给出生产智能体处理大 JSON 负载时降低 token 成本和延迟的三种工程策略,并用同一数据集对比优化前后的结果。

正文 · SI 翻译

随着企业构建拥有数十种工具和大型结构化输入的生产级智能体,令牌消耗和延迟成为良好用户体验的主要阻碍。当这些智能体处理大型 JSON 数据时,每次额外的工具调用都会将完整负载注入到大语言模型(LLM)的上下文窗口中,导致令牌使用量和响应延迟激增。在多轮对话中,这种压力会不断累积,从而推高成本并降低响应质量。在智能体系统中有效管理上下文窗口压力,是实现大规模可靠性和响应性的关键。在本文中,我们分享了用于构建 Flightscape 生产级智能体的三种可组合策略,该智能体能够处理 20 MB 以上的 JSON 负载。您可以应用这些策略来降低令牌成本、减少延迟,并在扩展会话中保持完整的推理能力。在我们的基准测试中,针对一个具有代表性的 23 MB 负载,这些优化措施将令牌消耗降低了多达 71%,并将平均延迟减少了多达 80%。

解决方案概览

Flightscape 是一个航空公司运营平台,帮助航空公司规划和管理人员、航班及运营。作为 Flightscape 人员管理功能的一部分,我们构建了一个培训日程优化智能体,用于根据业务规则验证机组人员培训日程分配。拥有 40 多种工具和以兆字节计的 JSON 输入,该智能体可以回答跨机组分配、调度和资源分配的复杂查询。尽管该智能体提供了所需的功能,但大多数调用的平均请求延迟超过 15 秒。每次工具调用都会将其完整负载注入模型上下文,导致令牌数量和成本膨胀。在较大的数据集上,上下文窗口在智能体完成推理之前就已填满。下图(图 1)详细说明了智能体架构和数据流:

Architecture diagram: the optimization workflow outputs request, response, and validation report JSON, which an AI agent reads to answer user questions through a chat interface

图 1:智能体架构和数据流

在图 1 中,优化器接收请求 JSON 并生成响应 JSON,随后由业务规则验证器进行验证以生成验证报告 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):

Diagram of one agent turn: hydrate session state, run tool calls, then dehydrate state back to storage

图 2:智能体流程

这是状态结构的样子。状态引用了 TOPT(培训优化器)请求和响应对象,它们代表机组调度输入和优化结果:

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]]

注意: 该状态最初内联存储了大型负载。后续章节将解释我们如何将大型工件移出对话上下文,以减少令牌使用量。

我们实施了三种策略,以减少通过模型上下文传递大型 JSON 负载所带来的令牌成本、延迟和内存开销。下图(图 3)展示了这三种策略如何整合到单个智能体回合中。策略 1 在每个回合的开始和结束时运行,而策略 2 和 3 在每次工具返回结果时运行。

Flow diagram of one agent turn. At the start of the turn, hydrate_state() restores lightweight session state from AgentCore memory. Tool results are checked for size: oversized lists return a count, a sample, and a handle (Strategy 2), and oversized dictionaries return a compact descriptor (Strategy 3). The model can fetch more data with get_result_page_tool(). At the end of the turn, dehydrate_state() saves references to AgentCore memory and heavy payloads to the S3ArtifactStore in Amazon S3.

图 3:单个智能体回合中三种优化策略概览

在回合开始时,hydrate_state() 函数从 AgentCore 内存中恢复轻量级会话状态。当工具返回过大的列表或字典时,智能体将完整结果存储在 Amazon Simple Storage Service (Amazon S3) 中,并向模型传递一个包含句柄的紧凑摘要。随后,模型可以使用 get_result_page_tool() 检索更多详细信息。在回合结束时,dehydrate_state() 函数将大型负载写入 S3ArtifactStore,并仅将引用保存到 AgentCore 内存中。以下章节将详细描述每种策略。

先决条件

要实施这些策略,请确保以下条件已就绪:

  1. 拥有访问 Amazon Bedrock 和支持模型的 AWS 账户。
  2. 用于工件存储的 Amazon S3 存储桶。
  3. 启用了 Amazon Bedrock AgentCore 内存以进行会话状态持久化的 Amazon Bedrock AgentCore。
  4. 支持工具调用的基于 LangGraph 的智能体(或等效的图编排框架)。
  5. 包含 boto3、langchain-core 和 langgraph 的 Python 3.12+ 环境。

优化策略

配套代码可在该 GitHub 仓库 中获取。

策略 1:持久化轻量级会话状态,卸载大型工件

我们的第一项优化是改变会话状态的持久化方式。最初,大型负载被存储得过于接近对话状态。因此,我们将大型工件(请求 JSON、响应 JSON、验证数据及其他大型衍生负载)移至 Amazon S3。AgentCore 内存随后仅持久化指向这些对象的稳定引用,从而保持会话状态的轻量级。

为此,我们引入了一个专用的持久化状态模式,仅保留轻量级字段和工件引用。实时图状态仍包含用于工具执行的解析后的领域对象,但持久化现在写入的是脱水形式。在运行时,工具使用这些引用按需水合大型负载,而不是在每个回合都加载所有内容。

此 PersistedState 模式是写入 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 内存中的数据量。由于大型负载不再内联持久化,工具调用响应成为上下文 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。

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

随着轻量级持久化状态、按需分页和字典压缩机制的到位,令牌增长变得可预测,即使在处理多兆字节的数据集时,智能体也保持响应灵敏。

结果

为了验证这三种策略的影响,我们在优化前和优化后的智能体版本上,针对同一数据集运行了相同的一组问题。随后,我们在 Amazon Bedrock AgentCore Observability(AgentCore 的一项功能)中比较了令牌使用量和延迟,观察到成本和响应性均有明显提升。

在 5 个问题的对话运行中,总令牌使用量下降了约 71%,从约 289,500 个令牌降至约 82,900 个令牌,而平均跟踪延迟降低了近 80%,从 15.4 秒降至 3.1 秒(图 4)。在 100 个样本问题中(图 5),总令牌数从 23.6 M 降至 8.5 M(64%),平均跟踪延迟从 7,930 毫秒降至 2,461 毫秒(69%)。

Bar chart comparing total token usage and average latency before and after optimization for a 5-question run

图 4:OTEL 会话对比

Bar chart comparing total tokens and average latency before and after optimization across 100 sample questions

图 5:100 个样本问题的 OTEL 会话对比

这种效果在大型单轮负载上最为显著。表 1 详细列出了最重的单个查询(列出所有验证类别中的有效机组)的每轮影响。

指标 优化前 优化后 降幅
输入令牌 ~32,000 ~8,000 75%
输出令牌 ~2,800 477 83%
轮次延迟 ~165 秒 9.9 秒 94%

表 1:输入、输出和延迟影响

图 6 和图 7 展示了优化前后的相应跟踪详情。

Observability trace timeline before optimization showing many spans and long per-turn latency

图 6:优化前跟踪详情

Observability trace timeline after optimization showing fewer spans and much shorter latency

图 7:优化后跟踪详情

这些收益主要来自于避免在每一轮都将完整负载注入模型上下文。相反,模型现在首先接收紧凑摘要,仅在需要时获取额外细节。

Trace event showing the agent receiving a compact summary with a result handle instead of the full payload

图 8:紧凑摘要事件

改进在跟踪时间线中也显而易见:优化前的轮次持续了将近 2 分 46 秒,而优化后的轮次在约 15 秒内完成(图 9)。

Side-by-side trace timelines: about 2 minutes 46 seconds before optimization versus about 15 seconds after

图 9:优化前后时间线

这些更改还改善了长对话中的行为。上下文增长在各轮次之间变得更加可预测,即使用户在大型数据集上提出后续问题,智能体也保持响应灵敏。实际上,这将系统从复合令牌成本转变为更受控的、按需驱动的访问模式。

最重要的是,这些收益并未以牺牲能力为代价。完整负载仍保留在工件存储中,并可通过句柄在需要深入检查时随时检索。在 Flightscape,这种模式为将对话式 AI 能力引入复杂的航空公司运营工作流奠定了基础,同时保持底层 AI 体验的可扩展性和成本效益。

清理

为避免持续收费,请删除您为此演练创建的资源:

  • 清空并可选删除用于工件存储的 S3 存储桶,或移除工件前缀下的所有对象(例如,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),以改善代理的令牌使用率和延迟。要开始使用,请克隆 GitHub 仓库 并将这些策略应用于您自己的代理。要了解有关使用 AgentCore 和 LangGraph 构建代理的更多信息,请参阅 Amazon Bedrock AgentCore 文档 和 LangGraph 框架文档。


关于作者

Pallav Gupta

Pallav Gupta

Pallav 是 Flightscape 的软件工程经理,领导 Flightscape AI Labs (FLAI),这是一个致力于将 AI 能力引入 Flightscape 解决方案生产环境的团队。拥有近二十年的软件经验,他曾任首席软件架构师,在 AWS 上构建可扩展、成本高效的系统。他目前的工作专注于生产级 AI 代理,强调可扩展性、成本效率和可靠性。他持有 AWS 和 Google Cloud 架构师认证。

Pascal Acquaah

Pascal Acquaah

Pascal 是 AWS 的高级解决方案架构师,致力于通过构建和现代化 AWS 上的架构,帮助企业客户实现业务成果。他倡导构建坚实的数据基础以最大化 AI 竞争优势,并帮助客户在 AWS 上制定和执行其数据和 AI 战略。

来源:AWS Machine Learning Blog · aws.amazon.com

© 2026 SI·Hot · Super Intelligence Hot · 超级智能热点 · 网站数据均来源于网络公开资料,版权归来源方所有