GraphRAG本地部署指南及漫谈企业知识库的规划考量，大模型入门到精通，收藏这篇就足够了！

关注

原创最新推荐文章于 2026-03-12 10:07:43 发布 752 阅读 AI 写同款· GEO 优化 ›

傻瓜操作：GraphRAG、Ollama 本地部署及踩坑记录这里按惯例介绍一下 GraphRAG (其实就是水字数，大部分是 GPT 写的)这是我踩的最大的坑，折腾了两个小时。原因是一些模型无法生成有效的 json 输出，将 settings.yaml 中的 model_supports_json 选项设为 false 仍然无法解决。后来改用 mistral 模型就很顺利。所以请注意你的模型。阅读详情

1 引言

在人工智能时代，通用大模型虽然能力强大，却难以满足企业对垂直领域知识的精准需求。因此，采用“大模型 + RAG”技术构建专属企业知识库，已从技术选项升级为企业人工智能进化的刚需。其核心意义在于，将分散、静态的信息资产转化为一个可实时交互的“企业数字大脑”。这一系统不仅能深度整各个信息孤岛的知识，让员工通过自然语言秒级获取精准答案，更实现了由AI训练带来的隐性经验的显性沉淀与专家能力的大规模复制。打破了部门壁垒，岗位固化形成了统一且持续进化的组织记忆，从而将知识库从传统的“成本中心”，重塑为驱动创新、决策与业务增长的“核心价值引擎”，为企业构筑起难以逾越的竞争壁垒。

RAG，又称检索增强生成（Retrieval Augumented Generation）。RAG目前已经成为大语言模型应用的核心组件之一，利用检索到的内容，无论是相似度检索，还是传统搜索、搜索引擎来增强大语言模型的外部知识。今天我们介绍下利用GraphRag搭建企业知识库的实操。

2 什么GraphRag

GraphRAG 字面意义理解就是使用知识图谱的检索增强生成（RAG），当然字面还有其他含义，那么，GraphRAG 到底是什么？

对我们来说，它是一组利用图形结构进行检索的 RAG 模式。每种模式都需要独特的数据结构或图形模式才能有效运行。

3 本次部署GraphRag的应用流程图

架构组件说明：

langchain：指挥中心，管理整个工作流

py2neo：数据管家，负责图谱的CRUD操作

sentence-transformers：语义理解专家，提供智能检索能力

这三个库共同构成了GraphRAG系统的技术基石，分别解决了"流程协调"、"知识存储"和"语义理解"这三个核心问题。

4部署实操

4.1 本地大模型、数据库软件及包安装

✓ 本地大模型：Ollama：deepseek-r1:1.5b

✓ Neo4j数据库安装，官网访问下载安装即可

创建数据库实例

4.2 编写graphrag_main.py代码

