Agent 记忆检索策略：怎样学会想起？

TL;DR

LLM Agent 的记忆系统关键不在“能记多少”，而在“能否精准想起”。
本文总结了 三类触发机制 与 六种检索策略，构成了一个从“何时想起”到“如何检索”的完整框架：

🧠 触发机制（When to Recall）

规则触发 —— 窗口容量不足时检索历史
反思触发 —— 模型自觉遗忘时主动检索
事件触发 —— 特定情境或失败日志触发回忆

🔍 检索策略（How to Retrieve）

语义相似检索
混合检索
图式检索
元数据过滤
重排
反思式检索

这些策略共同构成了 RAG（Retrieval-Augmented Generation）的多种实现形态，从简单的语义召回到带有反思与路由能力的自适应检索。
记忆不是仓库，而是过滤器——检索策略定义了 Agent 的注意力边界，也塑造了它的“思考深度”。

前言

LLM Agent 记忆系统的挑战不在“能存多少”，而在“能否精准想起”。
AutoGPT 曾经尝试将所有任务摘要向量化存入 Pinecone，但检索常常召回“语义相似但任务无关”的记录。
Voyager 在 Minecraft 中的“技能库”检索则恰好相反：每次仅召回可执行的技能模块，显著提升学习效率。

检索的关键不是容量，而是相关性。

一个好的记忆检索系统，应该能回答三件事：

什么时候需要想起？
想起哪些内容？
想起后如何用？

触发机制：Agent 何时“想起”

一个有记忆的 Agent，并不会在每次对话都去翻遍自己的“记忆仓库”。
真正聪明的系统，知道什么时候该想起。
触发检索的时机，其实构成了 Agent 的“意识边界”。
我们可以把它想象成人类的三种“回忆瞬间”：

1. 规则触发：因为“容量不够”

最常见的情况，是模型的上下文窗口装不下了。
当对话历史变长、任务链变复杂时，旧的信息被挤出窗口，模型开始遗忘。
于是我们让 Agent 在这种情况下主动去检索——像是人类“翻笔记”的瞬间。
在工程上，这通常由一个简单的规则触发：

当上下文长度接近阈值（比如 80% 的窗口容量）时，调用检索模块，把最相关的历史片段重新召回。

这是一种节制型的记忆唤醒。
它让 Agent 在不增加计算负担的前提下，维持对过去的最小感知。

2. 反思触发：当 Agent 自觉“忘了什么”

更有意思的情况是 Agent 自己意识到记忆的缺口。
比如模型在生成中评估到不确定性上升、连续几步推理逻辑断裂，或自己产生了矛盾。
这时，它可能会触发一次“反思式检索”（Reflective Retrieval）：
让大模型生成一句类似

“我好像需要回忆一下之前用户提过的限制条件。”

然后根据这句话，再去检索相关记忆。
这种机制不靠固定阈值，而靠自我监控（self-monitoring）。
它更接近人类思维里的那种模糊直觉——“等等，好像哪儿不太对”。
在实现上，我们会给模型一个简单的函数调用接口，例如：

1 2	if model.confidence < 0.5: memories = retrieve(query)

让反思和检索之间形成闭环。
这正是 Self-RAG、A-Mem 这类系统的核心思想：Agent 主动决定何时“想起”。

3. 事件触发：因为“当下需要”

最后一种触发是情境性的。
有些记忆并不是因为遗忘才被召回，而是因为情境再次出现。
比如，当一个任务执行失败、某个工具调用报错，Agent 会去搜索之前的失败记录：

“上次这个 API 报 403 错时，我是怎么修的？”

又或者，当用户在不同会话中再次提到某个主题，Agent 会识别关键词，自动检索该主题下的历史交互。
这类触发往往和事件监听或日志回放机制相关。
它让 Agent 的记忆像一个条件反射系统： “相同的信号 → 激活相似的记忆 → 快速反应。”

检索策略：从“找得到”到“找得准”

以下策略可按复杂度逐级叠加：

1. 语义相似检索（Dense Retrieval）

最基础的做法：将每条记忆文本编码为向量，通过余弦相似度召回前 K 条。

# 工程核心代码
from sentence_transformers import SentenceTransformer
import faiss, numpy as np

# 初始化模型和索引
embedder = SentenceTransformer("all-MiniLM-L6-v2")
index = faiss.IndexFlatIP(384)  # 内积相似度

# 写入记忆
docs = ["用户喜欢猫", "昨天搜索了寿司餐厅", "会议纪要：讨论新功能"]
embeddings = embedder.encode(docs, normalize_embeddings=True)
index.add(np.array(embeddings))

# 查询检索
query = "找一家日本料理店"
q_emb = embedder.encode([query], normalize_embeddings=True)
scores, idx = index.search(q_emb, k=2)
retrieved = [docs[i] for i in idx[0]]
print(retrieved)

# 改进方向：加上时间/任务过滤，形成 Hybrid 检索。

✅ 优点：语义泛化强，易实现
⚠️ 缺点：可能召回“看似相关”的错误记忆（例如“猫”与“寿司”都和“喜欢”同义）

2. 稀疏检索与混合检索（Sparse + Dense Hybrid）

BM25 等稀疏方法对关键词精确匹配更可靠，可与向量检索融合：
最终得分 = α * dense_score + (1 - α) * bm25_score

# Hybrid 检索
from rank_bm25 import BM25Okapi

corpus = [doc.split() for doc in docs]
bm25 = BM25Okapi(corpus)

