微软GraphRAG知识图谱增强检索

可视化演示

展示GraphRAG核心流程：文档分块与实体关系抽取构建知识图谱、Leiden社区聚类与分层摘要、以及朴素RAG与GraphRAG的检索范式对比。

RAG基础概念

你站在街头随机问一位路人：“这个城市的人最怀念什么？”路人只会愣住——他熟悉自己小区附近的小店和公园，却不敢代表整座城市回答。传统 RAG 就像这位路人：它把文档切成许多小片段，用向量相似度找出与问题最像的几个片段，交还给大模型生成答案。对于“地铁站怎么走”这种点状问题，这个流程高效又精准。

但技术实现上，RAG 的检索过程是把问题变成一个向量，在预先向量化的文档片段库中做相似度匹配，取相似度 Top-K 的片段拼进上下文。这就像一个只看局部地图的问路人，碎片与碎片之间没有关联，更看不到全貌。

$$\displaystyle \text{Ret}(q) = \arg \max_{d \in \mathcal{D}} \text{sim}(\mathbf{e}_q, \mathbf{e}_d)$$

1. 查询文本 $q$：用户输入的问题，比如“这家面馆几点开门”。

$$\displaystyle q$$

2. 向量化 $\mathbf{e}_q$：用嵌入模型把文本变成一串数字向量，语义相近的文本向量距离近。

$$\displaystyle \mathbf{e}_q = \text{Embed}(q)$$

3. 文档库 $\mathcal{D}$：全部被切成小块的文档片段集合，每个片段也预先向量化。

$$\displaystyle \mathcal{D} = \{d_1, d_2, \dots, d_N\}$$

4. 相似度 $\text{sim}(\mathbf{e}_q, \mathbf{e}_d)$：计算问题向量与每个片段向量的余弦相似度。

$$\displaystyle \text{sim}(\mathbf{e}_q, \mathbf{e}_d) = \frac{\mathbf{e}_q \cdot \mathbf{e}_d}{\|\mathbf{e}_q\| \|\mathbf{e}_d\|}$$

5. 取最大 $\arg\max$：选出相似度最高的几个片段作为上下文喂给大模型。

$$\displaystyle \text{Ret}(q) = \arg \max_{d \in \mathcal{D}} \text{sim}(\mathbf{e}_q, \mathbf{e}_d)$$

这就解释了为什么传统 RAG 回答全局性问题时总是“只见树木不见森林”。当问题需要跨越几十个文档片段才能回答时，Top-K 检索到的碎片就像路人甲的所见所闻，东拼西凑也难成体系。RAG 的“问路人”模式本质是单跳问答：一次检索、一次生成，没有把碎片之间的结构关系纳入考量。这也是 GraphRAG 被设计出来的直接动机。

GraphRAG架构

面对“这座城市的核心气质是什么”这类问题，聪明的旅行作家不会去随机问路人，而是先花几天时间绘制全城地图、划分街区、编写导览手册，然后翻开手册从容作答。GraphRAG 的架构正是这份从容：它把整条链路拆成“离线索引”和“在线查询”两个阶段。

索引阶段像绘制城市地图的工程队：大模型逐块阅读文档，抽取实体与关系构建知识图谱；图算法把图谱划分成多个社区；再为每个社区预生成摘要并缓存。查询阶段则像游客服务中心：先判断问题是“点状”还是“全局”，点状问题仍走向量检索快速定位，全局问题则直接调用预计算的社区摘要做综合回答。

$$\displaystyle \text{GraphRAG}(q) = \text{Query}\left(q,\ \text{Index}(\mathcal{D})\right)$$

1. 文档集 $\mathcal{D}$：全部待索引的原始文档，相当于要勘察的整座城市范围。

$$\displaystyle \mathcal{D}$$

2. 索引阶段 $\text{Index}(\mathcal{D})$：离线执行的四步流水线——抽取实体、构建图谱、社区聚类、生成摘要。

$$\displaystyle \text{Index}(\mathcal{D}) = \text{Summarize}(\text{Cluster}(\text{Graph}(\text{Extract}(\mathcal{D}))))$$

