《LangChain.js 学习指南：从基础到 Agent 实战》

1
import { ChatOpenAI } from "@langchain/openai";
2

3
const llm = new ChatOpenAI({
4
  model: "qwen-plus",
5
  apiKey: process.env.QWEN_API_KEY,
6
  temperature: 0.7,        // 控制随机性，值越大越随机
7
  streamUsage: false,      // 是否开启流式返回
8
  logprobs: true,          // 是否返回每个 token 的概率信息
9
  configuration: {
10
    baseURL: "https://dashscope.aliyuncs.com/compatible-mode/v1",
11
  },
12
});

1
import { PromptTemplate } from "@langchain/core/prompts";
2

3
// 定义模板
4
const prompt = PromptTemplate.fromTemplate(`
5
你是一个{role}。
6
请用不超过{limit}字回答以下问题：
7
{question}
8
`);
9

10
// 注入数据，生成最终提示词
11
const promptStr = await prompt.format({
12
  role: "前端面试官",
13
  limit: "50",
14
  question: "什么是闭包",
15
});
16

17
// 发送给模型
18
const res = await llm.invoke(promptStr);
19
console.log(res.content);

1
const prompt = PromptTemplate.fromTemplate(`
2
你是一个{role}。
3
请用不超过{limit}字回答以下问题：
4
{question}
5
`);
6

7
// .pipe() 将 prompt 和 llm 串联成一个新链
8
const chain = prompt.pipe(llm);
9

10
// 一次 invoke，数据依次流过两个节点
11
const res = await chain.invoke({
12
  role: "前端面试官",
13
  limit: "50",
14
  question: "什么是闭包",
15
});
16

17
console.log("链式调用结果:", res.content);

1
输入参数 → prompt（格式化）→ llm（推理）→ AIMessage

1
const prompt = PromptTemplate.fromTemplate(`
2
你是一位严格的{role}。
3
请用专业且简洁的语言回答：
4
{question}
5
限制在{limit}字以内。
6
`);
7

8
const chain = prompt.pipe(llm);
9

10
// 前端面试
11
const res1 = await chain.invoke({
12
  role: "前端面试官",
13
  question: "什么是闭包",
14
  limit: "80",
15
});
16

17
// 后端面试：同一个模板，切换角色即可复用
18
const res2 = await chain.invoke({
19
  role: "后端面试官",
20
  question: "什么是微服务架构",
21
  limit: "80",
22
});

1
import { StringOutputParser, JsonOutputParser } from "@langchain/core/output_parsers";
2

3
const prompt = PromptTemplate.fromTemplate("用一句话解释：{topic}");
4
const parser = new StringOutputParser();
5

6
// 三节点链
7
const chain = prompt.pipe(llm).pipe(parser);
8
const result = await chain.invoke({ topic: "闭包" });
9
console.log("类型：", typeof result);  // string
10
console.log("结果：", result);

1
const jsonPrompt = PromptTemplate.fromTemplate(`
2
请以 JSON 格式返回以下语言的三个特性：
3
语言：{language}
4
格式：{{"features": ["特性1", "特性2", "特性3"]}}
5
`);
6

7
const jsonParser = new JsonOutputParser();
8
const jsonChain = jsonPrompt.pipe(llm).pipe(jsonParser);
9
const jsonResult = await jsonChain.invoke({ language: "TypeScript" });
10
console.log("第一个特性：", jsonResult.features[0]);

1
原始任务（混合）：
2
"请详细解释闭包，并总结3个要点"
3
→ 解释不够深入
4
→ 总结不够精炼
5

6
拆解后（单一职责）：
7
Step 1: 专门解释（300字详细说明）
8
Step 2: 专门总结（3个核心要点）
9
Step 3: 专门格式化（JSON输出）

1
import { RunnableSequence } from "@langchain/core/runnables";
2

3
// 子链 1：详细解释
4
const explainPrompt = PromptTemplate.fromTemplate(`
5
你是一个前端专家，请详细介绍以下概念: {topic}
6
要求：
7
1. 包含定义、原理、使用场景
8
2. 不超过300字
9
`);
10
const explainChain = explainPrompt.pipe(llm).pipe(parser);
11

