Neo4j 图数据库深度调研报告

// 事务示例
BEGIN
CREATE (p:Person {name: 'Alice'})
CREATE (m:Movie {title: 'Matrix'})
CREATE (p)-[:ACTED_IN]->(m)
COMMIT

(node)-[relationship]->(node)

// 节点模式
(p:Person {name: 'Alice'})

// 关系模式
-[:KNOWS]->           // 有向关系
-[:KNOWS]-            // 无向关系
-[:KNOWS*1..3]->      // 可变长度路径 (1-3 跳)

// 完整路径模式
(a:Person)-[:KNOWS]->(b:Person)-[:WORKS_AT]->(c:Company)

// 查找 Alice 的朋友
MATCH (alice:Person {name: 'Alice'})-[:KNOWS]->(friend:Person)
RETURN friend.name AS friendName

// 查找两人之间的最短路径
MATCH path = shortestPath(
  (alice:Person {name: 'Alice'})-[:KNOWS*]-(bob:Person {name: 'Bob'})
)
RETURN path

// 朋友的朋友推荐（排除已认识的人）
MATCH (me:Person {name: 'Alice'})-[:KNOWS]->(friend)-[:KNOWS]->(foaf)
WHERE NOT (me)-[:KNOWS]->(foaf) AND me <> foaf
RETURN foaf.name, count(*) AS mutualFriends
ORDER BY mutualFriends DESC
LIMIT 10

// 指定 Cypher 版本
CYPHER 25
MATCH (p:Person)
RETURN p.name

// Range Index
CREATE INDEX person_name FOR (p:Person) ON (p.name)

// Composite Index
CREATE INDEX person_name_age FOR (p:Person) ON (p.name, p.age)

// Full-text Index
CREATE FULLTEXT INDEX movie_search FOR (m:Movie) ON EACH [m.title, m.plot]

// Vector Index (4096 维)
CREATE VECTOR INDEX doc_embedding FOR (d:Document) ON (d.embedding)
OPTIONS {
  indexConfig: {
    `vector.dimensions`: 1536,
    `vector.similarity_function`: 'cosine'
  }
}

// 唯一性约束
CREATE CONSTRAINT person_id_unique FOR (p:Person) REQUIRE p.id IS UNIQUE

// 存在性约束 (Enterprise)
CREATE CONSTRAINT person_name_exists FOR (p:Person) REQUIRE p.name IS NOT NULL

// 类型约束 (Enterprise)
CREATE CONSTRAINT person_age_type FOR (p:Person) REQUIRE p.age IS :: INTEGER

// Key 约束 (Enterprise)
CREATE CONSTRAINT person_key FOR (p:Person) REQUIRE (p.id, p.email) IS NODE KEY

// 查看执行计划
EXPLAIN MATCH (p:Person {name: 'Alice'}) RETURN p

// 详细执行统计
PROFILE MATCH (p:Person {name: 'Alice'}) RETURN p

# 在线备份 (Enterprise)
neo4j-admin database backup --database=neo4j --to-path=/backup/

# 离线备份 (Community)
neo4j-admin database dump --database=neo4j --to-path=/backup/neo4j.dump

# 恢复数据库
neo4j-admin database restore --database=neo4j --from-path=/backup/

// 创建向量索引
CREATE VECTOR INDEX movie_plots FOR (m:Movie) ON (m.plotEmbedding)
OPTIONS {
  indexConfig: {
    `vector.dimensions`: 1536,
    `vector.similarity_function`: 'cosine'
  }
}

// 存储向量
MATCH (m:Movie {title: 'Matrix'})
SET m.plotEmbedding = $embedding  // 1536 维向量

// 向量相似度搜索
// 注：db.index.vector.queryNodes 在 Neo4j 2026.04+ 中已标记为 deprecated，推荐使用新的 SEARCH 子句
CALL db.index.vector.queryNodes('movie_plots', 10, $queryVector)
YIELD node, score
RETURN node.title, score
ORDER BY score DESC

// 混合查询：向量 + 图遍历
CALL db.index.vector.queryNodes('movie_plots', 10, $queryVector)
YIELD node AS movie, score
MATCH (movie)<-[:ACTED_IN]-(actor:Person)
RETURN movie.title, score, collect(actor.name) AS actors