3. 查询阶段 $\text{Query}(q, \cdot)$：在线执行的回答函数，输入是用户问题以及索引产物。

$$\displaystyle \text{Query}(q,\ \text{Index}(\mathcal{D}))$$

4. 整套复合结构：先离线建好“导览手册”，再在线按图索骥。

$$\displaystyle \text{GraphRAG}(q) = \text{Query}\left(q,\ \text{Index}(\mathcal{D})\right)$$

GraphRAG 的架构精髓在于“知识图谱中间层”——它把杂乱文档转成结构化网络，让机器看见了实体之间的关联。而“社区摘要缓存”则像导览手册的章节，把底层图谱压缩成高层语义卡片。这种两阶段设计带来的好处是：索引阶段再昂贵也只在后台一次性发生，查询阶段几乎零延迟复用成果，真正做到了“慢工出细活，一本手册反复用”。

实体图谱构建

绘制城市地图的第一步，是标记每一座地标建筑——钟楼、广场、老面馆——并在它们之间画上道路。GraphRAG 的索引阶段同样如此：大模型逐段阅读文档，抽出“实体”（地标）与“关系”（道路），形成一张知识图谱。

具体做法是设计一段提示词，让 LLM 从每个文本块中抽取结构化三元组。比如读到“乔布斯在 1976 年创立了苹果公司”，就抽出（乔布斯，创立，苹果公司）。同时，LLM 还会抽取实体属性，如“苹果公司总部位于库比蒂诺”中的地点属性。这一步是整条流水线的地基，地标标错了，后面的地图、社区、导览全都歪。

$$\displaystyle \mathcal{G} = \{(h, r, t) \mid h, t \in \mathcal{E},\ r \in \mathcal{R}\}$$

1. 实体集合 $\mathcal{E}$：所有被抽取出的实体，如“乔布斯”“苹果公司”“库比蒂诺”。

$$\displaystyle \mathcal{E} = \{e_1, e_2, \dots, e_n\}$$

2. 关系集合 $\mathcal{R}$：所有关系类型，如“创立”“发布”“位于”。

$$\displaystyle \mathcal{R} = \{r_1, r_2, \dots, r_m\}$$

3. 三元组 $(h, r, t)$：一条有向边的完整表达：头实体通过关系指向尾实体。

$$\displaystyle (h, r, t) \quad h, t \in \mathcal{E},\ r \in \mathcal{R}$$

4. 图谱 $\mathcal{G}$：全部三元组的集合，构成一张带方向的图。

$$\displaystyle \mathcal{G} = \{(h, r, t) \mid h, t \in \mathcal{E},\ r \in \mathcal{R}\}$$

构建图谱时还有一个关键环节叫共指消解——“乔布斯”“史蒂夫·乔布斯”"Jobs"在地图上应该是同一座地标，需要合并。这就像两张街区图上同一座钟楼被标了两个名字，必须合成一个节点。构建完成后，图谱以节点表和边表的形式存储，支持后续社区检测时的快速遍历。这个阶段还支持增量式索引：新文档来了只更新相关子图，不必推倒全图重画，像城市扩建时只需在旧地图上补新区块。

社区聚类发现

地图上的地标并不是均匀分布的——老城区的钟楼、教堂、集市彼此挨得近，大学区的教学楼和图书馆也扎堆。GraphRAG 用社区检测算法自动找出这种“扎堆”结构，把图谱划分成一个个社区。算法采用的是图计算领域著名的 Leiden 算法，它是 Louvain 算法的升级版，能保证划分出的社区内部连接紧密、社区之间连接稀疏。

Leiden 算法的目标是通过优化“模块度”来找到最佳划分。模块度衡量的是：社区内部的连接比例，比随机连接预期多出多少。模块度越高，说明划分质量越好。GraphRAG 会递归地应用社区检测，形成一棵“社区树”——底层是最细粒度的叶子社区，往上层层合并成更大范围的社区，对应到城市里就是“街区→城区→全城”。

