返回专栏
· 22 分钟阅读

多轮对话与上下文管理:大语言模型如何理解连续对话并保持记忆?


一、什么是多轮对话?

多轮对话(Multi-turn Conversation)是指用户与大语言模型围绕一个或多个主题,连续进行多次交互的过程。

与单轮问答不同,多轮对话中的当前请求往往依赖之前的交流内容。

例如:

用户:什么是 Transformer?

模型:Transformer 是一种基于注意力机制的神经网络架构。

用户:它为什么比 RNN 更适合并行计算?

模型:因为 Transformer 可以并行处理序列中的多个位置……

用户:那它的缺点是什么?

模型:Transformer 的主要缺点包括注意力计算开销较大……

最后一个问题中的“它”,需要结合前面的对话才能确定指的是 Transformer。

如果模型只收到最后一句:

那它的缺点是什么?

就可能无法准确判断用户所指的对象。

因此,多轮对话需要解决两个核心问题:

  1. 上下文理解: 当前问题依赖哪些历史信息?
  2. 上下文管理: 如何将必要的历史信息提供给模型?

需要明确:

大语言模型通常不会因为一次对话就自动获得永久记忆。模型能够利用历史对话,主要是因为相关信息被重新组织并传入当前请求的上下文。

二、单轮对话与多轮对话的区别

1. 单轮对话

单轮对话通常只包含一次用户输入和一次模型响应。

flowchart TD
    A["用户输入"] --> B["模型接收 Prompt"]
    B --> C["模型生成回答"]
    C --> D["返回用户"]

    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:#DCEFE5,stroke:#4F8B70,color:#24563F

单轮对话中,模型主要根据当前输入和系统指令生成结果。

2. 多轮对话

多轮对话需要在后续请求中携带与当前任务相关的历史信息。

flowchart TD
    A["第一轮用户输入"] --> B["模型生成第一轮回答"]
    B --> C["保存对话历史"]
    C --> D["第二轮用户输入"]
    D --> E["组织历史上下文"]
    E --> F["模型生成第二轮回答"]
    F --> G["更新对话历史"]
    G --> H["第三轮用户输入"]
    H --> I["再次组织上下文"]
    I --> J["模型生成第三轮回答"]

    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:#DCEFE5,stroke:#4F8B70,color:#24563F
    style E fill:#EAF3EC,stroke:#83A995,color:#315D49
    style F fill:#EAF3EC,stroke:#83A995,color:#315D49
    style G fill:#EAF3EC,stroke:#83A995,color:#315D49
    style H fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style I fill:#EAF3EC,stroke:#83A995,color:#315D49
    style J fill:#DCEFE5,stroke:#4F8B70,color:#24563F

多轮对话并不是模型在内部持续运行一个不间断的推理过程。

在常见的无状态 API 调用模式下,每一轮请求都是一次新的模型推理调用。应用程序需要将必要的历史消息重新组织到当前请求中。

3. 两种模式的核心区别

对比维度 单轮对话 多轮对话
输入内容 当前问题 当前问题与相关历史
上下文依赖 较低 较高
历史管理 通常不需要 需要
指代消解 相对简单 需要结合历史
主题连续性 不强调 需要维持
Token 消耗 相对固定 随历史增长
实现复杂度 较低 较高

三、模型如何理解多轮对话?

多轮对话的关键不是简单地保存历史文本,而是让模型能够从历史信息中识别当前问题所需的内容。

1. 对话历史作为上下文输入

假设用户进行了三轮交互:

第一轮:
用户:我准备使用 Python 开发一个 Web 项目。

第二轮:
用户:推荐一个 Web 框架。

模型:可以考虑 FastAPI、Django 和 Flask。

第三轮:
用户:它适合构建高并发 API 吗?

第三轮中的“它”具有指代歧义。

如果历史信息中没有进一步说明用户选择了哪个框架,模型就不应该直接假设用户已经选定某一个框架。

应用程序可以将相关历史消息一起传入模型:

[
  {
    "role": "user",
    "content": "我准备使用 Python 开发一个 Web 项目。"
  },
  {
    "role": "user",
    "content": "推荐一个 Web 框架。"
  },
  {
    "role": "assistant",
    "content": "可以考虑 FastAPI、Django 和 Flask。"
  },
  {
    "role": "user",
    "content": "它适合构建高并发 API 吗?"
  }
]

模型根据整个消息序列理解当前问题。

但这里仍然存在一个问题:用户并没有明确指定“它”指的是哪个框架。

合理的模型行为应该是结合上下文判断,必要时向用户澄清,而不是将不确定的信息当作事实。