// 生成嵌入向量
CALL genai.vector.encode('This is a sample text', 'OpenAI', {
  token: $apiKey,
  model: 'text-embedding-3-small'
}) YIELD vector
RETURN vector

// 批量生成嵌入
UNWIND $texts AS text
CALL genai.vector.encode(text, 'OpenAI', {token: $apiKey})
YIELD vector
RETURN text, vector

// 1. 投影图到内存
CALL gds.graph.project('socialGraph', 'Person', 'KNOWS')

// 2. 运行 PageRank 算法
CALL gds.pageRank.stream('socialGraph')
YIELD nodeId, score
RETURN gds.util.asNode(nodeId).name AS name, score
ORDER BY score DESC
LIMIT 10

// 3. 清理投影
CALL gds.graph.drop('socialGraph')

// 社区检测 - Louvain
CALL gds.louvain.stream('socialGraph')
YIELD nodeId, communityId
RETURN gds.util.asNode(nodeId).name, communityId

// 节点相似性
CALL gds.nodeSimilarity.stream('productGraph')
YIELD node1, node2, similarity
RETURN gds.util.asNode(node1).name,
       gds.util.asNode(node2).name,
       similarity
ORDER BY similarity DESC

// 节点嵌入 - FastRP
CALL gds.fastRP.stream('socialGraph', {embeddingDimension: 128})
YIELD nodeId, embedding
MATCH (n) WHERE id(n) = nodeId
SET n.embedding = embedding

from langchain_neo4j import Neo4jGraph, Neo4jVector
from langchain_openai import OpenAIEmbeddings

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

# 向量存储
embeddings = OpenAIEmbeddings()
vector_store = Neo4jVector.from_documents(
    documents,
    embeddings,
    url="bolt://localhost:7687",
    username="neo4j",
    password="password"
)

# 相似性搜索
results = vector_store.similarity_search("AI agents", k=5)

# GraphCypherQA Chain
from langchain_neo4j import GraphCypherQAChain
chain = GraphCypherQAChain.from_llm(llm, graph=graph)
response = chain.invoke({"query": "谁导演了 Matrix?"})

from llama_index.graph_stores.neo4j import Neo4jPropertyGraphStore
from llama_index.core import PropertyGraphIndex

# 创建图存储
graph_store = Neo4jPropertyGraphStore(
    username="neo4j",
    password="password",
    url="bolt://localhost:7687"
)

# 创建索引
index = PropertyGraphIndex.from_documents(
    documents,
    property_graph_store=graph_store,
    embed_model=embed_model
)

# 查询
query_engine = index.as_query_engine()
response = query_engine.query("什么是知识图谱?")

from neo4j_graphrag.retrievers import VectorRetriever
from neo4j_graphrag.generation import GraphRAG

# 创建检索器
retriever = VectorRetriever(
    driver=driver,
    index_name="document_embeddings",
    embedder=embedder
)

# 创建 GraphRAG 管道
rag = GraphRAG(retriever=retriever, llm=llm)
response = rag.search("AI agents 的核心组件是什么?")

// 导入 JSON
CALL apoc.load.json('https://api.example.com/data')
YIELD value
CREATE (n:Data) SET n = value

// 批量创建关系
CALL apoc.periodic.iterate(
  'MATCH (a:Person), (b:Person) WHERE a.city = b.city RETURN a, b',
  'CREATE (a)-[:LIVES_NEAR]->(b)',
  {batchSize: 1000}
)

// 论文节点
(:Paper {
  id: STRING,
  title: STRING,
  abstract: TEXT,
  arxiv_id: STRING,
  published_date: DATE,
  embedding: LIST<FLOAT>  // 1536 维向量
})

// 作者节点
(:Author {
  id: STRING,
  name: STRING,
  affiliation: STRING
})

// 概念节点
(:Concept {
  id: STRING,
  name: STRING,
  description: STRING
})

// 关系
(:Paper)-[:AUTHORED_BY {order: INT}]->(:Author)
(:Paper)-[:CITED_BY]->(:Paper)
(:Paper)-[:COVERS {relevance: FLOAT}]->(:Concept)
(:Author)-[:AFFILIATED_WITH]->(:Institution)

# 拉取 Neo4j 镜像
docker pull neo4j:5.26.0

