4月1日学习笔记--LangChain 官方课程 Module 1

目录#

模型初始化与调用
Prompt 提示词设计
工具 Tools
网络搜索工具
记忆 Memory
多模态输入
常用函数速查表
完整流程模板

1. 模型初始化与调用#

概念#

LangChain 提供了一个统一的接口 init_chat_model，可以用同一套代码接入不同的模型提供商（OpenAI、Anthropic、Google 等）。初始化完模型之后，可以直接用 .invoke() 发消息。

Agent 是在模型之上封装了一层”行动能力”——它不只是回答问题，还可以决定要不要调用工具、怎么调用。

初始化模型#

1
from langchain.chat_models import init_chat_model
2

3
# 基础初始化
4
model = init_chat_model(model="gpt-4o-mini")
5

6
# 调整参数（temperature 越高，回答越有创意/随机）
7
model = init_chat_model(
8
    model="gpt-4o-mini",
9
    temperature=0.7
10
)
11

12
# 切换到其他提供商
13
model = init_chat_model(model="claude-sonnet-4-5")       # Anthropic

直接调用模型#

1
response = model.invoke("月球的首都是哪里？")
2
print(response.content)          # 打印回答文字
3
print(response.response_metadata) # 打印 token 用量等元信息

创建 Agent 并调用#

1
from langchain.agents import create_agent
2
from langchain.messages import HumanMessage
3

4
agent = create_agent(model=model)
5

6
response = agent.invoke(
7
    {"messages": [HumanMessage(content="月球的首都是哪里？")]}
8
)
9

10
print(response['messages'][-1].content)  # 取最后一条消息（AI 的回答）

model vs agent 的区别：model.invoke() 直接返回一个 AIMessage 对象；agent.invoke() 返回一个包含完整消息列表的字典，用 response['messages'][-1].content 取最终答案。

多轮对话（手动传历史）#

1
from langchain.messages import HumanMessage, AIMessage
2

3
response = agent.invoke({
4
    "messages": [
5
        HumanMessage(content="月球的首都叫 Luna City"),
6
        AIMessage(content="好的，已记录。"),
7
        HumanMessage(content="告诉我更多关于 Luna City 的事")
8
    ]
9
})

流式输出#

1
for token, metadata in agent.stream(
2
    {"messages": [HumanMessage(content="给我介绍一下 Luna City")]},
3
    stream_mode="messages"
4
):
5
    if token.content:
6
        print(token.content, end="", flush=True)

2. Prompt 提示词设计#

概念#

Prompt 是你给模型的”指令”，质量直接影响输出结果。常见的几种设计方式：

方式	适用场景
基础提问	简单问答
System Prompt	设定 AI 的角色和行为边界
Few-shot 示例	通过例子教模型输出特定格式
结构化 Prompt	规定输出字段
结构化输出	用 Pydantic 强制返回结构化数据

System Prompt（设定角色）#

1
agent = create_agent(
2
    model="gpt-4o-mini",
3
    system_prompt="你是一位科幻小说作家，根据用户的要求创造一座太空首都城市。"
4
)

Few-shot 示例（给例子）#

在 system prompt 里直接写几个例子，模型会模仿这种风格回答：

1
system_prompt = """
2
你是一位科幻小说作家，根据用户的要求创造一座太空首都城市。
3

4
User: 火星的首都是什么？
5
Scifi Writer: Marsialis
6

7
User: 金星的首都是什么？
8
Scifi Writer: Venusovia
9
"""

结构化 Prompt（规定输出格式）#

1
system_prompt = """
2
你是一位科幻小说作家，根据用户的要求创造一座太空首都城市。
3

4
请按以下格式回答：
5
名称：城市名称
6
位置：所在星球或位置
7
氛围：2-3个词描述
8
经济：主要产业
9
"""

结构化输出（Pydantic）#

当你需要在代码里直接使用 AI 的输出时，用 Pydantic 定义数据结构，让模型强制返回 JSON 格式：

1
from pydantic import BaseModel
2
from langchain.agents import create_agent
3
from langchain.messages import HumanMessage
4

5
class CapitalInfo(BaseModel):
6
    name: str
7
    location: str
8
    vibe: str
9
    economy: str
10

11
agent = create_agent(
12
    model='gpt-4o-mini',
13
    system_prompt="你是一位科幻小说作家，根据用户的要求创造一座首都城市。",
14
    response_format=CapitalInfo
15
)
16

17
response = agent.invoke({"messages": [HumanMessage(content="月球的首都是什么？")]})
18

19
# 访问结构化数据
20
capital = response["structured_response"]
21
print(capital.name)
22
print(f"{capital.name} 位于 {capital.location}")

response_format=CapitalInfo 告诉模型按这个结构返回数据，之后通过 response["structured_response"] 拿到的就是一个 CapitalInfo 对象，可以直接用 .name、.location 等属性访问。

3. 工具 Tools#

概念#

Tool（工具）是你给 Agent 额外的”能力”。比如计算器、搜索引擎、数据库查询等。Agent 会在需要时自主决定是否调用工具，而不是每次都调用。

