tech

从 RAG 到 GraphRAG,再到 Agent Memory:把 AI 知识系统拆开看

从 Embedding、HNSW 与混合检索讲起,拆解 GraphRAG、LightRAG、RAPTOR、Self-RAG、CRAG、CF-RAG 和长期记忆的实现,用八张极简手绘图串起数据、检索、控制与记忆。

RAG、GraphRAG、LightRAG、Self-RAG、Agent Memory,看名字很容易把它们理解成一轮接一轮的技术升级。但把实现拆开,会发现它们常常在解决不同层面的问题:信息怎么表示、怎么找到、怎么判断够不够,以及怎么跨会话留下来。

这篇把这些概念放进同一张地图里,从向量和索引一直讲到检索控制与长期记忆。重点放在数据结构、执行流程和工程边界,而不是框架 API 的罗列。

大模型从参数中学到了知识和统计规律,但参数本身不能替代可更新、可追溯的知识存储。模型能够接收很长的上下文,也不代表应用已经解决了检索、权限、成本和历史状态管理。

因此,可以先记住四个问题:

  • 表示:知识以文本、向量、图,还是摘要层次保存?
  • 检索:当前问题需要什么证据,怎么找得又快又准?
  • 控制:什么时候检索,结果不够好时怎么办,何时停止?
  • 记忆:哪些信息值得跨会话保存,如何更新、纠错和删除?

这些能力可以组合,标题中的“从……到……”也不表示新方法必然替代旧方法。

AI 知识系统由表示、检索、证据检查、Agent 控制与长期记忆等模块组合而成

图 1:先看各个模块解决什么问题,再决定是否需要它。图是系统地图,不是技术淘汰顺序。

阅读路线:想补基础,先看第一、二部分;想比较 GraphRAG 等方案,看第三、四部分;做 Agent 的状态管理,看第五、六部分;准备落地选型,可以先跳到第八、九部分,再按需回读。

本文的向量、业务场景和数据结构均为教学示例;论文机制、工程建议与简化代码会分别说明。

第一部分:Embedding 与搜索系统

1. Embedding:文字为什么能变成向量?

Embedding 的本质,是把离散的信息表示成连续的数值向量。

例如:

TEXT
输入文本:
“苹果是一种水果。”

Embedding 模型:

[0.21, -0.34, 0.82, 0.17, ...]

输入文本:
“香蕉是一种水果。”

Embedding 模型:

[0.24, -0.29, 0.79, 0.19, ...]

这些向量只是演示数据,不是真实模型输出。

在一个训练良好的语义向量模型中,意思相近的文本通常会被映射到相对接近的位置。

1.1 Embedding 在底层是如何计算的?

以常见的 Transformer 文本编码模型为例:

文本经过编码器生成向量,相近语义聚集,但相似不代表事实正确

图 2:Embedding 的计算路径与语义空间。位置和向量均为示意,不是真实模型输出。

首先,Tokenizer 把文本切分为 Token,并映射为整数 ID。

这些整数经过嵌入层,被映射成初始向量。

然后,Transformer 通过 Attention 等机制,让每个 Token 的表示受到上下文影响。

以文本“苹果公司发布了新产品”为例,模型可以结合上下文,将“苹果”表示为公司相关的语义,而不是单纯表示水果。

最后,通过 Pooling 或模型指定的向量输出方式,获得整段文本的向量。

不同 Embedding 模型的具体结构不完全相同,并非所有模型都使用相同的 Pooling 策略。

1.2 为什么语义相近的文本会靠近?

关键不是“把文字变成数字”这一步,而是模型训练的目标。

以对比学习为例,训练数据可能包含:

TEXT
问题:谁提出了万有引力定律?

正样本:
牛顿提出了万有引力定律。

负样本:
爱因斯坦提出了广义相对论。

训练希望模型提高问题与正样本的相似度,同时降低与负样本的相似度。下面的分母包含正样本与负样本候选。

一种典型损失函数是:

L=−log⁡exp⁡(sim⁡(q,d+)/τ)∑iexp⁡(sim⁡(q,di)/τ)\mathcal{L}=-\log\frac{\exp(\operatorname{sim}(q,d^{+})/\tau)}{\sum_i\exp(\operatorname{sim}(q,d_i)/\tau)}

其中:

  • q:查询向量
  • d+:正样本向量
  • di:候选文档向量
  • sim:相似度函数
  • τ:温度参数

经过大量训练,模型逐渐形成适合语义匹配的向量空间。

但需要注意:

Embedding 学到的是训练目标下的相关性表示,不是严格的逻辑事实,也不是语义理解正确性的保证。

1.3 向量怎么比较?

常见方式包括:

  • 余弦相似度(Cosine Similarity)
  • 点积(Dot Product)
  • 欧氏距离(Euclidean Distance)

余弦相似度公式:

cos⁡(A,B)=A⋅B∥A∥ ∥B∥\cos(A,B)=\frac{A\cdot B}{\lVert A\rVert\,\lVert B\rVert}

它计算两个向量方向的接近程度。

对于非零向量,如果双方都已经进行 L2 归一化,点积就等于余弦相似度。

但不同距离指标的表现取决于模型训练方式,不能随意替换。

1.4 Embedding 的核心限制

例如:

TEXT
A:牛顿提出了万有引力定律。

B:爱因斯坦提出了万有引力定律。

这两句话可能具有很高的语义相似度,因为绝大多数词语和句子结构相同。

然而,它们的事实含义不同。

因此:

语义相似度不等于事实正确性。

这也是后续 RAG 需要精确匹配、重排序、事实验证与结构化关系的原因之一。


2. 向量数据库:如何在海量向量中快速搜索?

有了 Embedding,我们就可以把文本向量存入数据库。

例如:

JSON
{
  "id": "chunk_001",
  "text": "牛顿提出了万有引力定律。",
  "embedding": [0.12, 0.56, -0.32],
  "source": "document_01"
}

真实向量的维度通常远高于这个示例。实际存储也应保留模型版本、来源文档、片段位置和访问权限,以便追溯与重新索引。

数据库需要解决的问题是:

当用户输入一个查询向量时,怎样快速找到最相似的 K 个向量?

2.1 最简单的方法:暴力搜索

假设数据库有 N 个向量,每个向量有 D 个维度。

直接搜索的方式是:

PYTHON
def search(query_vector, vectors, top_k):
    results = []

    for vector in vectors:
        score = cosine_similarity(query_vector, vector)
        results.append(score)

    return sorted(results, reverse=True)[:top_k]

查询需要逐个比较。

对于通常的稠密向量运算,一次完整扫描的主要计算成本大约与 N×D 成正比。

数据量小时,这种方式简单、精确,有时甚至很高效。