import os
import re
from langchain_ollama import OllamaLLM
from langchain_core.documents import Document
from py2neo import Graph, Node, Relationship
import hashlib
# 配置
NEO4J_URI = "bolt://localhost:7687"
NEO4J_USER = "neo4j"
NEO4J_PASSWORD = "neo4j123"  # 替换为你的密码
class GraphRAGSystem:
def __init__(self):
"""初始化GraphRAG系统"""
# 初始化LLM
print("初始化LLM...")
self.llm = OllamaLLM(model="deepseek-r1:1.5b")
print("LLM初始化完成")
# 连接Neo4j
print("连接Neo4j数据库...")
try:
# 先尝试简单连接测试
from py2neo import Graph, Node, Relationship, Transaction
self.graph = Graph(NEO4J_URI, auth=(NEO4J_USER, NEO4J_PASSWORD))
# 执行简单查询测试连接
test_query = "RETURN '连接测试成功' AS result"
result = self.graph.run(test_query).evaluate()
print(f"Neo4j连接测试成功: {result}")
# 检查数据库状态
node_count = self.graph.run("MATCH (n) RETURN count(n) as count").evaluate()
rel_count = self.graph.run("MATCH ()-[r]->() RETURN count(r) as count").evaluate()
print(f"Neo4j数据库当前状态: {node_count}个节点, {rel_count}个关系")
except Exception as e:
print(f"Neo4j连接失败: {e}")
# 尝试使用更简单的连接方式
try:
# 尝试不使用auth参数（如果数据库配置为无需认证）
self.graph = Graph(NEO4J_URI)
print("尝试无认证连接Neo4j...")
test_query = "RETURN '连接测试成功' AS result"
result = self.graph.run(test_query).evaluate()
print(f"Neo4j无认证连接测试成功: {result}")
except Exception as e2:
print(f"无认证连接也失败: {e2}")
# 提供一个模拟的图对象，以便代码可以继续运行进行测试
print("创建模拟图对象用于测试...")
self.graph = MockGraph()
print("GraphRAG系统初始化完成")
def clear_graph(self):
"""清空现有图谱"""
self.graph.run("MATCH (n) DETACH DELETE n")
def chunk_documents(self, text, chunk_size=500):
"""文档分块"""
words = text.split()
chunks = []
for i in range(0, len(words), chunk_size):
chunk = ' '.join(words[i:i+chunk_size])
chunks.append(Document(
page_content=chunk,
metadata={"chunk_id": len(chunks)}
))
return chunks
def extract_entities_relations(self, text):
"""使用LLM抽取实体和关系"""
prompt = f"""
请精确地从以下文本中提取实体和关系，并严格按照指定格式返回：
## 输出格式要求（非常重要）
实体: [实体1, 实体2, 实体3, ...]
关系: [(实体A, 关系类型, 实体B), (实体C, 关系类型, 实体D), ...]
请确保：
1. 只返回上述两个字段，不要添加其他解释或文本
2. 实体名称要精确提取，不要添加额外的描述
3. 关系类型要简洁明了
4. 所有内容都用中文返回
文本: {text}
"""
try:
response = self.llm.invoke(prompt)
print(f"LLM响应: {response}")  # 添加调试输出
entities, relations = self.parse_llm_response(response)
print(f"提取的实体: {entities}")  # 添加调试输出
print(f"提取的关系: {relations}")  # 添加调试输出
return entities, relations
except Exception as e:
print(f"实体抽取失败: {e}")
return [], []
def parse_llm_response(self, response):
"""解析LLM返回的实体和关系"""
entities = []
relations = []
print(f"开始解析LLM响应: {response[:100]}...")
# 1. 尝试JSON格式解析
try:
# 查找JSON格式的响应部分
json_match = re.search(r'\{[^}]*"实体"[^}]*\}', response)
if json_match:
import json
json_data = json.loads(json_match.group())
# 提取实体
if "实体" in json_data:
entities = json_data["实体"]
if isinstance(entities, str):
# 如果是字符串格式，尝试分割
entities = [e.strip() for e in entities.strip('[]').split(',') if e.strip()]
# 提取关系
if "关系" in json_data:
relations_data = json_data["关系"]
# 处理不同格式的关系数据
if isinstance(relations_data, list):
for rel_item in relations_data:
# 检查是否是嵌套列表
if isinstance(rel_item, list):
for rel_tuple in rel_item:
if isinstance(rel_tuple, (list, tuple)) and len(rel_tuple) >= 3:
relations.append((rel_tuple[0], rel_tuple[1], rel_tuple[2]))
# 检查是否已经是三元组
elif isinstance(rel_item, (list, tuple)) and len(rel_item) >= 3:
relations.append((rel_item[0], rel_item[1], rel_item[2]))
if entities or relations:
print(f"JSON解析成功 - 实体: {entities}, 关系: {relations}")
return entities, relations
except Exception as e:
print(f"JSON解析失败: {e}")
# 2. 尝试直接文本格式解析
try:
# 查找实体列表
entities_match = re.search(r'实体:[\s\[\]]*(.+?)(?=\n|$)', response, re.DOTALL)
if entities_match:
# 可能的格式："[实体1, 实体2]" 或 "实体1, 实体2"
entities_text = entities_match.group(1).strip().strip('[]')
entities = [e.strip() for e in entities_text.split(',') if e.strip()]
print(f"文本解析实体: {entities}")
# 查找关系列表
relations_match = re.search(r'关系:[\s\[\]]*(.+?)(?=\n|$)', response, re.DOTALL)
if relations_match:
relations_text = relations_match.group(1).strip()
# 尝试提取所有的三元组格式，包括(实体1, 关系, 实体2)或["实体1", "关系", "实体2"]等
relation_tuples = re.findall(r'\(([^()]+)\)', relations_text)
for rel_tuple in relation_tuples:
# 处理可能包含引号的情况
parts = []
if '"' in rel_tuple:
# 提取引号中的内容
quoted_parts = re.findall(r'"([^"]+)"', rel_tuple)
parts = quoted_parts
elif '\'' in rel_tuple:
quoted_parts = re.findall(r"'([^']+)',?", rel_tuple)
parts = quoted_parts
else:
# 简单分割
parts = [p.strip() for p in rel_tuple.split(',')]
if len(parts) >= 3:
relations.append((parts[0], parts[1], parts[2]))
print(f"文本解析关系: {relations}")
except Exception as e:
print(f"文本解析失败: {e}")
# 3. 如果还是没有解析到，尝试直接从响应中提取
if not entities:
try:
# 尝试提取所有可能的实体名称
possible_entities = re.findall(r'["\']([^"\']+)["\']', response)
# 过滤掉太短的或明显不是实体的词
entities = [e for e in possible_entities if len(e) > 1 and e not in ['实体', '关系']]
print(f"备用解析实体: {entities}")
except:
pass
# 4. 检查是否有明确的三元组格式
if not relations:
try:
# 查找类似 (A, B, C) 的格式
triples = re.findall(r'\(\s*["\']?([^,"\']+)["\']?\s*,\s*["\']?([^,"\']+)["\']?\s*,\s*["\']?([^,"\']+)["\']?\s*\)', response)
for triple in triples:
if len(triple) >= 3 and all(triple):
relations.append((triple[0].strip(), triple[1].strip(), triple[2].strip()))
print(f"备用解析关系: {relations}")
except:
pass
print(f"最终解析结果 - 实体: {entities}, 关系: {relations}")
return entities, relations
def build_knowledge_graph(self, documents):
"""构建知识图谱"""
total_entities = 0
total_relations = 0
print("开始构建知识图谱...")
# 尝试使用事务来提高性能和可靠性
try:
# 检查是否可以使用事务
if hasattr(self.graph, 'begin'):
tx = self.graph.begin()
print("使用事务进行图谱构建...")
else:
tx = None
print("直接使用图对象进行构建...")
for doc in documents:
print(f"处理文档块: {doc.page_content[:100]}...")
entities, relations = self.extract_entities_relations(doc.page_content)
print(f"  提取到实体: {entities}")
print(f"  提取到关系: {relations}")
# 创建实体节点
for entity in entities:
try:
node = Node("Entity", name=entity, id=hashlib.md5(entity.encode()).hexdigest()[:8])
if tx:
tx.merge(node, "Entity", "name")
else:
self.graph.merge(node, "Entity", "name")
print(f"  创建/更新实体: {entity}")
total_entities += 1
except Exception as e:
print(f"  创建实体 {entity} 失败: {e}")
# 创建关系
for rel in relations:
try:
source, relationship, target = rel
print(f"  创建关系: {source} - {relationship} - {target}")
# 先确保两个实体都存在
source_node = Node("Entity", name=source)
target_node = Node("Entity", name=target)
if tx:
tx.merge(source_node, "Entity", "name")
tx.merge(target_node, "Entity", "name")
# 创建关系
rel_query = """
MATCH (a:Entity {name: $source})
MATCH (b:Entity {name: $target})
MERGE (a)-[r:RELATION {type: $rel_type}]->(b)
"""
tx.run(rel_query, source=source, target=target, rel_type=relationship)
print(f"  关系创建成功: {source} - {relationship} - {target}")
total_relations += 1
else:
# 直接使用图对象
self.graph.merge(source_node, "Entity", "name")
self.graph.merge(target_node, "Entity", "name")
rel_query = """
MATCH (a:Entity {name: $source})
MATCH (b:Entity {name: $target})
MERGE (a)-[r:RELATION {type: $rel_type}]->(b)
RETURN r
"""
result = self.graph.run(rel_query, source=source, target=target, rel_type=relationship).data()
if result:
print(f"  关系创建成功: {source} - {relationship} - {target}")
total_relations += 1
else:
print(f"  关系创建失败: {source} - {relationship} - {target}")
except Exception as e:
print(f"  创建关系 {rel} 失败: {e}")
# 提交事务
if tx:
tx.commit()
print("事务提交成功")
except Exception as e:
print(f"知识图谱构建过程中出错: {e}")
# 如果有事务，回滚
if tx:
try:
tx.rollback()
print("事务回滚成功")
except:
pass
# 验证图谱中的节点和关系数量
try:
node_count = self.graph.run("MATCH (n) RETURN count(n) as count").evaluate()
rel_count = self.graph.run("MATCH ()-[r]->() RETURN count(r) as count").evaluate()
print(f"\n知识图谱统计:\n  创建的实体总数: {total_entities}")
print(f"  创建的关系总数: {total_relations}")
print(f"  图谱中实际节点数: {node_count}")
print(f"  图谱中实际关系数: {rel_count}")
except Exception as e:
print(f"获取图谱统计信息失败: {e}")
def test_neo4j_connection(self):
"""测试Neo4j连接和基本操作"""
print("\n测试Neo4j连接和基本操作...")
try:
# 创建测试节点
test_node = Node("Test", name="TestNode")
result = self.graph.merge(test_node, "Test", "name")
print("创建测试节点成功")
# 查询测试节点
query = "MATCH (n:Test {name: 'TestNode'}) RETURN n.name"
result = self.graph.run(query).evaluate()
print(f"查询测试节点结果: {result}")
# 删除测试节点
delete_query = "MATCH (n:Test {name: 'TestNode'}) DELETE n"
self.graph.run(delete_query)
print("删除测试节点成功")
return True
except Exception as e:
print(f"Neo4j测试操作失败: {e}")
return False
def query_graph(self, question):
"""在图谱中检索相关信息"""
print(f"\n查询问题: {question}")
# 首先提取问题中的关键实体
entities, _ = self.extract_entities_relations(question)
print(f"问题中的实体: {entities}")
if not entities:
return "未找到相关实体信息"
# 构建查询，获取相关子图
context = ""
for entity in entities[:2]:  # 取前两个实体
print(f"查询实体: {entity} 的相关信息")
# 检查实体是否存在
exists = self.graph.run("MATCH (n:Entity {name: $entity}) RETURN count(n) > 0 as exists", entity=entity).evaluate()
print(f"  实体 {entity} 在图谱中存在: {exists}")
# 扩展查询，包括双向关系和更多上下文
query = """
MATCH (a:Entity {name: $entity})-[r]-(b:Entity)
RETURN a.name as source, type(r) as relation_type, r.type as relation, b.name as target
UNION
MATCH (b:Entity)-[r]-(a:Entity {name: $entity})
RETURN b.name as source, type(r) as relation_type, r.type as relation, a.name as target
LIMIT 15
"""
results = self.graph.run(query, entity=entity)
result_count = 0
for record in results:
# 确保我们有所有必要的字段
source = record.get('source', '未知')
rel_type = record.get('relation', record.get('relation_type', '相关'))
target = record.get('target', '未知')
rel_info = f"{source} - {rel_type} - {target}"
context += rel_info + "\n"
print(f"  找到关系: {rel_info}")
result_count += 1
if result_count == 0:
print(f"  未找到实体 {entity} 的相关关系")
# 如果context为空，尝试更广泛的查询
if not context.strip():
print("尝试更广泛的查询...")
# 对问题中的关键词进行模糊匹配
for keyword in entities[:2]:
fuzzy_query = """
MATCH (n:Entity)
WHERE toLower(n.name) CONTAINS toLower($keyword)
RETURN n.name as entity
LIMIT 5
"""
fuzzy_results = self.graph.run(fuzzy_query, keyword=keyword)
for record in fuzzy_results:
fuzzy_entity = record.get('entity')
if fuzzy_entity != keyword:
print(f"  发现相似实体: {fuzzy_entity}")
print(f"查询返回的上下文长度: {len(context)} 字符")
return context
def answer_question(self, question):
"""回答问题"""
context = self.query_graph(question)
if not context or len(context) < 10:
return "抱歉，我在知识库中没有找到足够的信息来回答这个问题。"
prompt = f"""
基于以下知识图谱信息：
{context}
问题：{question}
请根据提供的知识图谱信息，给出准确、简洁的回答。如果信息不足，请明确表示不知道。
"""
try:
print("生成回答中...")
answer = self.llm.invoke(prompt)
print(f"生成的回答: {answer}")
return answer
except Exception as e:
print(f"生成回答时出错: {e}")
return f"生成回答时出错: {e}"
# 使用示例
# 模拟图对象，用于连接失败时的测试
class MockGraph:
def __init__(self):
self.nodes = {}
self.relations = []
print("使用模拟图对象，所有操作将在内存中进行")
def merge(self, node, label, property_key):
if label not in self.nodes:
self.nodes[label] = {}
node_id = node.get(property_key)
self.nodes[label][node_id] = node
return node
def run(self, query, **parameters):
if "RETURN '连接测试成功'" in query:
return MockResult([{'result': '连接测试成功'}])
elif "RETURN count(n) as count" in query and "MATCH (n)" in query:
total = sum(len(nodes) for nodes in self.nodes.values())
return MockResult([{'count': total}])
elif "RETURN count(r) as count" in query and "MATCH ()-[r]->()" in query:
return MockResult([{'count': len(self.relations)}])
elif "MERGE" in query and "RELATION" in query:
source = parameters.get('source')
target = parameters.get('target')
rel_type = parameters.get('rel_type')
self.relations.append((source, rel_type, target))
return MockResult([{'r': {'type': rel_type}}])
elif "MATCH" in query and "RETURN" in query:
# 简单模拟查询
entity = parameters.get('entity')
if entity:
results = []
for rel in self.relations:
if rel[0] == entity:
results.append({'source': rel[0], 'relation': rel[1], 'target': rel[2]})
elif rel[2] == entity:
results.append({'source': rel[2], 'relation': rel[1], 'target': rel[0]})
return MockResult(results)
return MockResult([])
def begin(self):
return self
def commit(self):
pass
def rollback(self):
pass
class MockResult:
def __init__(self, data):
self.data_list = data
def data(self):
return self.data_list
def evaluate(self):
if self.data_list:
first_key = list(self.data_list[0].keys())[0]
return self.data_list[0][first_key]
return None
def __iter__(self):
return iter(self.data_list)
def main():
print("启动GraphRAG系统...")
# 初始化系统
rag_system = GraphRAGSystem()
# 测试Neo4j连接
if hasattr(rag_system, 'test_neo4j_connection'):
rag_system.test_neo4j_connection()
# 准备示例文本
sample_texts = [
"苹果公司由史蒂夫·乔布斯、史蒂夫·沃兹尼亚克和罗纳德·韦恩于1976年创立。苹果公司的主要产品包括iPhone、iPad和Mac电脑。蒂姆·库克是苹果公司的现任CEO。",
"微软公司由比尔·盖茨和保罗·艾伦创立。微软开发了Windows操作系统和Office办公软件。萨提亚·纳德拉是微软的现任CEO。",
"谷歌由拉里·佩奇和谢尔盖·布林创立。谷歌开发了Android操作系统和Chrome浏览器。桑达尔·皮查伊是谷歌的CEO。"
]
print(f"\n准备处理 {len(sample_texts)} 条示例文本")
# 构建知识图谱
print("\n开始构建知识图谱...")
for text in sample_texts:
chunks = rag_system.chunk_documents(text)
rag_system.build_knowledge_graph(chunks)
print("知识图谱构建完成！")
# 测试问题
questions = [
"苹果公司的创始人是谁？",
"微软的CEO是谁？",
"谷歌开发了哪些产品？"
]
# 回答问题
print("\n开始回答问题...")
for question in questions:
print(f"\n处理问题: {question}")
answer = rag_system.answer_question(question)
print(f"问题: {question}")
print(f"回答: {answer}")
if __name__ == "__main__":
main()

运行结果：