AI Agent从无到有61:LangGraph 核心组件与工作流控制完全指南

AI Agents 2026:从对话界面到自主执行的操作系统 AI Agent(智能体)是具备感知、规划、工具调用与执行能力的自主软件实体,其核心原理在于将大语言模型与外部系统深度耦合,通过任务分解、记忆管理、安全沙箱和可验证规划实现闭环决策。相比传统RAG或单点AI应用,Agent的技术价值在于系统级自动化——它不只生成答案,更能驱动ERP、MES、CRM等生产系统完成真实业务动作。典型应用场景覆盖制造业预测性维护、金融风控决策、SaaS客户成功运营等高价值、高确定性流程。2026年成为落地拐点,关键得益于工具调用语义化、LLM推理成本坍缩与OpenTool Pro 阅读详情

纲要

  • LangGraph 概述:图结构替代链式调用
  • 核心概念
    • State:节点间共享的数据流
    • Node:功能单元,输入 → 输出
    • Edge:普通边与条件边
    • Graph:编排节点与边的执行流程
  • 基础入门:第一个 LangGraph
    • 定义 State 与节点函数
    • 构建图并可视化
  • 工作流控制模式
    • 串行执行
    • 并行分支
    • 条件分支与循环
    • 运行时动态配置
    • Map-Reduce 模式
  • 完整可运行示例
    • 环境准备
    • 综合演示代码
  • API 速览
  • 参考文档
  • 总结

LangGraph 是什么

LangChain 中的 Chain 概念适用于线性串联任务,但当应用需要复杂的分支、循环或并行处理时,链式结构难以应对。LangGraph 将应用建模为有向图:节点代表任务单元,边控制数据流动方向。这种范式天然适合多步推理、人机协同和多智能体编排。

LangGraph 建立在 LangChain 之上,与其生态系统完全兼容,开发者可以无缝复用现有的 LCEL 链、工具和模型。

核心概念:State、Node、Edge、Graph

一切工作流都由四个核心元素构成:

  • State:在节点之间传递的共享数据,通常用 TypedDict 或 Pydantic 模型定义。State 的更新遵循 reducer 函数指定的合并逻辑。
  • Node:一个 Python 可调用对象(函数或 Runnable),接收 State 并返回部分更新的 State。节点可以封装大模型调用、工具执行或任意业务逻辑。
  • Edge:
    • 普通边:固定指向下一个节点,表示确定性流转。
    • 条件边:根据 State 中的某个字段或函数返回值动态决定目标节点,支持分支和循环。
  • Graph:组合节点和边的执行引擎,通过 compile() 生成可运行对象,支持 invoke、stream 和 ainvoke 等接口。

Graph

Edge

Conditional Edge

Edge

State

Node A

Node B

Node C

END

基础入门:第一个 LangGraph

从一个极简示例开始:一个节点响应消息,然后结束。

from typing import TypedDict
from langgraph.graph import StateGraph, END
from langchain_core.messages import HumanMessage, AIMessage

# 1. 定义 State
class SimpleState(TypedDict):
    messages: list

# 2. 定义节点
def greeting_node(state: SimpleState) -> dict:
    # 安全地获取最后一条用户消息
    user_msg = state["messages"][-1].content if state.get("messages") else "未提供内容"
    reply = AIMessage(content=f"你好,你刚才说:「{user_msg}」")
    return {"messages": state.get("messages", []) + [reply]}

# 3. 构建图
builder = StateGraph(SimpleState)
builder.add_node("greet", greeting_node)
builder.set_entry_point("greet")
builder.add_edge("greet", END)
app = builder.compile()

# 4. 运行
result = app.invoke({"messages": [HumanMessage(content="大家好")]})
for m in result["messages"]:
    print(m.content)

这段代码展示了 StateGraph 的基本用法:定义状态、添加节点、设置入口和出口,最后编译运行。

图可视化

LangGraph 支持将图结构渲染为 Mermaid 图表,便于调试和文档生成:

# 生成 Mermaid 代码
print(app.get_graph().draw_mermaid())

# 在 Jupyter 中直接渲染
# from IPython.display import Image
# Image(app.get_graph().draw_mermaid_png())

工作流控制模式

串行执行

多个节点按顺序执行,上一节点的输出自动传递到下一节点。这是最基础的工作流模式。

from typing import TypedDict
from langgraph.graph import StateGraph, END

class SerialState(TypedDict):
    value: str

def step_a(state: SerialState) -> dict:
    return {"value": state["value"] + " -> A"}

def step_b(state: SerialState) -> dict:
    return {"value": state["value"] + " -> B"}

def step_c(state: SerialState) -> dict:
    return {"value": state["value"] + " -> C"}

