Neo4j实战：AI应用中的图数据库

原创灵阙教研团队

S 精选进阶教程 | 约 7 分钟阅读更新于 2026-02-28

AI 导读

Neo4j实战：AI应用中的图数据库 Cypher查询基础、图建模模式、GDS算法、向量索引与LLM集成工程指南引言...

Neo4j实战：AI应用中的图数据库

Cypher查询基础、图建模模式、GDS算法、向量索引与LLM集成工程指南

引言

图数据库在AI应用中的角色正在从"辅助存储"升级为"核心推理引擎"。Neo4j作为图数据库领域的领导者，通过原生向量索引、图数据科学库（GDS）和LLM集成工具链，成为知识图谱、GraphRAG和智能推荐系统的首选技术栈。本文将从Cypher基础到高级AI集成，覆盖Neo4j在AI应用中的完整实践路径。

Cypher查询基础

核心语法

Cypher是Neo4j的声明式图查询语言，其设计哲学是"让图查询像画图一样直观"。

// === 节点和关系创建 ===

// 创建节点
CREATE (p:Person {name: 'Zhang Wei', age: 35, title: 'CTO'})
CREATE (c:Company {name: 'TechCorp', founded: 2020, industry: 'AI'})

// 创建关系
MATCH (p:Person {name: 'Zhang Wei'}), (c:Company {name: 'TechCorp'})
CREATE (p)-[:WORKS_AT {since: 2021, role: 'CTO'}]->(c)

// === 查询模式 ===

// 基础匹配
MATCH (p:Person)-[:WORKS_AT]->(c:Company)
WHERE c.industry = 'AI'
RETURN p.name, c.name, p.title

// 多跳查询（朋友的朋友）
MATCH (a:Person {name: 'Zhang Wei'})-[:KNOWS*2]->(fof:Person)
WHERE fof <> a
RETURN DISTINCT fof.name

// 变长路径
MATCH path = (a:Person)-[:REPORTS_TO*1..5]->(ceo:Person {title: 'CEO'})
RETURN path, length(path) AS depth

// 最短路径
MATCH path = shortestPath(
    (a:Person {name: 'Zhang Wei'})-[:KNOWS*]-(b:Person {name: 'Li Na'})
)
RETURN path, length(path)

// 聚合与排序
MATCH (c:Company)<-[:WORKS_AT]-(p:Person)
RETURN c.name, count(p) AS employee_count, collect(p.name) AS employees
ORDER BY employee_count DESC
LIMIT 10

常用查询模式

// 模式1: 推荐（协同过滤）
// 找到和我看过相同电影的人，推荐他们看过但我没看过的电影
MATCH (me:Person {name: 'Zhang Wei'})-[:WATCHED]->(m:Movie)<-[:WATCHED]-(other:Person)
MATCH (other)-[:WATCHED]->(rec:Movie)
WHERE NOT (me)-[:WATCHED]->(rec)
RETURN rec.title, count(other) AS score
ORDER BY score DESC
LIMIT 10

// 模式2: 影响力传播（PageRank应用场景）
MATCH (p:Person)-[:FOLLOWS]->(target:Person)
WITH target, count(p) AS followers
ORDER BY followers DESC
RETURN target.name, followers
LIMIT 20

// 模式3: 社区检测
MATCH (p:Person)-[:WORKS_AT]->(c:Company)-[:LOCATED_IN]->(city:City)
RETURN city.name, collect(DISTINCT c.name) AS companies,
       count(DISTINCT p) AS talent_pool
ORDER BY talent_pool DESC

// 模式4: 知识图谱问答
MATCH (e:Entity {name: $entity_name})-[r]->(related)
RETURN type(r) AS relation, related.name, labels(related) AS types

图建模模式

AI应用的典型图模型

知识图谱模型

(Person)─────[:WORKS_AT]────→(Company)
   │                              │
   │[:KNOWS]                      │[:LOCATED_IN]
   │                              │
   ▼                              ▼
