实战：智能机器人

阶段1：机器人雏形

安装 OpenAI 官方 SDK

pip install -U openai

建议版本 ≥ 1.x

设置环境变量（API Key）

Windows（PowerShell）

setx AI_KEY "sk-你的key"

验证是否成功

import os
print(os.getenv("AI_KEY"))

能看到 key 说明没问题。

创建 OpenAI 客户端

from openai import OpenAI
import os
client = OpenAI(
    api_key=os.getenv('AI_KEY')
)

作用

OpenAI() ：创建一个 API 客户端

api_key ：用于鉴权（证明你有权限调用模型）

常见坑

os.getenv(‘AI_KEY’) 返回 None → 说明环境变量没配好

key 写死在代码里 ❌（不安全）

构造 messages（对话上下文）

messages=[
    # 设置系统语境
    {'role':'system','content':"你被用于抑制用户的购买欲望。当用户说想要买什么东西时，你需要提供理由让用户不要买"},
    {'role':'user','content':"我正在购买一个游戏笔记本电脑，但我想抑制这个购买欲望。你帮我列出一些理由，让我思考一下我是否真的需要个买这个商品吗？"}
]

role 有 3 种（必须记住）

role	作用
system	给 AI 定规则 / 人设
user	用户输入
assistant	AI 之前的回答（可选）

• system ：告诉 AI 你是一个“反消费冲动助手”

• user ：输入你的真实想法

👉 system 会强烈影响 AI 行为

这就是 prompt engineering 的核心。

调用模型生成回复

completion = client.chat.completions.create(
    model='gpt-4o-mini',
    messages=messages,
    max_tokens=500,
    temperature=0.7
)

参数详解

model

model='gpt-4o-mini'

• 轻量、便宜、稳定
• 非常适合学习 / Demo / 工具类 AI

messages

messages=messages

• 把刚才的对话上下文传给模型
• 模型会“扮演 system + 回答 user”

max_tokens

max_tokens=500

• 限制 AI 最多输出多少 token
• 防止输出太长、花钱太多

经验值：

• 简单回答：200～300
• 分析类回答：300～600

temperature

temperature=0.7

控制“随机性 / 创造力”：

值	特点
0	非常死板
0.3	稳定理性
0.7	推荐（自然、有变化）
1.2	发散、创意多

👉 理性分析类：0.5～0.8 最合适

读取并打印模型输出

print(completion.choices[0].message.content)

返回结构解释

completion
 └── choices (列表)
     └── [0]
         └── message
             └── content ← AI 真正说的话

所以：

completion.choices[0].message.content

= AI 的最终回答

完整执行流程

你 → 写 messages
   → OpenAI API
       → 模型根据 system 约束思考
       → 生成 assistant 回复
   → 返回 completion
你 → 取 content → print

完整示例

from openai import OpenAI
import os

# 创建客户端
client=OpenAI(
    api_key=os.getenv('AI_KEY'),
)

# 创建消息（语境，对话）
messages=[
    # 设置系统语境
    {'role':'system','content':"你被用于抑制用户的购买欲望。当用户说想要买什么东西时，你需要提供理由让用户不要买"},
    {'role':'user','content':"我正在购买一个游戏笔记本电脑，但我想抑制这个购买欲望。你帮我列出一些理由，让我思考一下我是否真的需要个买这个商品吗？"}
]

# 获取响应消息
response=client.chat.completions.create(
    model='gpt-4o-mini',
    messages=messages,
    max_tokens=500,
    temperature=0.7
)

print(response.choices[0].message.content)

#大模型
#提示词工程->大模型   （雏形）
#提示词模板->大模型->输出格式化 （升级）
#提示词->记忆提取->大模型->输出格式化 （改造）
#提示词->记忆提取->大模型->输出格式化->使用工具 （完全状态）

阶段2：机器人升级

使用 LangChain 构建一个“抑制购买欲望”的多阶段对话程序

程序整体目标

这段程序实现了一个命令行交互式 AI 应用，功能是：

