课程目标

✅ 理解回调（Callbacks）的作用与核心场景 ✅ 掌握 LangChainCallbackHandler 的基础用法 ✅ 学会对话持久化（存到文件 / 数据库） ✅ 能给你的链加上日志追踪，调试问题更轻松

---

一、核心概念：回调（Callbacks）

1. 什么是回调？

回调就是钩子函数，在 LangChain 的组件执行前后自动触发，用来：

• 打印日志、记录耗时
• 监控模型调用次数、token 消耗
• 给前端实时推送生成进度
• 做错误捕获、重试逻辑

2. 内置回调：StdOutCallbackHandler

最常用的控制台日志回调，能帮你打印链里每一步的执行细节，是调试必备！

python

运行

from langchain.callbacks import StdOutCallbackHandler
from langchain_openai import OpenAI
from langchain.chains import LLMChain
from langchain.prompts import PromptTemplate

# 1. 初始化模型+回调
llm = OpenAI(temperature=0, callbacks=[StdOutCallbackHandler()])

# 2. 组装链
prompt = PromptTemplate(input_variables=["topic"], template="解释一下{topic}")
chain = LLMChain(llm=llm, prompt=prompt)

# 3. 执行，控制台会自动打印完整执行过程
chain.run("LangChain回调")

你运行后会看到：模型调用、prompt 拼接、token 消耗等日志，调试超方便！

---

二、自定义回调：实现日志追踪

如果想把日志存到文件、数据库，或者做更复杂的监控，可以继承 BaseCallbackHandler 写自定义回调：

python

运行

from langchain.callbacks.base import BaseCallbackHandler
import time

class MyCustomCallback(BaseCallbackHandler):
    def on_llm_start(self, serialized, prompts, **kwargs):
        print(f"[日志] 模型开始调用，prompt：{prompts[0][:100]}...")
        self.start_time = time.time()

    def on_llm_end(self, response, **kwargs):
        duration = time.time() - self.start_time
        print(f"[日志] 模型调用结束，耗时：{duration:.2f}秒")
        print(f"[日志] 模型回复：{response.generations[0][0].text[:100]}...")

# 使用自定义回调
llm = OpenAI(temperature=0, callbacks=[MyCustomCallback()])
chain = LLMChain(llm=llm, prompt=prompt)
chain.run("LangChain自定义回调")

你可以在这些钩子方法里，把数据写入文件、发送到日志服务器，实现持久化监控。

---

三、对话持久化：把聊天记录存起来

之前用的 ConversationBufferMemory 是存在内存里的，程序重启就丢了。LangChain 支持把对话历史持久化到文件 / 数据库，这里给你 2 种常用方案：

方案 1：文件持久化（简单易上手）

python

运行

from langchain.memory import ConversationBufferMemory
from langchain.chains import ConversationChain
import json

# 1. 初始化记忆
memory = ConversationBufferMemory()
conv_chain = ConversationChain(llm=OpenAI(temperature=0), memory=memory)

# 2. 对话
conv_chain.predict(input="你好，我在学LangChain")
conv_chain.predict(input="回调是什么？")

# 3. 保存对话到文件
history = memory.load_memory_variables({})["history"]
with open("chat_history.json", "w", encoding="utf-8") as f:
    json.dump(history, f, ensure_ascii=False, indent=2)

# 4. 下次启动时加载对话
from langchain.memory.chat_message_histories import FileChatMessageHistory
from langchain.memory import ConversationBufferMemory

chat_history = FileChatMessageHistory("chat_history.json")
memory = ConversationBufferMemory(chat_memory=chat_history, return_messages=True)
conv_chain = ConversationChain(llm=OpenAI(temperature=0), memory=memory)

方案 2：SQLite 数据库持久化（适合长期使用）

python

运行

from langchain.memory.chat_message_histories import SQLChatMessageHistory
from langchain.memory import ConversationBufferMemory

# 连接SQLite数据库，存储对话历史
chat_history = SQLChatMessageHistory(
    session_id="user_123",  # 每个用户/会话一个ID
    connection_string="sqlite:///chat_history.db"
)
memory = ConversationBufferMemory(chat_memory=chat_history, return_messages=True)
conv_chain = ConversationChain(llm=OpenAI(temperature=0), memory=memory)

# 对话会自动保存到数据库，重启不丢失
conv_chain.predict(input="我又来了，接着聊回调")

---

四、课后作业（30 分钟搞定）