(Person)                      (Location)
   │
   │[:AUTHORED]
   │
   ▼
(Paper)─────[:CITES]─────→(Paper)
   │
   │[:ABOUT]
   │
   ▼
(Topic)─────[:SUBTOPIC_OF]──→(Topic)


RAG知识库模型

(Document)───[:HAS_CHUNK]───→(Chunk)
    │                           │
    │[:IN_COLLECTION]           │[:SIMILAR_TO]
    │                           │
    ▼                           ▼
(Collection)                 (Chunk)
    │                           │
    │                           │[:MENTIONS]
    │                           │
    │                           ▼
    │                       (Entity)
    │                           │
    │                           │[:RELATED_TO]
    │                           ▼
    │                       (Entity)
    └───[:TAGGED_WITH]────→(Tag)

建模最佳实践

原则	说明	示例
实体→节点	独立存在的事物建模为节点	Person, Company, Product
动作→关系	实体间的动态联系建模为关系	WORKS_AT, PURCHASED
属性→属性	描述性信息附加为属性	name, created_date
中间实体	N:M关系携带丰富属性时提升为节点	Order, Transaction
避免超级节点	单个节点关系数不宜超过10万	按时间/地区分片

GDS图算法

常用算法分类

# Neo4j GDS algorithm categories and use cases
gds_algorithms = {
    "centrality": {
        "PageRank": {
            "use_case": "Identify influential nodes",
            "complexity": "O(V + E)",
            "ai_application": "Entity importance ranking in KG",
        },
        "Betweenness": {
            "use_case": "Find bridge nodes",
            "complexity": "O(V * E)",
            "ai_application": "Key connector identification",
        },
        "Degree": {
            "use_case": "Count connections",
            "complexity": "O(V)",
            "ai_application": "Popularity/activity scoring",
        },
    },
    "community_detection": {
        "Louvain": {
            "use_case": "Find communities/clusters",
            "complexity": "O(V * log V)",
            "ai_application": "Topic clustering, user segmentation",
        },
        "Label Propagation": {
            "use_case": "Fast community detection",
            "complexity": "O(V + E)",
            "ai_application": "Real-time community assignment",
        },
    },
    "similarity": {
        "Node Similarity": {
            "use_case": "Find similar nodes by neighbors",
            "complexity": "O(V^2)",
            "ai_application": "Recommendation, entity matching",
        },
        "KNN": {
            "use_case": "K nearest neighbors",
            "complexity": "O(V * log V)",
            "ai_application": "Vector similarity search",
        },
    },
    "path_finding": {
        "Shortest Path": {
            "use_case": "Find optimal paths",
            "complexity": "O(V + E)",
            "ai_application": "Relationship explanation",
        },
        "All Shortest Paths": {
            "use_case": "Find all optimal paths",
            "complexity": "O(V * E)",
            "ai_application": "Multi-hop reasoning",
        },
    },
}

GDS实战：GraphRAG中的社区摘要

// Step 1: Create graph projection
CALL gds.graph.project(
    'knowledge-graph',
    ['Entity', 'Chunk'],
    {
        RELATED_TO: {orientation: 'UNDIRECTED'},
        MENTIONS: {orientation: 'UNDIRECTED'}
    }
)

// Step 2: Run Louvain community detection
CALL gds.louvain.write('knowledge-graph', {
    writeProperty: 'community_id',
    maxLevels: 10,
    maxIterations: 20
})
YIELD communityCount, modularity

// Step 3: Get community members for LLM summarization
MATCH (e:Entity)
WITH e.community_id AS community, collect(e.name) AS members
WHERE size(members) >= 3
RETURN community, members, size(members) AS size
ORDER BY size DESC
LIMIT 50

// Step 4: Run PageRank within communities
CALL gds.pageRank.write('knowledge-graph', {
    writeProperty: 'pagerank',
    maxIterations: 20,
    dampingFactor: 0.85
})

向量索引

Neo4j原生向量搜索