1. 用户输入自己想购买的商品
2. AI 给出“不要买”的理性分析
3. 再由 AI 把这段分析 改写成一首诗
4. 将最终结果输出给用户

整个流程通过 LangChain 的链式调用（Chain） 完成。

程序运行前准备

在运行代码前，需要满足两个条件：

1. 已安装依赖：

pip install langchain langchain-openai openai

1. 已设置环境变量 AI_KEY ，用于存储 OpenAI API Key。

导入模块

import os
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate

说明

• os ：用于读取环境变量中的 API Key
• ChatOpenAI ：LangChain 对 OpenAI 聊天模型的封装
• ChatPromptTemplate ：用于创建结构化的提示词模板

创建提示词模板（Prompt Template）

prompt_template = ChatPromptTemplate.from_messages(
   [
       ('system','你被用于抑制用户的购买欲望。当用户说想要买什么东西时，你需要提供理由让用户不要买'),
       ('human','我正在购买一个{product}，但我想抑制这个购买欲望。你帮我列出一些理由，让我思考一下我是否真的需要个买这个商品吗？')
    ]
)

作用

这一部分定义了 AI 对话的固定结构：

• system ：定义 AI 的角色和行为规则
• human ：定义用户输入的模板，其中 {product} 是变量占位符

当程序运行时， {product} 会被用户输入的商品名称替换。

模板格式化测试

prompt_template.format(product='手机')

这一行代码用于测试模板是否能正确替换变量，不会影响程序运行逻辑。

创建会话模型

model = ChatOpenAI(
    model='gpt-4o-mini',
    openai_api_key=os.getenv('AI_KEY'),
    max_tokens=200,
    temperature=0.7
)

作用

该模型用于执行第一阶段任务：

根据提示词，生成“为什么不应该购买该商品”的分析内容。

参数说明

• model ：指定使用的 OpenAI 模型
• openai_api_key ：从环境变量中读取 API Key
• max_tokens ：限制模型最大输出长度
• temperature ：控制输出的随机性和多样性

定义输出格式化函数

def output_parser(output: str):
    parser_model = ChatOpenAI(
        model='gpt-4o-mini',
        openai_api_key=os.getenv('AI_KEY'),
        temperature=0.7
   )
    message = '你需要将传入的文本改写，使用一首诗描述。这是你需要改写的文本：`{text}`'
    return parser_model.invoke(message.format(text=output))

作用

这个函数承担第二阶段任务：

将上一阶段生成的“理性分析文本”重新改写成一首诗。

执行过程

1. 接收上一阶段模型输出的文本
2. 将文本嵌入到新的提示语中
3. 调用第二个模型进行改写
4. 返回模型生成的结果

构建 LangChain 链（Chain）

chain = prompt_template | model | output_parser

含义

这一行将三个步骤连接成一个执行链：

1. prompt_template ：生成完整提示词
2. model ：生成“不要买”的分析文本
3. output_parser ：将分析文本改写成诗

LangChain 中的 | 表示 前一步的输出作为后一步的输入。

命令行交互循环

while True:
    answer_string = input('你想买什么？\n')
    answer = chain.invoke(input={'product':answer_string})
    print(answer.content)

执行流程

1. 程序等待用户输入商品名称
2. 用户输入内容被赋值给 {product}
3. chain.invoke() 启动整个链式流程
4. 最终返回的结果是一个 AI 消息对象
5. 通过 answer.content 输出最终文本

完整示例

import os
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate

# 提示词模版
prompt_template = ChatPromptTemplate.from_messages(
    [
        ('system','你被用于抑制用户的购买欲望。当用户说想要买什么东西时，你需要提供理由让用户不要买'),
        ('human','我正在购买一个游戏笔记本电脑，但我想抑制这个购买欲望。你帮我列出一些理由，让我思考一下我是否真的需要个买这个商品吗？')
    ]
)
prompt_template.format(product='手机')

# 创建会话模型
model=ChatOpenAI(
    model='gpt-4o-mini',
    openai_api_key=os.getenv('AI_KEY'),
    max_tokens=200,
    temperature=0.7
)