builder = StateGraph(SerialState)
builder.add_node("a", step_a)
builder.add_node("b", step_b)
builder.add_node("c", step_c)
builder.set_entry_point("a")
builder.add_edge("a", "b")
builder.add_edge("b", "c")
builder.add_edge("c", END)
app = builder.compile()

result = app.invoke({"value": "START"})
print(result["value"])  # START -> A -> B -> C

A

B

C

END

并行分支

从一个节点出发,可以同时触发多个后继节点,它们的输出会按 State 中定义的 reducer 规则(如列表追加)自动汇合。

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

class BranchState(TypedDict):
    items: Annotated[list, operator.add]

def source(state: BranchState) -> dict:
    # 确保 items 不为空,供下游节点安全访问
    return {"items": ["root"]}

def branch_x(state: BranchState) -> dict:
    last = state["items"][-1] if state.get("items") else "root"
    return {"items": [f"X({last})"]}

def branch_y(state: BranchState) -> dict:
    last = state["items"][-1] if state.get("items") else "root"
    return {"items": [f"Y({last})"]}

builder = StateGraph(BranchState)
builder.add_node("src", source)
builder.add_node("x", branch_x)
builder.add_node("y", branch_y)
builder.set_entry_point("src")
builder.add_edge("src", "x")
builder.add_edge("src", "y")
builder.add_edge("x", END)
builder.add_edge("y", END)
app = builder.compile()

result = app.invoke({"items": []})
print(result["items"])  # 输出: ['root', 'X(root)', 'Y(root)'](顺序可能不同)

src

x

y

END

注意:并行分支的执行顺序是不确定的,如果业务逻辑依赖顺序,应使用串行模式或在 State 中维护排序信息。

条件分支与循环

条件边根据当前 State 动态选择下一个节点。配合循环可以实现类似 Agent 的“思考-行动”循环。

from typing import TypedDict, Annotated, Sequence
from langchain_core.messages import BaseMessage
from langgraph.graph import StateGraph, END
import operator

class LoopState(TypedDict):
    messages: Annotated[Sequence[BaseMessage], operator.add]
    counter: int

def thinker(state: LoopState) -> dict:
    # 模拟思考:每轮递增计数器
    return {"counter": state.get("counter", 0) + 1}

def router(state: LoopState) -> str:
    if state.get("counter", 0) < 5:
        return "continue"
    return "end"

builder = StateGraph(LoopState)
builder.add_node("think", thinker)
builder.set_entry_point("think")
builder.add_conditional_edges(
    "think",
    router,
    {
        "continue": "think",
        "end": END
    }
)
app = builder.compile()

result = app.invoke({"messages": [], "counter": 0})
print(result["counter"])  # 输出 5

counter < 5

counter >= 5

think

router

END

运行时动态配置

在调用时传入配置,可以动态切换节点内使用的资源,例如选择不同的 LLM 或调整超参数。

from typing import TypedDict
from langgraph.graph import StateGraph, END
from langchain_openai import ChatOpenAI

class ConfigState(TypedDict):
    query: str
    answer: str

def model_node(state: ConfigState, config: dict) -> dict:
    # 从运行时配置中读取模型名称
    model_name = config.get("configurable", {}).get("model", "gpt-3.5-turbo")
    llm = ChatOpenAI(model=model_name, temperature=0)
    response = llm.invoke(state["query"])
    return {"answer": response.content}

builder = StateGraph(ConfigState)
builder.add_node("model", model_node)
builder.set_entry_point("model")
builder.add_edge("model", END)
app = builder.compile()

# 使用默认模型
res1 = app.invoke({"query": "说一个关于程序员的简短笑话"})
print(res1["answer"])

# 动态切换模型(假设已配置相应的 API Key)
res2 = app.invoke(
    {"query": "说一个关于程序员的简短笑话"},
    {"configurable": {"model": "deepseek-chat"}}
)
print(res2["answer"])

Map-Reduce 模式

将一个任务拆分为多个子任务并行处理(Map),再汇总结果进行最终决策(Reduce)。以下示例将一个主题扩展为多个子话题,分别生成笑话,最后评选最佳笑话。

from typing import TypedDict, List, Annotated
import operator
from langgraph.graph import StateGraph, END
from langchain_openai import ChatOpenAI
from langchain.prompts import ChatPromptTemplate
from langchain.schema.output_parser import StrOutputParser

class JokeState(TypedDict):
    topic: str
    subtopics: List[str]
    jokes: Annotated[list, operator.add]
    best_joke_id: int

llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0.7)

