第3章：GraphRAG检索引擎

第3章：GraphRAG检索引擎

本章将深入讲解GraphRAG系统的检索引擎实现，包括图语义检索、路径推理和混合检索策略等核心技术。

3.1 基于图的语义检索

3.1.1 图语义检索原理

图语义检索是基于知识图谱结构进行的语义信息检索，通过分析图中的节点、边和路径来实现语义理解。

检索基本原理

# 图语义检索基本框架
class GraphSemanticRetriever:
    def __init__(self, knowledge_graph):
        self.kg = knowledge_graph
    
    def semantic_search(self, query, max_depth=3):
        """
        基于图的语义检索
        :param query: 查询语句
        :param max_depth: 搜索深度
        :return: 相关实体和路径
        """
        # 1. 查询理解：解析查询意图
        query_intent = self._parse_query_intent(query)
        
        # 2. 实体识别：识别查询中的实体
        query_entities = self._extract_entities(query)
        
        # 3. 图遍历：基于图结构搜索相关实体
        related_entities = self._graph_traversal(
            query_entities, max_depth
        )
        
        # 4. 路径分析：构建语义路径
        semantic_paths = self._analyze_paths(
            query_entities, related_entities
        )
        
        return semantic_paths
​

3.1.2 多阶检索策略

一阶检索：直接关联

一阶检索直接查找与查询实体直接相连的节点。

def first_order_search(self, entities):
    """
    一阶检索：直接相连的实体
    """
    direct_relations = []
    
    for entity in entities:
        # 查找直接相连的实体
        neighbors = self.kg.get_neighbors(entity)
        
        for neighbor in neighbors:
            relation = self.kg.get_relation(entity, neighbor)
            direct_relations.append({
                'from': entity,
                'to': neighbor,
                'relation': relation,
                'distance': 1
            })
    
    return direct_relations
​

高阶检索：间接关联

高阶检索通过多跳连接发现间接相关的实体。

def high_order_search(self, entities, max_depth=3):
    """
    高阶检索：间接关联的实体
    """
    all_paths = []
    visited = set()
    
    for entity in entities:
        paths = self._find_paths(
            entity, max_depth, visited
        )
        all_paths.extend(paths)
    
    return all_paths

def _find_paths(self, start_entity, max_depth, visited, current_depth=0, current_path=None):
    """
    递归查找路径
    """
    if current_path is None:
        current_path = []
    
    if current_depth >= max_depth:
        return []
    
    paths = []
    neighbors = self.kg.get_neighbors(start_entity)
    
    for neighbor in neighbors:
        if neighbor in visited:
            continue
            
        visited.add(neighbor)
        new_path = current_path + [(start_entity, neighbor)]
        
        # 添加到结果
        paths.append({
            'path': new_path,
            'distance': current_depth + 1,
            'entities': [e for p in new_path for e in p]
        })
        
        # 继续递归
        paths.extend(self._find_paths(
            neighbor, max_depth, visited, 
            current_depth + 1, new_path
        ))
        
        visited.remove(neighbor)
    
    return paths
​

3.2 路径推理与上下文扩展

3.2.1 语义路径推理

推理规则设计

class PathReasoning:
    def __init__(self):
        self.reasoning_rules = {
            'transitive': self._transitive_reasoning,
            'symmetric': self._symmetric_reasoning,
            'inference': self._inference_reasoning
        }
    
    def _transitive_reasoning(self, path):
        """
        传递性推理：A→B, B→C => A→C
        """
        if len(path) >= 2:
            return [(path[0][0], path[-1][1], 'transitive')]
        return []
    
    def _symmetric_reasoning(self, path):
        """
        对称性推理：A→B => B→A
        """
        symmetric_pairs = []
        for from_entity, to_entity, relation in path:
            symmetric_pairs.append((to_entity, from_entity, f'symmetric_{relation}'))
        return symmetric_pairs
    
    def _inference_reasoning(self, path):
        """
        推理性推理：基于领域规则的推理
        """
        inferences = []
        # 基于领域知识进行推理
        if '属于' in [r[2] for r in path] and '用于' in [r[2] for r in path]:
            # A属于B, B用于C => A用于C
            for i in range(len(path)-1):
                if path[i][2] == '属于' and path[i+1][2] == '用于':
                    inferences.append((path[i][0], path[i+1][1], '间接用于'))
        return inferences
​

3.2.2 上下文扩展策略

扩展范围控制

class ContextExpander:
    def __init__(self, max_expansion=5):
        self.max_expansion = max_expansion
    
    def expand_context(self, entities, kg, strategy='semantic'):
        """
        上下文扩展
        """
        if strategy == 'semantic':
            return self._semantic_expansion(entities, kg)
        elif strategy == 'structural':
            return self._structural_expansion(entities, kg)
        elif strategy == 'hybrid':
            return self._hybrid_expansion(entities, kg)
    
    def _semantic_expansion(self, entities, kg):
        """
        语义扩展：基于语义相似度扩展
        """
        expanded = set(entities)
        
        for entity in entities:
            # 查找语义相关的实体
            similar_entities = kg.find_similar_entities(entity)
            for sim_entity in similar_entities[:self.max_expansion]:
                expanded.add(sim_entity)
        
        return list(expanded)
    
    def _structural_expansion(self, entities, kg):
        """
        结构扩展：基于图结构扩展
        """
        expanded = set(entities)
        
        for entity in entities:
            # 查找结构相关的实体
            related_entities = kg.find_structurally_related(entity)
            for rel_entity in related_entities[:self.max_expansion]:
                expanded.add(rel_entity)
        
        return list(expanded)
