using-graph-databases

Compare original and translation side by side

🇺🇸

Original

English

🇨🇳

Translation

Chinese

Graph Databases

图数据库

Purpose

用途

This skill guides selection and implementation of graph databases for applications where relationships between entities are first-class citizens. Unlike relational databases that model relationships through foreign keys and joins, graph databases natively represent connections as properties, enabling efficient traversal-heavy queries.

本技能指导你为以实体间关系为核心的应用选择和实现图数据库。与通过外键和连接来建模关系的关系型数据库不同，图数据库以原生方式将连接表示为属性，从而支持高效的遍历型查询。

When to Use This Skill

适用场景

Use graph databases when:

Deep relationship traversals (4+ hops): "Friends of friends of friends"
Variable/evolving relationships: Schema changes don't break existing queries
Path finding: Shortest route, network analysis, dependency chains
Pattern matching: Fraud detection, recommendation engines, access control

Do NOT use graph databases when:

Fixed schema with shallow joins (2-3 tables) → Use PostgreSQL
Primarily aggregations/analytics → Use columnar databases
Key-value lookups only → Use Redis/DynamoDB

在以下场景中使用图数据库：

深度关系遍历（4层及以上）：例如“朋友的朋友的朋友”
可变/演化的关系：Schema变更不会破坏现有查询
路径查找：最短路径、网络分析、依赖链
模式匹配：欺诈检测、推荐引擎、访问控制

请勿在以下场景使用图数据库：

固定Schema且仅需浅层次连接（2-3张表）→ 使用PostgreSQL
主要用于聚合/分析 → 使用列存数据库
仅需键值查询 → 使用Redis/DynamoDB

Quick Decision Framework

快速决策框架

DATA CHARACTERISTICS?
├── Fixed schema, shallow joins (≤3 hops)
│   └─ PostgreSQL (relational)
│
├── Already on PostgreSQL + simple graphs
│   └─ Apache AGE (PostgreSQL extension)
│
├── Deep traversals (4+ hops) + general purpose
│   └─ Neo4j (battle-tested, largest ecosystem)
│
├── Multi-model (documents + graph)
│   └─ ArangoDB
│
├── AWS-native, serverless
│   └─ Amazon Neptune
│
└── Real-time streaming, in-memory
    └─ Memgraph

数据特征?
├── 固定Schema，浅层次连接（≤3层）
│   └─ PostgreSQL（关系型）
│
├── 已使用PostgreSQL且仅需简单图功能
│   └─ Apache AGE（PostgreSQL扩展）
│
├── 深度遍历（4层及以上）+ 通用场景
│   └─ Neo4j（技术成熟，生态最完善）
│
├── 多模型（文档+图）
│   └─ ArangoDB
│
├── AWS原生、无服务器
│   └─ Amazon Neptune
│
└─ 实时流、内存型
    └─ Memgraph

Core Concepts

核心概念

Property Graph Model

属性图模型

Graph databases store data as:

Nodes (vertices): Entities with labels and properties
Relationships (edges): Typed connections with properties
Properties: Key-value pairs on nodes and relationships

(Person {name: "Alice", age: 28})-[:FRIEND {since: "2020-01-15"}]->(Person {name: "Bob"})

图数据库以以下结构存储数据：

节点（顶点）：带有标签和属性的实体
关系（边）：带有属性的类型化连接
属性：节点和关系上的键值对

(Person {name: "Alice", age: 28})-[:FRIEND {since: "2020-01-15"}]->(Person {name: "Bob"})

Query Languages

查询语言

Language	Databases	Readability	Best For
Cypher	Neo4j, Memgraph, AGE	⭐⭐⭐⭐⭐ SQL-like	General purpose
Gremlin	Neptune, JanusGraph	⭐⭐⭐ Functional	Cross-database
AQL	ArangoDB	⭐⭐⭐⭐ SQL-like	Multi-model
SPARQL	Neptune, RDF stores	⭐⭐⭐ W3C standard	Semantic web

