Write 的核心思想是:不要指望上下文窗口永远记住一切——把重要信息主动写到外部持久化存储。对话历史终将被压缩或截断,但写入文件/数据库的信息不会丢失。
如果你觉得这个思想很熟悉,那就对了——Write 策略正是我们在前课中已经完整实现过的记忆机制的上层抽象。在前课中,我们分两层实现了 Write:
- 短期记忆层的 Write:
SessionManager在对话轮次超过MAX_HISTORY时,调用 LLM 将早期对话压缩为摘要,写入compressed_context字段 - 长期记忆层的 Write:
mem0.add()用 LLM 裁判机制从对话中提取关键事实,结构化后存入向量数据库
下面我们用同一段对话,分别演示这两层 Write 的实际效果。
短期记忆层的 Write:LLM 压缩摘要
短期记忆的 Write 目标是:在不丢失关键语义的前提下,用更少的 Token 保留更多的对话信息。 SessionManager 在消息数超过 COMPRESS_TRIGGER 时,将早期对话压缩为摘要写入 compressed_context 字段,同时只保留最近的消息在 messages 中——整个 session 以 JSON 文件持久化到 sessions/ 目录。下面我们复现这个完整过程,从创建 session 文件、触发压缩、到验证持久化结果:
# === 短期记忆层的 Write:LLM 压缩摘要 + 持久化到 sessions/ ===
import json, os, time
SESSIONS_DIR = "./sessions"
os.makedirs(SESSIONS_DIR, exist_ok=True)
# 核心参数(与 SessionManager 一致:消息数达到阈值时,压缩前半部分,只保留后半部分)
COMPRESS_TRIGGER = 8 # 演示用小阈值(生产环境 SessionManager 用 20)
KEEP_RECENT = 4 # 压缩后保留最近 4 条消息
# ---- 步骤 1:创建 session,写入 8 条多轮对话 ----
session_id = "write_demo"
session = {
"title": "新项目技术选型讨论",
"created_at": time.strftime("%Y-%m-%d %H:%M"),
"updated_at": time.strftime("%Y-%m-%d %H:%M"),
"compressed_context": "", # 压缩前为空
"messages": [
{"role": "user", "content": "新项目的数据库用什么?"},
{"role": "assistant", "content": "推荐 PostgreSQL。理由:项目有大量关联查询,团队熟悉度高,配合 SQLAlchemy 2.0 的 async 支持性能优秀。"},
{"role": "user", "content": "缓存方案呢?"},
{"role": "assistant", "content": "Redis,Cache-Aside 模式。热点数据 TTL=300s,写操作先更新 DB 再删缓存。"},
{"role": "user", "content": "部署方案定了吗?"},
{"role": "assistant", "content": "Docker Compose 本地开发,AWS ECS 生产。CI/CD 用 GitHub Actions,自动化金丝雀发布。"},
{"role": "user", "content": "预算上限是多少?"},
{"role": "assistant", "content": "初期 15 万以内。服务器 3 万/年,API 调用预留 2 万/月。"},
]
}
# 写入 JSON(压缩前:8 条消息,compressed_context 为空)
session_path = os.path.join(SESSIONS_DIR, f"{session_id}.json")
with open(session_path, "w", encoding="utf-8") as f:
json.dump(session, f, ensure_ascii=False, indent=2)
print(f"=== 压缩前:{session_path} ===")
print(f"messages: {len(session['messages'])} 条(达到 COMPRESS_TRIGGER={COMPRESS_TRIGGER})")
print(f"compressed_context: (空)")
# ---- 步骤 2:达到阈值,压缩前 4 条为摘要,只保留后 4 条 ----
if len(session["messages"]) >= COMPRESS_TRIGGER:
early_messages = session["messages"][:-KEEP_RECENT] # 前 4 条:将被压缩
recent_messages = session["messages"][-KEEP_RECENT:] # 后 4 条:保留原文
# LLM 压缩早期对话(一句话回复,控制运行时间)
early_text = "\n".join(f'{m["role"]}: {m["content"]}' for m in early_messages)
compress_prompt = f"""请将以下对话历史压缩为一段简洁的摘要,保留所有关键技术决策和数字:\n\n{early_text}\n\n输出要求:一段话,不超过 80 字。"""
summary = llm.invoke(compress_prompt).content
# 写回 session:compressed_context 存摘要,messages 只留最近的
session["compressed_context"] = summary
session["messages"] = recent_messages
session["updated_at"] = time.strftime("%Y-%m-%d %H:%M")
with open(session_path, "w", encoding="utf-8") as f:
json.dump(session, f, ensure_ascii=False, indent=2)
# ---- 步骤 3:展示压缩结果 ----
original_tokens = count_tokens(early_text)
summary_tokens = count_tokens(summary)
print(f"\n=== 压缩后:{session_path} ===")
print(f"compressed_context ({summary_tokens} tokens,原始 {original_tokens} tokens,压缩率 {(1 - summary_tokens/original_tokens)*100:.0f}%):")
print(f" {summary}")
print(f"messages: {len(session['messages'])} 条(只保留最近 {KEEP_RECENT} 条)")
for m in session["messages"]:
print(f" [{m['role']}] {m['content'][:50]}")
# 从文件读回验证
print(f"\n=== 验证:从文件读回 ===")
with open(session_path, "r", encoding="utf-8") as f:
saved = json.load(f)
print(f"compressed_context 长度: {len(saved['compressed_context'])} 字符")
print(f"messages 数量: {len(saved['messages'])} 条")
# 清理演示文件
# import shutil
# shutil.rmtree(SESSIONS_DIR)
# print(f"\n(演示清理:已删除 {SESSIONS_DIR}/)")
=== 压缩前:./sessions/write_demo.json ===
messages: 8 条(达到 COMPRESS_TRIGGER=8)
compressed_context: (空)
=== 压缩后:./sessions/write_demo.json ===
compressed_context (66 tokens,原始 104 tokens,压缩率 37%):
数据库选用 PostgreSQL(关联查询、团队熟悉、SQLAlchemy 2.0 async 支持),缓存采用 Redis Cache-Aside 模式,热点数据 TTL=300s,写操作先更新数据库再删缓存。
messages: 4 条(只保留最近 4 条)
[user] 部署方案定了吗?
[assistant] Docker Compose 本地开发,AWS ECS 生产。CI/CD 用 GitHub Acti
[user] 预算上限是多少?
[assistant] 初期 15 万以内。服务器 3 万/年,API 调用预留 2 万/月。 === 验证:从文件读回 === compressed_context 长度: 106 字符 messages 数量: 4 条
运行后打开 sessions/write_demo.json,可以清楚地看到压缩前后的变化:压缩前 compressed_context 为空、messages 有 8 条;压缩后早期 4 条对话被 LLM 浓缩为一段摘要写入 compressed_context,messages 只剩最近 4 条。下次对话时,SessionManager 会将 compressed_context 作为 system message 注入 LLM,让模型「记住」早期对话的要点,而不需要占用完整的 Token 开销。
这就是短期 Write 的本质:用 LLM 做有损压缩,用文件系统做持久化,在 Token 成本和信息保留之间取得平衡。
长期记忆层的 Write:mem0 选择性提取
长期记忆的 Write 目标完全不同:从对话中识别出值得跨会话保留的关键事实,结构化后写入向量数据库。前课的 mem0.add() 内部会调用 LLM 裁判(_extract_facts())判断哪些信息值得记住,然后执行 ADD/UPDATE/NONE 三分类。
这里有一个关键细节:mem0 默认从 user 角色的消息中提取事实。因此,如果用户只是在提问(「数据库用什么?」),mem0 提取不到有价值的决策信息。真实场景中,用户会在对话中确认决策(「数据库我们决定用 PostgreSQL」),这些确认性表述才是长期记忆的提取目标。下面我们模拟这个场景:
# === 长期记忆层的 Write:mem0.add() 选择性提取 ===
import os, shutil
from mem0 import Memory
QDRANT_PATH = "./qdrant_write_demo"
# 清理残留锁(Notebook 重复运行时文件锁不会自动释放)
for p in [QDRANT_PATH, os.path.expanduser("~/.mem0/migrations_qdrant")]:
if os.path.exists(p):
shutil.rmtree(p)
# mem0 配置(DeepSeek 做 LLM,OpenAI 做 Embedding)
config = {
"llm": {
"provider": "openai",
"config": {
"model": "deepseek-chat",
"api_key": os.getenv("DEEPSEEK_API_KEY"),
"openai_base_url": "https://api.deepseek.com/v1",
"temperature": 0.1,
}
},
"embedder": {
"provider": "openai",
"config": {
"model": "text-embedding-3-small",
"api_key": os.getenv("OPENAI_API_KEY"),
}
},
"vector_store": {
"provider": "qdrant",
"config": {
"collection_name": "write_demo",
"path": QDRANT_PATH,
}
},
"version": "v1.1"
}
memory = Memory.from_config(config)
# 关键:mem0 默认从 user 消息中提取事实
# 因此对话需要反映真实场景——用户确认技术决策,而非只是提问
decisions_conversation = [
{"role": "user", "content": "数据库我们决定用 PostgreSQL,项目有大量关联查询,团队熟悉度高,配合 SQLAlchemy 2.0 做 async"},
{"role": "assistant", "content": "好的,PostgreSQL + SQLAlchemy 2.0 async 已记录。"},
{"role": "user", "content": "缓存方案定了,用 Redis Cache-Aside 模式,热点数据 TTL 设 300 秒,写操作先更新 DB 再删缓存"},
{"role": "assistant", "content": "了解,Redis Cache-Aside + write-through 策略。"},
{"role": "user", "content": "部署方案:本地用 Docker Compose,生产上 AWS ECS,CI/CD 走 GitHub Actions 自动金丝雀发布"},
{"role": "assistant", "content": "部署流水线已记录。"},
{"role": "user", "content": "预算上限 15 万,服务器 3 万一年,API 调用预留 2 万每月"},
{"role": "assistant", "content": "预算约束已记录。"},
]
# 一行代码完成「提取 + 去重 + 向量化 + 存储」
add_result = memory.add(decisions_conversation, user_id="dev_team_lead")
print("=== 长期 Write:mem0.add() 提取的记忆条目 ===")
for item in add_result.get("results", []):
event = item.get("event", "UNKNOWN")
mem_text = item.get("memory", "")
print(f" [{event}] {mem_text}")
# 验证:search 能检索到刚才写入的记忆
search_result = memory.search("项目用什么数据库", user_id="dev_team_lead")
print(f'\n=== 验证:search("项目用什么数据库") ===')
for item in search_result.get("results", []):
print(f" [score={item['score']:.2f}] {item['memory']}")
# Token 对比
mem_texts = [item.get("memory", "") for item in add_result.get("results", [])]
mem_tokens = sum(count_tokens(t) for t in mem_texts)
print(f"\n=== 三层 Write 的 Token 经济学对比 ===")
print(f"原始对话: {original_tokens} tokens(完整历史)")
print(f"短期 Write: {summary_tokens} tokens(压缩摘要,保留在 session 内)")
print(f"长期 Write: {mem_tokens} tokens({len(mem_texts)} 条结构化记忆,永久存入向量库)")
# 清理演示数据
# if os.path.exists(QDRANT_PATH):
# shutil.rmtree(QDRANT_PATH)
=== 长期 Write:mem0.add() 提取的记忆条目 ===
[ADD] 数据库决定用 PostgreSQL,项目有大量关联查询,团队熟悉度高,配合 SQLAlchemy 2.0 做 async [ADD] 缓存方案定了,用 Redis Cache-Aside 模式,热点数据 TTL 设 300 秒,写操作先更新 DB 再删缓存
[ADD] 部署方案:本地用 Docker Compose,生产上 AWS ECS,CI/CD 走 GitHub Actions 自动金丝雀发布
[ADD] 预算上限 15 万,服务器 3 万一年,API 调用预留 2 万每月
=== 验证:search("项目用什么数据库") ===
[score=0.54] 数据库决定用 PostgreSQL,项目有大量关联查询,团队熟悉度高,配合 SQLAlchemy 2.0 做 async
[score=0.51] 缓存方案定了,用 Redis Cache-Aside 模式,热点数据 TTL 设 300 秒,写操作先更新 DB 再删缓存
[score=0.49] 预算上限 15 万,服务器 3 万一年,API 调用预留 2 万每月
[score=0.45] 部署方案:本地用 Docker Compose,生产上 AWS ECS,CI/CD 走 GitHub Actions 自动金丝雀发布
=== 三层 Write 的 Token 经济学对比 ===
原始对话: 79 tokens(完整历史)
短期 Write: 53 tokens(压缩摘要,保留在 session 内)
长期 Write: 108 tokens(4 条结构化记忆,永久存入向量库)
对比短期 Write 和长期 Write 的输出:短期层保留了对话的完整语境(「谁问了什么、怎么回答的」),压缩后仍然是一段连贯叙述;而长期层只提取了结构化的事实(「数据库用 PostgreSQL」「缓存用 Redis」),每条记忆都是独立可检索的知识单元。两者的存储位置也不同——短期摘要留在 session JSON 文件中,随会话生命周期存在;长期记忆写入向量数据库,跨会话永久可用。
任务状态层的 Write:Scratchpad / todo.md
除了记忆层的两种 Write,还有一种在生产 Agent 中极为常见的 Write 形态:把任务执行进度写入结构化文件(如 todo.md、CLAUDE.md),让 Agent 在上下文窗口被重置后能恢复执行状态。这对应我们在 2.6 节介绍的「任务状态层」——Scratchpad 就是 Agent 的「草稿纸」。
与前两种 Write 的关键区别:短期压缩保留的是对话语义,mem0 提取的是用户知识,而 todo.md 记录的是任务进度——哪些步骤做完了、当前卡在哪、下一步是什么。下面模拟一个多步骤项目任务,展示 Agent 如何通过 Write to Scratchpad 实现「断点续传」:
# === 任务状态层的 Write:Scratchpad(todo.md)断点续传 ===
import json, os
TODO_FILE = "./todo_demo.md"
# ---- 第一阶段:Agent 执行任务并实时写入进度 ----
task_plan = [
{"step": 1, "task": "初始化 PostgreSQL 连接池", "status": "done", "result": "pool_size=20, max_overflow=10"},
{"step": 2, "task": "创建 users 表迁移脚本", "status": "done", "result": "alembic revision --autogenerate 完成"},
{"step": 3, "task": "实现 JWT 认证中间件", "status": "in_progress", "result": "refresh token 逻辑未完成"},
{"step": 4, "task": "配置 Redis 缓存层", "status": "pending", "result": ""},
{"step": 5, "task": "编写 API 集成测试", "status": "pending", "result": ""},
]
# Agent 将当前进度写入 todo.md(Write to Scratchpad)
def write_todo(tasks, filepath):
lines = ["# 项目任务进度\n\n"]
status_icon = {"done": "[x]", "in_progress": "[-]", "pending": "[ ]"}
for t in tasks:
icon = status_icon[t["status"]]
line = f"{icon} Step {t['step']}: {t['task']}"
if t["result"]:
line += f" → {t['result']}"
lines.append(line + "\n")
with open(filepath, "w") as f:
f.writelines(lines)
write_todo(task_plan, TODO_FILE)
print("=== Agent 写入 todo.md(模拟执行到 Step 3 中断)===")
print(open(TODO_FILE).read())
# ---- 第二阶段:模拟上下文重置(新会话/auto-compact 后)----
# Agent 读回 todo.md,恢复执行状态
def read_todo(filepath):
with open(filepath) as f:
content = f.read()
# 解析出当前进度
done = content.count("[x]")
in_progress = content.count("[-]")
pending = content.count("[ ]")
return content, done, in_progress, pending
content, done, in_prog, pending = read_todo(TODO_FILE)
print("=== 新会话:Agent 读取 todo.md 恢复状态 ===")
print(f"已完成: {done} | 进行中: {in_prog} | 待开始: {pending}")
print(f"→ Agent 决策:继续 Step 3(JWT refresh token),无需从头开始")
# Token 对比:todo.md vs 完整对话历史
todo_tokens = count_tokens(content)
# 假设完成前 3 步产生了约 20 轮对话
estimated_history = "user: ...\nassistant: ...\n" * 20
history_tokens = count_tokens(estimated_history) * 5 # 真实对话每轮约 200 tokens
print(f"\n=== Scratchpad Write 的 Token 经济学 ===")
print(f"todo.md: {todo_tokens} tokens(结构化进度)")
print(f"完整对话历史: ~{history_tokens} tokens(20 轮对话估算)")
print(f"恢复执行所需上下文:只需 todo.md + 当前步骤描述,不需要回放全部历史")
# 清理
os.remove(TODO_FILE)
=== Agent 写入 todo.md(模拟执行到 Step 3 中断)===
# 项目任务进度
[x] Step 1: 初始化 PostgreSQL 连接池 → pool_size=20, max_overflow=10
[x] Step 2: 创建 users 表迁移脚本 → alembic revision --autogenerate 完成
[-] Step 3: 实现 JWT 认证中间件 → refresh token 逻辑未完成
[ ] Step 4: 配置 Redis 缓存层
[ ] Step 5: 编写 API 集成测试
=== 新会话:Agent 读取 todo.md 恢复状态 ===
已完成: 2 | 进行中: 1 | 待开始: 2
→ Agent 决策:继续 Step 3(JWT refresh token),无需从头开始
=== Scratchpad Write 的 Token 经济学 ===
todo.md: 118 tokens(结构化进度)
完整对话历史: ~600 tokens(20 轮对话估算)
恢复执行所需上下文:只需 todo.md + 当前步骤描述,不需要回放全部历史
同一段对话,三层 Write 各取所需:短期层压缩为摘要,保留在 session 内供后续对话引用;长期层提取关键事实,写入向量数据库供跨会话检索;任务状态层记录执行进度,写入 todo.md 供断点续传。这就是 Write 策略的完整形态——任何将信息从上下文窗口卸载到外部存储的操作,都是 Write。
在实际 Agent 系统中(如 Claude Code),这三层 Write 同时运作:auto-compact 压缩对话历史(短期),Memory Tool 提取用户偏好(长期),CLAUDE.md / todo.md 追踪任务进度(Scratchpad)。三者协同,确保 Agent 在任何时刻都不会因为上下文窗口的物理限制而「失忆」。