def generate_subtopics(state: JokeState) -> dict:
    prompt = ChatPromptTemplate.from_template(
        "围绕「{topic}」生成3个搞笑段子主题,以逗号分隔,只返回主题本身。"
    )
    chain = prompt | llm | StrOutputParser()
    result = chain.invoke({"topic": state["topic"]})
    subtopics = [t.strip() for t in result.split(",")]
    return {"subtopics": subtopics}

def generate_jokes(state: JokeState) -> dict:
    jokes = []
    prompt = ChatPromptTemplate.from_template("写一个关于「{subtopic}」的短笑话")
    chain = prompt | llm | StrOutputParser()
    for sub in state.get("subtopics", []):
        joke = chain.invoke({"subtopic": sub})
        jokes.append(joke)
    return {"jokes": jokes}

def pick_best(state: JokeState) -> dict:
    jokes_text = "\n".join([f"{i}: {j}" for i, j in enumerate(state.get("jokes", []))])
    if not jokes_text:
        return {"best_joke_id": -1}
    prompt = ChatPromptTemplate.from_template(
        "以下是几个笑话,选出最搞笑的一个,只返回它的编号:\n{jokes}"
    )
    chain = prompt | llm | StrOutputParser()
    best_id = int(chain.invoke({"jokes": jokes_text}))
    return {"best_joke_id": best_id}

builder = StateGraph(JokeState)
builder.add_node("gen_subtopics", generate_subtopics)
builder.add_node("gen_jokes", generate_jokes)
builder.add_node("best_joke", pick_best)
builder.set_entry_point("gen_subtopics")
builder.add_edge("gen_subtopics", "gen_jokes")
builder.add_edge("gen_jokes", "best_joke")
builder.add_edge("best_joke", END)
app = builder.compile()

result = app.invoke({"topic": "程序员", "subtopics": [], "jokes": [], "best_joke_id": -1})
print("最佳笑话ID:", result["best_joke_id"])
print("笑话列表:", result["jokes"])

gen_subtopics

gen_jokes

best_joke

END

完整可运行示例

环境准备

确保已安装以下依赖(版本要求基于 langgraph>=0.0.20):

pip install langgraph langchain langchain-openai

如使用 DeepSeek 等第三方模型,需额外配置环境变量:

export OPENAI_API_KEY="your-api-key"
export DEEPSEEK_API_KEY="your-deepseek-key"  # 如使用 DeepSeek

综合演示代码

以下代码演示了一个包含条件分支、循环和动态配置的完整 Agent 工作流:

"""
LangGraph 综合演示:带条件循环和动态配置的问答 Agent
适用版本:langgraph >= 0.0.20
"""
from typing import TypedDict, Annotated, Sequence
import operator
from langgraph.graph import StateGraph, END
from langchain_core.messages import BaseMessage, HumanMessage, AIMessage
from langchain_openai import ChatOpenAI

class AgentState(TypedDict):
    messages: Annotated[Sequence[BaseMessage], operator.add]
    iteration: int
    max_iterations: int

def call_model(state: AgentState, config: dict) -> dict:
    model_name = config.get("configurable", {}).get("model", "gpt-3.5-turbo")
    llm = ChatOpenAI(model=model_name, temperature=0.3)
    response = llm.invoke(state["messages"])
    return {"messages": [response]}

def should_continue(state: AgentState) -> str:
    # 检查是否达到最大迭代次数或消息中包含结束信号
    if state.get("iteration", 0) >= state.get("max_iterations", 3):
        return "end"
    # 检查最后一条 AI 消息是否包含结束标记
    last_msg = state["messages"][-1] if state.get("messages") else None
    if last_msg and hasattr(last_msg, "content") and "STOP" in last_msg.content.upper():
        return "end"
    return "continue"

builder = StateGraph(AgentState)
builder.add_node("agent", call_model)
builder.set_entry_point("agent")
builder.add_conditional_edges(
    "agent",
    should_continue,
    {
        "continue": "agent",
        "end": END
    }
)
app = builder.compile()

result = app.invoke(
    {"messages": [HumanMessage(content="请用三句话解释什么是 AI Agent,然后输出 STOP")],
     "iteration": 0,
     "max_iterations": 5},
    {"configurable": {"model": "gpt-3.5-turbo"}}
)

for msg in result["messages"]:
    if isinstance(msg, AIMessage):
        print(f"AI: {msg.content}")

API 速览

API所属模块方法签名说明
StateGraphlanggraph.graphStateGraph(state_schema: Type)图构建器,需传入 State 类型
add_nodeStateGraphadd_node(name: str, action: Callable)添加节点,action 接收 state 和可选的 config
add_edgeStateGraphadd_edge(from: str, to: str)添加普通边
add_conditional_edgesStateGraphadd_conditional_edges(from: str, condition: Callable, mapping: dict)添加条件边
set_entry_pointStateGraphset_entry_point(name: str)设置入口节点
compileStateGraphcompile()编译为可运行的图对象
invokeCompiledGraphinvoke(input: dict, config: dict = None)同步执行
ainvokeCompiledGraphainvoke(input: dict, config: dict = None)异步执行
streamCompiledGraphstream(input: dict, config: dict = None)流式输出