# 启动 Neo4j 容器
docker run -d \
  --name neo4j-demo \
  -p 7474:7474 \
  -p 7687:7687 \
  -e NEO4J_AUTH=neo4j/your_password \
  -e NEO4J_PLUGINS='["apoc", "graph-data-science"]' \
  -v $HOME/neo4j/data:/data \
  -v $HOME/neo4j/logs:/logs \
  neo4j:5.26.0

# 验证启动
curl http://localhost:7474

# 创建虚拟环境
python -m venv neo4j-env
source neo4j-env/bin/activate

# 安装依赖
pip install neo4j langchain-neo4j neo4j-graphrag openai

from neo4j import GraphDatabase

driver = GraphDatabase.driver(
    "bolt://localhost:7687",
    auth=("neo4j", "your_password")
)

def create_sample_data(tx):
    # 创建约束
    tx.run("CREATE CONSTRAINT paper_id IF NOT EXISTS FOR (p:Paper) REQUIRE p.id IS UNIQUE")
    tx.run("CREATE CONSTRAINT author_id IF NOT EXISTS FOR (a:Author) REQUIRE a.id IS UNIQUE")

    # 创建示例论文
    tx.run("""
        MERGE (p1:Paper {id: 'arxiv:2312.10997'})
        SET p1.title = 'Practices for Governing Agentic AI Systems',
            p1.abstract = 'Agentic AI systems are...',
            p1.published_date = date('2023-12-18')

        MERGE (p2:Paper {id: 'arxiv:2401.00001'})
        SET p2.title = 'Chain-of-Thought Prompting',
            p2.abstract = 'We explore...',
            p2.published_date = date('2024-01-01')

        MERGE (a1:Author {id: 'author-1'})
        SET a1.name = 'John Smith'

        MERGE (p1)-[:AUTHORED_BY]->(a1)
        MERGE (p1)-[:CITED_BY]->(p2)
    """)

with driver.session() as session:
    session.execute_write(create_sample_data)

from langchain_neo4j import Neo4jVector
from langchain_openai import OpenAIEmbeddings
import os

os.environ["OPENAI_API_KEY"] = "your-api-key"

# 创建向量存储
embeddings = OpenAIEmbeddings(model="text-embedding-3-small")

vector_store = Neo4jVector.from_existing_graph(
    embeddings,
    url="bolt://localhost:7687",
    username="neo4j",
    password="your_password",
    node_label="Paper",
    text_node_properties=["title", "abstract"],
    embedding_node_property="embedding",
    index_name="paper_embeddings"
)

# 语义搜索
results = vector_store.similarity_search(
    "multi-agent collaboration in AI systems",
    k=5
)

for doc in results:
    print(f"- {doc.page_content[:100]}...")

from neo4j_graphrag.retrievers import VectorCypherRetriever
from neo4j_graphrag.generation import GraphRAG
from neo4j_graphrag.llm import OpenAILLM

# 创建检索器（向量 + 图遍历）
retriever = VectorCypherRetriever(
    driver=driver,
    index_name="paper_embeddings",
    retrieval_query="""
        MATCH (paper:Paper)
        WHERE paper.id = node.id
        OPTIONAL MATCH (paper)-[:AUTHORED_BY]->(author:Author)
        OPTIONAL MATCH (paper)-[:CITED_BY]->(cited:Paper)
        RETURN paper.title AS title,
               paper.abstract AS content,
               collect(DISTINCT author.name) AS authors,
               count(cited) AS citation_count
    """,
    embedder=embeddings
)

# 创建 GraphRAG
llm = OpenAILLM(model_name="gpt-4o-mini")
rag = GraphRAG(retriever=retriever, llm=llm)

# 查询
response = rag.search("What are the key components of agentic AI systems?")
print(response.answer)

// 投影引用网络
CALL gds.graph.project(
  'citation-network',
  'Paper',
  'CITED_BY'
)

// 计算 PageRank 识别重要论文
CALL gds.pageRank.stream('citation-network')
YIELD nodeId, score
WITH gds.util.asNode(nodeId) AS paper, score
RETURN paper.title, score
ORDER BY score DESC
LIMIT 10

// 社区检测
CALL gds.louvain.stream('citation-network')
YIELD nodeId, communityId
WITH gds.util.asNode(nodeId) AS paper, communityId
RETURN communityId, collect(paper.title) AS papers
ORDER BY size(papers) DESC