但当数据达到百万、千万甚至更大规模时,延迟和计算成本就可能成为问题。

2.2 ANN:近似最近邻搜索

ANN(Approximate Nearest Neighbor)的设计思想是:

不一定找出数学上绝对最近的所有向量,而是在可接受的误差范围内,用更少的计算找到足够好的结果。

它用一部分精度换取搜索速度、内存效率或吞吐量。

常见方法有:

  • HNSW:图结构近似搜索
  • IVF:倒排分区搜索
  • PQ:乘积量化压缩
  • ScaNN:优化的近似向量搜索方案

这些是不同的索引算法或技术组合,不是向量数据库的同义词。

2.3 HNSW 到底怎么工作?

HNSW 全称为 Hierarchical Navigable Small World。

它会为向量构建多层邻近关系图。

可以把它想象为:

HNSW 从稀疏上层沿近邻连接逐层下探,在底层扩展查询附近的候选

图 3:HNSW 从稀疏上层逐步下探到稠密底层。圆点是已索引向量,右侧菱形是查询;竖向虚线对应同一向量在不同层的位置。沿绿色箭头阅读:从上层入口靠近查询,再下探到底层,在底层扩展搜索并筛选候选,黄色区域突出显示示例候选。灰线是用于搜索的近邻连接,不表示“提出”“属于”等事实关系。

图中的排列只是示意,不代表向量的真实距离,也不表示底层搜索只访问黄色区域。

查询过程:

  1. 从最高层的入口节点开始。
  2. 在当前层寻找距离查询向量更近的邻居。
  3. 找到较好的位置后向下一层移动。
  4. 在底层扩大候选搜索范围。
  5. 返回最接近的 K 个候选。

为什么这样更快?

因为它避免了每次都从第一个向量开始,把所有向量逐一比较。

HNSW 的核心参数包括:

  • M:每个节点建立邻近连接的规模参数
  • efConstruction:索引构建时的搜索候选规模
  • efSearch:查询时的候选搜索规模

参数通常会影响索引构建时间、内存、查询延迟和召回率。

更高的搜索候选规模一般有机会获得更高召回率,但也会增加查询成本。

一个容易混淆的事实:

HNSW 虽然采用图结构,但这里的边表示向量之间的距离关联,不是知识图谱中的语义关系。

例如 HNSW 的一条边不代表“牛顿提出了万有引力定律”,而是代表两个向量在搜索空间中具有邻近连接。

参考:Malkov 与 Yashunin 的 HNSW 论文↗。


3. 全文搜索:为什么有 Embedding 还需要 BM25?

Embedding 解决语义匹配,但并不擅长所有精确匹配问题。

例如:

TEXT
错误码:ERR_CONN_RESET_1042
产品型号:ABC-X900
论文编号:arXiv:2401.15884

这类内容往往需要精确匹配。

传统搜索引擎主要通过倒排索引解决这类查询。

3.1 倒排索引的数据结构

假设有三篇文档:

TEXT
Doc1:牛顿研究经典力学
Doc2:爱因斯坦研究相对论
Doc3:经典力学包含牛顿运动定律

索引结构可能是:

TEXT
牛顿       → [Doc1, Doc3]
经典力学   → [Doc1, Doc3]
相对论     → [Doc2]

查询“牛顿 经典力学”时,搜索引擎可以直接访问对应的 Posting List,而不是重新阅读全部文档。

真实倒排索引还可以保存词频、词语位置及其他统计信息。

3.2 BM25 如何排序?

BM25 使用词频、逆文档频率和文档长度归一化等信号,为文档计算相关性分数。

直观理解:

  • 查询词在文档中出现,通常增加相关性。
  • 相对罕见的查询词,通常具有更强的区分作用。
  • 词语重复很多次,收益会逐渐递减。
  • 文档长度需要纳入调整。

BM25 对明确术语、代码符号和编号等查询很有价值,但精确匹配仍取决于分词器和字段配置。错误码、型号通常需要保留完整 token,必要时采用 keyword 字段,而不是默认任何全文索引都能原样匹配。

3.3 Hybrid Search:混合检索

现代搜索系统经常同时运行两路检索:

两路并行:BM25 关键词检索 + Embedding 向量检索 → 候选结果融合 → Reranker → Top-K 文档。下文的图 4 把它放进了完整 RAG 链路。

一种常见融合方式叫 RRF(Reciprocal Rank Fusion)。

公式:

RRF⁡(d)=∑i1k+rank⁡i(d)\operatorname{RRF}(d)=\sum_i\frac{1}{k+\operatorname{rank}_i(d)}

它利用文档在不同结果列表中的排名来计算融合分数;求和针对包含文档 d 的结果列表,k 是平滑常数,不是返回结果数 Top-K。

优势是不用直接比较 BM25 分数和向量相似度分数,因为两者并不处于相同量纲。

随后,可以使用 Cross-Encoder 或其他重排序模型,重新评估查询与候选文档的相关性。

向量检索负责扩大语义覆盖面,关键词检索保留精确匹配能力,重排序负责进一步筛选证据。

这是一种非常常见的现代检索架构。


第二部分:传统 RAG,把外部知识引入生成过程

4. RAG 的设计理念

RAG(Retrieval-Augmented Generation)的思想是:

把模型内部的参数化知识,与外部可检索的非参数化知识结合起来。

2020 年,Lewis 等人在《Retrieval-Augmented Generation for Knowledge-Intensive NLP Tasks》中系统提出了 RAG 模型。

需要区分:

论文中的原始 RAG 模型结合了可训练的检索器与生成模型;今天工程中常见的“检索文本、拼接上下文、调用 LLM”是更宽泛的 RAG 实现形式,不完全等同于原论文架构。

5. RAG 的完整底层流程

RAG 通常分为离线索引和在线查询两个阶段。

5.1 离线阶段:构建知识索引

RAG 离线解析切块建索引,在线进行关键词和向量检索、融合重排并生成带来源的答案

图 4:离线索引和在线回答是两条相接的链路。混合检索、重排是可选增强,不是所有 RAG 的必选配置。

这里的 Chunk 就是文本片段。

例如把一本书拆成:

JSON
{
  "chunk_id": "book1_chapter2_003",
  "document_id": "book1",
  "chapter": "第二章",
  "text": "声音传播需要介质……",
  "embedding": [0.11, 0.24, -0.39]
}

切块方法会影响检索质量。

常见切块策略包括:

  • 固定长度切块
  • 重叠滑动窗口
  • 按段落或标题切块
  • 递归分隔符切块
  • 基于语义边界切块

如果切块太小,可能导致上下文缺失。

如果切块太大,则可能引入大量不相关信息,并增加上下文成本。

