Neo4j on Chico's Tech Bloghttps://realtime-ai.chat/tags/neo4j/Recent content in Neo4j on Chico's Tech BlogChico's Tech Bloghttps://github.com/chicogong.pnghttps://github.com/chicogong.pngHugozh-cnFri, 05 Dec 2025 10:00:00 +0800LangGraph 1.0 详解：构建生产级有状态Agent工作流https://realtime-ai.chat/posts/langgraph-stateful-agent-workflow/Fri, 05 Dec 2025 10:00:00 +0800https://realtime-ai.chat/posts/langgraph-stateful-agent-workflow/LangGraph 1.0 完整详解:图状态编排、持久化执行、检查点机制,手把手构建生产级有状态 Agent 工作流。引言

2025年，LangGraph正式发布1.0版本，成为构建生产级AI Agent的首选框架。作为LangChain生态系统的核心组件，LangGraph提供了图状态编排（Graph-based Orchestration）能力，支持Agent的循环、分支、回溯和动态决策。更重要的是，它内置了持久化执行（Durable Execution）、**检查点（Checkpointing）和人工干预（Human-in-the-Loop）**等企业级功能。本文将深入探讨LangGraph的概念、工作原理、应用场景以及实践技巧。

知识图谱与LangChain Graph基础

什么是知识图谱？

知识图谱(Knowledge Graph)是一种结构化数据模型，用于表示实体(Entities)之间的关系(Relations)。它以图的形式组织信息，其中：

  • 节点(Nodes)：代表实体或概念
  • 边(Edges)：代表实体间的关系
graph LR
    A["艾伦·图灵"] -->|"发明"| B["图灵机"]
    A -->|"出生于"| C["英国"]
    A -->|"被誉为"| D["计算机科学之父"]
    B -->|"是"| E["理论计算模型"]

LangChain Graph的定义与价值

LangChain Graph是LangChain框架中专注于知识图谱构建、存储和查询的模块集合。它将LLM的自然语言处理能力与图数据库的结构化表示结合，实现了：

  1. 自动从文本中提取实体和关系
  2. 构建和维护知识图谱
  3. 基于图结构进行复杂查询和推理
  4. 增强LLM应用的上下文理解和回答质量

LangChain Graph架构

LangChain Graph的整体架构可以通过以下图示来理解：

