返回专栏
· 27 分钟阅读

Context Engineering 上下文工程:构建高质量 AI 上下文的系统方法


一、什么是 Context Engineering?

Context Engineering,中文通常称为上下文工程,是指围绕大语言模型的运行需求,对输入模型的全部上下文进行设计、构建、筛选、组织、压缩和管理的一套工程方法。

它关注的不是单条 Prompt 应该怎么写,而是:

  • 模型应该获得哪些信息?
  • 哪些信息应该进入上下文?
  • 如何从外部数据源检索相关知识?
  • 如何管理多轮对话中的历史信息?
  • 如何组织工具定义、工具结果和任务状态?
  • 如何控制上下文长度、信息质量和 Token 成本?
  • 如何确保模型在复杂任务中持续获得正确的信息?

传统 Prompt Engineering 更关注指令本身,而 Context Engineering 进一步关注模型执行任务时所依赖的整个信息环境。

1.1 从 Prompt Engineering 到 Context Engineering

Prompt Engineering 通常关注提示词的表达方式,例如:

  • 如何明确任务目标?
  • 如何设计角色指令?
  • 如何约束模型输出格式?
  • 是否需要提供 Few-shot 示例?
  • 如何使用 CoT 引导复杂任务?

Context Engineering 的关注范围更广。它不仅包含 Prompt,还包含模型运行时需要的其他信息。

对比维度 Prompt Engineering Context Engineering
核心对象 提示词与指令 模型完整上下文
主要目标 提高指令理解与执行质量 提供完整、相关、可靠的信息环境
关注内容 角色、任务、约束、示例 指令、知识、历史、工具、状态、记忆
数据来源 主要由应用构造文本 内部数据、外部知识库、工具、用户输入等
工程重点 提示词设计与优化 信息获取、筛选、组织、更新和管理
典型应用 分类、抽取、内容生成 RAG、Agent、多轮对话、复杂工作流

可以将两者理解为:

  • Prompt Engineering:设计如何向模型提出要求。
  • Context Engineering:设计模型完成任务时能够看到什么信息,以及这些信息如何组织。

Prompt Engineering 是 Context Engineering 的重要组成部分,但并不能代表上下文工程的全部。

1.2 为什么需要上下文工程?

大语言模型本身存在几个重要限制。

第一,模型无法自动访问所有外部信息。

模型能够使用训练过程中学习到的参数化知识,但无法天然读取企业数据库、内部文档、实时业务数据或用户本地文件。

需要通过检索、工具调用和数据接口,将相关信息提供给模型。

第二,模型的上下文窗口有限。

上下文窗口决定了模型一次请求能够处理的 Token 总量。

即使模型支持较长上下文,也不意味着把所有历史记录和文档都放进去就是最优方案。

过长的上下文可能带来:

  • Token 成本增加。
  • Prefill 计算量增加。
  • 响应延迟增加。
  • 无关信息干扰。
  • 关键内容被大量信息淹没。
  • 长上下文中的信息利用效率下降。

第三,多轮任务需要维护状态。

在复杂对话中,模型不仅需要理解当前问题,还可能需要知道:

  • 用户之前提出了什么要求。
  • 已经完成了哪些步骤。
  • 当前任务处于什么阶段。
  • 哪些工具已经执行。
  • 哪些结果已经确认。
  • 接下来应该完成什么。

如果缺乏状态管理,模型可能重复执行任务、遗忘约束,或者基于过时信息作出判断。

第四,Agent 需要动态获取信息。

Agent 不只是接收一次输入并生成答案,还可能在执行过程中检索资料、调用工具、观察结果、调整计划。

上下文必须随着任务进展动态变化。

因此,Context Engineering 的核心价值是:将原本零散的信息获取与组织过程,变成可设计、可控制、可评估的工程系统。

二、模型上下文包含哪些内容?

上下文不是单纯的一段 Prompt,而是模型在一次推理请求中能够访问的信息集合。

在不同模型和 API 中,上下文的具体消息结构可能不同,但通常可以从以下几个维度理解。

2.1 Instructions:指令信息

指令定义模型应该做什么,以及应该遵循哪些规则。