从Neo4j 5.11开始，原生支持向量索引，这使得Neo4j可以同时承担图数据库和向量数据库的双重角色。

// 创建向量索引
CREATE VECTOR INDEX chunk_embeddings IF NOT EXISTS
FOR (c:Chunk) ON (c.embedding)
OPTIONS {
    indexConfig: {
        `vector.dimensions`: 1536,
        `vector.similarity_function`: 'cosine'
    }
}

// 写入带向量的节点
CREATE (c:Chunk {
    text: 'Knowledge graphs enable structured reasoning...',
    source: 'paper_001',
    embedding: $embedding_vector
})

// 向量相似搜索
CALL db.index.vector.queryNodes(
    'chunk_embeddings',
    10,                    -- top-K
    $query_embedding       -- query vector
)
YIELD node, score
RETURN node.text, node.source, score
ORDER BY score DESC

// 混合查询: 向量搜索 + 图遍历
CALL db.index.vector.queryNodes('chunk_embeddings', 20, $query_embedding)
YIELD node AS chunk, score
WHERE score > 0.7
MATCH (chunk)-[:MENTIONS]->(entity:Entity)-[:RELATED_TO]-(related:Entity)
RETURN chunk.text, score,
       collect(DISTINCT entity.name) AS entities,
       collect(DISTINCT related.name) AS related_entities
ORDER BY score DESC
LIMIT 5

LLM集成

Neo4j + LangChain GraphRAG

from langchain_community.graphs import Neo4jGraph
from langchain_community.vectorstores import Neo4jVector
from langchain_openai import OpenAIEmbeddings, ChatOpenAI
from langchain.chains import GraphCypherQAChain

# Initialize Neo4j connection
graph = Neo4jGraph(
    url="bolt://localhost:7687",
    username="neo4j",
    password="password",
)

# Vector store on top of Neo4j
vector_store = Neo4jVector.from_existing_graph(
    embedding=OpenAIEmbeddings(model="text-embedding-3-small"),
    url="bolt://localhost:7687",
    username="neo4j",
    password="password",
    index_name="chunk_embeddings",
    node_label="Chunk",
    text_node_properties=["text"],
    embedding_node_property="embedding",
)

# Text-to-Cypher chain
llm = ChatOpenAI(model="gpt-4o", temperature=0)
cypher_chain = GraphCypherQAChain.from_llm(
    llm=llm,
    graph=graph,
    verbose=True,
    validate_cypher=True,
    return_intermediate_steps=True,
)

# Query: natural language -> Cypher -> answer
result = cypher_chain.invoke({
    "query": "Which companies in Beijing have more than 100 employees working on AI?"
})
print(result["result"])
# Intermediate: MATCH (c:Company)-[:LOCATED_IN]->(:City {name:'Beijing'})
#               MATCH (c)<-[:WORKS_AT]-(p:Person)
#               WHERE c.industry = 'AI'
#               WITH c, count(p) AS emp_count
#               WHERE emp_count > 100
#               RETURN c.name, emp_count

混合检索：向量+图结构

class HybridGraphRetriever:
    """Combine vector similarity with graph traversal for RAG."""

    def __init__(self, driver, embed_fn):
        self.driver = driver
        self.embed_fn = embed_fn

    def retrieve(self, query: str, top_k: int = 5,
                 graph_depth: int = 1) -> list[dict]:
        """
        1. Vector search for relevant chunks
        2. Graph traversal to enrich context
        3. Combine and rank
        """
        query_embedding = self.embed_fn(query)

        with self.driver.session() as session:
            result = session.run("""
                // Step 1: Vector search
                CALL db.index.vector.queryNodes(
                    'chunk_embeddings', $top_k * 3, $embedding
                )
                YIELD node AS chunk, score
                WHERE score > 0.6

                // Step 2: Get mentioned entities
                OPTIONAL MATCH (chunk)-[:MENTIONS]->(entity:Entity)

                // Step 3: Get related entities (1-hop)
                OPTIONAL MATCH (entity)-[:RELATED_TO]-(related:Entity)

                // Step 4: Get chunks mentioning related entities
                OPTIONAL MATCH (related_chunk:Chunk)-[:MENTIONS]->(related)
                WHERE related_chunk <> chunk

                RETURN chunk.text AS text,
                       score,
                       collect(DISTINCT entity.name) AS entities,
                       collect(DISTINCT related.name) AS related_entities,
                       collect(DISTINCT related_chunk.text)[0..2] AS related_texts
                ORDER BY score DESC
                LIMIT $top_k
            """, embedding=query_embedding, top_k=top_k)

            return [dict(record) for record in result]

