KNOWLEDGE GRAPH

Step 4: 定义属性

为每种实体类型指定需要记录的属性字段：

🧠 使用大语言模型 (LLM) 进行知识抽取

当前更高效的方式是结合 Prompt Engineering 直接让LLM抽取三元组：

从以下文本中抽取知识三元组，
格式为 (Subject, Predicate, Object)。

文本："特斯拉创始人埃隆·马斯克出生于南非，
后移居美国，现任特斯拉CEO。"

请输出三元组列表：

(埃隆·马斯克, 创始人, 特斯拉)
(埃隆·马斯克, 出生地, 南非)
(埃隆·马斯克, 居住地, 美国)
(埃隆·马斯克, 职位, 特斯拉CEO)

知名知识图谱项目

Step 1: 环境准备

# 方法一：Docker快速启动 (推荐)
docker run -d --name neo4j \
  -p 7474:7474 -p 7687:7687 \
  -e NEO4J_AUTH=neo4j/password \
  neo4j:latest

# 方法二：直接下载安装
# https://neo4j.com/download/

# 安装Neo4j Python驱动
pip install neo4j

# 安装NLP工具 (可选)
pip install spacy
python -m spacy download zh_core_web_sm

Step 2: 准备数据源

假设我们有以下电影数据（JSON格式）：

{
  "movies": [
    {
      "title": "盗梦空间",
      "year": 2010,
      "director": "克里斯托弗·诺兰",
      "actors": ["莱昂纳多·迪卡普里奥", "渡边谦"],
      "genre": "科幻"
    },
    {
      "title": "星际穿越",
      "year": 2014,
      "director": "克里斯托弗·诺兰",
      "actors": ["马修·麦康纳", "安娜·海瑟薇"],
      "genre": "科幻"
    }
  ]
}

Step 3: 构建知识图谱

使用 Python 将数据导入 Neo4j：

from neo4j import GraphDatabase

# 1. 连接Neo4j数据库
driver = GraphDatabase.driver(
    "bolt://localhost:7687",
    auth=("neo4j", "password")
)

# 2. 定义创建节点和关系的函数
def create_movie_graph(tx, movie_data):
    # 创建电影节点
    tx.run("""
        MERGE (m:Movie {title: $title})
        SET m.year = $year, m.genre = $genre
    """, title=movie_data['title'],
         year=movie_data['year'],
         genre=movie_data['genre'])

    # 创建导演节点和关系
    tx.run("""
        MERGE (d:Person {name: $director})
        MERGE (m:Movie {title: $title})
        MERGE (d)-[:DIRECTED]->(m)
    """, director=movie_data['director'],
         title=movie_data['title'])

    # 创建演员节点和关系
    for actor in movie_data['actors']:
        tx.run("""
            MERGE (a:Person {name: $actor})
            MERGE (m:Movie {title: $title})
            MERGE (a)-[:ACTED_IN]->(m)
        """, actor=actor, title=movie_data['title'])

# 3. 执行导入
with driver.session() as session:
    for movie in movies_data['movies']:
        session.execute_write(create_movie_graph, movie)

print("✅ 知识图谱构建完成!")
driver.close()

Step 4: 可视化图谱

访问 Neo4j Browser http://localhost:7474，执行以下查询查看图谱：

MATCH (n) RETURN n LIMIT 50

🔗 知识图谱 + LLM 融合

当前研究热点：将知识图谱与大语言模型结合，缓解LLM的"幻觉"问题。

#!/usr/bin/env python3
"""
知识图谱完整示例 - 电影图谱构建与查询
Prerequisites:
  1. docker run -d --name neo4j -p 7474:7474 -p 7687:7687 -e NEO4J_AUTH=neo4j/password neo4j:latest
  2. pip install neo4j
"""

from neo4j import GraphDatabase
import json

# ============ 配置区 ============
NEO4J_URI = "bolt://localhost:7687"
NEO4J_USER = "neo4j"
NEO4J_PASSWORD = "password"

# ============ 数据源 ============
MOVIES_DATA = {
    "movies": [
        {
            "title": "盗梦空间",
            "year": 2010,
            "director": "克里斯托弗·诺兰",
            "actors": ["莱昂纳多·迪卡普里奥", "渡边谦", "约瑟夫·高登-莱维特"],
            "genre": "科幻"
        },
        {
            "title": "星际穿越",
            "year": 2014,
            "director": "克里斯托弗·诺兰",
            "actors": ["马修·麦康纳", "安娜·海瑟薇"],
            "genre": "科幻"
        },
        {
            "title": "泰坦尼克号",
            "year": 1997,
            "director": "詹姆斯·卡梅隆",
            "actors": ["莱昂纳多·迪卡普里奥", "凯特·温斯莱特"],
            "genre": "爱情"
        }
    ]
}