常见内容包括:

  • System Prompt:系统级行为指令。
  • Developer Prompt:应用开发者提供的任务和行为约束。
  • User Prompt:用户当前输入。
  • 输出格式要求。
  • 任务执行规则。
  • 安全与权限约束。

例如,一个企业知识库问答系统可能要求:

角色:企业知识库助手

任务:
根据提供的企业文档回答用户问题。

约束:
1. 优先使用检索到的文档作为依据。
2. 不得编造文档中不存在的信息。
3. 如果证据不足,明确说明无法确认。
4. 回答时标明相关文档来源。

输出格式:
使用 Markdown。

指令解决的是模型行为和任务执行规则问题。

2.2 Knowledge:知识信息

Knowledge 指模型完成当前任务所需要的事实、文档和业务知识。

常见来源包括:

  • 企业内部文档。
  • 产品说明书。
  • 技术文档。
  • 数据库记录。
  • API 返回数据。
  • 搜索引擎结果。
  • 向量数据库检索结果。
  • 用户上传的文件。

例如,用户询问企业某项产品的退款规则,模型需要获得对应的产品政策,而不是仅依赖训练过程中学到的通用知识。

知识信息通常通过 RAG、数据库查询或外部 API 获取。

2.3 History:历史对话

History 指当前任务相关的历史交互信息。

包括:

  • 用户之前提出的问题。
  • 模型之前给出的回答。
  • 已经确认的约束条件。
  • 已经执行的工具调用。
  • 工具返回的结果。
  • 尚未解决的问题。

历史对话帮助模型理解当前输入与之前交互之间的关系。

但并不是所有历史消息都需要永久保留。无关内容、重复内容和过期内容可能需要过滤或压缩。

2.4 Tools:工具信息

工具信息通常包含模型可以使用的外部能力及其调用规则。

例如:

  • 搜索工具。
  • 数据库查询工具。
  • 文件读取工具。
  • 代码执行工具。
  • 日历工具。
  • 订单查询工具。
  • 企业内部业务 API。

工具上下文通常包括:

  • 工具名称。
  • 工具用途。
  • 参数定义。
  • 参数类型。
  • 必填字段。
  • 调用约束。
  • 返回数据结构。

工具定义让模型能够判断何时需要调用外部能力,以及应该如何构造调用参数。

需要注意:工具调用请求本身并不代表工具已经执行。通常由应用程序或 Agent Runtime 负责校验、执行工具,并将执行结果重新提供给模型。

2.5 State:任务状态

State 是复杂任务中非常重要的一类上下文。

它记录当前任务的运行状态,而不是简单地重复历史对话。

例如,旅行预订 Agent 可以维护:

{
  "task": "旅行预订",
  "status": "in_progress",
  "destination": "Tokyo",
  "departure_date": "2026-12-10",
  "return_date": "2026-12-15",
  "hotel_selected": false,
  "flight_selected": true,
  "pending_actions": [
    "选择酒店",
    "确认订单"
  ]
}

结构化状态比从大量聊天记录中重新推断任务进度更加可靠。

需要区分:

  • History:发生过什么。
  • State:当前处于什么状态。
  • Plan:接下来准备做什么。

三者相互关联,但不能简单等同。

2.6 Memory:记忆信息

Memory 通常用于保存跨轮次、跨任务或跨会话仍然有价值的信息。

例如:

  • 用户长期偏好。
  • 用户明确确认的业务约束。
  • 长期项目背景。
  • 经常使用的技术栈。
  • 已经确定的工作方式。

Memory 与 History 的区别在于:

对比维度 History Memory
核心用途 还原交互过程 保留长期有价值的信息
时间范围 当前会话或近期任务 跨会话或长期
数据形式 消息记录 摘要、事实、偏好、结构化记录
更新方式 随对话产生 经过筛选、提取和更新
主要问题 历史过长 记忆过时或不准确

记忆不应该成为所有历史消息的简单备份。工程上需要考虑信息有效期、来源可信度、更新机制和冲突处理。

三、Context Engineering 的整体架构

在实际系统中,上下文工程通常不是一个独立模块,而是由多个组件共同构成。

3.1 典型架构

