跳到主要内容

3 篇博文 含有标签「langgraph」

查看所有标签

LangChain and LangGraph

· 阅读需 4 分钟

一、核心定位对比​

维度LangChainLangGraph
本质AI应用开发框架有状态工作流编排引擎
设计目标简化LLM集成与链式调用管理复杂决策流程与循环
抽象层级组件化工具集流程控制层
典型场景单次问答、文档检索多步骤业务决策、自适应系统

二、架构差异图解​

graph TD
subgraph LangChain
A[Prompt模板] --> B[LLM调用]
B --> C[输出解析]
C --> D[工具调用]
end

subgraph LangGraph
E[状态对象] --> F{条件判断}
F -->|是| G[节点A]
F -->|否| H[节点B]
G & H --> I[状态更新]
I --> J[持久化检查点]
end

三、关键技术特性对比​

1. 执行模型​

  • LangChain:

    # 线性链式执行
    chain = prompt | llm | output_parser
    result = chain.invoke({"input": "..."})
  • LangGraph:

    # 图状工作流
    workflow = StateGraph(MyState)
    workflow.add_node("analyze", analyze_node)
    workflow.add_conditional_edges(
    "analyze",
    lambda x: "retry" if x["needs_retry"] else "continue"
    )

2. 状态管理​

能力LangChainLangGraph
多轮对话记忆✅✅🌟
中间结果持久化❌✅
流程回溯❌✅
分支状态存储❌✅

3. 错误恢复机制​

  • LangChain:需手动实现重试逻辑

    from tenacity import retry

    @retry(stop=stop_after_attempt(3))
    def unreliable_chain():
    chain.invoke(...)
  • LangGraph:内置容错流程

    workflow.add_conditional_edges(
    "query_db",
    lambda s: "retry" if s["db_error"] else "next",
    max_retries=3
    )

四、性能基准测试​

测试场景:电商客服工单处理系统(5个决策节点)

指标LangChain实现LangGraph实现
吞吐量 (req/s)1218
平均延迟 (ms)450320
错误恢复时间 (ms)1200400
内存占用 (GB)1.21.8

五、典型应用场景选择指南​

1. 优先选择LangChain的场景​

  • 简单RAG系统:

    retriever = vectorstore.as_retriever()
    qa_chain = RetrievalQA.from_chain_type(llm, retriever=retriever)
  • 快速原型开发:

    chain = (
    PromptTemplate.from_template("...")
    | ChatOpenAI()
    | StrOutputParser()
    )

2. 必须使用LangGraph的场景​

  • 多阶段审批流程:

    def approve_request(state):
    if state["amount"] > 10000:
    return {"next_step": "manager_approval"}
    return {"next_step": "auto_approve"}
  • 动态分析系统:

    workflow.add_conditional_edges(
    "initial_analysis",
    lambda s: "deep_dive" if s["needs_detail"] else "summary"
    )

六、混合架构最佳实践​

1. LangChain作为能力组件​

from langgraph.prebuilt import ToolNode

# 将LangChain工具集成到LangGraph
search_tool = ToolNode.from_langchain_tool(
tavily_search,
name="web_search"
)
workflow.add_node("search", search_tool)

2. 状态感知的Chain调用​

def smart_retrieval(state: dict):
# 根据状态动态调整检索参数
chain = create_retriever_chain(
k=state.get("retrieve_size", 5)
)
return {"results": chain.invoke(state["query"])}

七、开发体验对比​

方面LangChainLangGraph
学习曲线平缓(线性思维)陡峭(图论概念)
调试难度低(单一执行路径)高(多路径跟踪)
扩展性中等(需自定义组件)高(内置分布式支持)
可视化支持LangSmith基础跟踪完整工作流图谱

八、迁移策略建议​

1. 从LangChain迁移到LangGraph​

# 原LangChain代码
chain = prompt | llm | output_parser