查询语言	支持数据库	可读性	适用场景
Cypher	Neo4j, Memgraph, AGE	⭐⭐⭐⭐⭐ 类SQL	通用场景
Gremlin	Neptune, JanusGraph	⭐⭐⭐ 函数式	跨数据库
AQL	ArangoDB	⭐⭐⭐⭐ 类SQL	多模型
SPARQL	Neptune, RDF存储	⭐⭐⭐ W3C标准	语义网

Common Cypher Patterns

常见Cypher模式

Reference

references/cypher-patterns.md

for comprehensive examples.

完整示例请参考

references/cypher-patterns.md

。

Pattern 1: Basic Matching

模式1：基础匹配

cypher

// Find all users at a company
MATCH (u:User)-[:WORKS_AT]->(c:Company {name: 'Acme Corp'})
RETURN u.name, u.title

cypher

// 查找某公司的所有用户
MATCH (u:User)-[:WORKS_AT]->(c:Company {name: 'Acme Corp'})
RETURN u.name, u.title

Pattern 2: Variable-Length Paths

模式2：可变长度路径

cypher

// Find friends up to 3 degrees away
MATCH (u:User {name: 'Alice'})-[:FRIEND*1..3]->(friend)
WHERE u <> friend
RETURN DISTINCT friend.name
LIMIT 100

cypher

// 查找最多3度人脉的好友
MATCH (u:User {name: 'Alice'})-[:FRIEND*1..3]->(friend)
WHERE u <> friend
RETURN DISTINCT friend.name
LIMIT 100

Pattern 3: Shortest Path

模式3：最短路径

cypher

// Find shortest connection between two users
MATCH path = shortestPath(
  (a:User {name: 'Alice'})-[*]-(b:User {name: 'Bob'})
)
RETURN path, length(path) AS distance

cypher

// 查找两个用户之间的最短连接
MATCH path = shortestPath(
  (a:User {name: 'Alice'})-[*]-(b:User {name: 'Bob'})
)
RETURN path, length(path) AS distance

Pattern 4: Recommendations

模式4：推荐算法

cypher

// Collaborative filtering: Products liked by similar users
MATCH (u:User {id: $userId})-[:PURCHASED]->(p:Product)<-[:PURCHASED]-(similar)
MATCH (similar)-[:PURCHASED]->(rec:Product)
WHERE NOT exists((u)-[:PURCHASED]->(rec))
RETURN rec.name, count(*) AS score
ORDER BY score DESC
LIMIT 10

cypher

// 协同过滤：相似用户喜欢的产品
MATCH (u:User {id: $userId})-[:PURCHASED]->(p:Product)<-[:PURCHASED]-(similar)
MATCH (similar)-[:PURCHASED]->(rec:Product)
WHERE NOT exists((u)-[:PURCHASED]->(rec))
RETURN rec.name, count(*) AS score
ORDER BY score DESC
LIMIT 10

Pattern 5: Fraud Detection

模式5：欺诈检测

cypher

// Detect circular money flows
MATCH path = (a:Account)-[:SENT*3..6]->(a)
WHERE all(r IN relationships(path) WHERE r.amount > 1000)
RETURN path, [r IN relationships(path) | r.amount] AS amounts

cypher

// 检测循环资金流
MATCH path = (a:Account)-[:SENT*3..6]->(a)
WHERE all(r IN relationships(path) WHERE r.amount > 1000)
RETURN path, [r IN relationships(path) | r.amount] AS amounts

Database Selection Guide

数据库选择指南

Neo4j (Primary Recommendation)

Neo4j（主推）

Use for: General-purpose graph applications

Strengths:

Most mature (2007), largest community (2M+ developers)
65+ graph algorithms (GDS library): PageRank, Louvain, Dijkstra
Best tooling: Neo4j Browser, Bloom visualization
Comprehensive Cypher support

Installation:

bash

undefined