flowchart TB
    A["用户请求"] --> B["任务识别与上下文构建"]
    B --> C["上下文数据获取"]

    C --> D["指令与规则"]
    C --> E["历史对话与记忆"]
    C --> F["知识检索"]
    C --> G["工具定义与任务状态"]

    D --> H["上下文筛选与整合"]
    E --> H
    F --> H
    G --> H

    H --> I["上下文预算与压缩"]
    I --> J["模型推理"]
    J --> K{"是否需要外部操作"}

    K -->|"需要"| L["工具调用与执行"]
    L --> M["结果校验与状态更新"]
    M --> H

    K -->|"不需要"| N["输出结果"]
    N --> O["响应与上下文维护"]

    style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style B fill:#EAF3EC,stroke:#83A995,color:#315D49
    style C fill:#EAF3EC,stroke:#83A995,color:#315D49
    style D fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style E fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style F fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style G fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style H fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style I fill:#EAF3EC,stroke:#83A995,color:#315D49
    style J fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style K fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style L fill:#EAF3EC,stroke:#83A995,color:#315D49
    style M fill:#EAF3EC,stroke:#83A995,color:#315D49
    style N fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style O fill:#F5F8F4,stroke:#B5CBBB,color:#40594A

这个架构展示了上下文工程的主要工作过程:

  1. 接收用户请求,识别任务类型。
  2. 获取任务所需的指令、知识、历史、记忆、工具和状态。
  3. 筛选与当前任务相关的信息。
  4. 根据上下文预算进行排序和压缩。
  5. 将构建后的上下文交给模型推理。
  6. 如果需要工具操作,则执行工具并更新上下文。
  7. 生成结果,并根据任务需要维护后续状态。

这里最重要的一点是:上下文不是一次性拼接完成后就不再变化,而是可能随着任务执行持续更新。

3.2 上下文构建与模型推理的边界

Context Engineering 通常由应用层和 Agent Runtime 负责。

模型主要负责:

  • 理解上下文。
  • 识别任务意图。
  • 生成回答。
  • 判断是否需要调用工具。
  • 生成工具调用参数。
  • 根据工具结果继续推理。

应用层通常负责:

  • 获取用户和业务数据。
  • 检索外部知识。
  • 管理历史记录。
  • 构建上下文。
  • 控制 Token 预算。
  • 校验工具参数。
  • 执行外部操作。
  • 更新任务状态。
  • 保存和管理记忆。

这种职责划分非常重要。

不能把模型生成的内容当作已经完成的外部操作,也不能将模型自身的判断当作权限校验。

四、上下文获取:如何选择正确的信息?

上下文工程的第一个核心问题是信息获取。

信息并不是越多越好,关键是找到与当前任务相关、可信且足够完整的信息。

4.1 静态上下文与动态上下文

从信息获取方式来看,可以分为两类。

静态上下文

在应用运行或请求处理时相对固定的信息。

例如:

  • 系统指令。
  • 角色定义。
  • 输出规范。
  • 工具 Schema。
  • 固定业务规则。
  • 产品能力说明。

静态上下文通常由应用配置或版本化模板管理。

动态上下文

随着用户输入、任务进度和外部数据变化而变化的信息。

例如:

  • 当前用户问题。
  • 最新对话历史。
  • 检索结果。
  • 实时数据库记录。
  • 工具执行结果。
  • 当前任务状态。
  • 用户临时上传的文件。

动态上下文需要根据每次任务请求重新获取或更新。

类型 主要来源 典型特点
静态上下文 配置、模板、规则库 相对稳定、可复用
动态上下文 用户输入、检索、工具、状态 随任务变化、需要更新

4.2 按需获取,而不是一次性加载

假设用户询问:

订单 20261120001 当前处于什么状态?

系统不需要把整个企业知识库、所有订单记录和全部历史对话都放进上下文。

更合理的做法是:

  1. 识别这是订单状态查询任务。
  2. 提取订单编号。
  3. 调用订单查询接口。
  4. 获取指定订单的数据。
  5. 校验查询结果。
  6. 将必要字段提供给模型。

这种方式可以减少无关信息,并降低上下文成本。

对于复杂任务,还可以采用分阶段获取策略:先获取完成当前步骤所需的信息,只有当后续任务确实需要时,再继续检索。

4.3 信息来源与可信度

不同来源的信息具有不同的可信度和时效性。

例如:

信息来源 典型特点 需要注意的问题
系统配置 权威性较高 配置可能过期
企业官方文档 业务规则明确 版本和适用范围
数据库记录 结构化、可查询 数据一致性与更新时间
外部网页 覆盖范围广 来源质量与时效性
历史对话 包含交互背景 用户可能曾提供错误信息
模型参数知识 无需外部检索 可能过时或不准确

工程上可以为上下文信息保留来源、时间戳、版本和可信度标记。

例如:

{
  "content": "标准退款期限为 7 天",
  "source": "official_refund_policy",
  "version": "v3",
  "updated_at": "2026-11-01",
  "authority": "official"
}

模型可以利用这些元数据理解信息的来源和时效性,应用也可以据此实施优先级和校验规则。

需要注意,给信息标注可信度并不会自动让模型正确识别真假。关键规则仍应由应用层控制。

五、上下文组织:如何让信息更容易被模型使用?

获取信息之后,还需要解决组织问题。

同样一批数据,采用不同的结构和顺序,可能产生不同的模型表现。

5.1 结构化上下文

尽量将不同类型的信息分开组织,而不是把所有内容混合成一大段自然语言。

例如:

# Task
回答用户关于订单状态的问题。

# User Request
订单 20261120001 当前处于什么状态?

# Business Rules
- 只能查询当前用户有权访问的订单。
- 不得推测未返回的订单信息。
- 订单状态以订单系统返回结果为准。

# Retrieved Data
订单编号:20261120001
订单状态:已发货
物流状态:运输中
更新时间:2026-11-20 09:30

# Output Requirements
说明订单当前状态和最近一次更新时间。

这种组织方式有助于区分任务、规则、数据和输出约束。

需要强调:这里的标题只是示意性的组织方式,并不是所有模型 API 都有统一的上下文分区协议。具体角色、消息字段和内容格式应以目标模型接口为准。

5.2 信息优先级

上下文中可能存在大量信息,但并不是所有信息都同等重要。

可以按照任务相关性和业务重要程度组织:

优先级 信息类型 示例
高 核心任务与硬性约束 当前任务、权限限制
高 直接证据 当前订单查询结果
高 关键任务状态 已完成步骤、待处理步骤
中 相关历史信息 用户之前确认的条件
中 辅助知识 产品背景、操作说明
低 无关历史 与当前任务无关的闲聊

需要注意,信息优先级是上下文管理策略,不等于模型协议中的指令优先级。

例如,安全规则和用户要求发生冲突时,不能仅依靠将某段文字放在前面或后面来解决。应根据模型接口的角色层级和应用侧权限策略处理。

5.3 信息顺序

上下文顺序可能影响模型对信息的利用。

例如:

  • 先给出任务目标,再提供相关背景。
  • 将重要约束放在清晰、稳定的位置。
  • 将直接证据与解释性内容区分开。
  • 在长上下文中避免关键条件被大量无关内容包围。

长上下文模型还可能出现所谓的 Lost in the Middle 现象:部分任务中,模型对位于上下文中间位置的信息利用效果低于开头或结尾的信息。

这并不是所有模型和任务都必然发生的规律,但说明上下文窗口容量不等于有效信息利用能力。

工程上应通过实际模型和业务任务测试信息顺序,而不是假设模型一定能平等利用每一个位置的信息。

六、上下文预算:有限 Token 如何分配?

上下文窗口是上下文工程的重要约束。

模型一次请求能够处理的信息总量有限,而且输入上下文与输出生成通常共享模型的上下文长度限制。

6.1 上下文窗口的组成

一个请求的上下文通常可能包含:

  • System / Developer 指令。
  • 当前用户输入。
  • 历史消息。
  • 检索文档。
  • 工具定义。
  • 工具调用与返回结果。
  • 多模态输入对应的数据或 Token 表示。
  • 其他模型接口所需的上下文信息。

可以将 Token 预算抽象为:

T_{\text{total}} = T_{\text{instructions}} + T_{\text{history}} + T_{\text{knowledge}} + T_{\text{tools}} + T_{\text{input}} + T_{\text{output}}