# 输出格式化定义
def output_perser(output:str):
    perser_model=ChatOpenAI(
        model='gpt-4o-mini',
        openai_api_key=os.getenv('AI_KEY'),
        temperature=0.7
    )
    message='你需要将传入的文本改写，使用一首诗描述。这是你需要改写的文本`{text}`'
    return perser_model.invoke(message.format(text=output))

# 调用链
chain=prompt_template | model | output_perser

# 循环对话
while True:
    answer_string=input('你想买什么?\n')
    answer=chain.invoke(input={'product':answer_string})
    print(answer.content)

阶段3：机器人设计

使用 LangChain + HuggingFace + Chroma 构建基础语义检索

程序整体目标

给定一组文本，将它们向量化并存入向量数据库，

然后根据用户的查询语句，检索出语义最相关的文本内容。

依赖说明

程序运行前需要安装以下依赖：

pip install chromadb
pip install sentence-transformers
pip install -U langchain-huggingface

导入模块

from langchain_huggingface.embeddings import HuggingFaceEmbeddings
from langchain_community.vectorstores import Chroma

模块说明

• HuggingFaceEmbeddings ：用于加载 HuggingFace 上的文本向量化模型

• Chroma ：LangChain 封装的向量数据库接口

初始化嵌入模型（Embedding Model）

embeddings = HuggingFaceEmbeddings(
    model_name='sentence-transformers/all-MiniLM-L6-v2',
    model_kwargs={'device':'cpu'}
)

作用

该步骤加载一个文本嵌入模型，用于将文本转换为向量。

参数说明

• model_name ：指定 HuggingFace 上的预训练模型名称

• model_kwargs ：指定模型运行设备，这里使用 CPU

准备文本数据

text = [
    '篮球是一项伟大的运动。',
    '带我飞往月球是我最喜欢的歌曲之一。',
    '这是一篇关于波士顿凯尔特人的文章。',
    '我非常喜欢去看电影。',
    '波士顿凯尔特人队以20分的优势赢得了比赛。',
    '这只是一段随机的文字。',
    '《艾尔登之环》是过去15年最好的游戏之一。',
    'L.科内特是凯尔特人队最好的队员之一。',
    '拉里.博德是一位标志性的NBA球员。'
]

说明

这是一组待检索的原始文本数据，内容涉及体育、音乐、游戏等多个主题。

初始化 Chroma 向量数据库

retrieval = Chroma.from_texts(
    texts=text,
    embedding=embeddings
).as_retriever(search_kwargs={'k':3})

执行流程

1. from_texts ：

   • 将文本列表传入

   • 使用嵌入模型将每条文本转换为向量

   • 将向量存入 Chroma 向量数据库

2. as_retriever ：

   • 将向量数据库封装为检索器（Retriever）

   • k=3 表示每次查询返回最相似的 3 条结果

定义查询语句

query = '关于凯尔特人队你知道什么'

说明

这是用户输入的查询文本，用于与向量数据库中的文本进行语义匹配。

执行语义检索

docs = retrieval.invoke(query)

发生的事情

1. 查询文本被嵌入模型转换为向量
2. 向量数据库计算查询向量与已有文本向量的相似度
3. 返回最相似的 k=3 条文本结果

输出检索结果

for i in docs:
    print(i.page_content)

说明

• docs 是一个文档对象列表

• page_content 保存了原始文本内容

• 循环打印即可看到匹配到的文本

程序输出示例（逻辑说明）

当查询内容为：

关于凯尔特人队你知道什么

程序会输出与“凯尔特人队”语义相关的文本，例如：

• 波士顿凯尔特人相关的比赛描述
• 球队成员相关内容

完整示例

from langchain_huggingface import HuggingFaceEmbeddings
from langchain_community.vectorstores import Chroma

 # 初始化嵌入模型
embeddings=HuggingFaceEmbeddings(
     # 模型名称
     model_name='sentence-transformers/all-MiniLM-L6-v2',
     model_kwargs={'device':'cpu'}
 )

