1
# 传统 QFS 的问题
2

3
class TraditionalQFS:
4
    """
5
    以查询为重点的总结（Query-Focused Summarization）
6
    """
7

8
    def __init__(self):
9
        self.limitations = {
10
            "scale": "无法处理大量文档",
11
            "redundancy": "难以处理重复信息",
12
            "coherence": "跨文档连贯性差"
13
        }

1
class GraphRAGIndex:
2
    """GraphRAG 两阶段索引"""
3

4
    def __init__(self):
5
        self.graph = None
6
        self.communities = None
7
        self.summaries = None
8

9
    def build_index(self, documents):
10
        """
11
        阶段 1：图谱构建
12
        """
13
        # 1. 实体抽取
14
        entities = self.extract_entities(documents)
15

16
        # 2. 关系抽取
17
        relations = self.extract_relations(entities)
18

19
        # 3. 构建知识图谱
20
        graph = self.build_graph(entities, relations)
21

22
        # 4. 社区检测
23
        communities = self.detect_communities(graph)
24

25
        # 5. 社区摘要生成
26
        summaries = self.generate_summaries(communities)
27

28
        self.graph = graph
29
        self.communities = communities
30
        self.summaries = summaries
31

32
    def query(self, question):
33
        """
34
        阶段 2：查询回答
35
        """
36
        # 1. 找到相关社区
37
        relevant_communities = self.find_relevant_communities(question)
38

39
        # 2. 汇总社区摘要
40
        partial_answers = []
41
        for community in relevant_communities:
42
            answer = self.answer_from_community(question, community)
43
            partial_answers.append(answer)
44

45
        # 3. 最终汇总
46
        final_answer = self.finalize_answer(partial_answers)
47

48
        return final_answer

1
class EntityExtractor:
2
    """从文档中抽取实体"""
3

4
    def __init__(self, llm):
5
        self.llm = llm
6

7
    def extract(self, document):
8
        """
9
        使用 LLM 抽取实体
10
        """
11
        prompt = f"""
12
        从以下文本中抽取所有实体及其类型。
13

14
        文本：{document}
15

16
        输出格式：
17
        [
18
            {{"entity": "实体名", "type": "类型", "description": "描述"}},
19
            ...
20
        ]
21
        """
22

23
        entities = self.llm.generate(prompt)
24
        return self.parse_entities(entities)

1
class RelationExtractor:
2
    """抽取实体之间的关系"""
3

4
    def extract(self, entity1, entity2, context):
5
        """
6
        判断两个实体之间的关系
7
        """
8
        prompt = f"""
9
        给定以下两个实体和上下文，判断它们之间的关系。
10

11
        实体 1：{entity1}
12
        实体 2：{entity2}
13
        上下文：{context}
14

15
        可能的关系类型：
16
        - works_for
17
        - part_of
18
        - located_in
19
        - related_to
20
        - none
21

22
        关系：
23
        """
24

25
        relation = self.llm.generate(prompt)
26
        return relation

1
class CommunityDetector:
2
    """使用 Louvain 等算法检测社区"""
3

4
    def detect(self, graph):
5
        """
6
        检测图谱中的社区
7
        """
8
        # 使用 Louvain 算法
9
        import networkx as nx
10
        from community import community_louvain
11

12
        G = self.build_networkx_graph(graph)
13
        partition = community_louvain.best_partition(G)
14

15
        communities = {}
16
        for node, community_id in partition.items():
17
            if community_id not in communities:
18
                communities[community_id] = []
19
            communities[community_id].append(node)
20

21
        return communities

1
class CommunitySummarizer:
2
    """为每个社区生成摘要"""
3

4
    def __init__(self, llm):
5
        self.llm = llm
6

7
    def summarize(self, community, graph):
8
        """
9
        生成社区的描述性摘要
10
        """
11
        # 获取社区中的实体和关系
12
        entities = community.entities
13
        relations = community.relations
14

15
        prompt = f"""
16
        给定以下实体及其关系，生成一个简洁的社区描述。
17

18
        实体：
19
        {self.format_entities(entities)}
20

21
        关系：
22
        {self.format_relations(relations)}
23

24
        描述这个社区的核心主题、主要成员和关键关系：
25
        """
26

27
        summary = self.llm.generate(prompt)
28
        return summary

1
class GlobalQueryProcessor:
2
    """处理全局查询"""
3

4
    def __init__(self, index, llm):
5
        self.index = index
6
        self.llm = llm
7

8
    def answer(self, question):
9
        """
10
        回答全局问题
11
        """
12
        # 1. 根据问题找到相关社区
13
        relevant = self.index.find_communities_by_relevance(question)
14

15
        # 2. 从每个社区生成部分回答
16
        partial_answers = []
17
        for community in relevant:
18
            community_text = self.index.get_community_text(community)
19
            answer = self.llm.generate(
20
                f"基于以下信息回答问题：{question}\n\n{community_text}"
21
            )
22
            partial_answers.append(answer)
23

24
        # 3. 汇总所有部分回答
25
        final = self.llm.generate(
26
            f"将以下回答汇总成一个连贯的答案：\n\n" +
27
            "\n\n".join(partial_answers)
28
        )
29

30
        return final

1
class LocalQueryProcessor:
2
    """处理局部查询（传统 RAG）"""
3

4
    def answer(self, question):
5
        """
6
        回答局部问题
7
        """
8
        # 1. 向量检索找到相关文档
9
        docs = self.vector_store.search(question, top_k=5)
10

11
        # 2. 生成答案
12
        answer = self.llm.generate(
13
            f"基于以下文档回答问题：{question}\n\n{docs}"
14
        )
15

16
        return answer

1
# GraphRAG 在大数据集上的表现
2

3
performance = {
4
    "dataset_size": "100 万 token",
5
    "communities": 1000,
6
    "avg_community_size": "约 50 个实体",
7
    "query_response_time": "< 30 秒",
8
    "answer_quality": "优秀"
9
}