适用场景：通用型图应用

优势：

技术最成熟（始于2007年），社区规模最大（200万+开发者）
65+图算法（GDS库）：PageRank、Louvain、Dijkstra
工具链最完善：Neo4j Browser、Bloom可视化工具
对Cypher支持最全面

安装方式：

bash

undefined

Python driver

Python驱动

pip install neo4j

TypeScript driver

TypeScript驱动

npm install neo4j-driver

Rust driver

Rust驱动

cargo add neo4rs


Reference: `references/neo4j.md`

cargo add neo4rs


参考文档：`references/neo4j.md`

ArangoDB

Use for: Multi-model applications (documents + graph)

Strengths:

Store documents AND graph in one database
AQL combines document and graph queries
Schema flexibility with relationships

Reference:

references/arangodb.md

适用场景：多模型应用（文档+图）

优势：

在单个数据库中同时存储文档和图数据
AQL支持文档和图查询的结合
兼具Schema灵活性和关系建模能力

参考文档：

references/arangodb.md

Apache AGE

Use for: Adding graph capabilities to existing PostgreSQL

Strengths:

Extend PostgreSQL with graph queries
No new infrastructure needed
Query both relational and graph data

Reference: Implementation details in examples/

适用场景：为现有PostgreSQL添加图功能

优势：

通过扩展为PostgreSQL增加图查询能力
无需新增基础设施
可同时查询关系型和图数据

实现细节请参考examples/目录

Amazon Neptune

Use for: AWS-native, serverless deployments

Strengths:

Fully managed, auto-scaling
Supports Gremlin AND SPARQL
AWS ecosystem integration

适用场景：AWS原生、无服务器部署

优势：

全托管、自动扩缩容
同时支持Gremlin和SPARQL
与AWS生态深度集成

Graph Data Modeling Patterns

图数据建模模式

Reference

references/graph-modeling.md

for comprehensive patterns.

完整建模模式请参考

references/graph-modeling.md

。

Best Practice 1: Relationships as First-Class Citizens

最佳实践1：将关系作为一等公民

Anti-pattern (storing relationships in node properties):

cypher

// BAD
(:Person {name: 'Alice', friend_ids: ['b123', 'c456']})

Pattern (explicit relationships):

cypher

// GOOD
(:Person {name: 'Alice'})-[:FRIEND]->(:Person {id: 'b123'})
(:Person {name: 'Alice'})-[:FRIEND]->(:Person {id: 'c456'})

反模式（在节点属性中存储关系）：

cypher

// 错误示例
(:Person {name: 'Alice', friend_ids: ['b123', 'c456']})

正确模式（显式定义关系）：

cypher

// 正确示例
(:Person {name: 'Alice'})-[:FRIEND]->(:Person {id: 'b123'})
(:Person {name: 'Alice'})-[:FRIEND]->(:Person {id: 'c456'})

Best Practice 2: Relationship Properties for Metadata

最佳实践2：用关系属性存储元数据

cypher

// Track interaction details on relationships
(:Person)-[:FRIEND {
  since: '2020-01-15',
  strength: 0.85,
  last_interaction: datetime()
}]->(:Person)

cypher

// 在关系上存储交互细节
(:Person)-[:FRIEND {
  since: '2020-01-15',
  strength: 0.85,
  last_interaction: datetime()
}]->(:Person)

Best Practice 3: Bounded Traversals for Performance

最佳实践3：通过有界遍历提升性能

cypher

// SLOW: Unbounded traversal
MATCH (a)-[:FRIEND*]->(distant)
RETURN distant

// FAST: Bounded depth with index
MATCH (a)-[:FRIEND*1..4]->(distant)
WHERE distant.active = true
RETURN distant
LIMIT 100

cypher

// 慢查询：无界遍历
MATCH (a)-[:FRIEND*]->(distant)
RETURN distant