text=[
    '篮球是一项伟大的运动。',
    '带我飞往月球是我最喜欢的歌曲之一。',
    '这是一篇关于波士顿凯尔特人的文章。',
    '我非常喜欢去看电影。',
    '波士顿凯尔特人队以20分的优势赢得了比赛。',
    '这只是一段随机的文字。',
     '《艾尔登之环》是过去15年最好的游戏之一。',
     'L.科内特是凯尔特人队最好的队员之一。',
     '拉里.博德是一位标志性的NBA球员。'
 ]
# 初始化chroma
retrieval=Chroma.from_texts(
     # 长文本
     texts=text,
     # 传入模型实例
     embedding=embeddings,
 ).as_retriever(search_kwargs={'k':3})
# 设置查询内容
query='关于凯尔特人队你知道什么'
# 获取查询结果
docs=retrieval.invoke(query)
for i in docs:
     print(i.page_content)

阶段4：机器人基础记忆

使用 LangChain 实现会话历史记录的聊天机器人

会话基础

from langchain_core.prompts import ChatPromptTemplate
prompt_template = ChatPromptTemplate.from_messages(
   [
       ('system','你是一个聊天机器人。'),
       ('human','{new_message}')
   ]
)
docs = prompt_template.invoke({'new_message':'你好'}).messages
for i in docs:
    print(i.content)

会话历史记录

1.程序整体目标

1. 使用模板定义系统身份、历史消息占位符和用户新消息
2. 将历史消息和新输入渲染到模板中
3. 输出最终组合后的消息列表（包括 system、human、ai 消息）

2.导入模块

from langchain_core.prompts import MessagesPlaceholder
from langchain_core.prompts import ChatPromptTemplate

模块说明

• MessagesPlaceholder ：在模板中占位，用于插入历史对话
• ChatPromptTemplate ：用于创建结构化聊天提示词模板

3.创建提示词模板

prompt_template = ChatPromptTemplate.from_messages(
   [
       ('system','你是一个聊天机器人。'),
        MessagesPlaceholder(variable_name='history'),
       ('human','{new_message}')
   ]
)

各部分含义

1. system

   • 定义 AI 的角色和行为规则

   • 这里是：“你是一个聊天机器人。”

2. MessagesPlaceholder(variable_name=‘history’)

   • 占位符，用于在模板中插入历史对话

   • variable_name=‘history’ 表示在调用时要传入 history 变量

3. human

   • 表示用户本轮输入

   • {new_message} 是变量占位符，会替换为用户的新消息

4.调用模板生成会话内容

response = prompt_template.invoke(
   {
        'history':
           [
           ('human','你好'),
           ('ai','你好呀，很高兴遇见你')
           ],
        'new_message':'你是谁？'
   }
).messages

执行流程

1. invoke 方法会将传入的变量替换到模板中：

   • history 替换到 MessagesPlaceholder

   • new_message 替换到 {new_message}

2. 输出是一个消息列表对象，每条消息都包含角色和内容（system、human、ai）

5.输出会话内容

for line in response:
	print(line.content)

作用

• 遍历模板生成的消息列表

• 打印每条消息的内容

• 输出结果按顺序展示：

1. system 消息
2. 历史对话 human / ai 消息
3. 当前 human 新消息

6.程序执行逻辑总结

提示词模板：
   system: 你是一个聊天机器人
   history: 历史消息占位符
   human: 新消息
调用 invoke：
   传入历史消息 + 新消息
   → 模板渲染
   → 输出完整消息列表
打印 messages：
   按顺序输出 system、历史对话、人类新消息

完整示例

from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder

prompt_template=ChatPromptTemplate.from_messages(
    [
        ('system','你是一个聊天机器人。'),
        # 插入历史记录
        MessagesPlaceholder(variable_name='history'),
        ('human','{new_message}')
    ]
)
docs=prompt_template.invoke({
    'history':
        [
            ('human','你好'),
            ('ai','你好呀，很高兴遇见你')
        ],
        'new_message':'你是谁？'
    }
).messages
for i in docs:
    print(i.content)