# 迁移为LangGraph节点
def chain_node(state):
result = chain.invoke(state["input"])
return {"output": result}

workflow.add_node("llm_chain", chain_node)

2. 渐进式改造路径​

  1. 保持现有Chain作为原子节点
  2. 用LangGraph编排复杂流程
  3. 逐步实现状态感知逻辑

九、未来演进预测​

  1. LangChain定位:

    • 继续作为LLM集成标准库
    • 发展更丰富的预制工具链
  2. LangGraph方向:

    • 强化分布式执行能力
    • 增加可视化编排界面
    • 企业级状态管理方案

最终决策矩阵:

选择依据推荐方案
简单问答/检索LangChain
需要复杂业务流程LangGraph
已有LangChain大量投资混合架构
需要持久化会话状态LangGraph
快速PoC开发LangChain

两种技术栈本质上是互补关系,现代AI系统通常同时使用:

  • LangChain作为"肌肉"(处理具体任务)
  • LangGraph作为"神经系统"(协调整体行为)

WhereQ-GPT with LangGraph and LangChain - II

· 阅读需 4 分钟

🧩 Workflow Overview​

  1. User Input: Receive a natural language question.
  2. Embedding: Convert the question into a vector representation.
  3. Schema Retrieval: Use FAISS to find relevant database schemas based on the vector.
  4. Term Mapping: Map domain-specific terms to database fields using a local knowledge base.
  5. Time Parsing: Identify and standardize time expressions in the question.
  6. SQL Generation: Use OpenAI's GPT model to generate the SQL query.
  7. Execution: Run the SQL query against the database and return results.(Kaggle)

🛠️ Implementation Details​

1. Setup​

Ensure you have the necessary packages installed:(Introduction | 🦜️🔗 LangChain)

pip install langgraph langchain langchain-community openai faiss-cpu

2. Define the LangGraph Nodes​

Each step in the workflow is represented as a node in LangGraph.

a. Embedding Node​

Converts the user's question into a vector.(YouTube)

from langchain.embeddings import OpenAIEmbeddings

def embed_question(state):
question = state['question']
embedding_model = OpenAIEmbeddings()
vector = embedding_model.embed_query(question)
state['vector'] = vector
return state

b. Schema Retrieval Node​

Uses FAISS to find relevant schemas.

import faiss
import numpy as np

def retrieve_schema(state):
vector = np.array(state['vector']).astype('float32')
D, I = state['faiss_index'].search(np.array([vector]), k=3)
matched_schemas = [state['schema_texts'][i] for i in I[0]]
state['matched_schemas'] = matched_schemas
return state

c. Term Mapping Node​

Maps domain-specific terms to database fields.

def map_terms(state):
question = state['question']
term_mappings = state['term_mappings'] # e.g., {'soft drinks': 'beverages'}
for term, field in term_mappings.items():
question = question.replace(term, field)
state['mapped_question'] = question
return state

d. Time Parsing Node​

Identifies and standardizes time expressions.

import re
from datetime import datetime

def parse_time(state):
question = state['mapped_question']
# Simple example for Q3 2024
match = re.search(r'Q([1-4]) (\d{4})', question)
if match:
quarter = int(match.group(1))
year = int(match.group(2))
month_start = (quarter - 1) * 3 + 1
start_date = datetime(year, month_start, 1).strftime('%Y-%m-%d')
end_month = month_start + 2
end_date = datetime(year, end_month, 28).strftime('%Y-%m-%d') # Simplified
state['time_range'] = (start_date, end_date)
else:
state['time_range'] = None
return state

e. SQL Generation Node​

Uses OpenAI's GPT model to generate the SQL query.

from langchain.chat_models import ChatOpenAI
from langchain.prompts import PromptTemplate