2. 上下文不是简单的文本拼接

模型接收的对话通常会被组织成具有角色和内容的消息结构。

常见角色包括:

Role 含义 作用
system 系统指令 定义模型行为和约束
developer 开发者指令 定义应用层行为规则
user 用户消息 提供问题和任务
assistant 模型消息 提供回答或工具调用
tool 工具结果 返回外部工具执行结果

一个简化的多轮对话结构:

[
  {
    "role": "system",
    "content": "你是一个专业的 Python 技术助手。"
  },
  {
    "role": "user",
    "content": "什么是 FastAPI?"
  },
  {
    "role": "assistant",
    "content": "FastAPI 是一个现代 Python Web 框架。"
  },
  {
    "role": "user",
    "content": "它有什么优势?"
  }
]

角色信息非常重要。

例如,用户消息和工具结果即使包含相同的文本,也具有不同的语义来源和信任边界。

不能将所有历史内容简单合并成一段无角色区分的文本。

3. 模型如何处理指代关系?

多轮对话中经常出现:

  • 它。
  • 这个。
  • 上面提到的方案。
  • 第二种方式。
  • 刚才那个问题。
  • 按之前的要求。

这些表达都需要结合历史上下文进行理解。

例如:

用户:比较一下 PostgreSQL 和 MySQL。

模型:PostgreSQL 在复杂查询和扩展性方面有优势……

用户:那它的 JSON 支持怎么样?

模型需要从历史中判断“它”可能指向哪个数据库。

如果前一轮重点讨论的是 PostgreSQL,模型可能倾向于将其作为指代对象。

但如果上下文中同时讨论了两个数据库,就可能存在歧义。

从模型计算角度看,历史消息经过 Tokenizer 编码后,作为当前输入序列的一部分进入 Transformer。

Self-Attention 机制允许当前 Token 根据上下文中的其他 Token 计算注意力权重,从而利用历史信息。

其核心计算形式为:

Attention(Q,K,V) = softmax\left(\frac{QK^T}{\sqrt{d_k}}\right)V

在因果语言模型中,当前位置只能关注允许访问的历史位置,不能直接访问未来 Token。

因此,模型能够利用上下文中的实体、主题和语义关联来理解当前表达。

需要注意:Attention 并不是一个独立的数据库检索机制。它是在给定上下文范围内进行神经网络计算,并不保证模型一定能准确找到或使用所有历史信息。

四、上下文窗口(Context Window)

上下文窗口是多轮对话管理中最重要的基础概念之一。

1. 什么是上下文窗口?

Context Window(上下文窗口)指模型在一次推理过程中能够处理的 Token 范围。

通常包括:

  • System Prompt。
  • Developer 指令。
  • 历史用户消息。
  • 历史模型回答。
  • 工具调用与工具结果。
  • 当前用户输入。
  • 预留的模型输出空间。

例如,某个模型支持 128K Token 上下文窗口,意味着一次请求的输入和输出需要在该模型规定的上下文预算内完成。

这里的 128K 表示 Token 数量,不是字符数,也不是对话轮数。

2. 上下文窗口的组成

可以将一次请求的 Token 预算抽象为:

T_{\text{total}} = T_{\text{system}} + T_{\text{history}} + T_{\text{current}} + T_{\text{output}} + T_{\text{overhead}}

其中:

  • T_{\text{system}}:系统指令和开发者指令。
  • T_{\text{history}}:历史对话。
  • T_{\text{current}}:当前用户输入。
  • T_{\text{output}}:为模型输出预留的 Token。
  • T_{\text{overhead}}:消息结构、特殊 Token 及其他协议开销。

需要满足:

T_{\text{total}} \leq T_{\text{context limit}}

实际 API 可能分别设置输入上限、输出上限或其他约束,不能简单认为所有模型都只使用一个统一的上下文限制。

3. 上下文窗口为什么会被占满?

假设用户持续与模型进行技术讨论。

每轮对话都可能增加:

  • 用户输入。
  • 模型回答。
  • 工具调用参数。
  • 工具执行结果。
  • 补充的系统上下文。

如果应用程序每轮都完整保留历史,输入 Token 数量就会持续增长。

例如:

对话轮次 历史 Token 当前输入 Token 输出预留 Token
第 1 轮 0 500 2,000
第 5 轮 4,000 500 2,000
第 10 轮 12,000 500 2,000
第 20 轮 30,000 500 2,000
第 40 轮 65,000 500 2,000

这里仅用于说明增长趋势,实际 Token 数量取决于文本长度、Tokenizer 和消息结构。

4. 上下文窗口耗尽后的问题