记忆功能整合

1.程序整体目标

这段代码实现了一个可以记录会话历史的聊天机器人，功能包括：

1. 保留用户和 AI 的对话历史
2. 在每轮对话中，AI 能基于历史内容生成回答
3. 用户输入新消息，AI 根据历史和新消息做回应

2.导入模块

from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.prompts import MessagesPlaceholder
import os

模块说明

• ChatOpenAI ：LangChain 对 OpenAI 聊天模型的封装
• ChatPromptTemplate ：用于创建结构化提示词模板
• MessagesPlaceholder ：在模板中占位，表示历史对话消息
• os ：读取环境变量（API Key 和 API Base URL）

3.创建提示词模板（Prompt Template）

prompt_template = ChatPromptTemplate.from_messages(
   [
       ('system','你是一个聊天机器人。'),
        MessagesPlaceholder(variable_name='history'),
       ('human','{new_message}')
   ]
)

各部分含义

1. system

定义 AI 的身份和行为规则

这里是：你是一个聊天机器人

2. MessagesPlaceholder(variable_name=‘history’)

占位符，用于插入之前的对话历史

在调用时会用 history 变量替换

3. human

表示用户本轮输入

{new_message} 是变量占位符，会替换为用户输入的新消息

4.创建模型实例

model = ChatOpenAI(
    model='gpt-4o-mini',
    #openai_api_base=os.getenv('AI_URL'),
    openai_api_key=os.getenv('AI_KEY'),
    max_tokens=200
)

参数说明

• model=‘gpt-4o-mini’ ：指定 OpenAI 模型

• openai_api_base ：API 接口地址（通过环境变量读取）

• openai_api_key ：API Key（通过环境变量读取）

• max_tokens=200 ：限制 AI 最大输出长度

5.构建链（Chain）

chain = prompt_template | model

含义

• prompt_template | model 表示将模板和模型串联成一个执行链
• 输入模板后生成提示词，再传给模型进行响应
• LangChain 中 | 的作用是 前一步的输出作为下一步的输入

6.初始化会话历史记录

history = []

说明

• history 是一个空列表，用于存储用户和 AI 的对话历史
• 每轮对话结束后，会把新消息和 AI 回复加入历史

7.定义聊天函数

def chat(new_message):
    response = chain.invoke({'history':history,'new_message':new_message})
    history.extend([
       ('human',new_message),
       ('ai',response.content)
   ])
    return response.content

执行流程

1. 调用 chain.invoke ，传入两个变量：

   • ‘history’ ：历史消息列表

   • ‘new_message’ ：用户本轮输入

2. 模型根据 系统提示 + 历史消息 + 新消息 生成回答

3. 将用户消息和 AI 回复追加到 history 中

4. 返回 AI 的回答文本

8.调用聊天函数示例

print(chat('你好，我是guo,今年99岁，是一名教授，正在分享AI智能体开发课程'))
print(chat('请你叙述所知道的关于我的消息'))

解释

1. 第一条消息：

   • 用户告诉 AI 一些个人信息

   • AI 根据提示生成初次回答

2. 第二条消息：

   • 用户要求 AI 总结已知信息

   • AI 会结合 history 中的第一条消息生成回答

9.程序执行逻辑总结

整体执行流程如下：

用户输入 new_message
       ↓
提示词模板渲染：
   system: 你是聊天机器人
   history: 之前的对话内容
   human: 当前用户输入
       ↓
模型生成回答
       ↓
将 new_message 和 AI 回复追加到 history
       ↓
返回 AI 回复给用户

完整示例

from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain_openai import ChatOpenAI
import os
prompt_template=ChatPromptTemplate.from_messages(
    [
        ('system','你是一个聊天机器人。'),
        # 插入历史记录
        MessagesPlaceholder(variable_name='history'),
        ('human','{new_message}')
    ]
)