其中:

  • T_{\text{total}}:总 Token 预算。
  • T_{\text{instructions}}:指令消耗。
  • T_{\text{history}}:历史对话消耗。
  • T_{\text{knowledge}}:检索知识消耗。
  • T_{\text{tools}}:工具定义与相关信息消耗。
  • T_{\text{input}}:当前输入消耗。
  • T_{\text{output}}:预留输出 Token。

实际系统还需要考虑模型接口的额外开销、特殊 Token、隐藏格式开销和多模态数据的 Token 计算方式。

因此,不能仅根据可见文本长度准确估算全部上下文成本。

6.2 Token 预算分配

假设某个模型请求允许使用 32,000 Token,可以根据任务特点设计预算。

上下文组成 示例预算
系统与开发者指令 2,000
历史对话 5,000
检索知识 10,000
工具定义与结果 3,000
当前用户输入 2,000
输出预留 5,000
缓冲空间 5,000
合计 32,000

这只是一个预算规划示例,不是通用最佳比例。

不同任务的上下文构成差异很大:

  • 简单问答需要较少历史和知识。
  • 长文档分析需要较多文档内容。
  • Agent 任务需要考虑工具定义、执行结果和状态。
  • 代码分析可能需要较大的代码上下文。
  • 多模态任务还需要考虑图像、音频或视频对应的数据开销。

预算分配应根据任务类型动态调整。

6.3 上下文压缩

当上下文接近窗口限制时,需要压缩或淘汰部分信息。

常见策略包括:

1. 历史截断

删除较早且与当前任务关系较弱的消息。

适合简单对话,但可能丢失早期重要约束。

2. 历史摘要

将较长的对话整理成结构化摘要。

例如:

用户目标:
构建一个企业知识库问答系统。

已确认条件:
- 使用 Python。
- 使用 PostgreSQL。
- 使用向量检索。
- API 采用 FastAPI。

当前进度:
已经完成数据导入设计。

待完成:
设计检索与重排序模块。

3. 检索式历史管理

不将所有历史内容放入当前上下文,而是将历史保存到外部存储中,在需要时检索相关内容。

4. 结构化状态提取

将对话中的关键事实、约束和任务进度提取为结构化数据。

5. 冗余信息删除

去除重复文档、重复工具结果、无关背景和已经失效的信息。

6.4 上下文压缩的风险

压缩不是简单地缩短文本。

如果压缩过程丢失了重要信息,可能导致模型做出错误判断。

常见风险包括:

  • 关键条件被摘要遗漏。
  • 数字、时间和实体名称被改写。
  • 已确认事实与待确认信息混淆。
  • 任务状态被错误合并。
  • 历史约束被新信息覆盖。
  • 来源和证据链丢失。

因此,压缩应遵循一个原则:

可以减少表达长度,但不能随意改变事实、约束和任务状态。

对于金额、订单编号、用户权限、时间范围等关键字段,优先使用结构化存储,而不是只依赖自然语言摘要。

七、RAG:上下文工程中的知识获取机制

RAG(Retrieval-Augmented Generation,检索增强生成)是上下文工程最典型的应用方式之一。

它解决的是模型如何在推理过程中获取外部知识的问题。

7.1 RAG 的核心思想

传统大语言模型主要依赖模型参数中编码的知识。

但参数化知识存在更新成本高、信息可能过时、无法天然访问私有数据等问题。

RAG 将外部知识检索与模型生成结合起来。

模型生成答案之前,系统先从知识库中检索相关内容,再将检索结果加入上下文。

7.2 RAG 的基本流程

flowchart TB
    A["原始文档"] --> B["文档解析"]
    B --> C["文本清洗"]
    C --> D["Chunk 分块"]
    D --> E["Embedding 向量化"]
    E --> F["向量数据库"]

    G["用户问题"] --> H["问题处理"]
    H --> I["检索相关内容"]
    F --> I
    I --> J["重排序 Reranking"]
    J --> K["上下文构建"]
    K --> L["大语言模型"]
    L --> M["生成答案"]

    style A fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style B fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style C fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style D fill:#EAF3EC,stroke:#83A995,color:#315D49
    style E fill:#EAF3EC,stroke:#83A995,color:#315D49
    style F fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style G fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style H fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style I fill:#EAF3EC,stroke:#83A995,color:#315D49
    style J fill:#EAF3EC,stroke:#83A995,color:#315D49
    style K fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style L fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style M fill:#DCEFE5,stroke:#4F8B70,color:#24563F