因此,Chunk 大小不是越大或越小越好,而是需要实验确定。

5.2 在线阶段:检索并生成答案

在线链路可以概括为:问题 → 检索 → 候选文本 → 可选重排序 → 上下文组装 → LLM → 回答与引用。使用向量检索时,查询也要用兼容的 Embedding 模型编码。

在最简化的向量 RAG 实现中,可以只使用:

  1. 一个 Embedding 模型
  2. 一个相似度检索器
  3. 一个生成模型

甚至不需要专门的向量数据库。如果采用 BM25 等关键词检索,RAG 也可以不使用 Embedding。

5.3 使用 OpenAI API 实现最小 RAG

下面是一份教学用 Python 示例。

它使用 OpenAI Embedding API 获取文本向量,通过 Python 计算余弦相似度,再调用 Responses API 生成答案。

安装依赖:

BASH
pip install openai

预先配置 OPENAI_API_KEY 和 OPENAI_GENERATION_MODEL 环境变量。后者填写账户有权限使用、且支持 Responses API 的生成模型 ID。密钥只保存在本地环境中,不要写进源码或提交到仓库。

PYTHON
import os
import math
from openai import OpenAI

client = OpenAI()

documents = [
    "牛顿提出了万有引力定律。",
    "爱因斯坦提出了广义相对论。",
    "经典力学研究物体的运动及其规律。"
]

def embed(text):
    response = client.embeddings.create(
        model="text-embedding-3-small",
        input=text
    )
    return response.data[0].embedding

def cosine(a, b):
    dot = sum(x * y for x, y in zip(a, b))
    norm_a = math.sqrt(sum(x * x for x in a))
    norm_b = math.sqrt(sum(x * x for x in b))
    return dot / (norm_a * norm_b)

# 离线阶段:这里只执行一次
vectors = [embed(doc) for doc in documents]

# 在线阶段
question = "谁提出了万有引力定律?"
query_vector = embed(question)

ranked = sorted(
    range(len(documents)),
    key=lambda i: cosine(query_vector, vectors[i]),
    reverse=True
)

top_ids = ranked[:2]
context = "\n".join(
    f"[{i}] {documents[i]}" for i in top_ids
)

response = client.responses.create(
    model=os.environ["OPENAI_GENERATION_MODEL"],
    input=(
        "请仅根据提供的资料回答。"
        "没有充分依据时说明不知道,"
        "并引用对应的资料编号。\n\n"
        f"资料:\n{context}\n\n"
        f"问题:{question}"
    )
)

print(response.output_text)

这个示例展示了 RAG 的基本原理。

生产系统还需要加入持久化存储、批量 Embedding、重排序、权限过滤、错误处理、上下文预算、引用校验等机制。

它也不能保证模型一定遵守“仅根据资料回答”的提示。

5.4 传统 RAG 的结构性限制

传统的文本块检索可能遇到几个问题:

第一,相关信息散落在不同文档。

某个问题可能需要同时读取五个不同的段落才能回答,但 Top-K 不一定全部召回。

第二,语义相似不等于逻辑关联。

文本相似度不容易直接表达“谁提出了什么”“某项技术依赖什么”这样的特定关系。

第三,全局问题可能缺少足够覆盖。

例如:

“这 500 篇研究论文有哪些共同的发展方向?”

只检索最相似的几个 Chunk,可能不足以总结整个语料库。

这就引出了下一类技术:结构增强检索。


第三部分:GraphRAG、LightRAG 与树结构检索

6. GraphRAG:从文本块走向知识关系

GraphRAG 不是单一固定算法,而是一类把图结构用于检索增强生成的系统。

它关注的问题是:

如果问题需要连接多个实体、多条关系、多个文档,能否通过图结构组织证据?

6.1 图数据如何表示?

假设原文是:

TEXT
牛顿提出了万有引力定律。
万有引力定律是经典力学的重要组成部分。

可以得到:

牛顿 → 提出 → 万有引力定律 → 属于 → 经典力学。这里的“提出”“属于”是明确的关系类型。

典型数据可以表示为:

JSON
{
  "nodes": [
    {"id": 1, "name": "牛顿"},
    {"id": 2, "name": "万有引力定律"},
    {"id": 3, "name": "经典力学"}
  ],
  "edges": [
    {"source": 1, "target": 2, "type": "PROPOSED"},
    {"source": 2, "target": 3, "type": "BELONGS_TO"}
  ]
}

这里的边是具有语义的关系。

这与 HNSW 完全不同。

HNSW 的边主要用于加速向量相似度搜索;知识图谱的边用于描述领域中的事实联系。

6.2 GraphRAG 的索引构建

以微软 GraphRAG 的标准索引思路为例:

标准索引的大致顺序是:文档 → TextUnit → 实体与关系抽取 → 实体描述整合 → 图构建 → 社区发现 → 社区报告,再为相关描述建立向量索引。不同索引配置会调整具体步骤。

GraphRAG 使用实体关系和社区报告,RAPTOR 使用递归生成的摘要层次

图 5:GraphRAG 与 RAPTOR 的结构对照。社区由图连接计算得到;摘要树表达信息粒度,都需要回到原文核对证据。

其中,实体和关系通常由 LLM 从文本中抽取。

例如:

JSON
{
  "entity": "牛顿",
  "type": "PERSON",
  "relations": [
    {
      "target": "万有引力定律",
      "type": "PROPOSED",
      "source_chunk": "chunk_001"
    }
  ]
}

source_chunk 是这里建议采用的示意字段,不代表微软 GraphRAG 的实际数据模型只有这些字段。

为什么需要保留来源?

因为 LLM 抽取的事实可能出错。

关系应该能够追溯到原始文本,方便验证、纠错和数据更新。

6.3 图查询到底如何运行?

下面是通用图数据库的教学例子,不是微软 GraphRAG 的默认查询实现。在 Neo4j 中,可以使用 Cypher:

CYPHER
MATCH (p:Person {name: "牛顿"})
      -[:PROPOSED]->
      (t)-[:BELONGS_TO]->
      (field)
RETURN t, field

数据库首先通过属性索引或其他访问方式定位起始节点,然后根据关系方向与类型遍历连接。

典型图数据库会维护节点到关系的连接信息,从而支持从已知节点访问相邻节点。

对于一个简单的图,也可以使用邻接表表示:

PYTHON
graph = {
    "牛顿": [
        ("PROPOSED", "万有引力定律")
    ],
    "万有引力定律": [
        ("BELONGS_TO", "经典力学")
    ]
}

从一个节点开始查找邻居,就相当于读取它的邻接表。

复杂图查询还需要处理:

  • 路径长度限制
  • 关系方向
  • 路径重复
  • 节点过滤
  • 查询优化
  • 结果数量控制