当请求超过模型允许的上下文范围时,可能出现:

  • API 拒绝请求。
  • 服务端要求缩短输入。
  • 应用程序删除或压缩部分历史。
  • 输出预算不足。
  • 部分历史无法继续保留。

即使没有达到硬性上下文限制,过长的上下文也可能带来额外的计算成本和注意力分配问题。

因此,上下文管理不是简单地尽可能保存更多历史,而是要保留当前任务真正需要的信息。

五、上下文管理的核心策略

上下文管理(Context Management)是指对历史消息进行选择、组织、压缩和更新,使模型在有限的上下文预算内获得完成当前任务所需的信息。

常见策略包括:

  1. 完整历史保留。
  2. 滑动窗口。
  3. 历史摘要。
  4. 重要信息提取。
  5. 长期记忆检索。
  6. 混合上下文管理。

1. 完整历史保留(Full History)

将整个对话历史完整传入模型。

例如:

System Prompt
第一轮用户消息
第一轮模型回答
第二轮用户消息
第二轮模型回答
第三轮用户消息
第三轮模型回答
当前用户消息

优点:

  • 保留完整对话细节。
  • 不需要额外摘要处理。
  • 对短对话非常直接。
  • 不容易因为主动删除历史而丢失信息。

缺点:

  • Token 消耗持续增加。
  • 请求延迟可能上升。
  • 上下文窗口可能被占满。
  • 历史噪声可能影响当前任务。

适用场景:

  • 短对话。
  • 需要精确引用前文的任务。
  • 历史内容较少的问答系统。

2. 滑动窗口(Sliding Window)

滑动窗口只保留最近若干轮对话,删除更早的历史内容。

例如,只保留最近 5 轮:

flowchart TD
    A["完整对话历史"] --> B["按照时间排序"]
    B --> C["计算最近窗口范围"]
    C --> D["保留最近 5 轮"]
    D --> E["移除窗口外的旧消息"]
    E --> F["构建当前模型上下文"]

    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:#DCEFE5,stroke:#4F8B70,color:#24563F
    style E fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style F fill:#E5F0E9,stroke:#83A995,color:#315D49

例如:

历史轮次 是否保留
第 1 轮 否
第 2 轮 否
第 3 轮 否
第 4 轮 是
第 5 轮 是
第 6 轮 是
第 7 轮 是
第 8 轮 是

优点:

  • 实现简单。
  • Token 消耗容易控制。
  • 适合持续对话场景。
  • 可以降低历史增长带来的开销。

缺点:

  • 早期的重要信息可能被删除。
  • 当前问题可能依赖很久以前的内容。
  • 简单按轮数裁剪可能破坏上下文完整性。

例如,用户在第一轮明确指定:

后续所有代码示例都使用 TypeScript。

如果第 1 轮被删除,而这个偏好没有保存在其他位置,模型可能在后续回答中重新使用 JavaScript。

因此,滑动窗口通常需要与摘要或长期记忆结合。

3. 历史摘要(Conversation Summarization)

历史摘要是将较长的对话压缩为一段结构化摘要,保留重要信息。

例如,原始历史包含:

用户正在开发一个 Python Web 项目。
用户选择 FastAPI 作为后端框架。
数据库使用 PostgreSQL。
项目采用 Docker 部署。
用户要求代码示例尽量使用异步写法。

可以压缩为:

项目背景:
- 后端框架:FastAPI
- 数据库:PostgreSQL
- 部署方式:Docker
- 编码偏好:优先使用异步写法

当前目标:
开发一个支持用户认证和订单管理的 Web API。

历史摘要可以明显减少 Token 消耗,同时保留任务所需的关键背景。

典型流程:

flowchart TD
    A["读取历史对话"] --> B["分析历史信息"]
    B --> C["识别重要事实与决策"]
    C --> D["去除重复和低价值内容"]
    D --> E["生成结构化摘要"]
    E --> F["保存摘要"]
    F --> G["后续请求加载摘要"]
    G --> H["与近期消息组合"]
    H --> I["构建模型上下文"]

    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:#DCEFE5,stroke:#4F8B70,color:#24563F
    style F fill:#EAF3EC,stroke:#83A995,color:#315D49
    style G fill:#EAF3EC,stroke:#83A995,color:#315D49
    style H fill:#EAF3EC,stroke:#83A995,color:#315D49
    style I fill:#DCEFE5,stroke:#4F8B70,color:#24563F

摘要的关键不是尽可能短,而是保留后续推理真正需要的信息。