flowchart TB
    subgraph "输入层"
        A["文本文档"] --> B["网页内容"]
        C["结构化数据"] --> D["用户查询"]
    end
    
    subgraph "处理层"
        E["实体提取
EntityExtractor"]
        F["关系提取
RelationExtractor"]
        G["知识图谱构建
KnowledgeGraphCreator"]
    end
    
    subgraph "存储层"
        H["图数据库
Neo4j/NetworkX"]
        I["向量存储
VectorStores"]
    end
    
    subgraph "应用层"
        J["图查询
GraphQuery"]
        K["图推理
GraphReasoning"]
        L["QA系统
GraphQAChain"]
    end
    
    A --> E
    B --> E
    C --> F
    D --> F
    E --> G
    F --> G
    G --> H
    G --> I
    H --> J
    H --> K
    I --> L

核心组件详解

1. 实体和关系提取器

这些组件负责从文本中识别实体和它们之间的关系：

sequenceDiagram
    participant Text as 文本输入
    participant LLM as 大语言模型
    participant EE as EntityExtractor
    participant RE as RelationExtractor
    participant KG as 知识图谱
    
    Text->>LLM: 发送文本
    LLM->>EE: 提取实体
    EE->>RE: 传递识别的实体
    RE->>LLM: 使用LLM确定实体间关系
    RE->>KG: 构建三元组(主体-关系-客体)

2. 知识图谱构建

flowchart LR
    A["文本"] --> B{"实体提取"}
    B --> |"人物/地点/组织等"| C["实体列表"]
    C --> D{"关系提取"}
    D --> |"分析实体间关联"| E["三元组集合"]
    E --> F["知识图谱构建器"]
    F --> G[("图数据库")]
    F --> H["内存图"]

3. 图存储和查询

LangChain Graph支持多种图存储方式：

graph TD
    A["知识图谱数据"] --> B{"存储方式"}
    B -->|"内存存储"| C["NetworkX"]
    B -->|"图数据库"| D["Neo4j"]
    B -->|"向量数据库"| E["Chroma/FAISS等"]
    
    C --> F{"查询方式"}
    D --> F
    E --> F
    F -->|"Cypher查询"| G["Neo4j查询"]
    F -->|"图算法"| H["NetworkX算法"]
    F -->|"自然语言"| I["LLM辅助查询"]

构建知识图谱的工作流程

以下是使用LangChain Graph构建知识图谱的完整流程：

flowchart TD
    A["准备文本数据"] --> B["文本处理和分块"]
    B --> C["实体提取"]
    C --> D["关系识别"]
    D --> E["三元组生成"]
    E --> F["图构建和存储"]
    F --> G["图查询和利用"]
    
    subgraph "文本处理阶段"
        A
        B
    end
    
    subgraph "信息提取阶段"
        C
        D
        E
    end
    
    subgraph "图构建阶段"
        F
    end
    
    subgraph "应用阶段"
        G
    end

实际代码示例

让我们通过实际代码来理解LangChain Graph的使用方法。

1. 基础设置

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

// 导入必要的包
import { ChatOpenAI } from "@langchain/openai";
import { EntityExtractor, RelationExtractor, KnowledgeGraph } from "langchain/graphs";
import { Neo4jGraph } from "langchain/graphs/neo4j_graph";
import { Document } from "langchain/document";

// 初始化LLM
const llm = new ChatOpenAI({
  temperature: 0,
  model: "gpt-4-turbo"
});

2. 从文本构建知识图谱

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

// 准备文本
const text = `
艾伦·图灵于1912年出生于英国伦敦。他是计算机科学和人工智能的先驱。
图灵在剑桥大学国王学院和普林斯顿大学学习。他于1936年发表了关于图灵机的论文。
在第二次世界大战期间，图灵在英国密码破译中心布莱切利园工作，成功破解了德国的英格玛密码。
`;

// 创建文档
const docs = [
  new Document({ pageContent: text })
];

// 初始化Neo4j图数据库连接
const graph = await Neo4jGraph.initialize({
  url: "neo4j://localhost:7687",
  username: "neo4j",
  password: "password"
});

// 创建知识图谱构建器
const kg = new KnowledgeGraph({
  llm,
  entityExtractor: new EntityExtractor({ llm }),
  relationExtractor: new RelationExtractor({ llm })
});

// 从文本构建知识图谱
await kg.buildFromDocuments(docs, { graph });

3. 查询知识图谱

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

// Cypher查询
const cypherQuery = `
MATCH (p:Person {name: '艾伦·图灵'})-[r]->(o)
RETURN p, r, o
`;

const result = await graph.query(cypherQuery);
console.log(result);

// 自然语言查询
import { GraphCypherQAChain } from "langchain/chains";

const chain = GraphCypherQAChain.fromLLM({
  llm,
  graph,
  verbose: true
});

const answer = await chain.invoke({
  query: "艾伦·图灵在哪里上的大学？"
});

console.log(answer.text);

应用场景图解

1. 智能问答系统

sequenceDiagram
    actor User as 用户
    participant QA as QA系统
    participant LLM as 大语言模型
    participant KG as 知识图谱
    
    User->>QA: 提问
    QA->>LLM: 分析问题
    LLM->>QA: 确定查询意图
    QA->>KG: 构建图查询
    KG->>QA: 返回相关子图
    QA->>LLM: 基于子图生成回答
    LLM->>QA: 生成回答
    QA->>User: 呈现回答

2. 知识发现与推理

graph TD
    A["文档集合"] --> B["知识图谱"]
    B --> C{"路径分析"}
    B --> D{"社区发现"}
    B --> E{"关系推断"}
    
    C --> F["隐藏关联发现"]
    D --> G["领域聚类"]
    E --> H["新知识产生"]
    
    F --> I["知识增强的应用"]
    G --> I
    H --> I

3. 内容推荐系统

flowchart LR
    A["用户"] --> B{"兴趣提取"}
    B --> C["用户实体图"]
    
    D["内容库"] --> E{"内容分析"}
    E --> F["内容知识图"]
    
    C --> G{"图匹配算法"}
    F --> G
    G --> H["个性化推荐"]
    H --> A

高级用法：复杂知识图谱

1. 多源数据集成

flowchart TB
    A1["文本文档"] --> B["数据预处理"]
    A2["结构化数据"] --> B
    A3["网页内容"] --> B
    A4["APIs"] --> B
    
    B --> C{"实体统一"}
    C --> D{"关系提取"}
    D --> E["图构建"]
    
    E --> F{"图增强"}
    F --> G["实体链接"]
    F --> H["异构合并"]
    F --> I["冲突消解"]
    
    G --> J["完整知识图谱"]
    H --> J
    I --> J

2. 图引导的推理增强

flowchart LR
    A["用户查询"] --> B{"分析意图"}
    B --> C["知识图谱查询"]
    C --> D["子图检索"]
    
    D --> E{"构建提示"}
    E --> F["边界约束"]
    E --> G["路径引导"]
    E --> H["属性填充"]
    
    F --> I["增强提示"]
    G --> I
    H --> I
    I --> J["LLM推理"]
    J --> K["精确回答"]

代码实现：复杂查询示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

// 创建自定义实体和关系提取器
const entityExtractor = new EntityExtractor({ 
  llm,
  allowedEntityTypes: ["Person", "Organization", "Location", "Event", "Work", "Concept"],
  contextWindowSize: 3000
});

const relationExtractor = new RelationExtractor({
  llm,
  relationExtractionPrompt: `识别以下文本中实体之间的关系，并以(主体, 关系, 客体)的形式返回。注意关系应该是具体且有意义的动词短语。`,
  validateRelations: true,
  maxRelationsPerEntityPair: 3
});

// 实现增量式图构建
async function incrementalGraphBuild(documents, graph) {
  const kg = new KnowledgeGraph({
    llm,
    entityExtractor,
    relationExtractor
  });
  
  // 批处理文档
  const batchSize = 5;
  for (let i = 0; i < documents.length; i += batchSize) {
    const batch = documents.slice(i, i + batchSize);
    console.log(`处理批次 ${Math.floor(i/batchSize) + 1}/${Math.ceil(documents.length/batchSize)}`);
    
    await kg.buildFromDocuments(batch, { 
      graph,
      mergeEntities: true  // 合并同名实体
    });
  }
  
  return graph;
}

// 复杂查询示例
async function complexGraphQuery(graph, query) {
  const chain = GraphCypherQAChain.fromLLM({
    llm: new ChatOpenAI({ model: "gpt-4", temperature: 0 }),
    graph,
    returnDirect: false,  // 不直接返回Cypher查询结果
    cypherPrompt: `根据以下问题，生成适当的Cypher查询以从知识图谱中检索相关信息。考虑使用图算法和复杂模式匹配。`
  });
  
  return chain.invoke({ query });
}

最佳实践与优化技巧

1. 实体和关系定义策略

graph TD
    A["定义实体类型"] --> B{"选择粒度"}
    B --> |"粗粒度"| C["主要类别
如人/地点/组织"]
    B --> |"细粒度"| D["详细类别
如政治家/城市/科技公司"]
    
    C --> E{"关系定义"}
    D --> E
    E --> |"语义明确"| F["精确关系
如'创立'而非'关联'"]
    E --> |"一致性"| G["标准化关系名称"]
    
    F --> H["图模式设计"]
    G --> H
    H --> I["属性与关系区分"]
    H --> J["多重关系处理"]

2. 性能优化技巧

对于大规模知识图谱，以下优化技巧至关重要：

flowchart TD
    A["性能优化"] --> B{"处理大型文档"}
    A --> C{"查询优化"}
    A --> D{"存储策略"}
    
    B --> B1["分块处理"]
    B --> B2["并行提取"]
    B --> B3["批量处理"]
    
    C --> C1["查询缓存"]
    C --> C2["索引优化"]
    C --> C3["查询重写"]
    
    D --> D1["图数据分区"]
    D --> D2["冷热数据分离"]
    D --> D3["增量更新"]

完整工作流：从文档到智能应用

下面是一个完整的工作流，展示了如何从文档构建知识图谱并应用到实际应用场景：

flowchart TD
    subgraph "数据准备"
        A1["文档收集"] --> A2["文档清洗"]
        A2 --> A3["文档分块"]
    end
    
    subgraph "知识提取"
        A3 --> B1["实体识别"]
        B1 --> B2["关系提取"]
        B2 --> B3["属性提取"]
    end
    
    subgraph "图构建与存储"
        B3 --> C1["三元组生成"]
        C1 --> C2["图构建"]
        C2 --> C3["图存储"]
    end
    
    subgraph "图增强"
        C3 --> D1["实体链接"]
        D1 --> D2["推理扩展"]
        D2 --> D3["图验证"]
    end
    
    subgraph "应用集成"
        D3 --> E1["问答系统"]
        D3 --> E2["搜索增强"]
        D3 --> E3["内容推荐"]
        D3 --> E4["决策支持"]
    end

实际案例：研究领域知识图谱

以下是一个构建学术研究领域知识图谱的完整示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81

// 示例：构建AI研究领域知识图谱
import { OpenAI } from "@langchain/openai";
import { RecursiveCharacterTextSplitter } from "langchain/text_splitter";
import { EntityExtractor, RelationExtractor, KnowledgeGraph } from "langchain/graphs";
import { Neo4jGraph } from "langchain/graphs/neo4j_graph";
import { GraphRAGRetriever } from "langchain/retrievers/graph_rag";
import { RetrievalQAChain } from "langchain/chains";
import { Document } from "langchain/document";

async function buildResearchGraph(papers, graph) {
  // 初始化LLM
  const llm = new ChatOpenAI({
    temperature: 0,
    model: "gpt-4"
  });
  
  // 自定义实体提取器
  const entityExtractor = new EntityExtractor({
    llm,
    allowedEntityTypes: [
      "Researcher", "Paper", "University", "Conference", 
      "ResearchField", "Method", "Algorithm", "Dataset"
    ]
  });
  
  // 自定义关系提取器
  const relationExtractor = new RelationExtractor({
    llm,
    validateRelations: true
  });
  
  // 初始化知识图谱构建器
  const kg = new KnowledgeGraph({
    llm,
    entityExtractor,
    relationExtractor
  });
  
  // 文本分割
  const textSplitter = new RecursiveCharacterTextSplitter({
    chunkSize: 2000,
    chunkOverlap: 200
  });
  
  // 处理每篇论文
  for (const paper of papers) {
    console.log(`处理论文: ${paper.title}`);
    
    // 创建文档
    const text = `标题: ${paper.title}\n作者: ${paper.authors.join(', ')}\n摘要: ${paper.abstract}\n关键字: ${paper.keywords.join(', ')}`;
    const docs = await textSplitter.createDocuments([text]);
    
    // 构建图
    await kg.buildFromDocuments(docs, {
      graph,
      mergeEntities: true
    });
  }
  
  return graph;
}

// 基于图的检索增强生成
async function graphBasedAnswering(graph, query) {
  const llm = new ChatOpenAI({ model: "gpt-4" });
  
  // 创建图检索器
  const retriever = new GraphRAGRetriever({
    graph,
    llm,
    searchDepth: 3,  // 图搜索深度
    maxHops: 2       // 最大跳数
  });
  
  // 创建问答链
  const chain = RetrievalQAChain.fromLLM(llm, retriever);
  
  // 获取答案
  const response = await chain.invoke({ query });
  return response;
}

总结

LangChain Graph为开发者提供了强大的工具集，使从非结构化文本构建知识图谱变得简单而高效。通过结合LLM的语义理解能力与图数据库的结构化表示，它开启了一系列新的应用可能性：

  1. 语义增强的信息检索：超越简单的关键词匹配
  2. 复杂关系推理：发现隐藏的知识连接
  3. 上下文感知回答：基于图结构的精准回答
  4. 知识整合与管理：连接多源异构数据

随着LLM技术和图数据库的不断发展，LangChain Graph将在智能知识系统中扮演越来越重要的角色，为构建下一代AI应用提供强大支持。

无论您是希望增强现有LLM应用的上下文理解能力，还是构建专门的知识管理系统，LangChain Graph都是一个值得深入学习和掌握的强大工具。

扩展阅读

]]>