定义一个工具#

用 @tool 装饰器把普通函数变成 LangChain 工具。docstring 很重要，模型靠它理解这个工具的用途。

1
from langchain.tools import tool
2

3
@tool
4
def square_root(x: float) -> float:
5
    """计算一个数的平方根"""
6
    return x ** 0.5
7

8
# 也可以自定义工具名称和描述
9
@tool("square_root", description="计算一个数的平方根")
10
def my_func(x: float) -> float:
11
    return x ** 0.5

手动测试工具#

1
square_root.invoke({"x": 467})  # 返回 21.61

把工具给 Agent 使用#

1
agent = create_agent(
2
    model=model,
3
    tools=[square_root],
4
    system_prompt="你是一个数学助手，用工具来计算结果。"
5
)
6

7
response = agent.invoke(
8
    {"messages": [HumanMessage(content="467 的平方根是多少？")]}
9
)
10
print(response['messages'][-1].content)

Agent 调用工具的完整消息流#

1
HumanMessage  →  "467 的平方根是多少？"
2
AIMessage     →  (空内容，但包含 tool_calls 字段，表示要调用工具)
3
ToolMessage   →  "21.61018..."（工具返回的结果）
4
AIMessage     →  "467 的平方根约为 21.61"（最终回答）

可以这样查看中间调用过程：

1
print(response["messages"][1].tool_calls)
2
# [{'name': 'square_root', 'args': {'x': 467}, ...}]

4. 网络搜索工具#

概念#

大模型的知识有截止日期，对于实时信息（比如今天的新闻、当前的市长）它一无所知。通过添加搜索工具，Agent 可以在需要时主动上网查询。

这里用的是 Tavily，一个专为 AI Agent 设计的搜索 API。

定义网络搜索工具#

1
from langchain.tools import tool
2
from tavily import TavilyClient
3

4
tavily_client = TavilyClient()  # 需要设置 TAVILY_API_KEY 环境变量
5

6
@tool
7
def web_search(query: str) -> dict:
8
    """在网上搜索信息"""
9
    return tavily_client.search(query)

单独测试搜索#

1
result = web_search.invoke("旧金山现任市长是谁？")
2
# 返回包含 url、title、content 的搜索结果列表

加入 Agent#

1
agent = create_agent(
2
    model=model,
3
    tools=[web_search]
4
)
5

6
response = agent.invoke(
7
    {"messages": [HumanMessage(content="旧金山现任市长是谁？")]}
8
)
9
print(response['messages'][-1].content)
10
# Agent 会先调用 web_search，再根据结果回答

5. 记忆 Memory#

概念#

默认情况下，Agent 每次 invoke 都是全新开始，完全不记得之前说过什么。要实现多轮对话记忆，需要用到 checkpointer + thread_id。

checkpointer：负责存储会话历史（InMemorySaver 是存在内存里，程序退出就没了）
thread_id：会话 ID，同一个 ID 下的对话共享历史记录

无记忆 vs 有记忆对比#

1
# 无记忆（每次 invoke 都是新的）
2
agent = create_agent(model=model)
3

4
agent.invoke({"messages": [HumanMessage(content="我叫 Runqi，最喜欢蓝色")]})
5
response = agent.invoke({"messages": [HumanMessage(content="我最喜欢的颜色是什么？")]})
6
# 结果：不知道，因为上一轮消息没传进来

1
# 有记忆
2
from langgraph.checkpoint.memory import InMemorySaver
3

4
agent = create_agent(
5
    model=model,
6
    checkpointer=InMemorySaver()
7
)
8

9
config = {"configurable": {"thread_id": "session_001"}}
10

11
agent.invoke(
12
    {"messages": [HumanMessage(content="我叫 Runqi，最喜欢蓝色")]},
13
    config
14
)
15

16
response = agent.invoke(
17
    {"messages": [HumanMessage(content="我最喜欢的颜色是什么？")]},
18
    config  # 同一个 thread_id，自动带入历史
19
)
20
print(response['messages'][-1].content)
21
# 结果：你之前提到你最喜欢的颜色是蓝色

多用户场景#

不同的 thread_id 代表不同的会话，互相隔离：

1
config_user1 = {"configurable": {"thread_id": "user_001"}}
2
config_user2 = {"configurable": {"thread_id": "user_002"}}
3

4
# user1 的对话不会影响 user2

6. 多模态输入#

概念#

多模态意味着 Agent 不只能处理文字，还能理解图片、音频等。关键是把非文字内容转成 base64 编码，再包装进 HumanMessage 的 content 列表里。

纯文字输入（显式格式）#

1
question = HumanMessage(content=[
2
    {"type": "text", "text": "月球的首都是什么？"}
3
])

图片输入#

1
import base64
2

3
# 读取图片并转 base64
4
with open("image.png", "rb") as f:
5
    img_b64 = base64.b64encode(f.read()).decode("utf-8")
6

7
question = HumanMessage(content=[
8
    {"type": "text", "text": "描述一下这张图片"},
9
    {"type": "image", "base64": img_b64, "mime_type": "image/png"}
10
])
11