def hybrid_search(query, topk=3, alpha=0.6):
    q_emb = embedder.encode([query], normalize_embeddings=True)
    dense_scores, idx = index.search(q_emb, k=len(docs))
    bm25_scores = bm25.get_scores(query.split())

    combined = []
    for i, doc in enumerate(docs):
        dense = float(np.dot(q_emb, embedder.encode([doc], normalize_embeddings=True).T))
        score = alpha * dense + (1 - alpha) * bm25_scores[i]
        combined.append((score, doc))
    return sorted(combined, key=lambda x: -x[0])[:topk]

✅ 优点：平衡语义与精确匹配，适合问答与代码检索
⚠️ 缺点：参数 α 需按语料调节，否则会失衡

3. 图式检索（Graph Retrieval）

将记忆组织为事件或知识图谱，更适合任务型 Agent（如工具调用日志、人物关系、因果事件）。

import networkx as nx

G = nx.Graph()
G.add_edge("任务A", "任务B", relation="前置")
G.add_edge("用户A", "任务B", relation="触发")

def graph_retrieve(node, relation=None):
    neighbors = []
    for n, attr in G[node].items():
        if relation is None or attr["relation"] == relation:
            neighbors.append(n)
    return neighbors

print(graph_retrieve("任务A"))  # -> ['任务B']

✅ 优点：可解释、支持多跳推理
⚠️ 缺点：构建与维护成本高，适合结构化日志/工具链场景

4. 元数据过滤与上下文路由

在语义检索前，先用元信息过滤搜索空间：
如「同会话」「同用户」「近7天」「主题=工具调用」等。

def metadata_filter(memory, user=None, topic=None, since=None):
    results = memory
    if user:
        results = [m for m in results if m["user"] == user]
    if topic:
        results = [m for m in results if topic in m["tags"]]
    if since:
        results = [m for m in results if m["timestamp"] >= since]
    return results

✅ 优点：降低搜索噪声、提升召回精度
⚠️ 缺点：依赖高质量标注（tagging/日志结构）

5. 重排（Reranking）

使用一个额外模型（Cross-Encoder 或 LLM）重新打分前 K 条结果。

from transformers import AutoModelForSequenceClassification, AutoTokenizer
import torch

tokenizer = AutoTokenizer.from_pretrained("cross-encoder/ms-marco-MiniLM-L-6-v2")
model = AutoModelForSequenceClassification.from_pretrained("cross-encoder/ms-marco-MiniLM-L-6-v2")

def rerank(query, candidates):
    inputs = tokenizer([[query, c] for c in candidates], padding=True, truncation=True, return_tensors="pt")
    scores = model(**inputs).logits.squeeze().detach().numpy()
    ranked = [c for _, c in sorted(zip(scores, candidates), reverse=True)]
    return ranked

✅ 优点：提升最终 Top-1 准确度
⚠️ 缺点：增加计算成本；通常仅用于检索后的 re-ranking

6. 反思式检索（Self-RAG / Agentic Retrieval）

让 Agent 先自我评估检索结果是否足够，再决定是否“再搜一次”。

def reflective_retrieve(query):
    results = hybrid_search(query)
    # Step 1: 让 LLM 评估是否充分
    assessment = llm(f"是否足够回答此问题？结果如下：{results}")
    if "不足" in assessment:
        new_query = llm(f"请改写更精确的查询：{query}")
        results = hybrid_search(new_query)
    return results

✅ 优点：适合复杂任务或模糊查询
⚠️ 缺点：多次调用 LLM，延迟较高；但往往带来最自然的“记忆感”

7. 六大检索策略选型

场景	推荐策略	说明
对话类 Agent	Dense + Metadata Filter	快速、足够准确
企业知识问答	Hybrid + Rerank	平衡精度与覆盖
工具日志分析	Graph + 时间过滤	可解释、结构化
自反式 Agent	Self-RAG + Hybrid	智能自修正

六种策略，正是 RAG 的六种变体

到这里我们已经看完六种检索策略。
它们从语义相似、混合检索，到图式、重排、反思式检索——构成了一个完整的“找回记忆”的谱系。
那这些策略，与我们常说的 RAG（Retrieval-Augmented Generation） 又是什么关系？

RAG 的核心逻辑其实很简单：先检索，再生成。
也就是说，当模型面对一个问题时，先到外部知识库中“查资料”，把相关文本取回来，再把这些资料和问题一起交给语言模型，生成最终回答。
这是一个流程定义，而不是具体算法。
换句话说，RAG 规定了“查资料”的框架，但没有规定“怎么查”。于是你看到的那些检索策略——Dense、Hybrid、Graph、Rerank、Self-RAG——其实都是在实现这个“查”的部分。它们是 RAG 框架的不同实现形态。

策略	对应的 RAG 阶段	说明
语义相似检索	基础 RAG 检索	最标准、也是最常见的实现
稀疏/混合检索	Hybrid RAG	融合语义与关键词得分，适合精准问答
图式检索	Graph RAG / Knowledge RAG	以关系为索引的多跳检索
元数据过滤	Query Routing / Filtered RAG	检索前预筛选，减少噪声
重排	RAG 后处理阶段（Reranker）	让模型重新打分、排序结果
反思式检索	Self-RAG / Agentic Retrieval	让模型主动决定是否检索与改写查询

总结

记忆不是仓库，而是过滤器。
检索策略的设计，其实是在定义 Agent 的“注意力”模式，它决定 Agent 记忆的边界，也定义了它的思考深度。

❤ 下一篇，我会分享 Agent Memory 如何避免记忆漂移，让零散的信息变成稳定的知识。