手把手教你构建基于知识图谱的GraphRAG之结构化数据篇【LangChain+Neo4j】

docker run \
    -p 7474:7474 -p 7687:7687 \
    -v $PWD/data:/data -v $PWD/plugins:/plugins \
    --name neo4j-apoc \
    -e NEO4J_apoc_export_file_enabled=true \
    -e NEO4J_apoc_import_file_enabled=true \
    -e NEO4J_apoc_import_file_use__neo4j__config=true \
    -e NEO4JLABS_PLUGINS=\[\"apoc\"\] \
    neo4j:latest

import pandas as pd
import mysql.connector
from neo4j import GraphDatabase

def fetch_table_data(table_name):
    cnx = mysql.connector.connect(
        host='你的mysql主机',
        user='你的mysql用户',
        password='******',
        database='sales'
    )
    cursor = cnx.cursor()
    query = f"SELECT * FROM {table_name}"
    cursor.execute(query)
    rows = cursor.fetchall()
    column_names = [desc[0] for desc in cursor.description]
    df = pd.DataFrame(rows, columns=column_names)
    cursor.close()
    cnx.close()
    return df

# 读取到dataframe
orders_df = fetch_table_data("orders")
customers_df = fetch_table_data("customers")
products_df = fetch_table_data("products")
salespersons_df = fetch_table_data("salespersons")
departs_df = fetch_table_data("departs")

def create_unique_nodes_from_dataframe(df, label, unique_id_property):
    # 连接到Neo4j数据库
    driver = GraphDatabase.driver("bolt://localhost:7687", auth=("neo4j", "******"))
    # 创建一个会话来执行Cypher查询
    with driver.session() as session:
        # 遍历DataFrame中的每一行
        for _, row in df.iterrows():
            # 从行中获取唯一id的值
            unique_id_value = row[unique_id_property]
            # 检查是否已经存在具有相同唯一id的节点
            query = f"MATCH (n:{label} {{{unique_id_property}: '{unique_id_value}'}}) RETURN n"
            result = session.run(query)
            if result.single() is not None:
                # 已经存在具有相同唯一id的节点，跳过创建新节点
                continue
            # 创建一个Cypher查询来创建具有给定标签和属性的节点
            properties = ", ".join(f"{key}: '{value}'" for key, value in row.to_dict().items())
            query = f"CREATE (n:{label} {{ {properties} }})"
            # 执行Cypher查询
            session.run(query)

# 为订单创建节点
create_unique_nodes_from_dataframe(orders_df, "Order","order_id")
create_unique_nodes_from_dataframe(customers_df, "Customer","customer_id")
create_unique_nodes_from_dataframe(products_df, "Product","product_id")
create_unique_nodes_from_dataframe(salespersons_df, "Salesperson","salesperson_id")
create_unique_nodes_from_dataframe(departs_df, "Depart","depart_id")

def create_relationships():
    # 连接到Neo4j数据库
    driver = GraphDatabase.driver("bolt://localhost:7687", auth=("neo4j", "******"))
    # 创建一个会话来执行Cypher查询
    with driver.session() as session:
        # 在顾客和订单之间创建关系
        query = "MATCH (c:Customer), (o:Order) WHERE c.customer_id = o.customer_id MERGE (c)-[:ORDERED]->(o)"
        session.run(query)
       
        # 在销售人员和订单之间创建关系
        query = "MATCH (s:Salesperson), (o:Order) WHERE s.salesperson_id = o.salesperson_id MERGE (s)-[:CREATED]->(o)"
        session.run(query)

        # 在产品和订单之间创建关系
        query = "MATCH (p:Product), (o:Order) WHERE p.product_id = o.product_id MERGE (p)-[:IS_ORDERED_IN]->(o)"
        session.run(query)

        # 在销售人员和部门之间创建关系
        query = "MATCH (s:Salesperson), (d:Depart) WHERE s.depart_id = d.depart_id MERGE (s)-[:BELONGS]->(d)"
        session.run(query)

# 调用函数来创建关系
create_relationships()

from langchain.prompts import PromptTemplate
cypher_generation_template = """
任务：
为Neo4j图数据库生成Cypher查询。
说明：
仅使用提供的模式中的关系类型和属性。
不要使用任何未提供的其他关系类型或属性。
模式：
{schema}
注意：
在回答中不要包含任何解释或道歉。
不要回答任何可能要求你构建除Cypher语句之外的任何文本的问题。
确保查询中的关系方向是正确的。
确保正确地为实体和关系设置别名。
不要运行会向数据库添加或删除内容的任何查询。
确保将后续所有语句都设置别名为with语句。
如果需要除法运算，请确保将分母过滤为非零值。
问题是：
{question}
"""

cypher_generation_prompt = PromptTemplate(
    input_variables=["schema", "question"], template=cypher_generation_template
)

qa_generation_template = """您是一个助手，根据Neo4j Cypher查询的结果生成人类可读的响应。
查询结果部分包含基于用户自然语言问题生成的Cypher查询的结果。
提供的信息是权威的，您绝不能怀疑它或尝试使用内部知识来纠正它。
使答案听起来像对问题的回答。
查询结果：
{context}
问题：
{question}
如果提供的信息为空，请说您不知道答案。
空信息的样子是这样的：[]
如果信息不为空，您必须使用结果提供答案。
如果问题涉及时间持续时间，请假设查询结果以天为单位，除非另有说明。
如果查询结果中有数据，永远不要说您没有正确的信息。始终使用查询结果中的数据。
有用的回答：
"""

qa_generation_prompt = PromptTemplate(
    input_variables=["context", "question"], template=qa_generation_template
)

from langchain_community.graphs import Neo4jGraph
from langchain.chains import GraphCypherQAChain
from langchain_openai import ChatOpenAI

graph = Neo4jGraph(
    url="bolt://localhost:7687",
    username="neo4j",
    password="******",
)

graph.refresh_schema()

hospital_cypher_chain = GraphCypherQAChain.from_llm(
    cypher_llm=ChatOpenAI(model='gpt-4o'),
    qa_llm=ChatOpenAI(model='gpt-4o'),
    graph=graph,
    verbose=True,
    qa_prompt=qa_generation_prompt,
    cypher_prompt=cypher_generation_prompt,
    validate_cypher=True,
    top_k=100,
)

response = hospital_cypher_chain.invoke("黄彬伟订购了哪些产品?总金额是多少")
print(response['result'])

response = hospital_cypher_chain.invoke("对比下不同产品的销售总额")
print(response['result'])

response = hospital_cypher_chain.invoke("销售金额最高的是哪一个产品？")
print(response['result'])