特别需要保留:

  • 用户明确提出的要求。
  • 已经确定的技术方案。
  • 重要业务规则。
  • 当前任务状态。
  • 尚未解决的问题。
  • 关键实体及其关系。
  • 必须遵守的约束条件。

摘要也有风险:

  • 细节丢失。
  • 数值被错误概括。
  • 时间顺序混乱。
  • 否定条件被遗漏。
  • 模型将推测误写成事实。

因此,重要信息应尽可能保留原始来源,不能只依赖模型生成的摘要。

4. 重要信息提取(Key Information Extraction)

并不是所有历史内容都需要以对话形式保存。

可以将历史中的重要事实提取为结构化数据。

例如:

{
  "project": {
    "language": "Python",
    "framework": "FastAPI",
    "database": "PostgreSQL",
    "deployment": "Docker"
  },
  "preferences": {
    "code_style": "异步优先",
    "explanation_level": "技术细节充分"
  },
  "current_task": {
    "goal": "实现订单管理 API",
    "status": "开发中"
  }
}

相比原始聊天记录,结构化信息更容易检索、更新和校验。

但结构化提取也需要考虑:

  • 信息来源。
  • 更新时间。
  • 可信程度。
  • 适用范围。
  • 是否已经失效。
  • 是否存在冲突。

5. 长期记忆检索(Long-term Memory Retrieval)

长期记忆用于保存当前对话之外,未来可能仍然有价值的信息。

例如:

  • 用户长期使用的技术栈。
  • 项目的架构约束。
  • 用户明确提出的输出偏好。
  • 持续进行中的任务背景。
  • 长期有效的业务规则。

当用户提出新问题时,系统可以根据当前问题检索相关记忆,再将结果放入模型上下文。

长期记忆通常不需要全部加载。

更合理的方式是按需检索,避免无关信息占用上下文预算。

六、短期上下文与长期记忆

多轮对话系统通常需要区分短期上下文和长期记忆。

1. 短期上下文(Short-term Context)

短期上下文主要服务于当前会话。

典型内容:

  • 最近几轮对话。
  • 当前任务要求。
  • 尚未完成的步骤。
  • 最近一次工具执行结果。
  • 当前对话中的临时约束。

它通常具有以下特点:

  • 与当前会话强相关。
  • 更新频繁。
  • 生命周期相对较短。
  • 更强调对话连续性。

2. 长期记忆(Long-term Memory)

长期记忆用于保存跨会话仍然有价值的信息。

典型内容:

  • 长期偏好。
  • 稳定的项目背景。
  • 持续性任务信息。
  • 经确认的重要事实。
  • 经常使用的工作方式。

它通常具有以下特点:

  • 可以跨会话使用。
  • 更新频率较低。
  • 需要持久化存储。
  • 需要处理过期与冲突。
  • 需要控制访问权限。

3. 两者的区别

对比维度 短期上下文 长期记忆
主要作用 保持当前对话连贯 跨会话保留重要信息
生命周期 当前会话或任务周期 可跨多个会话
内容范围 最近消息和任务状态 稳定事实与长期偏好
更新频率 高 相对较低
存储方式 消息历史、缓存、会话状态 数据库、向量库等
加载方式 按当前对话组织 根据需要检索
主要风险 上下文过长 过期、错误和隐私问题

4. 两者如何协同工作?

一个常见架构:

flowchart TD
    A["用户发送新请求"] --> B["读取当前会话"]
    B --> C["加载近期对话"]
    A --> D["提取当前问题关键词与语义"]
    D --> E["检索长期记忆"]
    E --> F["筛选相关记忆"]
    C --> G["组合上下文"]
    F --> G
    G --> H["加入系统指令"]
    H --> I["发送给大语言模型"]
    I --> J["生成回答"]
    J --> 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:#EAF3EC,stroke:#83A995,color:#315D49
    style F fill:#EAF3EC,stroke:#83A995,color:#315D49
    style G fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    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:#EAF3EC,stroke:#83A995,color:#315D49
    style L fill:#F7F4E8,stroke:#C7B77A,color:#675A2D

这里需要区分:

历史消息是对话记录,长期记忆是经过筛选和组织的信息。

历史消息不应该全部自动变成长期记忆。

例如,用户临时询问某个产品的价格,并不意味着这个价格需要永久保存。

七、记忆系统的实现方式

长期记忆不仅是一段文本,还涉及数据存储、索引、检索、更新和删除。

常见实现方式包括:

1. 关系型数据库

可以使用 PostgreSQL、MySQL 等数据库保存结构化记忆。

例如:

CREATE TABLE conversation_memory (
    id BIGINT PRIMARY KEY,
    user_id VARCHAR(128) NOT NULL,
    memory_type VARCHAR(64) NOT NULL,
    content TEXT NOT NULL,
    source VARCHAR(128),
    confidence FLOAT,
    created_at TIMESTAMP,
    updated_at TIMESTAMP
);

字段含义:

字段 作用
id 记忆记录 ID
user_id 记忆所属用户
memory_type 记忆类型
content 记忆内容
source 信息来源
confidence 可信程度或置信评分
created_at 创建时间
updated_at 更新时间

关系型数据库适合保存:

  • 用户偏好。
  • 项目配置。
  • 明确的业务规则。
  • 任务状态。
  • 结构化实体信息。

其中,confidence 只是应用程序可以维护的评分字段,并不意味着模型天然能够给出可靠的事实概率。

2. 向量数据库

对于自然语言形式的长期记忆,可以使用 Embedding 将文本转换为向量,再通过相似度检索相关信息。

例如:

记忆 A:
用户的后端项目主要使用 FastAPI。

记忆 B:
用户的数据库主要使用 PostgreSQL。

记忆 C:
用户习惯使用 Docker 部署服务。

当前问题:

我之前的 Python 项目使用什么框架?

系统可以将当前问题转换为向量,在记忆库中检索语义相关内容。

基本流程:

flowchart TD
    A["历史信息"] --> B["记忆内容提取"]
    B --> C["生成 Embedding"]
    C --> D["保存向量与元数据"]
    E["当前用户问题"] --> F["生成查询向量"]
    F --> G["向量相似度检索"]
    D --> G
    G --> H["获取候选记忆"]
    H --> I["相关性筛选"]
    I --> J["将记忆加入上下文"]

    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:#DCEFE5,stroke:#4F8B70,color:#24563F
    style F fill:#EAF3EC,stroke:#83A995,color:#315D49
    style G fill:#EAF3EC,stroke:#83A995,color:#315D49
    style H fill:#EAF3EC,stroke:#83A995,color:#315D49
    style I fill:#EAF3EC,stroke:#83A995,color:#315D49
    style J fill:#DCEFE5,stroke:#4F8B70,color:#24563F

向量检索的核心是语义相似性,而不是严格的事实匹配。

例如:

用户使用 FastAPI。

与:

用户使用 Python Web 框架。

可能具有较高的语义相似度。

但这并不意味着系统可以仅凭向量相似度就确定所有事实关系。

3. 混合检索

实际系统通常不应只依赖向量检索。

可以结合:

  • 关键词检索。
  • 向量相似度检索。
  • 用户 ID 过滤。
  • 时间过滤。
  • 记忆类型过滤。
  • 业务字段精确匹配。

例如,用户询问:

上次确定的订单编号是多少?

这种问题更适合结合结构化字段或精确关键词检索,而不是仅依赖语义相似度。

混合检索可以提高记忆召回的准确性。

八、上下文压缩与 Token 预算管理

上下文管理不仅需要决定保留哪些信息,还需要控制输入 Token 的总量。

1. Token 预算分配

假设模型允许的上下文预算为 32K Token。

可以将预算划分为:

内容 示例预算
System Prompt 2K
Developer 指令 1K
长期记忆 2K
历史摘要 4K
最近对话 12K
当前用户输入 2K
输出预留 8K
其他开销 1K
合计 32K

这只是一个预算设计示例,并非固定分配比例。

具体分配应根据任务类型、模型能力和输出需求调整。

例如:

  • 代码审查需要保留更多代码上下文。
  • 客服任务需要保留订单和用户状态。
  • 普通知识问答不需要加载大量长期记忆。
  • 长文档分析需要为原始文档预留更多输入预算。

2. 基于 Token 数量裁剪

不能简单按照字符数量控制上下文。

不同语言、代码、数字和特殊符号的 Token 数量可能存在明显差异。

更合理的做法是使用目标模型对应的 Tokenizer 估算输入长度。

伪代码:

def build_context(
    system_prompt,
    memory,
    summary,
    recent_messages,
    current_message,
    max_tokens,
    output_reserve
):
    context = {
        "system": system_prompt,
        "memory": memory,
        "summary": summary,
        "messages": recent_messages,
        "current": current_message
    }

    while count_tokens(context) + output_reserve > max_tokens:
        if context["messages"]:
            context["messages"].pop(0)
        elif context["summary"]:
            context["summary"] = compress_summary(
                context["summary"]
            )
        elif context["memory"]:
            context["memory"] = filter_memory(
                context["memory"]
            )
        else:
            raise ValueError("无法在当前预算内构建上下文")

    return context