LangChain 框架：从编排层到 Agent Engineering

上篇你把多智能体流水线跑通了——调度员派活，研究员、写手、编辑各司其职。但手写协议、手写重试、手写上下文传递，工程负担越来越重。这篇换一条路：认识 LangChain——把 LLM、工具、记忆、检索组装成应用的编排层，以及它眼里的 Agent。

小明想做「AI 旅游助手」

小明已经会 Function Calling、ReAct、Plan-and-Execute，还写过 Researcher → Writer → Editor。同事丢来一个新需求：

做一个 AI 旅游助手：
- 能聊天（模型）
- 能查天气、搜景点（工具）
- 能记住用户偏好（记忆）
- 能翻内部攻略库（检索）
- 最好还能看一眼行程有没有跑偏（回调/日志）

他打开旧项目，打算「再拼一套」。半小时后，文件树已经乱了：

travel_bot/
  openai_client.py    # 调模型
  tools_weather.py    # 工具 A
  tools_poi.py      # 工具 B
  memory_list.py    # 自己维护的 messages
  rag_hack.py       # 半成品检索
  agent_loop.py     # 又抄了一遍 ReAct
  logger.py       # print 当仪表盘

小明去找老张：”概念我都懂，但每做一个助手，就要重写一遍胶水代码。网上都说用 LangChain，它到底解决什么？”

老张说：”你现在缺的不是再懂一个算法，而是一个编排层——把模型、工具、记忆、检索用同一套积木拼起来。”

什么是 LangChain

老张在白板上写了三行：

LLM    = 大脑（会说、会推理）
Agent    = 带手脚与思维逻辑的独立个体
LangChain  = 帮你把大脑接到数据、API、工具上的编排平台

“LangChain 由 Harrison Chase 创建于 2022 年 10 月，定位是 Agent Engineering 平台：帮助开发者把大语言模型与外部数据源、API、工具连接起来，快速构建复杂 AI 应用。

官网：https://www.langchain.com/
中文文档：https://langchain-doc.cn/

你可以把它想成智能应用的乐高底板：

• 底板本身不负责’变聪明’——聪明靠模型
• 底板负责’插得上、换得开、组合得起来’——这叫模块化与可组合“

小明：”那跟我手写 OpenAI SDK 有啥区别？”

“直写课回答怎么调用；LangChain 课回答怎么组织成可维护的项目。”

六大核心模块 + Agent 三阶段

老张继续画：

┌─────────────────────────────────────────────┐
│         LangChain          
│  1.模型 I/O   2.检索   3.链   4.记忆     
│  5.智能体   6.回调（仪表盘）         
│       ↑ 用 LCEL 管道拼起来 ↑       
└─────────────────────────────────────────────┘

“导图里的六大模块，你可以这么记：

1. 模型 I/O —— 与 LLM 对话的标准接口
2. 检索 —— 给模型装上外挂知识库
3. 链 —— 应用的骨架（一步步流水线）
4. 记忆 —— 给应用装上状态
5. 智能体 —— 让模型当指挥官（自己决定调不调工具）
6. 回调 —— 应用的仪表盘（看中间发生了什么）

现代拼法不靠古老的 LLMChain 类山，而靠 LCEL（LangChain Expression Language）：用 | 把 Prompt、模型、解析器串成管道。”

说到 Agent，老张换了个比喻：

如果说大模型（LLM）是「大脑」，那么 Agent 就是「拥有手脚和思维逻辑的独立个体」。
它不再只是被动回答问题，而是能主动拆解任务并调用各种工具来完成工作。

“做《AI 旅游助手》可以分三阶段——这也是能力演进路线：

阶段一：给 Agent 手脚   → 工具使用
阶段二：给镜子 + 日记本   → 反思自省 + 长期记忆
阶段三：给 Agent 团队   → 协作分工（多智能体）

你之前手写的 FC / Memory / Multi-Agent，其实就是在这三个阶段里裸奔。LangChain 不换掉这些概念，只是换了一套标准零件。”

小明复述：”LangChain 是底板；六大模块是积木；Agent 是会自己选积木干活的角色；能力从手脚 → 记忆反思 → 团队。”

“对。下面看零件长什么样——用课件里的真代码。”

代码拆解：先摸到「模型」和「链」

1. 模型工厂：统一接到 ChatModel

from dotenv import load_dotenv
from langchain.chat_models import init_chat_model
from langchain_openai import ChatOpenAI

load_dotenv()


def get_chat_model(*, temperature: float = 0.7) -> ChatOpenAI:
  """显式 ChatOpenAI（通义等兼容端最直观）。"""
  return ChatOpenAI(
    model=os.environ.get("OPENAI_MODEL", "qwen-plus"),
    api_key=os.environ["OPENAI_API_KEY"],
    base_url=os.environ.get("OPENAI_BASE_URL"),
    temperature=temperature,
  )


def get_init_chat_model(*, temperature: float = 0.7):
  """官方统一入口 init_chat_model。"""
  return init_chat_model(
    os.environ.get("OPENAI_MODEL", "qwen-plus"),
    model_provider="openai",
    api_key=os.environ["OPENAI_API_KEY"],
    base_url=os.environ.get("OPENAI_BASE_URL"),
    temperature=temperature,
  )