1. 用 StdOutCallbackHandler 给一个 LLMChain 加上控制台日志，运行并观察输出。
2. 写一个自定义回调，实现：模型调用开始 / 结束时，打印耗时和 prompt 前 100 字符。
3. 用 FileChatMessageHistory 实现对话持久化：
   • 第一次运行：和模型聊 2 轮
   • 第二次运行：加载历史对话，接着聊，验证历史不丢失

     作业 1：用 StdOutCallbackHandler 给 LLMChain 加控制台日志

     python

     运行

     from langchain_openai import OpenAI
     from langchain.chains import LLMChain
     from langchain.prompts import PromptTemplate
     from langchain.callbacks import StdOutCallbackHandler
     
     # 1. 初始化模型 + 控制台日志回调
     llm = OpenAI(
         temperature=0,
         callbacks=[StdOutCallbackHandler()]  # 开启内置日志回调
     )
     
     # 2. 定义提示词模板
     prompt = PromptTemplate(
         input_variables=["topic"],
         template="请用大白话解释一下：{topic}"
     )
     
     # 3. 组装链
     chain = LLMChain(llm=llm, prompt=prompt)
     
     # 4. 执行，控制台会自动打印完整执行过程
     result = chain.run("LangChain的回调机制")
     print("\n最终回答：", result)
     

     运行后，你会在控制台看到模型调用、提示词拼接、Token 消耗等完整日志，方便调试。

     ---

     作业 2：自定义回调，记录模型调用耗时和 Prompt

     python

     运行

     from langchain.callbacks.base import BaseCallbackHandler
     from langchain_openai import OpenAI
     from langchain.chains import LLMChain
     from langchain.prompts import PromptTemplate
     import time
     
     # 1. 自定义回调类
     class MyCustomCallback(BaseCallbackHandler):
         def on_llm_start(self, serialized, prompts, **kwargs):
             # 模型调用开始时触发
             self.start_time = time.time()
             print("\n=== [日志] 模型调用开始 ===")
             print(f"收到的Prompt前100字符：\n{prompts[0][:100]}...")
     
         def on_llm_end(self, response, **kwargs):
             # 模型调用结束时触发
             duration = time.time() - self.start_time
             print("\n=== [日志] 模型调用结束 ===")
             print(f"耗时：{duration:.2f} 秒")
             print(f"模型回复前100字符：\n{response.generations[0][0].text[:100]}...")
     
     # 2. 初始化模型 + 自定义回调
     llm = OpenAI(
         temperature=0,
         callbacks=[MyCustomCallback()]
     )
     
     # 3. 组装链并执行
     prompt = PromptTemplate(input_variables=["topic"], template="解释一下：{topic}")
     chain = LLMChain(llm=llm, prompt=prompt)
     chain.run("LangChain的持久化")
     

     ---

     作业 3：用 FileChatMessageHistory 实现对话持久化

     第 1 步：第一次运行（保存对话）

     python

     运行

     from langchain_openai import OpenAI
     from langchain.chains import ConversationChain
     from langchain.memory import ConversationBufferMemory
     from langchain.memory.chat_message_histories import FileChatMessageHistory
     
     # 1. 初始化文件持久化历史
     chat_history = FileChatMessageHistory("chat_history.json")
     memory = ConversationBufferMemory(
         chat_memory=chat_history,
         return_messages=True
     )
     
     # 2. 初始化对话链
     llm = OpenAI(temperature=0)
     conv_chain = ConversationChain(llm=llm, memory=memory)
     
     # 3. 对话（会自动保存到文件）
     print(conv_chain.predict(input="你好，我在学LangChain的持久化"))
     print(conv_chain.predict(input="程序重启后对话会丢吗？"))
     
     # 查看保存的消息
     print("\n当前对话历史：", chat_history.messages)
     

     第 2 步：第二次运行（加载历史，接着聊）

     python

     运行

     from langchain_openai import OpenAI
     from langchain.chains import ConversationChain
     from langchain.memory import ConversationBufferMemory
     from langchain.memory.chat_message_histories import FileChatMessageHistory
     
     # 1. 从文件加载历史对话
     chat_history = FileChatMessageHistory("chat_history.json")
     memory = ConversationBufferMemory(
         chat_memory=chat_history,
         return_messages=True
     )
     
     # 2. 初始化对话链
     llm = OpenAI(temperature=0)
     conv_chain = ConversationChain(llm=llm, memory=memory)
     
     # 3. 接着之前的对话聊
     print(conv_chain.predict(input="你还记得我们刚才聊了什么吗？"))
     
     # 验证：能看到之前的对话历史
     print("\n加载后的对话历史：", chat_history.messages)