​

3.3 混合检索策略优化

3.3.1 向量-图混合检索

混合检索架构

class HybridRetriever:
    def __init__(self, vector_store, graph_store):
        self.vector_store = vector_store
        self.graph_store = graph_store
    
    def hybrid_search(self, query, alpha=0.7, beta=0.3):
        """
        混合检索：向量检索 + 图检索
        :param alpha: 向量检索权重
        :param beta: 图检索权重
        """
        # 1. 向量检索
        vector_results = self.vector_store.similarity_search(query)
        vector_scores = self._normalize_scores([r.score for r in vector_results])
        
        # 2. 图检索
        graph_results = self.graph_store.semantic_search(query)
        graph_scores = self._normalize_scores([r.score for r in graph_results])
        
        # 3. 结果融合
        combined_results = self._combine_results(
            vector_results, graph_results,
            vector_scores, graph_scores,
            alpha, beta
        )
        
        return combined_results
​

3.3.2 检索结果排序算法

多维度排序策略

class ResultRanker:
    def __init__(self):
        self.rank_weights = {
            'semantic_similarity': 0.4,
            'path_quality': 0.3,
            'recency': 0.2,
            'importance': 0.1
        }
    
    def rank_results(self, results):
        """
        多维度排序
        """
        scored_results = []
        
        for result in results:
            # 计算综合得分
            score = self._calculate_composite_score(result)
            scored_results.append((result, score))
        
        # 按得分排序
        scored_results.sort(key=lambda x: x[1], reverse=True)
        
        return [result for result, score in scored_results]
    
    def _calculate_composite_score(self, result):
        """
        计算综合得分
        """
        score = 0.0
        
        # 语义相似度得分
        semantic_score = result.get('semantic_similarity', 0)
        score += semantic_score * self.rank_weights['semantic_similarity']
        
        # 路径质量得分
        path_score = self._evaluate_path_quality(result.get('path', []))
        score += path_score * self.rank_weights['path_quality']
        
        # 新鲜度得分
        recency_score = self._evaluate_recency(result.get('timestamp'))
        score += recency_score * self.rank_weights['recency']
        
        # 重要性得分
        importance_score = self._evaluate_importance(result.get('importance'))
        score += importance_score * self.rank_weights['importance']
        
        return score
​

本章小结

本章详细介绍了GraphRAG检索引擎的核心技术，包括图语义检索、路径推理和混合检索策略。这些技术为GraphRAG系统提供了强大的语义理解和推理能力。下一章将讲解系统的架构设计和性能优化。

本章聚焦 GraphRAG 系统的核心引擎——检索模块。检索质量直接决定 GraphRAG 的最终效果，是整个系统中最关键、也最值得投入优化的部分。

传统 RAG 的检索是"一锤子买卖"：通过向量相似度找到最相关的文本片段，直接交给 LLM。GraphRAG 的检索则是"多层次探索"：从实体出发，沿关系边遍历图谱，发现隐式的关联路径，同时结合语义向量进行模糊匹配，最终将多路检索结果融合排序。这种多维度检索策略使 GraphRAG 能够回答传统 RAG 无法处理的复杂问题。

3.1 节讲解基于图的语义检索基础。我们从最基础的 BFS/DFS 图遍历算法出发，逐步引入 PageRank 排序、SimRank 相似度和图神经网络（GNN）嵌入等高级技术。这些算法的选择和组合，是检索质量的核心影响因素。特别值得关注的是混合检索策略——将图结构检索和向量语义检索通过 RRF 算法融合，实测表明可以比单一检索策略提升 15-30% 的准确率。

3.2 节深入路径推理与上下文扩展。路径推理是 GraphRAG 区别于传统 RAG 的标志性能力——通过分析实体间的关系路径，系统能够回答需要多跳推理的问题。例如"某公司的 CTO 之前在哪家公司任职"，传统 RAG 需要在同一篇文档中找到完整信息，而 GraphRAG 可以通过图谱遍历自动发现。上下文扩展则是在检索到核心实体后，自动补充相关实体的属性和关系信息，为 LLM 生成提供更丰富的上下文。

3.3 节讲解混合检索策略优化。混合检索的关键不在于用多少种检索器，而在于如何有效地融合多路结果。我们将详细介绍加权融合、倒数排名融合（RRF）和分数归一化融合三种策略的原理和实现，以及基于用户反馈的动态权重调整方法。

学习建议：3.1 是基础，务必理解透彻。3.2 和 3.3 可以根据实际需求选择性深入。如果你的应用场景以单跳查询为主，3.2 可以快速浏览；如果需要多跳推理，3.2 是重点。