// 快查询：带索引的有界深度
MATCH (a)-[:FRIEND*1..4]->(distant)
WHERE distant.active = true
RETURN distant
LIMIT 100

Best Practice 4: Avoid Supernodes

最佳实践4：避免超级节点

Problem: Nodes with thousands of relationships slow traversals.

Solution: Intermediate aggregation nodes

cypher

// Instead of: (:User)-[:POSTED]->(:Post) [1M relationships]

// Use time partitioning:
(:User)-[:POSTED_IN]->(:Year {year: 2025})
       -[:HAS_MONTH]->(:Month {month: 12})
       -[:HAS_POST]->(:Post)

问题：拥有数千个关系的节点会拖慢遍历速度。

解决方案：使用中间聚合节点

cypher

// 替代：(:User)-[:POSTED]->(:Post) [100万条关系]

// 使用时间分区：
(:User)-[:POSTED_IN]->(:Year {year: 2025})
       -[:HAS_MONTH]->(:Month {month: 12})
       -[:HAS_POST]->(:Post)

Use Case Examples

应用场景示例

Social Network

社交网络

Schema and implementation in

examples/social-graph/

Key features:

Friend recommendations (friends-of-friends)
Mutual connections
News feed generation
Influence metrics

Schema和实现代码位于

examples/social-graph/

核心功能：

好友推荐（好友的好友）
共同好友
信息流生成
影响力指标

Knowledge Graph for AI/RAG

AI/RAG知识图谱

Integration example in

examples/knowledge-graph/

Key features:

Hybrid vector + graph search
Entity relationship mapping
Context expansion for LLM prompts
Semantic relationship traversal

Integration with Vector Databases:

python

undefined

集成示例位于

examples/knowledge-graph/

核心功能：

混合向量+图搜索
实体关系映射
为LLM提示词扩展上下文
语义关系遍历

与向量数据库的集成：

python

undefined

Step 1: Vector search in Qdrant/pgvector

步骤1：在Qdrant/pgvector中进行向量搜索

vector_results = qdrant.search(collection="concepts", query_vector=embedding)

Step 2: Expand with graph relationships

步骤2：通过图关系扩展上下文

concept_ids = [r.id for r in vector_results] graph_context = neo4j.run(""" MATCH (c:Concept) WHERE c.id IN $ids MATCH (c)-[:RELATED_TO|IS_A*1..2]-(related) RETURN c, related, relationships(path) """, ids=concept_ids)

undefined

undefined

Recommendation Engine

Fraud Detection

欺诈检测

Pattern detection in examples/

Detection patterns:

Circular money flows
Shared devices across accounts
Rapid transaction chains
Connection pattern anomalies

模式检测示例位于examples/目录

检测模式：

循环资金流
多账户共享设备
快速交易链
连接模式异常

Performance Optimization

性能优化

Reference

references/cypher-patterns.md

for detailed optimization.

详细优化指南请参考

references/cypher-patterns.md

。

Indexing

索引优化

cypher

// Single-property index
CREATE INDEX user_email FOR (u:User) ON (u.email)

// Composite index (Neo4j 5.x+)
CREATE INDEX user_name_location FOR (u:User) ON (u.name, u.location)

// Full-text search
CREATE FULLTEXT INDEX product_search FOR (p:Product) ON EACH [p.name, p.description]

cypher

// 单属性索引
CREATE INDEX user_email FOR (u:User) ON (u.email)

// 复合索引（Neo4j 5.x+）
CREATE INDEX user_name_location FOR (u:User) ON (u.name, u.location)

// 全文搜索索引
CREATE FULLTEXT INDEX product_search FOR (p:Product) ON EACH [p.name, p.description]

Caching Expensive Aggregations

缓存昂贵的聚合查询

cypher

// Materialize friend count as property
MATCH (u:User)-[:FRIEND]->(f)
WITH u, count(f) AS friendCount
SET u.friend_count = friendCount

// Query becomes instant
MATCH (u:User) WHERE u.friend_count > 100
RETURN u.name, u.friend_count