7.3 RAG 与 Context Engineering 的关系

RAG 主要负责获取外部知识,而 Context Engineering 负责管理这些知识如何进入模型上下文。

例如,RAG 检索得到 20 个文档片段,但并不意味着应该全部直接交给模型。

上下文工程还需要考虑:

  • 哪些片段真正相关?
  • 是否存在重复内容?
  • 是否存在相互冲突的文档?
  • 文档是否已经过期?
  • 是否需要保留原始来源?
  • 是否需要进一步重排序?
  • 最终应该占用多少 Token?

因此,RAG 是上下文获取机制,Context Engineering 是更完整的上下文管理体系。

7.4 RAG 的关键优化点

检索质量

检索结果必须与用户问题相关。向量检索可以用于语义匹配,但在精确编号、产品型号、专有名词等场景中,通常还需要关键词检索。

Chunk 策略

Chunk 太小,可能丢失语义完整性;Chunk 太大,则可能包含大量无关信息。

分块大小、重叠比例和分块方式应根据文档类型和任务评估。

Reranking

初步检索可以扩大候选范围,再通过重排序模型对候选内容进行相关性排序。

元数据过滤

根据文档版本、部门、权限、时间等元数据进行过滤。

证据保留

保留文档 ID、标题、页码、段落位置等来源信息,便于引用和追溯。

权限控制

检索阶段必须执行用户权限过滤,不能只依赖模型判断哪些文档可以访问。

八、Memory:如何管理长期上下文?

对于跨会话和长期任务,仅依靠当前对话历史通常不够。

这时需要引入 Memory 机制。

8.1 Memory 的核心作用

Memory 主要解决两个问题:

  1. 当前对话窗口之外的信息如何保留?
  2. 未来任务需要这些信息时,如何重新提供给模型?

Memory 不等于完整聊天记录,也不等于模型参数。

它通常是应用层维护的一组外部信息,可以通过数据库、文件存储、向量数据库或其他持久化系统实现。

8.2 Memory 的常见类型

类型 说明 示例
Profile Memory 用户长期属性和偏好 常用语言、表达偏好
Semantic Memory 长期事实和知识 项目技术栈、业务规则
Episodic Memory 过去发生的重要事件 某项任务的完成情况
Procedural Memory 长期工作方法或流程 固定的代码审查规范
Task Memory 当前任务的中间状态 当前进度、待完成事项

这些类型是常见的工程分类方式,不是所有框架都采用完全相同的定义。

8.3 Memory 的生命周期

记忆不是简单的写入和读取,还需要管理完整生命周期。

flowchart TB
    A["产生交互信息"] --> B["识别候选记忆"]
    B --> C["提取关键事实"]
    C --> D["质量与权限检查"]
    D --> E{"是否值得保存"}

    E -->|"是"| F["写入记忆存储"]
    E -->|"否"| G["丢弃或仅保留在历史"]

    F --> H["检索与使用"]
    H --> I["更新或合并"]
    I --> J["有效性检查"]
    J --> K{"是否仍然有效"}

    K -->|"是"| F
    K -->|"否"| L["过期或删除"]

    style A fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style B fill:#EAF3EC,stroke:#83A995,color:#315D49
    style C fill:#EAF3EC,stroke:#83A995,color:#315D49
    style D fill:#EAF3EC,stroke:#83A995,color:#315D49
    style E fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style F fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style G fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style H fill:#EAF3EC,stroke:#83A995,color:#315D49
    style I fill:#EAF3EC,stroke:#83A995,color:#315D49
    style J fill:#EAF3EC,stroke:#83A995,color:#315D49
    style K fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style L fill:#F7EAE7,stroke:#C98D7C,color:#754438

8.4 Memory 需要解决的问题

记忆筛选

并不是用户说过的所有内容都值得保存。

应该根据长期价值、任务相关性、用户授权和敏感程度进行筛选。

记忆冲突

例如,用户之前使用 Java,后来改为 Go。

系统需要识别新旧信息的时间关系,避免同时保留两个互相矛盾的当前事实。

记忆过期