并不是简单地无限向外扩展。

6.4 为什么微软 GraphRAG 还要做社区发现?

这是它与“普通知识图谱 + LLM 问答”的重要区别。

微软 GraphRAG 不只存储实体关系,还尝试识别图中的知识社区。

例如:

可以把经典力学相关概念想象成一个社区,把相对论和量子理论相关概念想象成另一个社区。

这只是概念示意。

实际社区是根据图连接结构计算出来的,不一定恰好对应人类定义的学科分类。

社区发现采用图聚类算法,例如分层 Leiden。

随后,LLM 可以根据社区内实体、关系和来源生成社区报告。

这样系统就有了两种不同粒度的信息:

  • 局部:具体实体、关系、文本证据
  • 全局:不同社区及其摘要

6.5 Local Search 如何实现?

问题 → 相关实体 → 相邻实体与关系、关联 TextUnit 等 → 按相关性和上下文预算筛选 → 生成回答。具体配置还可以纳入社区报告。

适合围绕某个具体实体或事件提问。

6.6 Global Search 如何实现?

问题 + 指定层级的社区报告 → 分批 Map → 带重要性评分的中间要点 → 筛选 → Reduce → 全局回答。

与 Local Search 不同,Global Search 侧重从多个社区的摘要中综合回答。

微软 GraphRAG 还提供 DRIFT Search 和 Basic Search 等查询方式。上述区别可以对照官方的 Local Search↗ 与 Global Search↗ 文档。

需要注意,微软 GraphRAG 默认可以把相关结构存储为 Parquet 表,并将 Embedding 写入向量存储。

GraphRAG 不要求必须使用 Neo4j。

它强调的是图结构如何参与索引和检索,而不是必须选择某一种数据库产品。


7. LightRAG:为什么还要重新设计 GraphRAG?

LightRAG 的设计目标之一,是降低图增强检索的复杂度,并支持较高效的知识更新。

LightRAG 的预印本发表于 2024 年,正式论文发表于 Findings of EMNLP 2025。

7.1 LightRAG 的双层检索思想

LightRAG 结合图结构和向量表示,区分不同粒度的检索需求:

Low-Level Retrieval

面向具体实体和局部关系。

例如:

“牛顿提出了什么理论?”

系统主要寻找与牛顿相关的实体及其关系。

High-Level Retrieval

面向更抽象的主题和关联。

例如:

“经典力学与现代物理有哪些重要联系?”

系统需要整合更广泛的实体和关系信息。

7.2 底层检索流程

问题先被拆成低层和高层关键词。低层关键词通过向量匹配寻找实体,高层关键词匹配关系;随后补充邻接信息与来源文本,组合成生成模型所用的上下文。

LightRAG 的高层检索以关系为重点,并不是微软 GraphRAG 的社区报告检索,具体可见原论文第 3.2 节↗。

LightRAG 并不是单纯用两个不同的 Prompt。

其设计将实体、关系、描述信息、向量索引结合起来,使不同类型的查询可以访问不同层次的信息。

当前开源项目也有多种组合检索模式和存储后端,因此不应该把论文初版的流程当成所有版本的完整实现。

7.3 增量更新为什么重要?

假设已经有一个知识图谱,现在新增一篇文章。

最简单的方法是全部重新构建:

把旧知识与新知识合在一起,全量重做实体抽取和图构建。

但这种方式可能成本很高。

增量更新的思路是:

新增文档 → 解析新增内容 → 抽取实体与关系 → 匹配已有实体 → 合并图结构 → 更新相关索引。

实际工程中还会遇到更困难的问题:

如果删除了原始文档,它所贡献的关系是否应该被删除?

如果多个文档共同支持一条关系,删除其中一个来源是否影响这条关系?

如果某个实体描述发生改变,哪些关联数据需要重新计算?

这些都需要来源追踪、实体归并和更新策略。

增量写入并不自动意味着图谱具有完整的数据一致性。


8. RAPTOR:为什么要用树结构组织知识?

RAPTOR 的全称是 Recursive Abstractive Processing for Tree-Organized Retrieval。

它解决的是另外一个问题:

文本切成 Chunk 之后,高层次的信息可能被切碎。

例如一本书:

TEXT
第一章:背景
第二章:理论
第三章:实验
第四章:结论

如果只按段落进行向量检索,模型可能找到某几个相关段落,却无法全面理解整本书的主要观点。

RAPTOR 采用递归摘要的方式组织信息。

8.1 底层构建过程

文本切块 → Chunk Embedding → 聚类 → 为每个聚类生成摘要 → 摘要重新 Embedding → 再次聚类与摘要,直到形成多层结构。

图 5 右侧是一棵简化的摘要树:底层“片段 1—4”是文本块,上层是主题摘要,更上层是整体摘要。真实方法中的软聚类可以让一个块归属多个簇,不能把示意图理解为严格的一块一父节点。

不同层级代表不同的信息粒度。

8.2 RAPTOR 如何检索?

用户提问后,系统可以从树中检索不同层级的信息。

问题涉及具体事实时,底层文本可能更有用。

问题涉及整体观点时,高层摘要可能更有用。

RAPTOR 的原始方法支持不同的树检索策略,并非所有查询都必须按照“根节点到叶节点”的固定路径执行。

8.3 RAPTOR 的局限

摘要本质上是一种有损压缩。

如果底层信息在生成摘要时被遗漏,高层节点就可能无法完整代表原始内容。

因此,实际系统往往仍然需要保留原始文档,以便回溯具体证据。

GraphRAG 更强调知识关系与社区结构,而 RAPTOR 更强调文本内容的层次化抽象。

两者都使用结构,但结构表达的含义不同。


第四部分:检索纠错、自我反思与反事实推理

传统 RAG 往往假设一个前提:

检索器返回的内容足够相关,可以直接交给生成模型。

但这个假设不一定成立。

后续一些研究开始关注:

  • 什么时候需要检索?
  • 检索结果是否可信?
  • 检索失败之后怎么办?
  • 相关性很高的证据是否可能误导模型?

于是出现了 Self-RAG、CRAG、CF-RAG 等方法。

9. Self-RAG:模型能否自己决定什么时候检索?

Self-RAG 的核心理念是:

检索不应该永远按照固定流程执行,模型应该能够判断何时需要外部证据,并对证据和自身回答进行评价。

9.1 与传统 RAG 的区别

传统 RAG 通常是:

TEXT
问题 → 固定检索 → 生成

Self-RAG 的思路是:

Self-RAG 把“是否检索”“证据是否相关”“回答是否得到支持”等判断纳入生成过程。

Self-RAG、CRAG 和 CF-RAG 分别关注检索决策、检索纠错和反事实证据比较

