从零开始学习搭建Agent第二天: 理解langchain core 和langgraph的概念

最新推荐文章于 2026-06-23 22:33:34 发布

原创最新推荐文章于 2026-06-23 22:33:34 发布 · 193 阅读

4 ·

本内容遵循CC 4.0 BY-SA版权协议

GEO检测

标签

#学习 #langchain #AI编程

AI Agent 学习记录（2026-06-16）

今天通过尚硅谷的视频教程，大概浏览了一遍 Python 的基础概念。

因为本身有 C# 开发经验，所以 Python 语法理解起来并不困难，大部分概念都能快速对应上。

当前阶段的重点并不是 Python 本身，而是：

LangChain Core
LangGraph
Agent 运行机制

后续计划：

深入阅读 LangChain / LangGraph 源码
自己用 C# 实现一套简化版
通过实践理解 Agent 的运行逻辑

模型环境

目前有两种方式：

方案一：调用 API

购买 DeepSeek API

from openai import OpenAI

client = OpenAI(
    api_key="xxx",
    base_url="https://api.deepseek.com"
)

优点：

简单
稳定
不需要本地显卡

方案二：本地模型

如果有显卡，可以通过 Ollama 启动模型。

例如：

ollama run deepseek-r1

或者：

ollama run qwen3

优点：

数据本地化
无调用成本
方便测试 Agent

LangChain 当前路线

目前 LangChain 官方重心已经转向：

LangChain Core
      ↓
LangGraph
      ↓
各种 Agent

因此不建议再花太多时间研究旧版本：

LLMChain
ConversationChain
AgentExecutor

1. LangChain Core 是什么

可以理解成：

Prompt
  ↓
Model
  ↓
Parser

以前：

LLMChain
ConversationChain
AgentExecutor

现在统一抽象为：

Runnable

示例：

from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate

llm = ChatOpenAI()

prompt = ChatPromptTemplate.from_template(
    "请介绍一下 {topic}"
)

chain = prompt | llm

result = chain.invoke({
    "topic": "LangGraph"
})

print(result.content)

这里的：

叫做：

LCEL
LangChain Expression Language

类似 Linux 管道：

cat a.txt | grep test

2. Prompt → LLM → OutputParser

实际项目最常见模式：

from langchain_core.output_parsers import StrOutputParser

chain = (
    prompt
    | llm
    | StrOutputParser()
)

result = chain.invoke({
    "topic": "Dify"
})

print(result)

执行流程：

Prompt
 ↓
ChatModel
 ↓
Parser
 ↓
String

3. RunnableLambda

用于插入自定义逻辑。

from langchain_core.runnables import RunnableLambda

def add_prefix(text):
    return f"AI回答：{text}"

chain = (
    prompt
    | llm
    | StrOutputParser()
    | RunnableLambda(add_prefix)
)

执行流程：

Prompt
 ↓
LLM
 ↓
Parser
 ↓
Python函数

4. RunnableParallel

并行执行多个任务。

from langchain_core.runnables import RunnableParallel

chain = RunnableParallel(
    summary=summary_chain,
    keyword=keyword_chain
)

结果：

{
    "summary": "xxx",
    "keyword": "xxx"
}

结构：

          content
          /    \
         /      \
    summary   keyword

5. RAG 核心写法

假设已经存在：

retriever

构建检索链：

from langchain_core.runnables import RunnablePassthrough

chain = (
    {
        "context": retriever,
        "question": RunnablePassthrough()
    }
    | prompt
    | llm
    | StrOutputParser()
)

调用：

chain.invoke(
    "什么是 Agent Loop？"
)

执行过程：

问题
 ↓
Retriever
 ↓
知识检索

{
  context: 检索结果,
  question: 原问题
}

 ↓
Prompt
 ↓
LLM

这已经是：

Dify
FastGPT
LangGraph

等产品的核心模式。

6. Tool 调用

定义工具：

from langchain_core.tools import tool

@tool
def get_weather(city: str):
    """获取天气"""
    return f"{city} 30度"

模型实际看到的是：

{
  "name": "get_weather",
  "description": "获取天气",
  "parameters": {
    "city": "string"
  }
}

流程：

LLM
 ↓
决定调用工具
 ↓
Tool
 ↓
返回结果
 ↓
LLM总结

7. Agent

官方现在推荐：

create_react_agent()

示例：

from langgraph.prebuilt import create_react_agent

agent = create_react_agent(
    model=llm,
    tools=[get_weather]
)

调用：

agent.invoke({
    "messages": [
        (
            "user",
            "上海天气怎么样"
        )
    ]
})

内部流程：

用户
 ↓
LLM

判断需要调用工具

 ↓
Tool

get_weather("上海")

 ↓
LLM总结

返回答案

8. State（LangGraph核心）

这是 LangGraph 最重要的概念。

定义状态：

from typing import TypedDict

class State(TypedDict):
    question: str
    answer: str

节点：

def llm_node(state):
    result = llm.invoke(
        state["question"]
    )

    return {
        "answer": result.content
    }

本质：

State
 ↓
Node
 ↓
State
 ↓
Node
 ↓
State

整个 Workflow 都围绕 State 流转。

9. ERP Agent 示例

用户：

查询前100条工单

流程：

用户问题
      ↓
Intent Node
      ↓
识别意图

      ↓
Tool Node

调用:
get_work_order()

      ↓
Result Node

格式化结果

      ↓
返回用户

对应 State：

{
    "question": "",
    "intent": "",
    "tool_result": "",
    "answer": ""
}

状态不断更新：

Question
   ↓
Intent
   ↓
Tool
   ↓
Answer

当前理解

现代 Agent 本质上就是：

State
 +
Node
 +
Tool
 +
LLM

不断循环执行。

用户输入
     ↓
状态更新
     ↓
LLM思考
     ↓
调用工具
     ↓
更新状态
     ↓
生成答案

而 Dify、FastGPT、LangGraph 本质上都是在解决同一个问题：

如何让状态在多个节点之间流转
并驱动大模型完成任务

下一步计划

第一阶段：

学习 LangChain Core
理解 Runnable
理解 Tool
理解 RAG

第二阶段：

学习 LangGraph
理解 State
理解 Node
理解 Edge
理解 Checkpoint

第三阶段：

阅读 Dify 源码
阅读 FastGPT 源码
阅读 OpenHands 源码

第四阶段：

使用 C# 实现简化版 Agent Framework
实现 Workflow
实现 Tool Calling
实现 Memory
实现 RAG