参考文档

官方文档

参考链接

总结

LangGraph 通过图结构重新定义了 AI 工作流的组织方式,让开发者可以像搭积木一样组合节点,实现从简单串行到复杂 Map-Reduce 的各种控制模式。掌握这些基础后,构建多智能体系统、Human-in-the-loop 等高级应用将水到渠成。

本文覆盖了 LangGraph 核心概念、节点与可控制性的所有模式(串行、分支、条件循环、运行时配置、Map-Reduce),并给出了代码示例。核心技术栈要点:

  • 状态管理:使用 TypedDict 定义状态结构,Annotated + reducer 函数控制状态合并逻辑
  • 图构建:StateGraph 作为图构建器,节点、边、条件边形成完整的执行流程图
  • 执行模式:支持 invoke 同步执行、ainvoke 异步执行和 stream 流式输出
  • 运行时配置:通过 configurable 字段实现节点级动态参数注入
  • 条件路由:条件边支持复杂的分支逻辑和循环控制,是实现 Agent 自主决策的核心
  • 生态兼容:完全兼容 LangChain 的模型、工具和提示模板
2026年AI智能体开发:从入门到企业级实战 AI智能体作为具备自主决策能力的数字化实体,正在从简单的对话系统进化为多模态任务编排引擎。其核心技术原理结合了大语言模型的语义理解、工具调用API的精准执行以及向量数据库的长期记忆能力。在工程实践中,智能体开发需要关注环境配置、异常处理、性能优化等关键环节,通过AutoGen、LangChain等框架可快速构建电商客服、智能推荐等应用场景。随着多模态交互和分布式架构的成熟,2026年的智能体已能处理85%的常规业务请求,错误率降至0.7%以下,成为企业数字化转型的核心组件。 阅读详情

相关推荐

AI学习-langgraph-1