图 6:三种方法的控制点不同。图中是概念化总结,不替代原论文的训练和推理细节。

9.2 底层如何实现?

原始 Self-RAG 研究的重要特点是使用经过专门训练的模型和反思 Token。

其反思机制可以包括:

  • 是否应该检索
  • 文档是否相关
  • 回答是否得到证据支持
  • 回答是否有用

模型学习生成相应的控制或评价标记,再利用这些信号影响生成过程。

例如,概念上可以表示为:

需要检索 → 获取文档 → 判断相关性 → 生成回答 → 判断证据支持程度。

这些中文标签只是解释思路,不是论文实际使用的特殊 Token。

需要特别区分:

使用普通 LLM 写一个“请检查自己的答案”的 Prompt,并不等于完整复现了 Self-RAG。

Self-RAG 原始方法包含特定的模型训练与推理机制。


10. CRAG:当检索器找错内容时怎么办?

CRAG 全称 Corrective Retrieval-Augmented Generation。

它的核心问题是:

RAG 过度依赖检索质量,一旦检索结果有问题,生成阶段就可能被错误证据影响。

CRAG 试图在检索后增加质量评估和纠错机制。

10.1 底层工作流程

初始检索之后,评估器给出三类判断:

  • Correct:对已有证据进行精炼,再用于生成。
  • Incorrect:转向外部搜索获取补充知识。
  • Ambiguous:结合精炼后的已有证据与外部信息。

图 6 中间一栏展示了这个纠错分支。

原始 CRAG 还提出了对文档进行分解和重组的机制,以减少无关信息的干扰。

10.2 检索评估器是什么?

可以构建一个专门的模型,输入:

TEXT
用户问题:
谁提出了万有引力定律?

候选文档:
牛顿提出了万有引力定律。

输出一个相关性或质量分数。

原始 CRAG 使用微调后的 T5-large 作为检索评估器。工程中可以设计其他打分机制,但那属于实现变体。

但“相关性评分高”本身并不保证文档真实、权威或没有过时。

10.3 一个简化版实现

PYTHON
def corrective_rag(question):
    docs = retrieve(question)

    quality = evaluate_retrieval(question, docs)

    if quality == "good":
        evidence = docs

    elif quality == "bad":
        evidence = external_search(question)

    else:
        extra = external_search(question)
        evidence = merge_and_filter(docs, extra)

    return generate_answer(
        question=question,
        evidence=evidence
    )

这是 CRAG 思想的教学伪代码,省略了原方法中的细粒度评估和知识精炼。

还必须强调:

当外部搜索也没有可靠证据时,合理的系统应该允许拒答,而不是强制生成一个看似完整的答案。


11. CF-RAG:相关信息很多,就一定是正确证据吗?

CF-RAG(Counterfactual RAG)与 CRAG 是不同的方法。

2026 年 ICLR 论文《Counterfactual Reasoning for Retrieval-Augmented Generation》提出了 CF-RAG。

它关注的是一种相关性陷阱:

大量看似支持某个结论的信息,可能只是统计相关,而不是对问题具有决定性意义的证据。

用一个教学类比来理解:假设系统要分析:

“某项系统故障是否由数据库升级引起?”

检索结果中可能有大量关于数据库升级的日志和讨论。

但这些信息的出现,并不能自动证明升级导致了故障。

11.1 反事实推理是什么意思?

反事实问题通常是:

如果某个条件没有发生,结果是否仍然会出现?

例如:

TEXT
原始问题:
数据库升级是否导致服务中断?

反事实问题:
如果数据库没有升级,
服务中断是否仍然可能发生?

CF-RAG 中的反事实查询范围更广,还包括对问题中的角色、时间、实体、类别或范围做语义扰动。上面的数据库故障只是帮助理解的类比,不是论文对方法的完整定义。

11.2 底层架构

根据 CF-RAG 正式论文↗,核心包含两个阶段:

阶段一:Counterfactual Exploration

针对原始问题生成反事实查询,进行多路检索与去重筛选,再通过证据聚类和分层采样组织候选证据集合。

阶段二:Parallel Arbitration

生成多路候选答案,结合证据一致性,以及原问题与反事实查询之间的支持差异进行仲裁,减少单一路径的偏差。

概念上的流程:

原始问题 → 反事实语义扰动 → 多路检索、去重筛选 → 证据聚类与分层采样 → 多路候选答案 → 并行仲裁。

11.3 CF-RAG 与 CRAG 的根本区别

CRAG 主要关注:

“我检索出来的证据质量够不够?要不要补充和纠正?”

CF-RAG 主要关注:

“这些证据是否真的能够区分竞争性解释,还是仅仅与结论高度相关?”

但反事实查询不等于严格的因果识别。

如果没有合适的数据、实验设计或可靠的因果假设,LLM 生成几个“假如……”的问题,并不能直接证明因果关系。

这是使用 CF-RAG 时尤其需要注意的边界。


第五部分:Agentic RAG,从固定流程变成自主决策

12. 为什么需要 Agentic RAG?

前面的很多 RAG 实现都有明确的检索流程。

但真实问题可能是这样的:

查找某个技术的原始论文,比较三个实现版本,并确认最近一年是否发生重大变化。

这种问题很难通过一次固定的 Top-K 检索完成。

系统可能需要:

  1. 搜索论文。
  2. 阅读摘要。
  3. 查找源码。
  4. 比对不同实现。
  5. 发现信息不足后再次搜索。
  6. 综合证据生成回答。

Agentic RAG 的核心理念是:

将检索过程变成一个能够规划、执行、观察和调整的决策循环。

它不是一种唯一确定的算法,更接近一类系统架构。

13. Agentic RAG 的底层执行机制

Agent 在计划、工具调用和观察之间循环,在证据足够时回答,并受预算和权限约束

图 7:检索器可以保持不变,改变的是控制它的执行循环。停止条件、权限和证据来源也属于架构的一部分。

这个循环通常被称为 Agent Loop。

13.1 Agent 为什么能够调用工具?

因为应用程序将外部工具描述提供给模型。

例如:

JSON
{
  "name": "search_documents",
  "description": "搜索知识库中的文档",
  "parameters": {
    "query": "string",
    "top_k": "integer"
  }
}

这是概念化的工具接口,不是某个 SDK 的完整函数 Schema。

模型会根据当前任务生成工具调用请求。

应用程序收到请求后,执行真正的检索代码,再将结果送回模型。

也就是说:

LLM 负责决策和生成工具调用参数,程序负责真正执行工具。

LLM 本身不会因为输出了一个工具名称,就自动拥有数据库或网络访问权限。

13.2 一个最简 Agent Loop