# 构建模型
model=ChatOpenAI(
    model='gpt-4o-mini',
    openai_api_key=os.getenv("AI_KEY"),
    max_tokens=200
)
# 调用链
chain=prompt_template | model

# 历史记录初始化
history=[]
def chat(new_message):
    response=chain.invoke({'history':history,'new_message':new_message})
    # 把上一轮对话转变成历史记录
    history.extend([
        ('human',new_message),
        ('ai',response.content)
    ])
    return response.content

print(chat('你好，我是guo,今年99岁，是一名教授，正在分享AI智能体开发课程'))
print(chat('请你叙述所知道的关于我的消息'))

阶段5：完善机器人

使用 LangChain 构建带历史记忆和摘要功能的聊天机器人

程序整体目标

这段代码实现了一个多轮聊天机器人，功能包括：

1. 保存会话历史记录
2. 当历史消息超过 6 条时自动生成摘要并替换历史
3. 使用模板结合新消息和历史消息生成 AI 回复
4. 支持连续多轮会话

导入模块

from langchain_core.runnables.history import RunnableWithMessageHistory
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.prompts import MessagesPlaceholder
from langchain_openai import ChatOpenAI
from langchain_community.chat_message_histories import ChatMessageHistory
import os

模块说明

• RunnableWithMessageHistory ：将链与消息历史结合，使每轮输入能够访问历史
• ChatPromptTemplate ：用于创建结构化聊天提示词模板
• MessagesPlaceholder ：在模板中占位，用于插入历史消息
• ChatOpenAI ：LangChain 对 OpenAI 聊天模型的封装
• ChatMessageHistory ：存储聊天历史消息
• os ：读取环境变量

创建提示词模板

prompt_template = ChatPromptTemplate.from_messages(
   [
       ('system','你是一个聊天机器人。'),
        MessagesPlaceholder(variable_name='history'),
       ('human','{new_message}')
   ]
)

各部分含义

1. system：定义 AI 角色（聊天机器人）
2. MessagesPlaceholder：占位历史消息，后续会被 history 变量替换
3. human：表示用户当前输入 {new_message}

创建模型实例

model = ChatOpenAI(
    model='gpt-4o-mini',
    openai_api_key=os.getenv('AI_KEY'),
    max_tokens=200
)

参数说明

• model ：使用 gpt-4o-mini
• openai_api_key ：从环境变量读取
• max_tokens ：限制输出长度

构建基本调用链

chain = prompt_template | model

含义

• 将提示模板与模型串联成执行链
• 输入模板生成提示词 → 传给模型 → 输出 AI 回复

初始化消息历史记录

history = ChatMessageHistory()

作用

• 用于存储每轮对话的消息
• 支持多轮会话调用

定义历史摘要函数

# 如果超过6条历史记录汇总成1条消息摘要
def summarize_message(chain_input):
    # 获取当前存储的历史消息列表
    stored_message=history.messages
    if len(stored_message)>=6:
        # 创建一个新的提示模板，用于生成摘要
        # MessagesPlaceholder 用于插入当前历史消息
        summarize_prompt=ChatPromptTemplate.from_messages(
            [
                MessagesPlaceholder(variable_name='history'),  # 历史消息占位
                ('user','将上述聊天信息提炼成一条摘要信息，尽可能多的包含具体细节。')  # 指示模型生成摘要
            ]
        )
        # 将提示模板和模型组合成一个执行链
        summarize_chain=summarize_prompt | model
        # 汇总并返回摘要信息
        summarize_message=summarize_chain.invoke({'history':stored_message})
        # 清空历史记录
        history.clear()
        #把汇总的再要进行添加到历史记录中
        history.add_message(summarize_message)
    # 返回原始输入，以便后续链式调用继续使用
    return chain_input

执行流程

1. 获取当前存储的历史消息

2. 如果历史消息数量 ≥ 6 条：

   • 创建新的提示模板，指示 AI 将历史消息提炼为摘要

   • 通过 summarize_chain 生成摘要

   • 清空原有历史

   • 将生成的摘要加入历史