$$\displaystyle Q = \frac{1}{2m} \sum_{ij} \left[ A_{ij} - \frac{k_i k_j}{2m} \right] \delta(c_i, c_j)$$

1. 邻接矩阵 $A_{ij}$：节点 $i$ 与节点 $j$ 之间有边则为 1，否则为 0。

$$\displaystyle A_{ij} \in \{0, 1\}$$

2. 节点的度 $k_i$：节点 $i$ 连接的边数，即这座“地标”的街道数量。

$$\displaystyle k_i = \sum_j A_{ij}$$

3. 总边数 $m$：整个图谱的边数，公式中的 $2m$ 是全部“度数”之和。

$$\displaystyle m = \frac{1}{2}\sum_i k_i$$

4. 同社区指示 $\delta(c_i, c_j)$：当节点 $i, j$ 被分到同一社区时取 1，否则取 0。

$$\displaystyle \delta(c_i, c_j) = \begin{cases} 1, & c_i = c_j \\ 0, & c_i \ne c_j \end{cases}$$

5. 模块度求和：对全图所有节点对累加“实际连接减随机期望”，再归一化。

$$\displaystyle Q = \frac{1}{2m} \sum_{ij} \left[ A_{ij} - \frac{k_i k_j}{2m} \right] \delta(c_i, c_j)$$

模块度的妙处在于它给“什么是好的街区划分”一个量化标准：如果划分纯靠随机，内部连接数就是 $k_i k_j / 2m$；实际连接比它多，说明这个社区真有“凝聚力”。Leiden 算法通过不断尝试移动节点来提升 Q 值，最终收敛到一个高质量划分。而递归划分则保证社区粒度可调——就像导览手册既有分街区详述，又有分城区概览，不同层级的读者各取所需。

社区摘要生成

街区划定之后，导览手册的编写者要动笔了：为每个街区写一段“性格概述”，说清楚这里以什么闻名、有哪些值得注意的地方。GraphRAG 用大模型为每个社区生成摘要——先对最底层的叶子社区生成详细摘要，再让上层社区把若干子社区的摘要“合并提炼”成更凝练的概览，逐层向上，形成一棵摘要树。

每个社区的摘要内容，来自该社区所有实体所关联的源文本片段。大模型把这些碎片读进去，输出一段结构化的社区概述，比如“该社区聚焦苹果公司的产品与领导层信息，涉及乔布斯与库克的继任关系”。由于社区是分层嵌套的，摘要也天然分层：叶子摘要细节丰富，上层摘要高屋建瓴。

$$\displaystyle \text{Summary}(C) = \text{LLM}\left(\bigcup_{v \in C} \text{Text}(v)\right)$$

1. 社区 $C$：一个簇内实体的集合，如“苹果公司、乔布斯、库克、iPhone、库比蒂诺”。

$$\displaystyle C = \{v_1, v_2, \dots, v_n\}$$

2. 实体关联文本 $\text{Text}(v)$：实体 $v$ 在原始文档中出现的上下文片段。

$$\displaystyle \text{Text}(v)$$

3. 文本合并 $\bigcup$：把社区内所有实体的文本片段汇总成一个文本袋。

$$\displaystyle T = \bigcup_{v \in C} \text{Text}(v)$$

4. 大模型提炼 $\text{LLM}(\cdot)$：将文本袋压缩成要点式摘要。

$$\displaystyle \text{Summary}(C) = \text{LLM}(T)$$

这些摘要不是查询时临时生成的，而是在索引阶段离线预计算好并缓存进存储系统。查询时直接读取，省去了在线计算成本，也让回答可以快速跨社区综合信息。从叶子到根部的全部社区摘要共同构成“导览手册”的完整内容。当用户提出全局性问题时，系统就能像翻阅手册一样快速定位到所有相关章节，而不是临时抱佛脚去检索零散段落。

全局查询增强