PYTHON
def agentic_rag(question):
    state = {
        "question": question,
        "evidence": [],
        "steps": 0
    }

    while state["steps"] < 5:
        action = planner(state)

        if action["type"] == "search":
            result = search(action["query"])
            state["evidence"].append(result)

        elif action["type"] == "read":
            result = read_document(action["doc_id"])
            state["evidence"].append(result)

        elif action["type"] == "answer":
            return generate(
                question,
                state["evidence"]
            )

        state["steps"] += 1

    return generate_or_abstain(state)

这里的 planner、search、read_document 和 generate_or_abstain 都是需要自行实现的接口。

这个示例说明:

Agentic RAG 的底层仍然可能使用传统 RAG、GraphRAG、全文搜索或其他检索器。

真正发生变化的是上层控制机制。

13.3 Agentic RAG 的代价

自主决策会引入新问题:

  • 工具可能调用错误。
  • Agent 可能反复搜索但没有进展。
  • 复杂流程可能产生额外延迟与费用。
  • 外部工具返回的内容可能包含不可信指令。
  • 中间结果错误可能影响后续决策。

因此,系统通常需要:

  • 最大执行步数
  • Token 与费用预算
  • 工具访问权限
  • 执行日志
  • 停止和失败条件
  • 引用及证据验证

Agent 的自主性不应该意味着失去控制。


第六部分:Memory System,让 AI 具备长期状态

14. 为什么有了 RAG 还需要记忆系统?

RAG 主要解决:

面对当前问题,应该获取哪些外部知识?

记忆系统进一步考虑:

随着时间推移,系统应该保存什么、更新什么、遗忘什么,以及如何使用过去的经历?

例如,用户在第一次对话中说:

“我更喜欢简洁的技术解释。”

第二次对话中又说:

“涉及算法时,希望看到实现细节。”

系统如果要长期适应这些偏好,就需要保留并更新相关信息。

直接把所有历史对话拼接到 Prompt 中,虽然简单,但会遇到:

  • 上下文窗口限制
  • Token 成本增加
  • 无关历史信息干扰
  • 长期信息难以更新
  • 同一事实在不同时间发生冲突

这就是长期记忆系统的设计动机。

15. 记忆系统通常包含哪些层次?

可以借鉴计算机系统中的分层存储思想。

层次主要保存什么
工作记忆当前问题、计划、执行状态
近期上下文最近的消息和任务进展
长期记忆跨会话有用的事实、偏好、经历和经验
持久存储支撑以上信息的数据库、文件、向量索引或图

不同研究对记忆层次的命名与定义并不统一。

从用途上,也可以区分:

情景记忆(Episodic Memory)

记录发生过的事件,例如一次任务、一次对话或一次失败。

语义记忆(Semantic Memory)

保存相对稳定的事实或概念。

程序性记忆(Procedural Memory)

保存完成任务的方法、规则或可复用流程。

这些划分借鉴了认知科学,但 AI 系统不一定严格采用人类记忆模型。


16. MemGPT:把操作系统的虚拟内存思想引入 LLM

MemGPT 的核心设计非常有意思。

它借鉴操作系统的虚拟内存管理机制,把有限的 LLM 上下文窗口视为一种需要管理的资源。

16.1 传统上下文方式

TEXT
系统提示
+ 历史对话
+ 当前问题
= 输入模型

随着对话变长,历史内容会不断占用上下文预算。

16.2 MemGPT 的思路

模型只看到有限的当前活跃上下文,通过记忆管理工具读取或修改核心记忆,并按需访问外部存储中的历史与归档信息。换入什么、保留什么,都需要显式的软件机制。

系统可以根据当前需求,把不同记忆内容移入或移出模型的上下文。

这种思想与操作系统中的内存层级、数据换入换出具有类比关系。

但它不是把 LLM 的上下文窗口真正变成操作系统虚拟内存,也不意味着物理意义上的无限上下文。

它依靠软件管理,让有限的上下文能够利用更大规模的外部历史信息。


17. Mem0:让记忆能够持续提取与更新

Mem0 关注长期对话中的记忆管理。

一个重要设计是:

不是保存每一句对话,而是从交互中提取值得长期保留的信息。

17.1 记忆写入流程

记忆从新事件提取,比较旧记忆后添加更新忽略或删除,查询时再按需读取

图 8:长期记忆同时有写入与读取路径。来源、时间、有效期和用户更正机制是工程设计要考虑的内容,并非所有框架的默认功能。

例如:

TEXT
原有记忆:
用户喜欢简洁回答。

新对话:
涉及技术底层时,希望解释详细。

合理的记忆管理不应该简单删除旧信息,也不应该直接把两个句子并列存储为无关事实。

它可以形成更精确的条件性记忆:

TEXT
用户通常偏好简洁回答;
讨论技术实现时偏好详细说明。

但这类信息提取需要考虑上下文、准确性和用户授权。

17.2 记忆数据结构

一个简化的记忆记录可以是:

JSON
{
  "memory_id": "m001",
  "subject": "user",
  "content": "技术原理希望有底层解释",
  "memory_type": "preference",
  "source_event": "conversation_102",
  "updated_at": "2026-11-10",
  "confidence": 0.95
}

这是教学示例,不代表 Mem0 的官方存储 Schema。

实际系统还可能记录:

  • 所属用户与权限范围
  • 来源
  • 时间信息
  • 有效期
  • 冲突状态
  • 向量索引
  • 图关系
  • 审计记录

17.3 查询时如何调用记忆?

分析新问题 → 检索相关记忆 → 检查时效与冲突 → 选择少量有用信息 → 注入当前上下文 → 回答。其中,时效与冲突过滤是应按业务实现的管理策略。

它与 RAG 的读取过程很像。

主要区别在于,记忆系统通常还需要持续执行写入、更新、冲突解决和遗忘操作。

17.4 A-MEM:让记忆互相关联

A-MEM 进一步借鉴 Zettelkasten 卡片笔记法的思想。

它会为记忆生成上下文描述、关键词和标签,让新记忆与已有记忆建立联系,并更新历史记忆的上下文表示。

可以理解为:

例如,记忆 A“正在研究 RAG”可以关联到记忆 B“关注检索质量”和记忆 C“偏好底层原理”,形成可沿关系检索的网络。

这种设计与知识图谱有相似之处,但记忆网络还需要处理时间、历史变化和信息生命周期。

17.5 长期记忆系统的难点

记忆系统的困难不只是“怎么存”。

更关键的是:

什么值得记住?

如果存储过多无关信息,检索质量会下降。

什么时候应该修改记忆?

用户的偏好可能变化,旧信息未必仍然有效。

如何区分事实与推测?

模型从一句话推断出的偏好,不应该自动成为永久事实。

如何保护隐私?