“两件事：

• ChatOpenAI：兼容 OpenAI 协议的端点最直观（通义、很多国内网关都走这条）
• init_chat_model：官方统一入口，换 provider 时少改胶水

注意：这里还不是 Agent。只是六大模块里的第一块——模型 I/O。先把大脑插上底板。”

入口演示在 main.py：

from langchain_core.messages import HumanMessage, SystemMessage
from llm import get_chat_model, get_init_chat_model


def demo_chat_openai_invoke() -> None:
  model = get_chat_model(temperature=0.3)

  msg = model.invoke("用一句话介绍 LangChain 是做什么的。")
  print(type(msg).__name__, ":", msg.content)

  msg2 = model.invoke(
    [
      SystemMessage(content="你是简洁的技术助教，回答不超过 40 字。"),
      HumanMessage(content="什么是 ChatModel？"),
    ]
  )
  print("messages:", msg2.content)

“看接口：invoke 既能吃字符串，也能吃 Messages 列表。后面 Messages、多模态、记忆，全都建立在这个消息协议上。”

2. LCEL：Prompt | Model | Parser

from langchain_core.output_parsers import StrOutputParser
from langchain_core.prompts import ChatPromptTemplate
from llm import get_chat_model


def build_explain_chain():
  """模板 → 模型 → 字符串。"""
  model = get_chat_model(temperature=0.4)

  prompt = ChatPromptTemplate.from_messages(
    [
      ("system", "你是简洁的助教。用中文回答，控制在 80 字以内。"),
      ("human", "请解释概念：{topic}"),
    ]
  )

  return prompt | model | StrOutputParser()

“这一行 | 就是 LCEL：

ChatPromptTemplate  →  填 {topic}
    ↓
   ChatModel    →  推理
    ↓
  StrOutputParser   →  只要字符串

链是应用的骨架：固定流水线，适合’解释概念、翻译、摘要’这类步骤清晰的任务。
Agent 则是指挥官：步骤不固定，自己决定调不调工具。

旅游助手里，’把景点介绍改写成小红书风’适合链；’先查天气再决定去不去爬山’适合 Agent。”

小明：”所以我以前手写的 messages = [system, user]; client.chat...，在 LangChain 里先被拆成模型工厂 + Prompt 模板 + 管道？”

“对。先会拼链，再上工具和 Agent，不会一上来被 create_agent 全家桶淹死。”

老张说：”这两次运行，你验证的是编排层最小闭环：

1. 环境变量 → 模型工厂 → invoke
2. Prompt 模板 → | → 模型 → 字符串解析

还没上工具、记忆、检索。但底板已经通了——后面六大模块都往这上面插。”

环境备忘：

OPENAI_API_KEY=你的key
OPENAI_BASE_URL=https://dashscope.aliyuncs.com/compatible-mode/v1
OPENAI_MODEL=qwen-plus

pip install -r requirements.txt

直写 Agent vs LangChain：别混成一件事

常见坑

坑 1：把 LangChain 当成「另一个更聪明的模型」

症状：以为 pip install langchain 后回答自动变准。

原因：聪明来自 LLM；LangChain 只负责连接与编排。

修法：先固定模型与 Prompt，再谈框架收益。

坑 2：第一天就上齐 Agent + 记忆 + RAG + 多 Agent

症状：环境报错一堆，概念搅成浆糊。

原因：六大模块同时引入，没有「先 I/O、再链、再工具」的坡度。

修法：按路线走——Models → Messages/Prompts(LCEL) → Tools → Memory → Runtime → RAG。

坑 3：用链硬扛「要决策」的任务

症状：prompt | model | parser 写了十几段 if，还是做不好工具选择。

原因：链擅长固定骨架；动态选工具是 Agent 的活。

修法：步骤固定用链；需要指挥官时上 Tools + Agent（下一篇快速入门）。

总结

老张说：”今天只办一件事——把 LangChain 在地图上钉住。”

“三个核心理解：

1. LangChain = Agent Engineering 编排层 —— 连接 LLM 与数据、API、工具，不替代模型本身
2. 六大模块 + LCEL —— 模型 I/O、检索、链、记忆、智能体、回调；用 | 组合
3. Agent 三阶段 —— 手脚（工具）→ 镜子与日记本（反思 + 长期记忆）→ 团队（多 Agent）”

系列从此分出一条 LangChain 支线：

手写 Agent 能力（FC → 记忆 → ReAct → Plan → 多智能体）
          ↓ 工程化
认识 LangChain（本篇：编排层地图）
          ↓
Agent 快速入门 → Models → Messages → Prompts/LCEL
          ↓
Tools → Memory → 实战 → Runtime → Middleware → 多Agent → Agentic RAG

小明说：”我明白了。以前是自己焊电路；现在是认乐高底板。下一篇就按四步把最小 Agent 跑起来。”

“对。下一篇：Agent 快速入门——加载环境变量、定义工具、create_agent、调用。”

LLM 是大脑；Agent 是带手脚的个体；LangChain 是让你把大脑、手脚、日记本、知识库插在同一块底板上的编排层。