游客走进咨询中心，抛出一个贯穿全城的问题：“这座城市最值得体验的三件事是什么？”咨询员不会只翻某一页，而是把整本导览手册的各个街区章节快速扫一遍，挑出高频亮点，汇总成一份综合推荐。GraphRAG 的全局查询阶段正是采用这样的"Map-Reduce"策略。

系统先判断问题属于全局性还是局部性。如果是局部性问题，走传统向量检索更快；如果是全局性问题，就进入 Map-Reduce 流水线：把问题同时分发给所有社区（Map），每个社区基于自己的摘要生成一个“从本街区视角出发”的答案片段；然后将所有片段汇总（Reduce），通过去重、排序、提炼，生成最终的全局答案。由于 Map 阶段可以并行执行，整个流程既全面又高效。

$$\displaystyle \text{Answer}(q) = \text{Reduce}\left(\{\text{Map}(q, \mathcal{S}_k)\}_{k=1}^{K}\right)$$

1. 全局性问题 $q$：需要综合全库信息才能回答的问题，如“公司有哪些福利类别”。

$$\displaystyle q$$

2. 社区摘要集合 $\mathcal{S}_k$：第 $k$ 个社区预先生成的摘要内容。

$$\displaystyle \mathcal{S}_k$$

3. Map 映射：将 $q$ 与单个社区摘要组合，生成该社区的局部回答。

$$\displaystyle \text{Map}(q, \mathcal{S}_k) \to a_k$$

4. Reduce 归约：把全部局部回答 $a_1, a_2, \dots, a_K$ 汇总成最终答案。

$$\displaystyle \text{Answer}(q) = \text{Reduce}(a_1, a_2, \dots, a_K)$$

这套 Map-Reduce 的设计巧妙之处在于：每个社区都像一个独立的信息源，它们各自只负责自己那片“街区”的见解，但组合起来便能覆盖整张知识图谱。Reduce 阶段还要避免重复信息——如果三个社区都提到“苹果公司重视创新”，最终答案只需保留一次并标注多个来源。这既保证了全局覆盖面，又保持了答案的简洁与可追溯性，正是 GraphRAG 处理全局问题的核心竞争力。

效果评估对比

当旅行手册出版后，我们终于可以客观对比两种问路方式了：随机拉路人问（朴素 RAG）与翻阅导览手册（GraphRAG）。微软在论文中系统评测了二者在全局性问题上的表现，GraphRAG 在答案的综合性、多样性、可授权性等指标上均显著胜出。所谓综合性，指答案是否覆盖了所有相关方面——问“公司的福利体系有哪些”，传统 RAG 往往遗漏一半，GraphRAG 能给出完整清单。

但这种碾压是有代价的：索引阶段的 Token 消耗远高于传统 RAG。构建知识图谱时要让 LLM 逐块抽取三元组，社区聚类后还要为每个社区生成摘要，一个中型文档库可能要消耗几百万到上千万 Token。好消息是这是离线成本，可以被大量查询摊薄。用一个指标来量化提升幅度：

$$\displaystyle \Delta = \frac{\text{Score}_{\text{GraphRAG}} - \text{Score}_{\text{Naive}}}{\text{Score}_{\text{Naive}}} \times 100\%$$

1. 朴素 RAG 得分 $\text{Score}_{\text{Naive}}$：在全局问题测评集上，传统 RAG 的综合度得分，假设为 58。

$$\displaystyle \text{Score}_{\text{Naive}} = 58$$

2. GraphRAG 得分 $\text{Score}_{\text{GraphRAG}}$：同一测评集上 GraphRAG 的得分，假设为 92。

$$\displaystyle \text{Score}_{\text{GraphRAG}} = 92$$

3. 分子（提升量）：两个得分的差额。

$$\displaystyle \text{Score}_{\text{GraphRAG}} - \text{Score}_{\text{Naive}} = 34$$

4. 分母归一：除以朴素 RAG 得分，得到相对提升。

$$\displaystyle \Delta = \frac{34}{58} \times 100\% \approx 58.6\%$$