长期记忆需要用户可控制的授权、隔离、更正和删除机制。

如何验证记忆?

长期记忆可以提高连续性,也可能把早期错误不断传播到后续对话。

因此,记忆系统不能只用“记住的内容越多”来衡量效果。


第七部分:OpenAI 在这些架构中处于什么位置?

18. OpenAI 是模型服务提供方,不是一种 RAG 算法

OpenAI 可以提供多种构建知识系统所需要的能力,例如:

  • Embedding API
  • 文本生成模型
  • Responses API
  • File Search
  • Vector Stores
  • 工具调用能力

它们可以参与 RAG、GraphRAG 或 Agentic RAG 的不同环节。

例如:

一种组合是:OpenAI Embedding API 负责向量化,自建 PostgreSQL / pgvector、Elasticsearch 或图数据库负责检索,Responses API 负责生成。这些组件由应用程序连接。

也可以直接使用 OpenAI 托管的 File Search,而不是自己实现完整的索引和检索流程。

OpenAI 官方提供 Vector Stores 和 File Search。

用户上传文件后,托管服务可以负责文件切块、Embedding 和索引构建。

简化 Python 示例(所选生成模型还需要支持 File Search 工具):

PYTHON
import os
from openai import OpenAI

client = OpenAI()

store = client.vector_stores.create(
    name="blog_knowledge_base"
)

with open("knowledge.txt", "rb") as f:
    client.vector_stores.files.upload_and_poll(
        vector_store_id=store.id,
        file=f
    )

response = client.responses.create(
    model=os.environ["OPENAI_GENERATION_MODEL"],
    input="总结文件中的主要技术观点。",
    tools=[
        {
            "type": "file_search",
            "vector_store_ids": [store.id]
        }
    ]
)

print(response.output_text)

代码按官方 Python SDK 文档的接口形式整理,未在此执行付费 API 调用。运行前还需检查模型权限、费用、文件格式和数据处理策略。需要调试检索结果时,可以在 Responses 请求中加上 include=["file_search_call.results"]。创建的 Vector Store 会保留在账户中,实验结束后应按自己的保留策略清理。

这个例子并不意味着 OpenAI File Search 内部的完整索引实现全部公开,也不能推断它使用了某个特定的数据库引擎。

两种开发方式的区别在于:

自建检索: 更容易控制索引策略、数据库、检索算法和调试信息,但维护成本更高。

托管检索: 接入相对简单,但部分内部实现和控制能力由服务提供方决定。


第八部分:如何将这些底层技术组合成一个完整系统?

20. 一个完整的现代知识系统

前面的技术并非只能单独使用。

下面是一种概念上可行的组合架构:

可以按五层来搭建:

  1. 数据层:解析文档,保留原文、来源和权限元数据。
  2. 索引层:先生成 Embedding 再建向量索引;按需建立关键词、实体关系或摘要层次索引。
  3. 检索层:Router 或 Agent 选择检索器,融合、重排并检查证据质量,必要时补充检索。
  4. 生成层:在预算内组装上下文,生成答案并核验引用和证据支持程度。
  5. 记忆层:把经筛选且适合保存的交互信息持久化;在未来任务中按需读取,并允许更新和删除。

文章开头的图 1 展示了这些模块如何组合。

这只是参考架构,不代表所有系统都应该包含上述全部组件。

实际上,每增加一个环节,都可能增加:

  • 延迟
  • Token 成本
  • 数据维护成本
  • 故障点
  • 结果的不确定性

因此,复杂不等于先进,组件多也不等于答案质量高。


21. 如何从技术原理出发选择方案?

核心问题可考虑的技术主要增加的能力
文本语义难以匹配Embedding / 向量搜索语义相关性
特定术语无法精确定位BM25 / 倒排索引关键词精确匹配
多路检索各有不足Hybrid Search多种信号融合
检索结果质量参差不齐Reranker / CRAG证据选择与纠错
需要跨实体关系查询知识图谱 / GraphRAG关系结构检索
需要跨大量资料做整体总结社区摘要型 GraphRAG全局知识整合
长文档具有多层级结构RAPTOR多粒度摘要检索
希望减少不必要的检索Self-RAG自适应检索决策
需要区分竞争性解释CF-RAG反事实证据探索
问题需要多次查找信息Agentic RAG动态检索与规划
需要跨会话保留信息Memory System持久记忆管理

值得注意的是:

很多表面上属于 GraphRAG 的需求,可能用传统 RAG 加多查询检索就能解决。

很多表面上需要 Agentic RAG 的任务,可能用固定工作流更加稳定。

因此,必须结合任务和评估结果选择技术,而不是单纯比较名称。


第九部分:这些方法到底应该怎么评估?

22. 不能只看生成结果是否流畅

检索系统至少包含两个不同的评价对象:

第一,检索是否正确?

第二,模型是否正确利用了检索结果?

如果只评价最终答案,就很难分辨:

  • 是检索器没有找到证据?
  • 还是找到了证据但排序不合理?
  • 还是模型忽略了正确证据?
  • 还是原始知识库本身存在错误?

因此,应该拆开评估。

22.1 检索层指标

Recall@K

在前 K 个检索结果中,找到了多少应当召回的相关证据。

Precision@K

前 K 个检索结果中,有多少是真正相关的。

MRR

衡量首个正确结果出现得有多靠前。

nDCG

考虑多个结果的相关性等级和排序位置。

22.2 生成层指标

可以考察:

  • 回答正确率
  • 证据支持程度
  • 引用准确率
  • 事实完整性
  • 无法回答时的拒答表现

其中,“答案符合事实”与“答案得到所提供证据支持”是两个不同维度。

模型可能说出了正确答案,但引用了错误资料。

也可能忠实复述了一份本身错误的资料。

22.3 系统层指标

还需要记录:

  • P50 / P95 延迟
  • Token 消耗
  • API 与索引费用
  • 索引构建时间
  • 更新与删除成本
  • 数据访问权限正确性
  • 并发吞吐量
  • 失败恢复能力

对于长期记忆,还需要单独衡量:

  • 记忆提取准确率
  • 跨会话召回率
  • 时间有效性
  • 冲突解决正确率
  • 错误记忆传播率
  • 删除与隐私控制的有效性

22.4 应该如何比较不同 RAG?

不要只拿最简单的向量检索去对比复杂 GraphRAG,然后直接宣布 GraphRAG 更好。

一个相对合理的对照顺序是:

  1. BM25
  2. Dense Vector Search
  3. BM25 + Vector
  4. Hybrid + Reranker
  5. GraphRAG / RAPTOR 等结构增强方案
  6. Agentic / Corrective RAG 等控制增强方案