12
// 子链 2：提炼要点
13
const summaryPrompt = PromptTemplate.fromTemplate(`
14
请将以下内容总结为3个核心要点：
15
内容：{explanation}
16
`);
17
const summaryChain = summaryPrompt.pipe(llm).pipe(parser);
18

19
// 子链 3：格式化输出
20
const formatPrompt = PromptTemplate.fromTemplate(`
21
请将以下内容整理成结构化格式并直接输出JSON。
22
解释内容：{explanation}
23
总结要点：{summary}
24
`);
25
const formatChain = formatPrompt.pipe(llm).pipe(parser);
26

27
// 构建完整流水线
28
const fullChain = RunnableSequence.from([
29
  // Step 1：生成解释
30
  async (input: { topic: string }) => {
31
    const explanation = await explainChain.invoke({ topic: input.topic });
32
    return { explanation };
33
  },
34

35
  // Step 2：生成总结（基于 explanation）
36
  async (data: { explanation: string }) => {
37
    const summary = await summaryChain.invoke({ explanation: data.explanation });
38
    return { explanation: data.explanation, summary };
39
  },
40

41
  // Step 3：结构化输出
42
  async (data: { explanation: string; summary: string }) => {
43
    const json = await formatChain.invoke({
44
      explanation: data.explanation,
45
      summary: data.summary,
46
    });
47
    return json;
48
  },
49
]);
50

51
// 执行
52
const result = await fullChain.invoke({ topic: "闭包" });
53
console.log(result);

1
用户输入 → Planner 制定计划 → Executor 逐步执行
2
           ↑ Replanner 评估 ←──┘

1
// 主循环
2
async function planAndExecute(task: string) {
3
  // 1. 制定计划
4
  let steps = await planTask(task);
5

6
  // 2. 逐步执行
7
  const completedResults: string[] = [];
8
  let currentStepIndex = 0;
9

10
  while (currentStepIndex < steps.length) {
11
    const result = await executeStep(steps[currentStepIndex]);
12
    completedResults.push(result);
13
    currentStepIndex++;
14

15
    // 3. 评估是否需要重规划
16
    const replanResult = await shouldReplan(task, completedResults, steps.slice(currentStepIndex));
17

18
    if (replanResult.status === "complete") {
19
      return replanResult.result;
20
    }
21
  }
22

23
  // 4. 生成最终总结
24
  return await generateSummary(task, completedResults);
25
}

1
import { Annotation, StateGraph, START, END } from "@langchain/langgraph";
2

3
// 定义状态
4
const PlanExecuteState = Annotation.Root({
5
  task: Annotation<string>(),
6
  plan: Annotation<string[]>({
7
    reducer: (_prev, next) => next,
8
    default: () => [],
9
  }),
10
  completed: Annotation<string[]>({
11
    reducer: (prev, next) => [...prev, ...next],
12
    default: () => [],
13
  }),
14
  currentStepIndex: Annotation<number>({
15
    reducer: (_prev, next) => next,
16
    default: () => 0,
17
  }),
18
  result: Annotation<string>({
19
    reducer: (_prev, next) => next,
20
    default: () => "",
21
  }),
22
});
23

24
// 构建图
25
const graph = new StateGraph(PlanExecuteState)
26
  .addNode("planner", planNode)
27
  .addNode("executor", executeNode)
28
  .addNode("replanner", replanNode)
29
  .addEdge(START, "planner")
30
  .addConditionalEdges("planner", shouldContinue)
31
  .addConditionalEdges("executor", () => "replanner")
32
  .addConditionalEdges("replanner", afterReplan)
33
  .compile();
34

35
// 执行
36
const result = await graph.invoke({ task: "我想了解北京的美食文化" });

1
Thought: 我需要查找天气
2
Action: search("北京")
3
Observation: 北京今天晴，25°C
4
Thought: 我已经知道天气了
5
Final Answer: 北京今天晴，25°C