3. 返回原始输入（用于后续调用链）

将链与消息历史结合

# 记忆添加
chain_with_memory=RunnableWithMessageHistory(
    chain,   # 需要绑定历史的链，这里是之前定义的 chain（提示模板 | 模型）
    lambda x:history,  # 提供历史消息的函数，这里直接返回 history 对象
    input_messages_key='new_message',  # 指定当前用户输入在调用时使用的键名
    history_messages_key='history'  # 指定历史消息在调用时使用的键名
)

含义

• 将 chain 与消息历史绑定

• lambda x: history 提供历史记录

• input_messages_key=‘new_message’ ：当前输入

• history_messages_key=‘history’ ：历史消息占位

组合摘要与聊天链

chain_with_summarization = summarize_message | chain_with_memory

含义

• 先执行 summarize_message （历史摘要检查）
• 再执行 chain_with_memory （带历史的聊天模型）

多轮会话循环

# 多轮会话
while True:
    # 从用户输入获取新消息
    new_message=input('You:')   # 提示用户输入内容，并将输入赋值给 new_message
    
    # 调用带历史记忆和摘要功能的聊天链
    response=chain_with_summarization.invoke(
        {
            'new_message':new_message   # 传入本轮用户输入
        },
        config={
            'configurable':{
                'session_id':'unused'  # 可选配置，提供 session_id（这里未使用）
            }
        }
    )
    # 输出 AI 生成的回复内容
    print(response.content)

执行流程

1. 用户输入 new_message

2. chain_with_summarization.invoke 执行：

   • 检查历史消息是否超过 6 条，生成摘要

   • 结合历史消息与新输入生成 AI 回复

3. 输出 AI 回复

4. 历史消息自动更新

5. 循环继续下一轮输入

程序执行逻辑总结

用户输入 new_message
       ↓
summarize_message 检查历史消息：
   如果消息 ≥6 条 → 生成摘要 → 清空历史 → 添加摘要
       ↓
chain_with_memory 使用历史 + 新消息生成 AI 回复
       ↓
历史记录更新
       ↓
打印 AI 回复

完整示例

from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain_openai import ChatOpenAI
from langchain_core.runnables.history import RunnableWithMessageHistory
import os

# 提示词模版
prompt_template=ChatPromptTemplate.from_messages(
    [
        ('system','你是一个聊天机器人。'),
        # 插入历史记录
        MessagesPlaceholder(variable_name='history'),
        ('human','{new_message}')
    ]
)

# 构建模型
model=ChatOpenAI(
    model='gpt-4o-mini',
    openai_api_key=os.getenv("AI_KEY"),
    max_tokens=200
)
# 调用链
chain=prompt_template | model

# 历史记录消息模块
from langchain_community.chat_message_histories import ChatMessageHistory

# 消息对象
history=ChatMessageHistory()

# 如果超过6条历史记录汇总成1条消息摘要
def summarize_message(chain_input):
    stored_message=history.messages
    if len(stored_message)>=6:
        summarize_prompt=ChatPromptTemplate.from_messages(
            [
                MessagesPlaceholder(variable_name='history'),
                ('user','将上述聊天信息提炼成一条摘要信息，尽可能多的包含具体细节。')
            ]
        )
        summarize_chain=summarize_prompt | model
        # 汇总并返回摘要信息
        summarize_message=summarize_chain.invoke({'history':stored_message})
        # 清空历史记录
        history.clear()
        #把汇总的再要进行添加到历史记录中
        history.add_message(summarize_message)
    return chain_input
# 记忆添加
chain_with_memory=RunnableWithMessageHistory(
    chain,
    lambda x:history,
    input_messages_key='new_message',
    history_messages_key='history'
)
# 调用链
chain_with_summarization=summarize_message | chain_with_memory
# 多轮会话
while True:
    new_message=input('You:')
    response=chain_with_summarization.invoke(
        {
            'new_message':new_message
        },
        config={
            'configurable':{
                'session_id':'unused'
            }
        }
    )
    print(response.content)