Interview AiBoxInterview AiBox 实时 AI 助手，让你自信应答每一场面试
•4 分钟阅读•Interview AiBox Team
自动做梦与记忆架构：AI Coding Agent 如何记住
理解让 AI Coding Agent 变得有效的记忆系统——从上下文窗口到持久记忆，从自动整合到检索增强的回忆。
- sellAI 洞察
- sellAi Agent Tools
Claude Code 实现中最有趣的揭示之一是其对记忆和上下文管理的方法。Coding Agent 面临一个独特的挑战：它们需要在有限的上下文窗口约束下保持跨会话的连贯理解、记住项目特定知识并基于之前的工作构建。
本分析探索使持久化 Coding Agent 成为可能的记忆架构。
上下文窗口问题
大型语言模型有固定的上下文窗口——通常 100K 到 200K tokens。对于 Coding Agent，这创造了几个挑战：
| 挑战 | 描述 | 影响 |
|---|---|---|
| 项目范围 | 大型代码库超出上下文容量 | Agent 看不到整个项目 |
| 会话连续性 | 之前会话发生了什么？ | Agent 丢失进度和上下文 |
| 知识积累 | 项目特定的模式、约定、决策 | Agent 每次会话都需要重新学习 |
| 状态管理 | 项目的当前状态是什么？ | Agent 基于过时理解操作 |
这些挑战需要超越简单扩大上下文窗口的架构解决方案。
记忆层级结构
有效的 Coding Agent 实现了多层记忆层级：
第一层：工作上下文
即时上下文窗口——活跃的对话和最近读取的文件。这是模型可以直接关注的"工作记忆"。
class WorkingContext:
def __init__(self, max_tokens: int):
self.max_tokens = max_tokens
self.messages = [] # 对话历史
self.recent_reads = [] # 最近访问的文件
self.current_task = None # 活跃任务状态
def add(self, content: str, priority: float = 1.0):
"""以优先级权重添加内容到工作上下文"""
token_count = estimate_tokens(content)
if self.total_tokens + token_count > self.max_tokens:
self.evict_low_priority(token_count)
self.content.append((content, priority))
def prioritize(self, content_type: str):
"""提升特定内容类型的优先级"""
# 代码文件 > 文档 > 对话
priorities = {
'code': 1.0,
'test': 0.9,
'config': 0.8,
'docs': 0.7,
'conversation': 0.5,
}
return priorities.get(content_type, 0.5)第二层：会话记忆
当前会话中应该跨轮次持续的信息。包括：
- 对话历史
- 任务进度
- 中间决策
- 错误状态和恢复操作
class SessionMemory:
def __init__(self):
self.task_history = [] # 尝试过的任务
self.decisions = [] # 做出的关键决策
self.errors = [] # 遇到的错误和解决的错误
self.artifact_summaries = {} # 生成代码的摘要
def record_task(self, task: Task, outcome: Outcome):
"""记录任务尝试以便会话连续性"""
self.task_history.append({
'task': task.summary(),
'outcome': outcome,
'timestamp': now(),
})
def get_relevant_history(self, current_task: Task) -> list:
"""检索与当前任务相关的历史"""
# 查找相似的过去任务
similar = find_similar(self.task_history, current_task)
return self.format_for_context(similar)第三层：项目记忆
关于特定项目的长期知识。这正是"自动做梦"概念变得相关的地方。
class ProjectMemory:
def __init__(self, project_path: str):
self.project_path = project_path
self.code_graph = CodeGraph(project_path)
self.decisions_log = DecisionsLog()
self.conventions = Conventions()
self.architecture = Architecture()
def query(self, query: str) -> QueryResult:
"""查询项目记忆以获取相关信息"""
results = []
# 在代码图中搜索相关代码
code_hits = self.code_graph.search(query)
results.extend(code_hits)
# 在决策日志中搜索
decision_hits = self.decisions_log.search(query)
results.extend(decision_hits)
# 在架构文档中搜索
arch_hits = self.architecture.search(query)
results.extend(arch_hits)
return self.rank_and_summarize(results)自动做梦：自动记忆整合
"自动做梦"一词来自生物系统的睡眠研究——在睡眠期间，大脑将体验整合为长期记忆，加强重要连接，并修剪不太有用的连接。
AI Agent 面临类似挑战：如何将会话体验整合为持久知识而不压垮上下文窗口。
整合管道
会话体验 → 提取 → 优先排序 → 存储 → 检索提取：识别会话中值得保留的内容
- 成功解决问题的方案
- 做出的架构决策
- 发现的项目的约定
- 错误模式和解决方案
优先排序：决定存储什么以及如何索引
- 引用频率
- 对项目成功的重要性
- 信息的独特性
- 预期的未来相关性
存储：决定存储在哪里以及如何存储
- 结构化：项目文档、决策日志
- 非结构化：代码注释、架构摘要
- 索引化：用于语义搜索的向量嵌入
检索：使存储的知识可访问
- 基于查询：当与当前任务相关时
- 基于上下文：当出现相似模式时
- 预定：定期审查重要知识
实现模式
class AutoDreamConsolidator:
def __init__(self, memory_store: MemoryStore):
self.store = memory_store
self.extractor = SessionExtractor()
self.prioritizer = ImportancePrioritizer()
def consolidate(self, session: Session) -> ConsolidationResult:
# 提取有意义的内容
raw_extractions = self.extractor.extract(session)
# 过滤和优先排序
prioritized = self.prioritizer.prioritize(raw_extractions)
# 用适当的策略存储
for item in prioritized:
storage_strategy = self.determine_storage(item)
self.store.store(item, strategy=storage_strategy)
return ConsolidationResult(
items_stored=len(prioritized),
storage_breakdown=self.store.get_stats()
)
def determine_storage(self, item: MemoryItem) -> StorageStrategy:
"""为记忆项确定最佳存储策略"""
if item.type == 'decision':
return StorageStrategy.STRUCTURED # 决策日志
elif item.type == 'pattern':
return StorageStrategy.INDEXED # 向量搜索
elif item.type == 'convention':
return StorageStrategy.DOCUMENTED # 项目文档
else:
return StorageStrategy.SUMMARY # 压缩摘要记忆检索挑战
有记忆是不够的——你需要在正确的时间检索正确的记忆。
检索策略
1. 语义搜索 跨存储记忆的基于向量的相似性搜索。有效地找到概念上相关的信息。
class SemanticRetriever:
def retrieve(self, query: str, top_k: int = 5) -> list[Memory]:
embedding = self.embed(query)
results = self.vector_db.search(embedding, top_k)
return [self.decode(r) for r in results]2. 结构化查询 在结构化记忆存储中直接查找。有效地获取特定事实。
class StructuredRetriever:
def retrieve(self, query: StructuredQuery) -> list[Memory]:
# 查询决策日志
decisions = self.decisions_log.query(query)
# 查询架构文档
arch = self.architecture.query(query)
return decisions + arch3. 上下文感知检索 考虑当前任务和工作区状态的检索。
class ContextAwareRetriever:
def __init__(self, semantic: SemanticRetriever,
structured: StructuredRetriever):
self.semantic = semantic
self.structured = structured
def retrieve(self, query: str, context: Context) -> list[Memory]:
# 获取基础结果
semantic_results = self.semantic.retrieve(query)
structured_results = self.structured.retrieve(context.to_query())
# 基于上下文重新排序
combined = semantic_results + structured_results
return self.contextual_rerank(combined, context)相关性 vs 时效性权衡
记忆检索面临一个根本权衡：
- 近期记忆：更可能与当前任务相关
- 重要记忆：更有价值但可能被遗忘
class RetrievalScorer:
def score(self, memory: Memory, query: str, context: Context) -> float:
# 语义相关性
semantic_score = memory.embedding.similarity(query)
# 时效性
recency_score = self.recency_weight(memory.timestamp)
# 重要性
importance_score = memory.importance
# 上下文相关性
context_score = self.context_relevance(memory, context)
# 加权组合
return (
0.3 * semantic_score +
0.2 * recency_score +
0.3 * importance_score +
0.2 * context_score
)实践中的记忆：Coding Agent 模式
模式 1：项目引导器
在会话开始时，将相关项目记忆加载到上下文中：
class ProjectPrimer:
def prepare_context(self, project: Project, task: Task) -> Context:
primer_parts = []
# 项目概览
primer_parts.append(self.summarize_project(project))
# 相关架构
arch = self.memory.query_architecture(task)
primer_parts.append(arch)
# 与任务相关的近期决策
decisions = self.memory.query_decisions(task)
primer_parts.append(format_decisions(decisions))
# 相似的过去任务和结果
history = self.memory.query_similar_tasks(task)
primer_parts.append(format_history(history))
return self.combine(primer_parts)模式 2：决策文档化
当 Agent 做出决策时，记录它们：
def make_decision(decision: Decision, context: Context):
"""做出并记录架构决策"""
# 在记忆中记录
memory_store.record_decision(
decision=decision,
rationale=context.rationale,
alternatives=context.alternatives_considered,
timestamp=now()
)
# 更新项目文档
docs.update_decisions_log(decision)
# 为未来检索建立索引
indexer.index(decision, context=context)模式 3：错误模式记忆
追踪错误及其解决方案：
class ErrorMemory:
def record_error(self, error: Error, resolution: Resolution):
self.errors.append({
'error_type': classify(error),
'error_message': error.message,
'resolution': resolution.steps,
'context': resolution.context,
'success': resolution.succeeded
})
def get_resolutions(self, error: Error) -> list[Resolution]:
"""查找类似错误及其解决方案"""
similar = self.find_similar(error)
return [s.resolution for s in similar if s.success]面试含义
当面试官问关于记忆系统时，他们探测：
- 对上下文限制的理解：你是否理解为什么无限上下文不是解决方案？
- 架构思维：你能设计多层记忆系统吗？
- 检索系统：你如何让存储的知识可访问？
- 实践模式：你能实现工作记忆模式吗？
常见问题："你如何为一个 Coding Agent 实现记忆？"
强有力回答结构：
- 承认上下文窗口约束
- 提出多层层级（工作 → 会话 → 项目）
- 讨论检索问题
- 解决整合问题
- 给出具体的实现模式
常见问题
RAG 和记忆系统有什么区别？
RAG（检索增强生成）通常用于外部知识库。记忆系统用于 Agent 自己的体验。RAG 从文档中检索；记忆从过去的行动和决策中检索。
如何防止记忆无限增长？
记忆系统需要：
- 基于重要性的淘汰
- 定期整合
- 语义去重
- 上下文剪枝
能不能只使用更大的上下文窗口？
上下文窗口是有限的和昂贵的。更大的上下文 = 更高的延迟和成本。记忆系统对维护长期知识更有效。
Interview AiBox 如何帮助
记忆架构是 AI Agent 角色面试中的常见话题。Interview AiBox 帮助你练习解释记忆系统设计、检索策略和实现模式。
从功能概览开始，了解 Interview AiBox 如何支持技术面试准备。
相关阅读
Interview AiBoxInterview AiBox — 面试搭档
不只是准备，更是实时陪练
Interview AiBox 在面试过程中提供实时屏幕提示、AI 模拟面试和智能复盘，让你每一次回答都更有信心。
AI 助读
一键发送到常用 AI
智能总结
深度解读
考点定位
思路启发
分享文章
复制链接，或一键分享到常用平台