1
async function runReAct(question: string, maxSteps: number = 5): Promise<string> {
2
  let context = "";
3
  let step = 0;
4

5
  while (step < maxSteps) {
6
    // 1. 调用 LLM
7
    const response = await llm.invoke(prompt + context);
8
    const text = response.content;
9

10
    // 2. 检查是否有最终答案
11
    if (text.includes("Final Answer:")) {
12
      return text.split("Final Answer:")[1].trim();
13
    }
14

15
    // 3. 解析 Action
16
    const actionMatch = text.match(/Action:\s*(\w+)\[(.*?)\]/);
17
    if (actionMatch) {
18
      const [, toolName, input] = actionMatch;
19

20
      // 4. 执行工具
21
      const observation = await executeTool(toolName, input);
22

23
      // 5. 更新上下文
24
      context += `\n${text}\nObservation: ${observation}`;
25
      step++;
26
    }
27
  }
28

29
  return "达到最大思考步骤，未能得出最终答案";
30
}

1
import { createAgent, tool } from "langchain";
2
import { z } from "zod";
3

4
// 定义工具
5
const searchTool = tool(
6
  async ({ query }: { query: string }) => {
7
    return "搜索结果...";
8
  },
9
  {
10
    name: "search",
11
    description: "搜索网络信息",
12
    schema: z.object({
13
      query: z.string().describe("搜索关键词"),
14
    }),
15
  }
16
);
17

18
// 创建 Agent
19
const agent = createAgent({
20
  model: llm,
21
  tools: [searchTool],
22
  systemPrompt: "你是一个智能助手，善于使用工具来回答用户的问题。",
23
});
24

25
// 执行
26
const result = await agent.invoke({
27
  messages: [{ role: "user", content: "北京今天天气怎么样？" }],
28
});

1
1. 定义工具（名称、描述、参数 schema）
2
2. 将工具绑定到 LLM（bindTools）
3
3. LLM 分析用户请求，决定是否调用工具
4
4. 执行工具，将结果返回给 LLM
5
5. LLM 基于工具结果生成最终回答

1
import { z } from "zod";
2

3
// 定义工具参数 schema
4
const searchSchema = z.object({
5
  query: z.string().describe("搜索关键词"),
6
});
7

8
const calculatorSchema = z.object({
9
  expression: z.string().describe("数学表达式，如 2+3*4"),
10
});

1
import { tool } from "@langchain/core/tools";
2
import { HumanMessage, ToolMessage } from "@langchain/core/messages";
3

4
// 定义工具
5
const searchTool = tool(
6
  async ({ query }: { query: string }) => {
7
    return "搜索结果...";
8
  },
9
  {
10
    name: "search",
11
    description: "搜索网络信息",
12
    schema: z.object({
13
      query: z.string().describe("搜索关键词"),
14
    }),
15
  }
16
);
17

18
// 绑定工具到 LLM
19
const llmWithTools = llm.bindTools([searchTool]);
20

21
// 执行循环
22
async function runToolCallingAgent(question: string): Promise<string> {
23
  const messages: any[] = [new HumanMessage(question)];
24

25
  for (let i = 0; i < 5; i++) {
26
    const response = await llmWithTools.invoke(messages);
27

28
    // 无工具调用，返回最终答案
29
    if (!response.tool_calls || response.tool_calls.length === 0) {
30
      return response.content;
31
    }
32

33
    messages.push(response);
34

35
    // 执行工具调用
36
    for (const toolCall of response.tool_calls) {
37
      const result = await searchTool.invoke(toolCall.args);
38
      messages.push(new ToolMessage({
39
        content: result,
40
        tool_call_id: toolCall.id,
41
      }));
42
    }
43
  }
44

45
  return "达到最大迭代次数";
46
}

1
基础 → 进阶 → 实战
2
 │       │       │
3
 ▼       ▼       ▼
4
模型    链式调用   Agent
5
模板    任务拆解   工具调用