性能优化

索引策略

索引类型	用途	创建语法
B-tree	精确匹配/范围查询	`CREATE INDEX FOR (n:Label) ON (n.prop)`
Full-text	文本搜索	`CREATE FULLTEXT INDEX FOR (n:Label) ON EACH [n.text]`
Vector	向量相似度	`CREATE VECTOR INDEX ... OPTIONS {vector.dimensions: N}`
Composite	多属性联合	`CREATE INDEX FOR (n:L) ON (n.a, n.b)`

查询优化清单

// 1. 使用 PROFILE 分析查询计划
PROFILE
MATCH (p:Person)-[:WORKS_AT]->(c:Company {industry: 'AI'})
RETURN p.name, c.name

// 2. 避免笛卡尔积
// Bad: 无连接条件的多 MATCH
MATCH (a:Person), (b:Company)  -- Cartesian product!

// Good: 通过关系连接
MATCH (a:Person)-[:WORKS_AT]->(b:Company)

// 3. 尽早过滤
// Bad:
MATCH (p:Person)-[*1..5]->(target)
WHERE p.name = 'Zhang Wei'

// Good:
MATCH (p:Person {name: 'Zhang Wei'})-[*1..5]->(target)

// 4. 使用参数化查询
// Good: 利用查询缓存
MATCH (p:Person {name: $name}) RETURN p

结论

Neo4j在AI应用中的价值正在从"存储图数据"扩展为"图原生推理引擎"。原生向量索引让Neo4j可以同时承担向量数据库和图数据库的双重角色，GDS算法库为社区检测和实体重要性排序提供了高效工具，而与LangChain等框架的深度集成则大幅降低了GraphRAG的开发门槛。对于需要结合结构化关系推理和语义检索的AI应用，Neo4j是当前最成熟的技术选择。

Maurice | [email protected]

深度加工（NotebookLM 生成）

基于本文内容生成的 PPT 大纲、博客摘要、短视频脚本与 Deep Dive 播客，用于多场景复用

PPT 大纲（5-8 张幻灯片）点击展开

Neo4j实战：AI应用中的图数据库 — ppt

幻灯片 1：Neo4j 在 AI 应用中的演进与核心角色

核心定位的升级：图数据库在 AI 应用中正从传统的“辅助存储”转变为“核心推理引擎” [1, 2]。
技术优势：Neo4j 原生支持向量索引，兼具图数据库与向量数据库的双重优势 [2-4]。
核心工具链：集成了强大的图数据科学库（GDS）以及完善的 LLM 工具链 [1]。
主要应用场景：已成为构建知识图谱、GraphRAG（图检索增强生成）和智能推荐系统的首选技术栈 [1]。

幻灯片 2：图数据建模的最佳实践

节点与关系定义：将独立存在的事物（如人、公司）建模为“节点”，事物间的动态联系（如工作于、购买）建模为“关系” [5]。
属性与中间实体：描述性信息作为附加属性；当 N:M 多对多关系需要携带丰富属性时，应将其提升为独立的中间实体节点（如订单、交易） [5]。
知识图谱与RAG模型：支持多维建模，例如在 RAG 模型中构建“文档-分块-实体-标签”的层级结构 [5]。
性能优化原则：在建模时应避免单个节点的关系数超过十万（超级节点），可考虑按时间或地区进行分片 [5]。

幻灯片 3：Cypher 查询基础与高阶模式