某些信息具有时效性,例如临时项目进度、订单状态和短期安排。

需要设置有效期或定期重新验证。

记忆污染

如果将模型生成的错误内容直接保存为长期记忆,错误可能在未来持续传播。

因此,重要记忆应该保留来源,并在必要时经过验证。

隐私与权限

记忆系统需要支持访问控制、用户授权、数据生命周期管理和删除机制。

不能因为某项信息曾经出现在对话中,就默认它可以永久保存和跨任务使用。

九、Agent Context Engineering:动态任务上下文

当系统从简单问答发展为 Agent,Context Engineering 的复杂度会进一步提高。

因为 Agent 的上下文不仅需要描述用户需求,还需要随着执行过程不断变化。

9.1 Agent 上下文的组成

一个 Agent 在运行时通常需要维护:

  • System Instructions:行为和执行规则。
  • User Goal:用户目标。
  • Task Plan:当前任务计划。
  • Working Memory:当前工作信息。
  • Tool Definitions:可调用工具。
  • Tool Results:工具执行结果。
  • Environment State:外部环境状态。
  • Execution History:执行历史。
  • Constraints:权限、安全和业务约束。

这些内容共同决定 Agent 下一步应该做什么。

9.2 Agent 的上下文循环

flowchart TB
    A["接收任务"] --> B["构建初始上下文"]
    B --> C["模型分析当前状态"]
    C --> D["生成下一步行动"]
    D --> E{"是否需要工具"}

    E -->|"需要"| F["校验工具调用"]
    F --> G["执行工具"]
    G --> H["获取执行结果"]
    H --> I["更新任务状态"]
    I --> J["更新上下文"]
    J --> C

    E -->|"不需要"| K["生成最终结果"]
    K --> L["保存必要任务信息"]

    style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style B fill:#EAF3EC,stroke:#83A995,color:#315D49
    style C fill:#EAF3EC,stroke:#83A995,color:#315D49
    style D fill:#EAF3EC,stroke:#83A995,color:#315D49
    style E fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style F fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style G fill:#EAF3EC,stroke:#83A995,color:#315D49
    style H fill:#EAF3EC,stroke:#83A995,color:#315D49
    style I fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style J fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style K fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style L fill:#F5F8F4,stroke:#B5CBBB,color:#40594A

这个过程可以持续多轮。

每次工具执行之后,Agent 都需要根据最新结果更新上下文。

例如:

用户要求:

帮我分析最近一个月的销售情况,
找出销售额下降最明显的产品,
并生成一份分析报告。

Agent 可能需要:

  1. 查询最近一个月的销售数据。
  2. 查询上一个月的销售数据。
  3. 对齐产品维度。
  4. 计算销售额变化。
  5. 找出下降最明显的产品。
  6. 查询相关产品信息。
  7. 组织分析结论。
  8. 生成报告。

每个阶段都会产生新的数据和状态。

如果只保留完整工具调用历史,而不维护结构化状态,随着任务变复杂,上下文会迅速膨胀。

9.3 Working Memory:工作记忆

Working Memory 是 Agent 执行当前任务时使用的临时信息集合。

它与长期 Memory 不同,主要服务于当前任务。

例如:

{
  "goal": "分析最近一个月的销售情况",
  "step": "compare_sales",
  "completed": [
    "query_current_month",
    "query_previous_month"
  ],
  "current_findings": {
    "highest_decline_product": "Product A",
    "decline_rate": 0.23
  },
  "pending": [
    "query_product_details",
    "generate_report"
  ]
}

这种结构化状态可以帮助 Agent 在多轮执行中明确当前进度。

需要注意,Working Memory 是应用架构中的概念,不一定对应模型 API 中的某个独立字段。

9.4 工具结果不应无差别进入上下文

工具可能返回大量数据。

例如,数据库查询返回 10,000 条记录,但模型可能只需要:

  • 总销售额。
  • 产品分组汇总。
  • 环比变化。
  • 异常产品。
  • 相关统计结果。

更好的方式是由程序先完成确定性的计算和数据筛选,再将必要结果提供给模型。

对于大规模数据分析,不能把模型当成数据库或高精度计算引擎。

模型更适合解释结果、组织分析和生成报告;精确计算应尽可能交给确定性程序执行。