所有方案尽可能使用:

  • 同一份测试数据
  • 相同问题集合
  • 一致的评价标准
  • 可比的生成模型
  • 明确记录的上下文与计算预算

再判断新增复杂度是否带来了足够收益。

对于 CF-RAG 等专门方法,还应该设计针对性的测试集,而不是只使用普通事实问答进行评价。


第十部分:这些技术背后的共同设计思想

重新回顾整个知识技术体系,可以发现研究者持续在解决几类基本问题。

23. 知识如何表示?

最早,人们主要使用文档、页面、表格和数据库保存知识。

知识图谱进一步引入显式语义关系。

Embedding 则提供连续向量表示,让系统能够通过统计相关性检索内容。

GraphRAG、RAPTOR 等方法在这些表示上引入更多结构。

它们对应不同的数据模型,并不存在适用于一切任务的唯一最佳表示。

24. 知识如何检索?

检索方法从关键词匹配发展到向量检索、图检索、层级检索,以及多路融合。

每种方法都表达了不同的相关性假设:

  • BM25:关键词统计相关性
  • Embedding:向量空间相似性
  • Graph:显式结构关联
  • Tree:层次结构与摘要关联

选择检索算法,本质上就是选择一种寻找信息的方式。

25. 知识如何被可靠使用?

RAG 让模型使用外部证据。

CRAG 关注检索失败时的纠错。

Self-RAG 研究自适应检索和自我评价。

CF-RAG 尝试区分相关证据和具有反事实区分能力的证据。

这些技术体现出一个共同变化:

从“找到信息”,进一步走向“判断信息是否足以支持回答”。

26. 知识如何在时间中持续存在?

Agentic RAG 让系统能够自主决定如何检索。

Memory System 则让系统在多个任务和会话之间保留并更新状态。

在这些系统中,数据不再只是一次性查询使用的静态资料。

它也可以包括历史行为、任务结果、长期事实和待更新的经验。

但这也带来了时间一致性、隐私和错误累积问题。


结语:从存储知识,到让知识参与决策

从 Embedding 到 GraphRAG,再到 Agentic RAG 和 Memory System,人们并不是单纯在发明越来越复杂的搜索工具。

更深层的目标,是探索:

如何让机器在有限的计算资源、有限的上下文和不完整的信息条件下,尽可能有效且可靠地利用外部知识。

我们可以用几句话概括它们的设计理念:

  • Embedding: 让信息进入可计算的语义向量空间。
  • 向量数据库: 高效存储和查找相似向量。
  • RAG: 让生成模型利用检索到的外部证据。
  • GraphRAG: 让图结构参与证据检索和组织。
  • LightRAG: 将图与向量检索结合,并关注检索效率与增量更新。
  • RAPTOR: 用递归摘要和层次结构组织长文本。
  • Self-RAG: 让模型学习何时检索及如何评价证据。
  • CRAG: 检索结果不可靠时,尝试补充和纠正。
  • CF-RAG: 用反事实问题探索证据的关键差异。
  • Agentic RAG: 让检索成为可规划、可调整的执行过程。
  • Memory System: 让系统能够跨时间保存、更新和调用信息。

未来的新技术可能继续改变这些实现方式,但它们背后的问题依然值得研究:

知识怎么表示?怎么索引?怎么检索?怎么验证?怎么更新?以及怎么在有限资源下可靠地使用?

理解这些问题,比单纯记住某个 RAG 框架的 API 更有长期价值。


参考资料与延伸阅读

以下优先选择原始论文、正式会议出版页面和官方技术文档。

基础检索与 RAG

  1. Lewis et al. (2020), Retrieval-Augmented Generation for Knowledge-Intensive NLP Tasks, NeurIPS 2020.
    https://arxiv.org/abs/2005.11401↗

  2. Malkov & Yashunin, Efficient and Robust Approximate Nearest Neighbor Search Using Hierarchical Navigable Small World Graphs, IEEE TPAMI.
    https://doi.org/10.1109/TPAMI.2018.2889473↗

  3. OpenAI, Vector Embeddings.
    https://developers.openai.com/api/docs/guides/embeddings↗

  4. OpenAI, Retrieval and Vector Stores.
    https://developers.openai.com/api/docs/guides/retrieval↗

  5. Elasticsearch, Reciprocal Rank Fusion.
    https://www.elastic.co/docs/reference/elasticsearch/rest-apis/reciprocal-rank-fusion↗

结构化 RAG

  1. Microsoft GraphRAG 官方项目与架构文档。
    https://github.com/microsoft/graphrag↗

  2. Guo et al. (2025), LightRAG: Simple and Fast Retrieval-Augmented Generation, Findings of EMNLP 2025.
    https://aclanthology.org/2025.findings-emnlp.568/↗
    https://github.com/HKUDS/LightRAG↗

  3. Sarthi et al. (2024), RAPTOR: Recursive Abstractive Processing for Tree-Organized Retrieval, ICLR 2024.
    https://arxiv.org/abs/2401.18059↗

检索决策与纠错

  1. Asai et al. (2024), Self-RAG: Learning to Retrieve, Generate, and Critique through Self-Reflection, ICLR 2024.
    https://arxiv.org/abs/2310.11511↗

  2. Yan et al. (2024), Corrective Retrieval Augmented Generation.
    https://arxiv.org/abs/2401.15884↗

  3. Qin et al. (2026), Counterfactual Reasoning for Retrieval-Augmented Generation, ICLR 2026.
    https://proceedings.iclr.cc/paper_files/paper/2026/hash/1c078897dc08d46091d0d361d9955c6b-Abstract-Conference.html↗

长期记忆系统

  1. Packer et al. (2023), MemGPT: Towards LLMs as Operating Systems.
    https://arxiv.org/abs/2310.08560↗

  2. Chhikara et al. (2025), Mem0: Building Production-Ready AI Agents with Scalable Long-Term Memory.
    https://arxiv.org/abs/2504.19413↗

  3. Xu et al. (2025), A-MEM: Agentic Memory for LLM Agents, NeurIPS 2025.
    https://arxiv.org/abs/2502.12110↗

OpenAI 实现参考

  1. OpenAI, File Search.
    https://developers.openai.com/api/docs/guides/tools-file-search↗

  2. OpenAI, Responses API.
    https://developers.openai.com/api/docs/quickstart↗


说明:本文将论文中提出的机制、官方实现以及用于教学的简化代码分开讨论。架构图和伪代码用于解释设计思想,不应直接视为可上线的完整实现。各方法的论文实验结果也不代表其在所有数据集和工程场景下都优于传统 RAG。

授权

从 RAG 到 GraphRAG,再到 Agent Memory:把 AI 知识系统拆开看

2026年11月10日
13493 字 · 52 分钟

© SunkCost · CC BY-NC-SA 4.0