cypher

// 将好友数物化为节点属性
MATCH (u:User)-[:FRIEND]->(f)
WITH u, count(f) AS friendCount
SET u.friend_count = friendCount

// 查询速度变为即时
MATCH (u:User) WHERE u.friend_count > 100
RETURN u.name, u.friend_count

Scaling Strategies

扩容策略

Scale	Strategy	Implementation
Vertical	Add RAM/CPU	In-memory caching, larger instances
Horizontal (Read)	Read replicas	Neo4j Cluster, ArangoDB Cluster
Horizontal (Write)	Sharding	ArangoDB SmartGraphs, JanusGraph
Caching	App-level cache	Redis for hot paths

扩容类型	策略	实现方式
垂直扩容	增加内存/CPU	内存缓存、更大规格实例
水平扩容（读）	读副本	Neo4j集群、ArangoDB集群
水平扩容（写）	分片	ArangoDB SmartGraphs、JanusGraph
缓存	应用层缓存	Redis缓存热点路径

Language Integration

语言集成

Python (Neo4j)

Python（Neo4j）

Complete example in

examples/social-graph/python-neo4j/

python

from neo4j import GraphDatabase

class GraphDB:
    def __init__(self, uri: str, user: str, password: str):
        self.driver = GraphDatabase.driver(uri, auth=(user, password))

    def find_friends_of_friends(self, user_id: str, max_depth: int = 2):
        query = """
        MATCH (u:User {id: $userId})-[:FRIEND*1..$maxDepth]->(fof)
        WHERE u <> fof
        RETURN DISTINCT fof.id, fof.name
        LIMIT 100
        """
        with self.driver.session() as session:
            result = session.run(query, userId=user_id, maxDepth=max_depth)
            return [dict(record) for record in result]

完整示例位于

examples/social-graph/python-neo4j/

python

from neo4j import GraphDatabase

class GraphDB:
    def __init__(self, uri: str, user: str, password: str):
        self.driver = GraphDatabase.driver(uri, auth=(user, password))

    def find_friends_of_friends(self, user_id: str, max_depth: int = 2):
        query = """
        MATCH (u:User {id: $userId})-[:FRIEND*1..$maxDepth]->(fof)
        WHERE u <> fof
        RETURN DISTINCT fof.id, fof.name
        LIMIT 100
        """
        with self.driver.session() as session:
            result = session.run(query, userId=user_id, maxDepth=max_depth)
            return [dict(record) for record in result]

Usage

使用示例

db = GraphDB("bolt://localhost:7687", "neo4j", "password") friends = db.find_friends_of_friends("u123", max_depth=3)

undefined

db = GraphDB("bolt://localhost:7687", "neo4j", "password") friends = db.find_friends_of_friends("u123", max_depth=3)

undefined

TypeScript (Neo4j)

TypeScript（Neo4j）

Complete example in

examples/social-graph/typescript-neo4j/

typescript

import neo4j, { Driver } from 'neo4j-driver'

class Neo4jService {
  private driver: Driver

  constructor(uri: string, username: string, password: string) {
    this.driver = neo4j.driver(uri, neo4j.auth.basic(username, password))
  }

  async findFriendsOfFriends(userId: string, maxDepth: number = 2) {
    const session = this.driver.session()
    try {
      const result = await session.run(
        `MATCH (u:User {id: $userId})-[:FRIEND*1..$maxDepth]->(fof)
         WHERE u <> fof
         RETURN DISTINCT fof.id, fof.name
         LIMIT 100`,
        { userId, maxDepth }
      )
      return result.records.map(r => r.toObject())
    } finally {
      await session.close()
    }
  }
}

完整示例位于

examples/social-graph/typescript-neo4j/

typescript

import neo4j, { Driver } from 'neo4j-driver'

class Neo4jService {
  private driver: Driver

  constructor(uri: string, username: string, password: string) {
    this.driver = neo4j.driver(uri, neo4j.auth.basic(username, password))
  }