# ============ 数据库操作类 ============
class MovieKnowledgeGraph:
    def __init__(self, uri, user, password):
        self.driver = GraphDatabase.driver(uri, auth=(user, password))

    def close(self):
        self.driver.close()

    # 清空数据库
    def clear_database(self):
        with self.driver.session() as session:
            session.run("MATCH (n) DETACH DELETE n")
            print("✅ 数据库已清空")

    # 创建电影图谱
    def create_movie(self, movie):
        with self.driver.session() as session:
            # 创建电影节点
            session.run("""
                MERGE (m:Movie {title: $title})
                SET m.year = $year, m.genre = $genre
            """, title=movie['title'], year=movie['year'], genre=movie['genre'])

            # 创建导演节点和关系
            session.run("""
                MERGE (d:Person {name: $director})
                SET d.role = 'Director'
                MERGE (m:Movie {title: $title})
                MERGE (d)-[:DIRECTED]->(m)
            """, director=movie['director'], title=movie['title'])

            # 创建演员节点和关系
            for actor in movie['actors']:
                session.run("""
                    MERGE (a:Person {name: $actor})
                    SET a.role = 'Actor'
                    MERGE (m:Movie {title: $title})
                    MERGE (a)-[:ACTED_IN]->(m)
                """, actor=actor, title=movie['title'])

    # 查询: 某导演的所有电影
    def get_movies_by_director(self, director_name):
        with self.driver.session() as session:
            result = session.run("""
                MATCH (d:Person)-[:DIRECTED]->(m:Movie)
                WHERE d.name = $name
                RETURN m.title AS title, m.year AS year
            """, name=director_name)
            return [record.data() for record in result]

    # 查询: 某演员的合作者
    def get_co_actors(self, actor_name):
        with self.driver.session() as session:
            result = session.run("""
                MATCH (a1:Person)-[:ACTED_IN]->(m:Movie)<-[:ACTED_IN]-(a2:Person)
                WHERE a1.name = $name AND a1 <> a2
                RETURN DISTINCT a2.name AS co_actor, m.title AS movie
            """, name=actor_name)
            return [record.data() for record in result]

    # 查询: 电影推荐
    def recommend_movies(self, movie_title, limit=5):
        with self.driver.session() as session:
            result = session.run("""
                MATCH (m1:Movie {title: $title})<-[:ACTED_IN]-(a:Person)-[:ACTED_IN]->(m2:Movie)
                WHERE m1 <> m2
                RETURN m2.title AS recommended, COUNT(a) AS common_actors
                ORDER BY common_actors DESC LIMIT $limit
            """, title=movie_title, limit=limit)
            return [record.data() for record in result]

    # 查询: 统计信息
    def get_statistics(self):
        with self.driver.session() as session:
            result = session.run("""
                MATCH (m:Movie) WITH COUNT(m) AS movies
                MATCH (p:Person) WITH movies, COUNT(p) AS persons
                MATCH ()-[r]->() WITH movies, persons, COUNT(r) AS relations
                RETURN movies, persons, relations
            """)
            return result.single().data()

# ============ 主程序 ============
if __name__ == "__main__":
    print("\n🎬 电影知识图谱演示\n" + "="*40)

    # 1. 初始化
    kg = MovieKnowledgeGraph(NEO4J_URI, NEO4J_USER, NEO4J_PASSWORD)

    try:
        # 2. 清空并构建图谱
        kg.clear_database()
        print("\n🛠️  构建图谱中...")
        for movie in MOVIES_DATA['movies']:
            kg.create_movie(movie)
            print(f"  + 已添加: {movie['title']}")

        # 3. 统计信息
        stats = kg.get_statistics()
        print(f"\n📊 图谱统计: 电影{stats['movies']}部, 人物{stats['persons']}个, 关系{stats['relations']}条")

        # 4. 查询演示
        print("\n" + "="*40)
        print("🔍 查询演示")

        # 查询诺兰的电影
        print("\n▶ 诺兰执导的电影:")
        for m in kg.get_movies_by_director("克里斯托弗·诺兰"):
            print(f"  - {m['title']} ({m['year']})")

        # 查询迪卡普里奥的合作者
        print("\n▶ 迪卡普里奥的合作演员:")
        for c in kg.get_co_actors("莱昂纳多·迪卡普里奥"):
            print(f"  - {c['co_actor']} (在《{c['movie']}》)")

        # 电影推荐
        print("\n▶ 看过《盗梦空间》的推荐:")
        for r in kg.recommend_movies("盗梦空间"):
            print(f"  - {r['recommended']} (共同演员:{r['common_actors']})")

        print("\n✅ 演示完成! 访问 http://localhost:7474 查看可视化图谱")

    finally:
        kg.close()