12
response = agent.invoke({"messages": [question]})
13
print(response['messages'][-1].content)

音频输入#

1
import sounddevice as sd
2
from scipy.io.wavfile import write
3
import base64, io
4

5
# 录音
6
audio = sd.rec(int(5 * 44100), samplerate=44100, channels=1)
7
sd.wait()
8

9
# 转 base64
10
buf = io.BytesIO()
11
write(buf, 44100, audio)
12
aud_b64 = base64.b64encode(buf.getvalue()).decode("utf-8")
13

14
# 需要支持音频的模型（如 gpt-4o-audio-preview）
15
agent = create_agent(model='gpt-4o-audio-preview')
16

17
question = HumanMessage(content=[
18
    {"type": "text", "text": "描述一下这段音频"},
19
    {"type": "audio", "base64": aud_b64, "mime_type": "audio/wav"}
20
])

7. 常用函数速查表#

函数 / 类	作用	来源模块
`init_chat_model(model, **kwargs)`	初始化聊天模型	`langchain.chat_models`
`create_agent(model, tools, system_prompt, ...)`	创建 Agent	`langchain.agents`
`HumanMessage(content)`	用户消息	`langchain.messages`
`AIMessage(content)`	AI 消息	`langchain.messages`
`@tool`	将函数转为 LangChain 工具	`langchain.tools`
`tool.invoke({"param": value})`	直接调用工具（测试用）	—
`agent.invoke({"messages": [...]})`	运行 Agent（单次）	—
`agent.stream({"messages": [...]}, stream_mode="messages")`	流式运行 Agent	—
`InMemorySaver()`	内存中的对话历史存储器	`langgraph.checkpoint.memory`
`BaseModel`	定义结构化输出的数据模型	`pydantic`
`TavilyClient()`	网络搜索客户端	`tavily`

8. 完整流程模板#

下面是一个集成了工具 + 记忆 + 结构化输出的完整 Agent 模板，你可以按需拆分或组合使用。

1
from dotenv import load_dotenv
2
load_dotenv()
3

4
# ── 1. 导入依赖 ────────────────────────────────────────────
5
from langchain.agents import create_agent
6
from langchain.chat_models import init_chat_model
7
from langchain.messages import HumanMessage
8
from langchain.tools import tool
9
from langgraph.checkpoint.memory import InMemorySaver
10
from pydantic import BaseModel
11
from tavily import TavilyClient
12

13
# ── 2. 定义工具 ────────────────────────────────────────────
14
tavily_client = TavilyClient()
15

16
@tool
17
def web_search(query: str) -> dict:
18
    """在网上搜索最新信息"""
19
    return tavily_client.search(query)
20

21
@tool
22
def calculate(expression: str) -> float:
23
    """计算数学表达式，例如 '2 + 2' 或 'sqrt(16)'"""
24
    import math
25
    return eval(expression, {"__builtins__": {}}, vars(math))
26

27
# ── 3. 定义结构化输出（可选）─────────────────────────────────
28
class Answer(BaseModel):
29
    summary: str      # 简短总结
30
    confidence: str   # 高 / 中 / 低
31
    source: str       # 信息来源
32

33
# ── 4. 初始化模型 ──────────────────────────────────────────
34
model = init_chat_model(
35
    model="gpt-4o-mini",
36
    temperature=0.3   # 低一点更稳定
37
)
38

39
# ── 5. 创建 Agent ──────────────────────────────────────────
40
agent = create_agent(
41
    model=model,
42
    tools=[web_search, calculate],
43
    system_prompt="你是一个智能助手，在需要时使用工具获取最新信息或进行计算。",
44
    checkpointer=InMemorySaver(),   # 开启记忆
45
    # response_format=Answer        # 需要结构化输出时取消注释
46
)
47

48
# ── 6. 设定会话 ID ─────────────────────────────────────────
49
config = {"configurable": {"thread_id": "my_session"}}
50

51
# ── 7. 多轮对话 ────────────────────────────────────────────
52
def chat(user_input: str) -> str:
53
    response = agent.invoke(
54
        {"messages": [HumanMessage(content=user_input)]},
55
        config
56
    )
57
    return response['messages'][-1].content
58

59
# 示例对话
60
print(chat("你好，我叫小明"))
61
print(chat("北京今天的天气怎么样？"))   # 会调用 web_search
62
print(chat("我叫什么名字？"))           # 从记忆中获取

流程图#

1
用户输入
2
   │
3
   ▼
4
HumanMessage
5
   │
6
   ▼
7
Agent（内置 LLM）
8
   │
9
   ├─ 需要工具？─── 是 ──→ 调用 Tool ──→ ToolMessage ──→ 返回 Agent
10
   │                                                          │
11
   └─ 不需要 / 已有结果 ────────────────────────────────────→ AIMessage（最终回答）
12
   │
13
   ▼
14
checkpointer 保存消息历史（按 thread_id 区分）

下一步：1.5 笔记本是一个综合实战项目（Personal Chef Agent），可以把上面学到的所有模块组合起来实现。建议自己动手实现一遍，加深理解。