def generate_sql(state):
llm = ChatOpenAI(model_name="gpt-3.5-turbo")
prompt = PromptTemplate.from_template("""
Given the following database schemas:
{schemas}

And the question:
{question}

Generate an appropriate SQL query.
""")
input_prompt = prompt.format(
schemas='\n'.join(state['matched_schemas']),
question=state['mapped_question']
)
sql_query = llm.predict(input_prompt)
state['sql_query'] = sql_query
return state

f. Execution Node​

Executes the SQL query against the database.

import sqlite3

def execute_query(state):
conn = sqlite3.connect('your_database.db')
cursor = conn.cursor()
cursor.execute(state['sql_query'])
results = cursor.fetchall()
state['results'] = results
conn.close()
return state

3. Build the LangGraph​

Assemble the nodes into a workflow.

from langgraph.graph import StateGraph, END

graph_builder = StateGraph()

graph_builder.add_node("embed_question", embed_question)
graph_builder.add_node("retrieve_schema", retrieve_schema)
graph_builder.add_node("map_terms", map_terms)
graph_builder.add_node("parse_time", parse_time)
graph_builder.add_node("generate_sql", generate_sql)
graph_builder.add_node("execute_query", execute_query)

graph_builder.set_entry_point("embed_question")
graph_builder.add_edge("embed_question", "retrieve_schema")
graph_builder.add_edge("retrieve_schema", "map_terms")
graph_builder.add_edge("map_terms", "parse_time")
graph_builder.add_edge("parse_time", "generate_sql")
graph_builder.add_edge("generate_sql", "execute_query")
graph_builder.add_edge("execute_query", END)

graph = graph_builder.compile()

4. Run the Workflow​

Initialize the state and run the graph.

initial_state = {
'question': "Sales statistics for soft drinks in Q3 2024",
'faiss_index': your_faiss_index,
'schema_texts': your_schema_texts,
'term_mappings': {'soft drinks': 'beverages'}
}

final_state = graph.invoke(initial_state)
print(final_state['results'])

References:​

WhereQ-GPT with LangGraph and LangChain

· 阅读需 6 分钟

一、平台架构革命:LangGraph驱动的执行引擎​

WhereQ-GPT采用全新的有状态工作流引擎设计,通过LangGraph实现复杂BI查询的智能化编排。平台核心技术栈包括:

  • Python 3.12:利用模式匹配和性能优化
  • LangGraph 0.1:构建闭环决策工作流
  • LangChain 0.2:提供AI基础能力组件
  • Weaviate:多模态向量数据库
  • OpenAI GPT-4o:最新多模态模型
graph LR
A[用户查询] --> B{LangGraph工作流}
B --> C[查询理解节点]
C --> D[多源向量检索]
D --> E[SQL生成节点]
E --> F[数据聚合节点]
F --> G[可视化决策节点]
G --> H{结果满意?}
H -- 否 --> C
H -- 是 --> I[输出结果]

二、LangGraph核心工作流实现​

1. 状态机定义​

from langgraph.graph import StateGraph, END
from typing import TypedDict, List, Annotated
import operator

class QueryState(TypedDict):
raw_query: str
parsed_query: dict
candidate_tables: List[str]
sql_query: str
query_results: dict
visualization_spec: dict

workflow = StateGraph(QueryState)

2. 节点定义与编排​

查询解析节点​

from langchain_core.prompts import ChatPromptTemplate
from langchain_openai import ChatOpenAI

def parse_query(state: QueryState):
parser_prompt = ChatPromptTemplate.from_template("""
作为BI分析师,请解析查询:
{query}

输出JSON结构:
{{
"intent": 查询意图,
"metrics": [指标列表],
"dimensions": [维度列表],
"time_range": {{
"start": "YYYY-MM-DD",
"end": "YYYY-MM-DD"
}}
}}
""")

chain = parser_prompt | ChatOpenAI(model="gpt-4o")
return {"parsed_query": chain.invoke({"query": state["raw_query"]})}

多源向量检索节点​

from langchain_community.vectorstores import Weaviate
from langchain_core.runnables import RunnableLambda