1. 定义全局状态定义整个运行图共享的全局状态(实际上,除了全局状态,LangGraph还支持其它类型的状态,下文详述)2. 创建状态图创建 StateGraph实例,将状态和状态图绑定3. 定义图结构定义节点和边并添加到状态图中全局状态是 LangGraph 运行图每个节点都可以访问的公共对象。return {"logs": ["node_1 运行完毕"],return {"logs": ["node_2 运行完毕"],状态的定义实际上是在声明状态的Schema,后者是状态字段的完整描述。

qq_62408075的博客 363

LangGraph从入门到精通(二)——条件边与循环流程实现工具调用

例如下方左右有两个并行运行流程,其中左侧的两个并行节点均有连接到 END 节点,右侧的只有一个,但是最终结果是一模一样的,只要不把 状态 看成是 传递,而是整个图的全局变量,每个节点执行的都是 修改 操作即可。• path_map:可选参数,类型为一个字典,用于表示 返回的path和 节点名称 的映射关系,如果不设置的话,path 的返回值应该是 节点名称。• then:可选参数,在执行 path 节点之后统一选择节点,通过该设置就不需要为后续的每一个节点都设置一个统一的关联节点。普通边 可以直接使用。

swpucwf的博客 1202

AI学习-langchain

也可以安装一下读取环境变量的依赖。

qq_62408075的博客 335

LangGraph多智能体工作流:从状态管理到复杂协作的架构实践

在构建复杂AI应用时,多智能体协作是解决复杂任务的关键技术。其核心原理在于通过定义清晰的交互协议与状态共享机制,使多个智能体能够协同工作,实现任务分解、并行执行与结果整合。这一架构的技术价值在于突破了单体智能体的能力上限,能够处理需要多步骤、多条件判断的复杂流程,显著提升了系统的灵活性与可扩展性。在实际应用场景中,多智能体系统广泛用于自动化工作流、复杂决策支持、动态任务规划等领域。本文以**LangGraph**框架为例,深入探讨如何利用**图(Graph)** 结构来直观定义和管理多智能体间的协作逻辑,解

weixin_30460489的博客 411

基于Python的高考志愿辅助填报系统

在实际应用中,系统需要处理更复杂的数据,包括更多的高校和专业信息、更详细的录取规则、以及用户的历史选择等。系统需要提供用户友好的界面,让考生输入自己的信息和偏好,然后通过后端的模型计算出推荐的志愿列表。此外,系统还应该提供一些个性化的服务,如根据考生的输入动态调整推荐策略、保存用户的填报历史和偏好等。特征可能包括考生的分数、所在省份、文理科类别、专业偏好、高校的地理位置、排名、专业的就业前景等。3. **推荐逻辑**:根据用户的分数和专业偏好,结合历史录取数据,使用简单的算法来推荐可能录取的高校和专业。

coder_wwwdy的博客 1981

【NVIDIA Jetson Orin系列 - 安装NVIDIA SDK Manager】

NVIDIA Jetson Orin - 安装NVIDIA SDK Manager

dally2的博客 2696

CrewAI vs LangGraph:多智能体框架选型指南(含性能测试对比)

本文对比分析了CrewAI和LangGraph两大AI多智能体框架的核心架构、性能表现及适用场景。通过详细的性能测试数据,揭示CrewAI在角色驱动的协作范式和快速配置上的优势,以及LangGraph在图计算导向的精细控制和并发处理上的卓越表现,为开发者提供选型指南。

k5l6m的博客 430

Power BI应用案例:淘宝用户行为分析实战

一、案例背景 基于千万级的淘宝用户的使用记录,对淘宝用户的行为进行分析,具体指标包括:日PV、日UV、小时PV、小时UV、不同用户行为的PV、用户购买次数分布、用户购买频次分布、活跃用户消费情况等。通过本案例,可以基本看看Power BI都能分析达到怎么样的效果。 二、数据来源及结构 阿里天池官方发布的1万用户在2014年双十二期间的行为记录,数据量达1200万+。 数据下载地址:...

灰哥数据智能的专栏 1万+

AI Agent 工程师面试题 200 题(codex出品)

AI Agent 是一个能围绕目标感知输入、选择行动、调用工具、观察结果并持续推进任务的系统。与单轮 LLM 调用相比,Agent 的关键不是“会回答”,而是具备可执行的循环、状态与边界。human-in-the-loop 是在关键决策点引入人工确认、审批或纠偏。常用于转账、删除、发外部邮件、生产变更、敏感数据访问等场景。上下文工程是选择、组织、压缩和注入模型输入的工程方法。它包含 Prompt、历史消息、检索片段、工具说明、用户画像、状态和安全策略。模型在长上下文中可能更容易忽略中间位置的信息。

zeng_jun_yv的博客 401

别再傻傻分不清了!Anaconda和Miniconda到底选哪个?附保姆级安装与镜像源配置(Windows/Mac)

本文详细解析了Anaconda和Miniconda的核心差异,包括体积、预装内容、系统资源占用等关键维度,并提供了针对不同需求的决策框架。附有Windows和Mac双平台的详细安装与配置指南,帮助用户根据实际需求选择最适合的conda工具,提升开发效率。

weixin_30315723的博客 427

Maya vray 3S皮肤材质球设置与材质节点连接

Maya vray 3S皮肤材质球设置与材质节点连接

WETQETF的博客 2697

从AI小镇到智能体虚拟实验室集群:多智能体系统架构与实战指南

多智能体系统(Multi-Agent Systems)是人工智能领域的重要分支,其核心原理在于通过多个自主智能体(Agent)之间的交互与协作,解决单个智能体难以处理的复杂问题。该技术的核心价值在于能够模拟真实世界的分布式协作,在科研、仿真、自动化等领域展现出巨大潜力。在实际应用中,智能体通常被赋予特定角色,并通过环境模拟、记忆系统和通信机制协同工作,共同完成目标导向的任务。本文以构建“智能体虚拟实验室集群”为具体场景,深入探讨了如何利用大语言模型(LLM)作为智能体大脑,结合向量数据库(如ChromaDB

weixin_34321753的博客 342

Unity热更实战:用YooAsset+HybridCLR实现小游戏资源与代码双更新(含避坑清单)

本文详细介绍了Unity小游戏开发中如何通过YooAsset与HybridCLR实现资源与代码双热更新方案。内容涵盖环境配置、架构设计、微信小游戏专项优化、热更代码工程化实践及真机调试技巧,帮助开发者解决审核周期长、紧急修复等痛点,提升更新效率与稳定性。

weixin_42520025的博客 507

langchain AI应用框架研究【核心概念-篇一】

langchain新版本1.1.0 出来了,老板了的api看了一些,api写法看起来有些凌乱,特别是那个构造chain的地方,先后顺序感觉不好记忆,还是SpringAI相对好好记忆一些。不知到1.x版本的会好使一些不。我们先来看看新版的langchain、langgraph、deepagents。LangChain 是一个用于开发由大语言模型(LLM)驱动的应用程序的开源框架。它的核心目标是提供一个统一的抽象层,让开发者可以方便地组合各种组件,而无需关心底层与不同模型API对接的细节。

yanghuashuiyue的专栏 602

正交试验实战指南:从PICT工具到混合水平表应用

本文详细介绍了正交试验法在测试设计中的实战应用,从基础概念到PICT工具的高级使用技巧。通过混合水平表设计和工程化实践案例,帮助测试工程师高效解决参数组合爆炸问题,提升测试覆盖率与效率。特别适合兼容性测试和复杂系统验证场景。

weixin_29230865的博客 261

从零构建Fama-French多因子模型:量化投资系统开发实战

本文详细介绍了如何从零构建Fama-French多因子模型,并将其应用于量化投资系统的开发。首先,文章概述了Fama-French多因子模型的背景、核心原理和架构,解释了其如何通过引入市场风险、规模、价值、盈利和投资等因子来解释股票收益率的变化。接着,文章详细阐述了构建该模型的具体步骤,包括因子的计算、因子暴露的确定以及模型的估计。通过数学模型和公式,文章对模型进行了理论推导,并举例说明了其应用。此外,文章还提供了项目实战的代码案例,从开发环境搭建到源代码实现,逐步指导读者完成量化投资系统的开发。最后,文章

2501_92132293的博客 1228

Agent应用开发面试:2026年核心考点全解析

本文系统介绍了Agent应用开发面试的核心考察点和技术要点。主要内容包括:1. 面试知识地图:涵盖大模型基础、Agent原理、RAG、工程开发、可靠性、系统设计六大模块。2. Agent核心概念:详细解析Agent与普通聊天的区别、运行循环机制、工具调用原理及设计要点。3. RAG关键技术:从文档处理、检索策略到结果优化和幻觉控制的全链路解决方案。4. 系统设计要素:包括状态管理、工作流编排、多Agent协同、安全防护和性能优化策略。5. 工程实践指导:提供工具调用实现、状态机设计、评测体系等代码示例和最佳

mayunlon的博客 780

深度学习工具包 DeepLearningToolbox

深度学习工具包Deprecation notice.-----This toolbox is outdated and no longer maintained.There are much better tools available for deep learning than this toolbox, e.g. [Theano](http://deeplearning.net/software/theano/), [torch](http://torch.ch/) or [tensorflow](http://www.tensorflow.org/)I would suggest you use one of the tools mentioned above rather than use this toolbox.Best, Rasmus.DeepLearnToolbox================A Matlab toolbox for Deep Learning.Deep Learning is a new subfield of machine learning that focuses on learning deep hierarchical models of data.It is inspired by the human brain's apparent deep (layered, hierarchical) architecture.A good overview of the theory of Deep Learning theory is[Learning Deep Architectures for AI](http://www.iro.umontreal.ca/~bengioy/papers/ftml_book.pdf)For a more informal introduction, see the following videos by Geoffrey Hinton and Andrew Ng.* [The Next Generation of Neural Networks](http://www.youtube.com/watch?v=AyzOUbkUf3M) (Hinton, 2007)* [Recent Developments in Deep Learning](http://www.youtube.com/watch?v=VdIURAu1-aU) (Hinton, 2010)* [Unsupervised Feature Learning and Deep Learning](http://www.youtube.com/watch?v=ZmNOAtZIgIk) (Ng, 2011)If you use this toolbox in your research please cite [Prediction as a candidate for learning deep hierarchical models of data](http://www2.imm.dtu.dk/pubdb/views/publication_details.php?id=6284)```@MASTERSTHESIS\{IMM2012-06284, author = "R. B. Palm", title = "Prediction as a candidate for learning deep hierarchical models of data", year = "2012",}```Contact: rasmusbergpalm at gmail dot comDirectories included in the toolbox-----------------------------------`NN/` - A library for Feedforward Backpropagation Neural Networks`CNN/` - A library for Convolutional Neural Networks`DBN/` - A library for Deep Belief Networks`SAE/` - A library for Stacked Auto-Encoders`CAE/` - A library for Convolutional Auto-Encoders`util/` - Utility functions used by the libraries`data/` - Data used by the examples`tests/` - unit tests to verify toolbox is workingFor references on each library check REFS.mdSetup-----1. Download.2. addpath(genpath('DeepLearnToolbox'));Example: Deep Belief Network---------------------```matlabfunction test_example_DBNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit RBM and visualize its weightsrand('state',0)dbn.sizes = [100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);figure; visualize(dbn.rbm{1}.W'); % Visualize the RBM weights%% ex2 train a 100-100 hidden unit DBN and use its weights to initialize a NNrand('state',0)%train dbndbn.sizes = [100 100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);%unfold dbn to nnnn = dbnunfoldtonn(dbn, 10);nn.activation_function = 'sigm';%train nnopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.10, 'Too big error');```Example: Stacked Auto-Encoders---------------------```matlabfunction test_example_SAEload mnist_uint8;train_x = double(train_x)/255;test_x = double(test_x)/255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit SDAE and use it to initialize a FFNN% Setup and train a stacked denoising autoencoder (SDAE)rand('state',0)sae = saesetup([784 100]);sae.ae{1}.activation_function = 'sigm';sae.ae{1}.learningRate = 1;sae.ae{1}.inputZeroMaskedFraction = 0.5;opts.numepochs = 1;opts.batchsize = 100;sae = saetrain(sae, train_x, opts);visualize(sae.ae{1}.W{1}(:,2:end)')% Use the SDAE to initialize a FFNNnn = nnsetup([784 100 10]);nn.activation_function = 'sigm';nn.learningRate = 1;nn.W{1} = sae.ae{1}.W{1};% Train the FFNNopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.16, 'Too big error');```Example: Convolutional Neural Nets---------------------```matlabfunction test_example_CNNload mnist_uint8;train_x = double(reshape(train_x',28,28,60000))/255;test_x = double(reshape(test_x',28,28,10000))/255;train_y = double(train_y');test_y = double(test_y');%% ex1 Train a 6c-2s-12c-2s Convolutional neural network %will run 1 epoch in about 200 second and get around 11% error. %With 100 epochs you'll get around 1.2% errorrand('state',0)cnn.layers = { struct('type', 'i') %input layer struct('type', 'c', 'outputmaps', 6, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %sub sampling layer struct('type', 'c', 'outputmaps', 12, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %subsampling layer};cnn = cnnsetup(cnn, train_x, train_y);opts.alpha = 1;opts.batchsize = 50;opts.numepochs = 1;cnn = cnntrain(cnn, train_x, train_y, opts);[er, bad] = cnntest(cnn, test_x, test_y);%plot mean squared errorfigure; plot(cnn.rL);assert(er<0.12, 'Too big error');```Example: Neural Networks---------------------```matlabfunction test_example_NNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);% normalize[train_x, mu, sigma] = zscore(train_x);test_x = normalize(test_x, mu, sigma);%% ex1 vanilla neural netrand('state',0)nn = nnsetup([784 100 10]);opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samples[nn, L] = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.08, 'Too big error');%% ex2 neural net with L2 weight decayrand('state',0)nn = nnsetup([784 100 10]);nn.weightPenaltyL2 = 1e-4; % L2 weight decayopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex3 neural net with dropoutrand('state',0)nn = nnsetup([784 100 10]);nn.dropoutFraction = 0.5; % Dropout fraction opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex4 neural net with sigmoid activation functionrand('state',0)nn = nnsetup([784 100 10]);nn.activation_function = 'sigm'; % Sigmoid activation functionnn.learningRate = 1; % Sigm require a lower learning rateopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex5 plotting functionalityrand('state',0)nn = nnsetup([784 20 10]);opts.numepochs = 5; % Number of full sweeps through datann.output = 'softmax'; % use softmax outputopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex6 neural net with sigmoid activation and plotting of validation and training error% split training data into training and validation datavx = train_x(1:10000,:);tx = train_x(10001:end,:);vy = train_y(1:10000,:);ty = train_y(10001:end,:);rand('state',0)nn = nnsetup([784 20 10]); nn.output = 'softmax'; % use softmax outputopts.numepochs = 5; % Number of full sweeps through dataopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, tx, ty, opts, vx, vy); % nntrain takes validation set as last two arguments (optionally)[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');```[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/rasmusbergpalm/deeplearntoolbox/trend.png)](https://bitdeli.com/free "Bitdeli Badge")

从零搭建AI智能体开发工具链:超越可视化平台的工程化实践

在AI应用开发领域,智能体(Agent)已成为连接大语言模型与实际业务场景的关键技术。其核心原理在于通过感知-思考-行动的自主循环,调用工具(Tool)完成复杂任务。工程化开发的价值在于提供高度的定制灵活性与系统可控性,尤其适用于需要深度集成、复杂逻辑与私有化部署的生产环境。本文聚焦于智能体开发工具链的构建,涵盖环境隔离、框架选型、工具扩展与流程编排等关键环节,并结合LangChain等主流框架,演示如何实现自定义工具封装与具备记忆、规划能力的多步推理工作流。通过引入可观测性(日志、追踪)与API服务化部署

weixin_30596023的博客 330

假人有限元模型

假人模型,车辆碰撞假人有限元模型,适合做乘员安全的研究者利用

Probability and Statistics - 4th edition

Probability and Statistics - 4th edition

langgraph的持久化机制和可恢复执行

在工作流、Agent、任务编排系统里,**可恢复执行 `Durable Execution`** 指的是: > 把一次任务执行过程中的关键进度、状态、结果保存到可靠存储中,使任务可以在中断、失败、等待外部输入后继续执行。

m0_59164520的博客 244

langgraph(三) - 持久化机制和可恢复运行

在工作流、Agent、任务编排系统里,可恢复执行 指的是:它解决的是“执行过程能否恢复”的问题。例如: 所以它关注的不是“数据长期保存”本身,而是:它关心的是:系统能否记住“任务执行到了哪里、当前状态是什么、接下来应该继续执行什么”。 的持久化机制()可以理解为:这里的“持久化”并不是简单地把某个变量保存到文件里,而是保存一次图执行所需的状态信息,使得未来可以基于检查点继续执行。 的持久化机制围绕以下几个问题展开:保存什么?保存图在某个时刻的状态快照,也就是 。保存到哪里?保存到 管理的存储后端中。 开

weixin_39724194的博客 374

AIGC 应用工程师(5-10年)面试题与答案全解析(2026 前沿版)

AIGC 应用工程师面试题与答案全解析(2026 前沿版) 摘要 本文系统整理了 2026 年 AIGC 应用工程师岗位的核心面试内容,包含 19 大模块、68 道关键题目及 15+ 代码示例。内容覆盖: 岗位定位:强调工程落地能力(RAG、Agent、系统集成)与业务闭环思维 技术体系:从基础理论(Transformer、涌现能力)到前沿应用(MCP协议、多模态生成) 工程实践:包含推理优化、成本控制、安全合规等关键落地能力 评估体系:详细讲解 golden set 构建、LLM-as-judge 等评估

weixin_48053866的博客 822

RAG不是加个数据库:四种工业级架构选型指南

RAG(检索增强生成)是一种将外部知识动态注入大语言模型的关键技术,其核心原理在于通过检索模块获取相关上下文,再交由生成模块合成答案。技术价值体现在显著降低幻觉、提升事实准确性,并支撑金融、政务、医疗等高可靠性场景的落地。然而,实际应用中效果不稳定、运维成本高、答案‘不够聪明’等问题频发,根源常在于架构误配——Naive RAG适合确定性文本匹配,Advanced RAG强化语义对齐与结构化后处理,Modular RAG面向多源异构知识实现模块解耦,Agentic RAG则支持多跳推理与自主工具调用。本文基

412

【LangChain】----第01章:LangChain使用概述

官网地址:https://www.langchain.com/langchain官网文档:https://python.langchain.com/docs/introduction/API文档:https://python.langchain.com/api_reference/github地址:https://github.com/langchain-ai/langchain。

朱朱博客,分享技术 523

【新书预告】《大模型应用开发》

本书系统梳理大模型应用开发的全链条知识,详解大模型应用开发过程中涉及到的理论、技术、方法、过程、工具和分析案例,为开发者搭建从理论到实践的桥梁,助力解决技术落地中的实际问题,推动大模型在工业、科研、服务等领域的规模化应用,配套示例源码、PPT课件、配图PDF文件、读者微信交流群。本书共分12章,内容包括大模型基础、大模型架构、多模态大模型、提示词工程、大模型微调、检索增强生成、AI智能体、大模型应用、大模型应用架构、大模型开发框架、法律咨询智能助手、代码修复智能助手。

夏天又到了的专栏 1448

大模型技术之-LangChain框架

摘要: LangChain是由哈佛大学Harrison Chase开发的开源框架(2022年10月发布),用于构建基于大语言模型(LLMs)的应用程序,支持Agent、问答系统、文档搜索等场景。其核心模块包括Model I/O(标准化模型输入/输出)、Chains(流程组合)、RAG(检索增强生成)和Agents(任务自动化)。相比直接调用GPT等API,LangChain简化开发流程、降低学习成本,并提供统一接口。 环境配置: 需Python 3.12环境,通过requirements.txt安装依赖,建

专业的计算机毕业设计指南 779

AI 问数真的能替代 BI 报表吗?

AI问数赋能自然语言查询,提升临时分析效率,但无法替代传统报表。报表适用于稳定输出与持续监控,AI则擅长探索性提问。企业用好AI问数,关键在于夯实数据模型、统一指标口径、健全权限体系与结果校验机制。合理组合报表、仪表板与AI,才能实现高效、准确的业务洞察。

葡萄城技术团队博客 332
上一篇: AI Agent从无到有60:基于LangGraph构建监管者多智能体系统
下一篇: AI Agent从无到有62: LangGraph 持久化与记忆系统——让智能体拥有“过目不忘”的能力
Wang's Blog
博客等级 码龄12年 7438粉丝 2422原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Wang's Blog

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值