除了分数提升，GraphRAG 还带来一个隐性红利——可追溯性。传统 RAG 的答案来自碎片拼接，读者很难搞清依据；GraphRAG 的每个结论都能对应到某个社区的摘要，而摘要又能追溯到原始文档，像导览手册每一页都标注了信息来源。因此在实际选型中，团队需要权衡：如果业务问题以全局分析为主，离线索引的高成本就值得投入；如果大量是简单单点查询，这笔账就要重新算——这是典型的“离线成本换在线质量”的取舍。

应用场景选择

回到旅行作家本人：并不是每一次出行都需要画全城地图。如果只是路过歇脚，想知道附近哪家便利店开着，问路人是最高效的；但如果要写一本深度城市指南，全域地图和大规模街区调研就必不可少。GraphRAG 的应用选型也遵循同样的逻辑——先分辨问题类型，再决定投入多重的方案。

适合 GraphRAG 的场景有一个共性：答案必须横跨多篇文档、多个主题才能形成。典型如企业制度库的全局分析——“我们公司一共有哪些类型的补贴政策？”答案散落在几十份 PDF 中，传统 RAG 检索到的碎片永远不完整。科研文献综述同样适合，研究者需要综合几十篇论文回答“这些试验的共同终点指标是什么”。这些场景中 GraphRAG 的社区摘要天然提供了“章节化”的知识组织方式。

$$\displaystyle \text{ROI} = \frac{\text{Gain}_{\text{query}}}{\text{Cost}_{\text{index}}}$$

1. 查询收益 $\text{Gain}_{\text{query}}$：引入 GraphRAG 后回答质量提升带来的业务价值（准确率、覆盖率、用户满意度）。

$$\displaystyle \text{Gain}_{\text{query}}$$

2. 索引成本 $\text{Cost}_{\text{index}}$：构建知识图谱和社区摘要消耗的 Token、算力与时间。

$$\displaystyle \text{Cost}_{\text{index}}$$

3. 比值判断：ROI 越高越值得投入；查询量越大，固定索引成本被摊销得越薄。

$$\displaystyle \text{ROI} = \frac{\text{Gain}_{\text{query}}}{\text{Cost}_{\text{index}}}$$

反过来，有两类场景要谨慎。一类是单点事实查询，如“某产品的保修期是多少”——向量检索直接命中，毫秒级返回，GraphRAG 反而大材小用。另一类是成本敏感且文档高频更新的场景，因为每次文档更新都可能触发实体图谱和社区摘要的重新计算，让索引成本不断追加。所以成熟的方案常常是“混合架构”：局部问题走朴素 RAG 快速通道，全局问题走 GraphRAG 深度通道，让导览手册只服务真正需要全局视野的游客。

AI 应用场景

Python 演示