def retrieve_schemas(state: QueryState):
client = weaviate.Client("http://weaviate:8080")
vectorstore = Weaviate(client, "BizSchema", "content")

# 多模态检索:结合文本和结构化特征
retriever = vectorstore.as_retriever(
search_type="hybrid",
search_kwargs={
"text_weight": 0.7,
"vector_weight": 0.3,
"k": 5
}
)

# 并行检索不同领域schema
domains = ["retail", "finance", "manufacturing"]
results = {}
for domain in domains:
results[domain] = retriever.invoke(
f"{state['raw_query']} [DOMAIN:{domain}]"
)

return {"candidate_tables": results}

3. 条件边与循环控制​

def should_retry(state: QueryState):
# 基于结果质量决定是否重试
last_score = state.get("result_score", 0)
return last_score < 0.8 # 置信度阈值

def finalize_output(state: QueryState):
# 验证结果完整性
required_fields = state["parsed_query"]["metrics"]
return all(field in state["query_results"] for field in required_fields)

# 构建工作流
workflow.add_node("parse", parse_query)
workflow.add_node("retrieve", retrieve_schemas)
workflow.add_node("generate_sql", generate_sql)
workflow.add_node("execute_query", execute_query)
workflow.add_node("visualize", generate_visualization)

# 定义边关系
workflow.add_edge("parse", "retrieve")
workflow.add_edge("retrieve", "generate_sql")
workflow.add_edge("generate_sql", "execute_query")
workflow.add_edge("execute_query", "visualize")

# 条件循环边
workflow.add_conditional_edges(
"visualize",
should_retry,
{"retry": "retrieve", "end": END}
)

# 验证边
workflow.add_edge("visualize", finalize_output)
workflow.set_entry_point("parse")

三、多领域商业模型支持​

1. 零售业增强实现​

class RetailWorkflow(StateGraph):
def __init__(self):
super().__init__(QueryState)
self.add_node("apply_promo_rules", self._apply_promo_rules)

def _apply_promo_rules(self, state: QueryState):
# 促销规则引擎集成
promo_chain = (
ChatPromptTemplate.from_template("""
根据促销规则修正查询:
原始查询:{{query}}
当前结果:{{results}}

可用促销规则:
- 买一赠一商品需合并统计
- 跨店满减需计算实际收入
""")
| ChatOpenAI(model="gpt-4", temperature=0)
| StrOutputParser()
)
return {"query_results": promo_chain.invoke(state)}

2. 制造业KPI计算​

manufacturing_kpis = {
"oee": {
"formula": "(good_units * ideal_cycle_time) / (production_time * max_speed)",
"dependencies": ["production_facts", "machine_specs"]
},
"throughput": {
"formula": "total_units / active_hours",
"vector_path": "manufacturing/kpis/throughput"
}
}

def calculate_kpi(state: QueryState):
# 从向量库加载KPI定义
kpi_def = vectorstore.similarity_search(
state["parsed_query"]["metrics"][0],
filter={"domain": "manufacturing"}
)

# 动态公式计算
return {"query_results": eval_kpi(kpi_def, state["query_results"])}

四、LangGraph高级特性应用​

1. 多工作流编排​

from langgraph.graph import Graph

master_graph = Graph()

@master_graph.node
def route_query(state):
# 领域路由
if "sales" in state["raw_query"].lower():
return {"subgraph": "retail"}
elif "machine" in state["raw_query"].lower():
return {"subgraph": "manufacturing"}

@master_graph.edge("route_query", lambda state: state["subgraph"])
def select_subgraph(state):
return state["subgraph"]

# 注册子工作流
master_graph.add_subgraph("retail", RetailWorkflow())
master_graph.add_subgraph("manufacturing", ManufacturingWorkflow())

2. 持久化状态管理​

from langgraph.checkpoint import MemorySaver

