消息、上下文工程与压缩、会话存储/恢复/分叉(dg M06/M08/M09/M10)
搞懂消息在 Agent 内部怎么组织和传递,上下文满了怎么压缩,以及会话如何持久化、恢复和分叉。
今日目标
- 能画出一条消息从用户输入到写入历史的完整流转路径
- 能实现一个简单的上下文压缩策略,在窗口快满时自动触发
- 能实现会话的持久化保存、恢复继续对话,以及从某一步分叉出新会话
昨天工具学会了自纠错,但 D5 结尾留了一笔账:每次工具调用往 messages 里塞两条消息,工具返回那条常是上千 token 的 JSON——工具越好用历史涨得越快,最后撑爆上下文窗口。今天正面解决它,读完回来勾掉三条目标。
小白版讲解
一条消息的一生:Agent 的记忆就是这个数组
小学时有种玩法叫接力日记:本子在班里传,轮到你就得从头翻一遍才知道该接着写什么。本子越厚翻得越久,但你没得选。Agent 的记忆就是这本本子——D1 说过模型无状态,"多轮对话"全靠你在客户端维护的那份 messages 数组。今天补它内部的结构:每条消息都有一个 role,D1 讲了三种(system、user、assistant),D2 加上工具后多了第四种——tool,装工具执行完的返回值。
于是一条消息的流转路径是:用户输入进来追加一条 user;发给模型;模型决定调工具,返回的 assistant 里带着 tool_calls,原样追加;执行工具,结果包成一条 tool 追加;数组重发一遍,模型这次才吐出给用户看的文字,这条 assistant 同样要追加。一轮带工具的对话,往历史里写的不是一条,是四条。
// Agent 的"记忆"就是这个数组:每一轮都要把它整个重新发给模型
const history = [
{ role: 'system', content: '你是订单助手。' },
{ role: 'user', content: '我三天前下的单什么时候到?' },
]
// 一次工具调用往历史里塞两条:模型的调用请求 + 工具的返回结果
function appendToolRound(history, call, result) {
history.push({ role: 'assistant', content: '', tool_calls: [call] })
history.push({ role: 'tool', tool_call_id: call.id, content: JSON.stringify(result) })
}
// 粗估 token:按 D1 的换算中文约 1.4 个字符一个 token,这里干脆一个字符算一个,
// 故意往高了估——低估会让压缩阈值永远触发不了,那是这里唯一不能犯的错
const estimateTokens = (msgs) =>
msgs.reduce((sum, m) => sum + (m.content ?? '').length + 4, 0)import json
import math
history: list[dict] = [
{"role": "system", "content": "你是订单助手。"},
{"role": "user", "content": "我三天前下的单什么时候到?"},
]
def append_tool_round(history: list[dict], call: dict, result: dict) -> None:
"""一次工具调用往历史里塞两条:模型的调用请求 + 工具的返回结果。"""
history.append({"role": "assistant", "content": "", "tool_calls": [call]})
history.append(
{
"role": "tool",
"tool_call_id": call["id"],
"content": json.dumps(result, ensure_ascii=False),
}
)
def estimate_tokens(msgs: list[dict]) -> int:
# 一个字符算一个 token,比真实值(中文约 1.4 字符一个)高,故意的:
# 低估会让压缩阈值永远触发不了。阈值判断不需要精确值,不必引入分词器
return sum(len(m.get("content") or "") + 4 for m in msgs)// 依赖:Jackson(com.fasterxml.jackson.databind)
// record 天生不可变,正好符合"历史只追加不改写"的语义。
// toolCalls 这个字段省不得:assistant 的调用请求靠 id 和下面那条 tool 结果配对,
// 后面讲压缩切口、讲恢复时的完整性校验,全都建立在这一对配对关系上
record ToolCall(String id, String name, String arguments) {}
record Message(String role, String content, String toolCallId, List<ToolCall> toolCalls) {
static Message user(String text) {
return new Message("user", text, null, List.of());
}
static Message tool(String id, String json) {
return new Message("tool", json, id, List.of());
}
static Message assistantCalling(ToolCall call) {
return new Message("assistant", "", null, List.of(call));
}
}
static final ObjectMapper MAPPER = new ObjectMapper();
static final List<Message> HISTORY = new ArrayList<>(List.of(
new Message("system", "你是订单助手。", null, List.of()),
Message.user("我三天前下的单什么时候到?")));
// 一次工具调用往历史里塞两条:模型的调用请求 + 工具的返回结果
static void appendToolRound(List<Message> history, ToolCall call, Object result) throws Exception {
history.add(Message.assistantCalling(call));
history.add(Message.tool(call.id(), MAPPER.writeValueAsString(result)));
}
// 一个字符算一个 token:比真实值高,故意的——低估会让压缩阈值永远触发不了
static int estimateTokens(List<Message> msgs) {
return msgs.stream().mapToInt(m -> m.content().length() + 4).sum();
}// 让 Message 直接 Codable:同一个类型既能发给 API,又能原样落盘,省掉两套模型
struct ToolCall: Codable {
let id: String
let name: String
let arguments: String
}
struct Message: Codable {
let role: String
let content: String
var toolCallId: String? = nil
// toolCalls 省不得:assistant 的调用请求靠 id 和下面那条 tool 结果配对,
// 后面的压缩切口与恢复完整性校验都建立在这一对配对关系上
var toolCalls: [ToolCall]? = nil
enum CodingKeys: String, CodingKey {
case role, content
case toolCallId = "tool_call_id"
case toolCalls = "tool_calls"
}
}
var history: [Message] = [
Message(role: "system", content: "你是订单助手。"),
Message(role: "user", content: "我三天前下的单什么时候到?"),
]
// 一次工具调用往历史里塞两条:模型的调用请求 + 工具的返回结果
func appendToolRound(_ history: inout [Message], call: ToolCall, resultJSON: String) {
history.append(Message(role: "assistant", content: "", toolCalls: [call]))
history.append(Message(role: "tool", content: resultJSON, toolCallId: call.id))
}
// 一个字符算一个 token:比真实值高,故意的——低估会让压缩阈值永远触发不了
func estimateTokens(_ msgs: [Message]) -> Int {
msgs.reduce(0) { $0 + $1.content.count + 4 }
}代码里那个 estimateTokens 值得多说一句。D1 算过,"你好,世界"这五个字符大约切成 3 到 4 个 token,也就是一个汉字差不多就是一个 token。所以这里直接拿字符数当 token 数,比真实值略高——方向是故意选的:估低了,真实占用顶到 100% 你的数字才刚过 70%,压缩阈值永远触发不了,等发现时已经是模型端甩回来的硬错误。
拿它算一笔账,就知道 D5 那句警告有多实在。一次订单库查询返回一张表就两三千 token;假设每轮一次工具调用、结果按 800 token 算,加上一问一答的文字,一轮进账约 1000 token,聊 30 轮就是 3 万,而它在第 31 轮要被完整重发一次。真正撑爆历史的从来不是用户打的字,是工具回给模型看的东西——它恰恰是你越把 Agent 做好用就涨得越快的那部分。所以问题不是"会不会满",是"满了怎么办"。
面试题库
长对话里上下文放不下了,你会怎么压缩?什么时候触发、压掉什么、保留什么?When a long conversation outgrows the context window, how do you compress it — when do you trigger, what do you drop, and what do you keep?
国内高频海外高频进阶#context-engineering#compression#cost🔒 解锁本章后查看答题要点。
会话的持久化、恢复和分叉分别解决什么问题?实现时各有什么坑?What problems do session persistence, restore, and forking each solve, and what goes wrong in each?
国内高频海外高频进阶#session-management#persistence#forking🔒 解锁本章后查看答题要点。
短期上下文和长期记忆的边界怎么划?一条信息该往哪放,你的判断依据是什么?Where do you draw the line between short-term context and long-term memory, and how do you decide where a given fact belongs?
国内高频海外高频基础#memory#context-engineering🔒 解锁本章后查看答题要点。
上下文工程和 RAG 检索是什么关系?只做 RAG 不做上下文管理会出什么问题?How do context engineering and RAG relate, and what breaks if you do RAG without context management?
国内高频海外高频深入#context-engineering#rag#retrieval🔒 解锁本章后查看答题要点。