  async findFriendsOfFriends(userId: string, maxDepth: number = 2) {
    const session = this.driver.session()
    try {
      const result = await session.run(
        `MATCH (u:User {id: $userId})-[:FRIEND*1..$maxDepth]->(fof)
         WHERE u <> fof
         RETURN DISTINCT fof.id, fof.name
         LIMIT 100`,
        { userId, maxDepth }
      )
      return result.records.map(r => r.toObject())
    } finally {
      await session.close()
    }
  }
}

Go (ArangoDB)

Go（ArangoDB）

import (
    "github.com/arangodb/go-driver"
    "github.com/arangodb/go-driver/http"
)

func findFriendsOfFriends(db driver.Database, userId string, maxDepth int) ([]User, error) {
    query := `
        FOR vertex, edge, path IN 1..@maxDepth OUTBOUND @startVertex GRAPH 'socialGraph'
            FILTER vertex._id != @startVertex
            RETURN DISTINCT vertex
            LIMIT 100
    `

    cursor, err := db.Query(ctx, query, map[string]interface{}{
        "startVertex": userId,
        "maxDepth": maxDepth,
    })

    // Handle results...
}

import (
    "github.com/arangodb/go-driver"
    "github.com/arangodb/go-driver/http"
)

func findFriendsOfFriends(db driver.Database, userId string, maxDepth int) ([]User, error) {
    query := `
        FOR vertex, edge, path IN 1..@maxDepth OUTBOUND @startVertex GRAPH 'socialGraph'
            FILTER vertex._id != @startVertex
            RETURN DISTINCT vertex
            LIMIT 100
    `

    cursor, err := db.Query(ctx, query, map[string]interface{}{
        "startVertex": userId,
        "maxDepth": maxDepth,
    })

    // 处理结果...
}

Schema Validation

Schema验证

Use

scripts/validate_graph_schema.py

to check for:

Unbounded traversals (missing depth limits)
Missing indexes on frequently queried properties
Supernodes (nodes with excessive relationships)
Relationship property consistency

Run validation:

bash

python scripts/validate_graph_schema.py --database neo4j://localhost:7687

使用

scripts/validate_graph_schema.py

检查以下问题：

无界遍历（缺少深度限制）
高频查询属性缺少索引
超级节点（关系数量过多的节点）
关系属性不一致

运行验证：

bash

python scripts/validate_graph_schema.py --database neo4j://localhost:7687

Integration with Other Skills

与其他技能的集成

With databases-vector (Hybrid Search)

与向量数据库集成（混合搜索）

Combine vector similarity with graph context for AI/RAG applications. See

examples/knowledge-graph/

将向量相似度与图上下文结合，用于AI/RAG应用。详见

examples/knowledge-graph/

With search-filter

与搜索过滤集成

Implement relationship-based queries: "Find all users within 3 degrees of connection"

实现基于关系的查询：“查找与某用户连接不超过3度的所有用户”

With ai-chat

与AI聊天集成

Use knowledge graphs to enrich LLM context with structured relationships.

使用知识图谱为LLM补充结构化关系上下文。

With auth-security (ReBAC)

与认证安全集成（ReBAC）

Implement relationship-based access control: "Can user X access resource Y through relation Z?"

实现基于关系的访问控制：“用户X是否可以通过关系Z访问资源Y？”

Common Schema Patterns

常见Schema模式

Star Schema (Hub and Spokes)

星型Schema（中心辐射）

cypher

(:User)-[:PURCHASED]->(:Product)
(:User)-[:VIEWED]->(:Product)
(:User)-[:RATED]->(:Product)

cypher

(:User)-[:PURCHASED]->(:Product)
(:User)-[:VIEWED]->(:Product)
(:User)-[:RATED]->(:Product)

Hierarchical Schema (Trees)

层级Schema（树形）

cypher