workflow = StateGraph(
QueryState,
checkpoint=MemorySaver()
)

# 从历史状态恢复
def restore_state(query_id):
return workflow.get_state(query_id)

# 自动保存点
workflow.add_node("savepoint", lambda state: state)
workflow.add_edge("generate_sql", "savepoint")

3. 分布式执行控制​

from langgraph.distributed import RayExecutor

ray_executor = RayExecutor(
workflow.compile(),
runtime_env={"pip": ["langchain", "weaviate-client"]}
)

future = ray_executor.submit({
"raw_query": "Q3季度各区域销售对比",
"session_id": "user123"
})
result = future.result()

五、性能优化策略​

1. 向量检索优化​

# Weaviate混合索引配置
class BizSchema(WeaviateClass):
class_name = "BizSchema"
vectorizer = "multi2vec-clip"
properties = [
{"name": "domain", "dataType": ["text"]},
{"name": "formula", "dataType": ["text"]},
{
"name": "structural_features",
"dataType": ["number[]"],
"vectorIndexConfig": {
"pq": {"enabled": True}
}
}
]

2. 工作流缓存​

from langgraph.cache import SQLiteCache

workflow = StateGraph(
QueryState,
checkpoint=SQLiteCache("whereq_cache.db")
)

3. 异步并行执行​

async def parallel_nodes(state):
# 并行执行不依赖的节点
parse_task = asyncio.create_task(parse_query(state))
retrieve_task = asyncio.create_task(retrieve_schemas(state))

parsed, schemas = await asyncio.gather(parse_task, retrieve_task)
return {**parsed, **schemas}

六、典型业务场景实现​

零售促销分析案例​

用户查询:
"对比618和双11大促期间,美妆品类在不同价格带的转化率差异"

工作流执行轨迹:

  1. 解析出关键要素:

    • 时间范围:618 vs 双11
    • 品类:美妆
    • 维度:价格带
    • 指标:转化率
  2. LangGraph触发多路径执行:

    graph TB
    A[解析查询] --> B[检索促销规则]
    A --> C[检索产品目录]
    B --> D[生成促销调整SQL]
    C --> D
    D --> E[执行查询]
    E --> F{数据质量检查}
    F -- 不满足 --> B
    F -- 通过 --> G[生成热力图]
  3. 最终输出:

    {
    "visualization": {
    "type": "heatmap",
    "data": {
    "x": ["0-100元", "100-300元", "300元以上"],
    "y": ["618", "双11"],
    "z": [[0.15, 0.22, 0.08], [0.18, 0.25, 0.12]]
    },
    "annotations": [
    {
    "text": "高端产品在双11表现更好",
    "position": [2, 1]
    }
    ]
    }
    }

七、平台扩展设计​

1. 插件系统​

from langgraph.extensions import Plugin

class CustomKpiPlugin(Plugin):
def __init__(self):
super().__init__()
self.hooks = {
"pre_visualization": self.add_kpi_trendline
}

def add_kpi_trendline(self, state):
# 自动添加趋势线分析
if "trend" in state["parsed_query"]["intent"]:
state["visualization_spec"]["config"]["trendline"] = True
return state

2. 实时流式响应​

from langgraph.streaming import StreamingEventHandler

class WhereQHandler(StreamingEventHandler):
def on_query_parsed(self, data):
self.emit("parser", data["parsed_query"])

def on_results_ready(self, data):
self.emit("data", data["query_results"])

def on_visualization(self, data):
self.emit("viz", data["visualization_spec"])

workflow = StateGraph(
QueryState,
handlers=[WhereQHandler()]
)

WhereQ-GPT通过LangGraph实现的工作流引擎,相比传统BI系统具有以下优势:

  1. 动态适应性:根据中间结果自动调整执行路径
  2. 领域智能:内置行业特定处理逻辑
  3. 可观测性:完整记录决策过程
  4. 持续进化:通过检查点机制实现经验积累