直观的查询语法：Cypher 是一种声明式查询语言，其设计哲学是“让图查询像画图一样直观” [1]。
基础与多跳查询：支持节点、关系的创建，以及高效的多跳查询（如朋友的朋友）和变长路径查找 [1, 6]。
典型查询模式（1）推荐与影响力：可用于实现协同过滤（推荐他人看过的电影）和基于 PageRank 逻辑的影响力传播分析 [6]。
典型查询模式（2）社区与问答：支持高效的社区发现（聚合特定公司、人才、城市数据）以及知识图谱的直接问答检索 [5, 6]。

幻灯片 4：GDS 图数据科学算法赋能 AI

节点中心性分析：如 PageRank（识别图谱中的重要实体）和 Betweenness（识别关键的桥梁节点） [5, 7]。
社区发现技术：利用 Louvain 或标签传播算法（Label Propagation）实现主题聚类、用户分层和实时社区划分 [7]。
相似度与路径寻优：通过节点相似度、KNN 进行向量相似性搜索与实体匹配；使用最短路径算法进行复杂的多跳推理与关系解释 [3, 7]。
GraphRAG 实战案例：可通过 GDS 运行社区检测，提取社区成员信息，从而交由大语言模型（LLM）进行社区摘要生成 [3]。

幻灯片 5：原生向量索引与混合检索

原生向量搜索支持：从 5.11 版本起，Neo4j 原生支持创建向量索引并进行基于余弦相似度等算法的向量相似度搜索 [3, 4, 8]。
向量数据管理：允许在图节点（如文档分块 Chunk）上直接存储高维文本嵌入（Embedding）信息 [4, 8]。
混合查询架构：检索时能够将“向量相似度打分”与“图遍历”结合，在找到高相关文本块后，进一步拓展查询其关联的实体上下文 [8]。
增强 RAG 上下文：混合检索可以极大丰富 RAG 的上下文，不仅获取文本，还能提取关联的结构化实体信息 [2, 8]。

幻灯片 6：Neo4j 与大语言模型 (LLM) 的深度集成

LangChain 生态支持：通过 Neo4jGraph 和 Neo4jVector，可轻松将其作为图谱或向量存储无缝接入 LangChain 框架 [8]。
Text-to-Cypher 能力：利用 GraphCypherQAChain，大模型可直接将自然语言（如“北京有哪些从事AI且员工过百的公司”）转化为 Cypher 查询并执行 [8]。
定制混合检索器：开发者可构建兼顾“向量检索”与“图谱多跳关联”的 HybridGraphRetriever，实现更精准的问答提取 [2, 8]。

幻灯片 7：查询性能优化与总结

丰富的索引策略：针对不同需求提供 B-tree（精确/范围匹配）、Full-text（文本搜索）、Vector（向量相似度）以及复合索引 [2]。
查询调优清单：使用 PROFILE 分析查询计划，并在查询时避免产生“笛卡尔积”（确保有连接条件） [2]。
过滤与缓存最佳实践：执行查询时应尽早应用过滤条件，并利用参数化查询（如 $name）来有效利用查询缓存 [2]。
核心结论：对于需要将结构化关系推理与语义检索结合的 AI 应用，Neo4j 是当前最为成熟的技术选择 [2]。

博客摘要 + 核心看点点击展开

Neo4j实战：AI应用中的图数据库 — summary

SEO 友好博客摘要

想要在AI应用中最大化图数据库的价值？本文为您深入解析Neo4j从辅助存储向核心推理引擎的演进之路 [1]。作为知识图谱与GraphRAG的理想技术栈，Neo4j创新结合了原生向量索引与GDS图算法，完美兼任图与向量数据库双重角色 [1-3]。本指南全面覆盖Cypher查询基础、图建模最佳实践，以及结合LangChain的混合检索工程实战 [1, 4, 5]。无论构建推荐系统还是LLM智能问答，本文都能助您轻松驾驭结构化推理与语义检索 [3, 6]。

3 条核心看点