(:CEO)-[:MANAGES]->(:VP)-[:MANAGES]->(:Director)

cypher

(:CEO)-[:MANAGES]->(:VP)-[:MANAGES]->(:Director)

Temporal Schema (Event Sequences)

时间Schema（事件序列）

cypher

(:Event {timestamp})-[:NEXT]->(:Event {timestamp})

cypher

(:Event {timestamp})-[:NEXT]->(:Event {timestamp})

Getting Started

快速开始

Choose database: Use decision framework above
Design schema: Reference
```
references/graph-modeling.md
```
Implement queries: Use patterns from
```
references/cypher-patterns.md
```
Validate: Run
```
scripts/validate_graph_schema.py
```
Optimize: Add indexes, bound traversals, cache aggregations

选择数据库：使用上方的决策框架
设计Schema：参考
```
references/graph-modeling.md
```
实现查询：使用
```
references/cypher-patterns.md
```
中的模式
验证：运行
```
scripts/validate_graph_schema.py
```
优化：添加索引、限制遍历深度、缓存聚合结果

拓展阅读

```
references/neo4j.md
```
- Neo4j setup, drivers, GDS algorithms
```
references/arangodb.md
```
- ArangoDB multi-model patterns
```
references/cypher-patterns.md
```
- Comprehensive Cypher query library
```
references/graph-modeling.md
```
- Data modeling best practices
```
examples/social-graph/
```
- Complete social network implementation
```
examples/knowledge-graph/
```
- Hybrid vector + graph for AI/RAG

```
references/neo4j.md
```
- Neo4j安装、驱动、GDS算法
```
references/arangodb.md
```
- ArangoDB多模型模式
```
references/cypher-patterns.md
```
- 完整Cypher查询库
```
references/graph-modeling.md
```
- 数据建模最佳实践
```
examples/social-graph/
```
- 完整社交网络实现
```
examples/knowledge-graph/
```
- AI/RAG混合向量+图实现

using-graph-databases

Original

Translation

Graph Databases

图数据库

Purpose

用途

When to Use This Skill

适用场景

Quick Decision Framework

快速决策框架

Core Concepts

核心概念

Property Graph Model

属性图模型

Query Languages

查询语言

Common Cypher Patterns

常见Cypher模式

Pattern 1: Basic Matching

模式1：基础匹配

Pattern 2: Variable-Length Paths

模式2：可变长度路径

Pattern 3: Shortest Path

模式3：最短路径

Pattern 4: Recommendations

模式4：推荐算法

Pattern 5: Fraud Detection

模式5：欺诈检测

Database Selection Guide

数据库选择指南

Neo4j (Primary Recommendation)

Neo4j（主推）

Python driver

Python驱动

TypeScript driver

TypeScript驱动

Rust driver

Rust驱动

ArangoDB

ArangoDB

Apache AGE

Apache AGE

Amazon Neptune

Amazon Neptune

Graph Data Modeling Patterns

图数据建模模式

Best Practice 1: Relationships as First-Class Citizens

最佳实践1：将关系作为一等公民

Best Practice 2: Relationship Properties for Metadata

最佳实践2：用关系属性存储元数据

Best Practice 3: Bounded Traversals for Performance

最佳实践3：通过有界遍历提升性能

Best Practice 4: Avoid Supernodes

最佳实践4：避免超级节点

Use Case Examples

应用场景示例

Social Network

社交网络

Knowledge Graph for AI/RAG

AI/RAG知识图谱

Step 1: Vector search in Qdrant/pgvector

步骤1：在Qdrant/pgvector中进行向量搜索

Step 2: Expand with graph relationships

步骤2：通过图关系扩展上下文

Recommendation Engine

推荐引擎

Fraud Detection

欺诈检测

Performance Optimization

性能优化

Indexing

索引优化

Caching Expensive Aggregations

缓存昂贵的聚合查询

Scaling Strategies

扩容策略

Language Integration

语言集成

Python (Neo4j)