"""简化版 Microsoft GraphRAG 核心流程演示 模拟四步：实体关系抽取 -> 构建知识图谱 -> 社区划分 -> 全局问答(Map-Reduce)仅用 Python 标准库，即可运行。"""import refrom collections import defaultdict # ---------- 第1步：输入文档集 ----------DOCUMENTS = [    "苹果公司由乔布斯创立，总部位于库比蒂诺。",    "乔布斯在1976年创办了苹果公司。",    "苹果公司在2007年发布了iPhone。",    "库克接替乔布斯成为苹果公司CEO。",    "iPhone是苹果公司最畅销的产品。",    "库克早年曾在IBM任职多年。",    "微软公司由比尔·盖茨创立，总部位于雷德蒙德。",    "纳德拉是微软公司现任CEO。",    "微软公司的Windows系统全球闻名。",    "特斯拉公司由马斯克领导，总部在奥斯汀。",    "马斯克还创立了太空探索公司SpaceX。",] # ---------- 第2步：实体与关系抽取（用规则模拟 LLM 抽取） ----------ENTITY_LIST = [    "苹果公司", "乔布斯", "库克", "iPhone", "库比蒂诺", "IBM",    "微软公司", "比尔·盖茨", "纳德拉", "Windows", "雷德蒙德",    "特斯拉公司", "马斯克", "奥斯汀", "SpaceX"]RELATION_VERBS = ["创立", "创办", "位于", "发布", "接替", "成为", "领导"]  def extract_entities(text):    """返回文本中出现的实体集合"""    return {e for e in ENTITY_LIST if e in text}  def extract_relations(text):    """用位置规则抽取 (头实体, 动词, 尾实体) 三元组"""    entities = [e for e in ENTITY_LIST if e in text]    triples = []    for verb in RELATION_VERBS:        if verb not in text:            continue        vidx = text.index(verb)        for head in entities:            if text.index(head) < vidx:                for tail in entities:                    if text.index(tail) > vidx and head != tail:                        triples.append((head, verb, tail))    return triples  # ---------- 第3步：构建知识图谱 ----------def build_graph(docs):    """返回邻接表图结构（实体 -> 邻居集合）与三元组列表"""    graph = defaultdict(set)    triples = []    for doc in docs:        for e in extract_entities(doc):            graph[e]        for h, r, t in extract_relations(doc):            graph[h].add(t)            graph[t].add(h)            triples.append((h, r, t))    return graph, triples  # ---------- 第4步：社区检测（用连通分量近似聚类） ----------def find_communities(graph):    """以连通分量作为最简社区划分，近似 Leiden 粗粒度结果"""    visited = set()    communities = []    for node in graph:        if node in visited:            continue        stack, comp = [node], []        visited.add(node)        while stack:            v = stack.pop()            comp.append(v)            for nb in graph[v]:                if nb not in visited:                    visited.add(nb)                    stack.append(nb)        communities.append(comp)    return communities  # ---------- 第5步：社区摘要 ----------def summarize_community(community, triples):    """统计社区内的实体与关系，生成简要描述"""    inner = [t for t in triples if t[0] in community and t[2] in community]    return "社区[{}]：{}个实体，{}条内部关系".format(        "、".join(community), len(community), len(inner))  # ---------- 第6步：全局问答（Map-Reduce） ----------def global_query(question, communities, summaries):    """Map：每个社区独立回答；Reduce：综合各社区视角输出最终答案"""    local_answers = []    for idx, (community, summary) in enumerate(zip(communities, summaries)):        local = "社区{}（{}）认为：结合摘要『{}』，{}".format(            idx, "、".join(community), summary, question)        local_answers.append(local)    final = "综合{}个社区的视角：".format(len(local_answers)) + "；".join(local_answers[:3])    return final  # ---------- 主流程 ----------def main():    print("=== GraphRAG 索引阶段 ===")    graph, triples = build_graph(DOCUMENTS)    print("抽取实体:", sorted(graph.keys()))    print("抽取关系:")    for h, r, t in triples:        print("  ({}, {}, {})".format(h, r, t))     communities = find_communities(graph)    print("\n社区聚类结果:")    for idx, c in enumerate(communities):        print("  社区{}: {}".format(idx, c))     summaries = [summarize_community(c, triples) for c in communities]    print("\n社区摘要:")    for s in summaries:        print("  -", s)     print("\n=== GraphRAG 查询阶段 ===")    answer = global_query("苹果公司的关键人物有哪些？", communities, summaries)    print(answer)  if __name__ == "__main__":    main()

1. graph = defaultdict(set)用邻接表存储知识图谱，每个实体映射到其邻居集合，后续社区检测只需遍历邻居。
2. extract_relations(text)用“动词位置 + 实体位置”规则抽取三元组，模拟 LLM 的结构化抽取能力。
3. triples.append((h, r, t))这里同时将头尾互连，把有向三元组转成无向图的边。
4. find_communities(graph)用 BFS 找连通分量，作为社区检测的最简近似；真实 GraphRAG 用 Leiden 算法。
5. summarize_community(community, triples)只统计社区内部关系，生成描述性摘要，模拟 LLM 摘要生成。
6. global_query(question, communities, summaries)Map 阶段让每个社区结合摘要独立回答，Reduce 阶段用字符串拼接模拟综合汇总。

常见误区

面试题