大模型应用开发教程
目录
三十二、Langchaini记忆系统-ConversationBufferMemory
一、什么是AI大模型开发
二、Gradio快速入门
Gradio 是一个用于快速构建机器学习模型 Web 界面的 Python 库，核心优势是仅需几行代码即可将函数转化为可交互的 UI。以下是从安装到进阶的核心教程。
官方网站:https://www.gradio.app/
官方文档 - 快速开始:https://www.gradio.app/guides/quickstart
1、安装
pip install gradio
出现这个报错，先更新pip
先去到这个目录：D:\Program Files\Python312\
然后输入下面这个命令
python.exe -m pip install --upgrade pip
在PyCharm新建一个项目，新建一个llm-exercise1项目
新建一个part.py,代码如下：
案例1一个接收文本输入并返回该文本倒序输出的应用。
import gradio as gr
#功能实现5
def reverse_text(text):
return text[::-1]
#界面配置
demo = gr.Interface(
fn=reverse_text,# 调用reverse_text函数
inputs="text", #输入组件类型为文本
outputs="text") #输出组件类型为文本
#启动应用
demo.launch()
在软件PyCharm的终端安装gradio，因为虚拟环境没有gradio
在终端输入 install gradio -i https://pypi.tuna.tsinghua.edu.cn/simple
判断是否安装
pip show gradio
运行 part1.py
在浏览器输入http://127.0.0.1:7860
输入内容
2、 把 PyCharm 解释器切换成全局 Python
把 PyCharm 解释器切换成全局 Python，不用 venv：
Ctrl+Alt+S→ Project:xxx → Python Interpreter- 顶部下拉，选择不带
venv路径的 python.exe - 应用保存，直接复用 CMD 全局已安装的 cv2、gradio
3、生成图片的素描的demo
先安装 pip install opencv-python -i https://pypi.tuna.tsinghua.edu.cn/simple
pip show opencv-python
创建part2.py
import gradio as gr
import numpy as np
import cv2
def image_to_sketch(image):
gray_image = image.convert('L')
inverted_image = 255 - np.array(gray_image)
blurred = cv2.GaussianBlur(inverted_image, (21, 21), 0)
inverted_blurred = 255 - blurred
pencil_sketch = cv2.divide(np.array(gray_image), inverted_blurred, scale = 256.0)
return pencil_sketch
demo = gr.Interface(
fn=image_to_sketch,
inputs=[gr.Image(label="上传图片", type="pil")],
outputs=[gr.Image(label="铅笔画")],
title="图像转铅笔画",
description="将上传的图片转为铅笔画。"
)
#启动应用
demo.launch()
安装openai
pip install openai -i https://pypi.tuna.tsinghua.edu.cn/simple
pip show openai
4、python调用千问大模型
先配置window的环境变量
配置环境变量后，要重启Pycharm软件
创建python3.py,内容如下：
#导入必要的库
import gradio as gr
import os
from openai import OpenAI
#从系统环境变量中获取DashScope API密钥
# 确保在运行此脚本前已设置DASHSCOPE_API_KEY环境变量
api_key = os.getenv("DASHSCOPE_API_KEY")
print("读取到的密钥：", api_key)
#如果未设置API密钥，提供友好的错误提示
if not api_key:
print("错误：API密钥未设置。请确保在调用API之前正确设置API密钥。")
# 定义一个函数，用于调用通义千问max模型生成回复
def call_qwen(message, history):
#调用通义千问max模型的函数
#message(str): 用户当前输入的消息内容
#history(list): 聊天历史记录，支持两种格式:
#格式1: [(用户消息，助手回复), ...] - 元组列表形式
#格式2: [{"role": "user" “content":" 消息内容 "}，...]-字典列表形式
if not api_key:
return "未设置DASHSCOPE_API_KEY环境变量"
client = OpenAI(
api_key=api_key,
# 使用环境变量中的API密钥进行身份验证
base_url="https://dashscope.aliyuncs.com/compatible-mode/v1" # DashScope兼容模式端点
)
messages = []
if history:
try:
#尝试处理字典格式的history(较新版本Gradio的格式)
for msg in history:
if isinstance(msg, dict) and 'role' in msg and 'content' in msg:
messages.append(msg)
elif isinstance(msg, (list, tuple)) and len(msg) == 2:
user_msg, assistant_msg = msg
messages.append({"role": "user", "content": user_msg})
messages.append({"role": "assistant", "content": assistant_msg})
except Exception as e:
print(f"处理历史记录时出错:{e}")
messages.append({"role":"user","content":message})
try:
response = client.chat.completions.create(
model="qwen-max",
messages=messages,
stream=False
)
return response.choices[0].message.content
except Exception as e:
return "Error: " + str(e)
demo=gr.ChatInterface(
fn=call_qwen,
title="通义千问-max",
description = "基于通义千问max的聊天机器人",
examples=[
#指定处理聊天消息的回调函数，将调用通
["你好"],
["你叫什么名字?"],
["给我讲一个笑话呗"]
]
)
#主程序入口点
#当直接运行此脚本时，启动GradioWeb服务器
if __name__ == "__main__":
# 启动Gradio服务，默认监听本地7860端口
# 用户访问该URL即可与通义千问Turbo模型进行交互
demo.launch(theme=gr.themes.Soft())
启动项目：
三、什么是提示词？
提示词：提示工程(Prompt Engineering)是一项通过优化提示词(Prompt)和生成策略，从而获得更好的模型返回结果的工程技术。
好的Prompt需要不断调优。
说清楚自己到底想要什么，要具体!
不要让机器去猜测太多。为了不让机器去猜测，我们就需要告诉细节。
提示工程有一些技巧，灵活掌握，事半功倍。
提示词构成
指示(Instruction):描述要让它做什么?
上下文(Context):给出与任务相关的背景信息
例子(Examples):给出一些例子，让模型知道怎么回复
输入(Input):任务的输入信息
输出(OutputFormat):输出的格式，想要什么形式的输出?
四、常见的提示词方法
IPython Notebook，是 Jupyter Notebook 的专属文件格式
如何打开运行
方案 1：浏览器网页运行（最通用，首选）
全程用 PyCharm 做文件管理、改代码，实际运行在浏览器，步骤极简：
打开 PyCharm 底部 Terminal 终端，先安装依赖（当前项目解释器）
bash
运行
pip install jupyter notebook ipykernel
终端输入启动命令
bash
运行
jupyter notebook
自动弹出浏览器页面，会直接定位到你当前项目文件夹，找到 demo.ipynb 点开即可正常写代码、逐单元格运行。
编辑技巧：可以一边 PyCharm 改文件，一边网页刷新；保存是双向同步的。
关闭：关掉终端窗口，Jupyter 服务就停止。
1. 定义清楚提示词
在pycharm编辑器里面新建一个par4.py,内容如下
（1）
import os
import pandas as pd
from openai import OpenAI
from dotenv import load_dotenv
load_dotenv()
client = OpenAI(
api_key = os.environ['DASHSCOPE_API_KEY'], # 替换为你的API Key
base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
)
def generate_responses(prompt, model="qwen-plus"):
response = client.chat.completions.create(
model=model,
messages=[
{"role": "user", "content": prompt},
],
temperature=0.7,
#max_tokens=128,
)
return response.choices[0].message.content
prompt = f"""
根据下面的上下文回答问题。保持答案简短且准确。如果不确定答案，请回答“不确定答案”。
Teplizumab起源于一个位于新泽西的药品公司，名为Ortho Pharmaceutical。\
在那里，科学家们生成了一种早期版本的抗体，被称为OKT3。最初这种分子是从小鼠中提取的，\
能够结合到T细胞的表面，并限制它们的细胞杀伤潜力。在1986年，它被批准用于帮助预防肾脏移植后的\
器官排斥，成为首个被允许用于人类的治疗性抗体。
问题：OKT3最初是从什么来源提取的？
"""
response = generate_responses(prompt)
print(response)
运行可以得到
（2）定义结构，定义变量
新建part5.py
import os
import pandas as pd
from openai import OpenAI
from dotenv import load_dotenv
load_dotenv()
client = OpenAI(
api_key = os.environ['DASHSCOPE_API_KEY'], # 替换为你的API Key
base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
)
def generate_responses(prompt, model="qwen-plus"):
response = client.chat.completions.create(
model=model,
messages=[
{"role": "user", "content": prompt},
],
temperature=0.7,
#max_tokens=128,
)
return response.choices[0].message.content
# 定义结构，定义变量
instruction = """
根据下面的上下文回答问题。保持答案简短且准确。如果不确定答案，请回答“不确定答案”。
"""
context = """
Teplizumab起源于一个位于新泽西的药品公司，名为Ortho Pharmaceutical。\
在那里，科学家们生成了一种早期版本的抗体，被称为OKT3。最初这种分子是从小鼠中提取的，\
能够结合到T细胞的表面，并限制它们的细胞杀伤潜力。在1986年，它被批准用于帮助预防肾脏移植后的\
器官排斥，成为首个被允许用于人类的治疗性抗体。
"""
query = """
OKT3最初是从什么来源提取的？
"""
prompt = f"""
{instruction}
### 上下文
{context}
### 问题：
{query}
"""
response = generate_responses(prompt)
print(response)
运行结果
（3）# 添加格式
import os
import pandas as pd
from openai import OpenAI
from dotenv import load_dotenv
load_dotenv()
client = OpenAI(
api_key = os.environ['DASHSCOPE_API_KEY'], # 替换为你的API Key
base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
)
def generate_responses(prompt, model="qwen-plus"):
response = client.chat.completions.create(
model=model,
messages=[
{"role": "user", "content": prompt},
],
temperature=0.7,
#max_tokens=128,
)
return response.choices[0].message.content
# 添加格式
instruction = """
根据下面的上下文回答问题。保持答案简短且准确。如果不确定答案，请回答“不确定答案”。
以Json格式输出:
{"具体问题":"答案"},
"""
context = """
Teplizumab起源于一个位于新泽西的药品公司，名为Ortho Pharmaceutical。\
在那里，科学家们生成了一种早期版本的抗体，被称为OKT3。最初这种分子是从小鼠中提取的，\
能够结合到T细胞的表面，并限制它们的细胞杀伤潜力。在1986年，它被批准用于帮助预防肾脏移植后的\
器官排斥，成为首个被允许用于人类的治疗性抗体。
"""
query = """
OKT3最初是从什么来源提取的？
"""
prompt = f"""
{instruction}
### 上下文
{context}
### 问题：
{query}
"""
response = generate_responses(prompt)
print(response)
运行结果
2. Few-shot learning
one-shot learning: 只给一个example
few-shot learning: 多个examples
zero-shot learning: 不给任何的examples
https://www.promptingguide.ai/zh
新建part7.py
import os
import pandas as pd
from openai import OpenAI
from dotenv import load_dotenv
load_dotenv()
client = OpenAI(
api_key = os.environ['DASHSCOPE_API_KEY'], # 替换为你的API Key
base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
)
def generate_responses(prompt, model="qwen-plus"):
response = client.chat.completions.create(
model=model,
messages=[
{"role": "user", "content": prompt},
],
temperature=0.7,
#max_tokens=128,
)
return response.choices[0].message.content
prompt = """
将文本分类为中性、负面或正面。
文本：我认为这次假期还可以。
情感：
"""
response = generate_responses(prompt)
print(response)
#输出是中性
#解释：文本中使用了“还可以”这样的表达，表明对假期的评价较为平淡，没有明显的正面或负面情绪，因此属于中性分类。
新建part8.py
import os
import pandas as pd
from openai import OpenAI
from dotenv import load_dotenv
load_dotenv()
client = OpenAI(
api_key = os.environ['DASHSCOPE_API_KEY'], # 替换为你的API Key
base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
)
def generate_responses(prompt, model="qwen-plus"):
response = client.chat.completions.create(
model=model,
messages=[
{"role": "user", "content": prompt},
],
temperature=0.7,
#max_tokens=128,
)
return response.choices[0].message.content
prompt = """
“whatpu”是坦桑尼亚的一种小型毛茸茸的动物。一个使用whatpu这个词的句子的例子是：
我们在非洲旅行时看到了这些非常可爱的whatpus。
“farduddle”是指快速跳上跳下。一个使用farduddle这个词的句子的例子是：
"""
response = generate_responses(prompt)
print(response)
新建part9.py
import os
import pandas as pd
from openai import OpenAI
from dotenv import load_dotenv
load_dotenv()
client = OpenAI(
api_key = os.environ['DASHSCOPE_API_KEY'], # 替换为你的API Key
base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
)
def generate_responses(prompt, model="qwen-plus"):
response = client.chat.completions.create(
model=model,
messages=[
{"role": "user", "content": prompt},
],
temperature=0.7,
#max_tokens=128,
)
return response.choices[0].message.content
# 数学问题需要推理
prompt = """
这组数字中的奇数加起来是一个偶数：15、32、5、13、82、7、1。
A:
"""
response = generate_responses(prompt)
print(response)
四、提示词总结
写清楚的指令 将复杂任务分解为更简单的子任务 系统地测试更改
提供参考文本 使用外部工具
早期测试和学习
引入新信息 可靠地复制复杂的风格或方法
五、RAG介绍
RAG
先从资料库中检索相关内容
在基于相关内容来生成答案
检索 增强 生成
六、RAG的基本流程
七、分片
分片的方式：1、按照字数分 2、按照段落分 3、按照章节分 4、按照页数分
八、索引
索引
1、通过Embedding将片段文本转换为向量
2、将片段文本和片段向量存入向量数据库
向量
Embedding排行榜
https://huggingface.co/spaces/mteb
向量数据库
九、召回
召回：搜索与用户问题相关的片段
十、重排
重排：就是重新排序
十一、生成
生成：就是生成答案
十二、高质量文本块实战指南
为什么你的RAG效果不佳?
核心痛点
LLM强大，Prompt精心调校，但答案仍不准确
检索算法和Embedding已优化，却忽略分块(Chunking)
关键结论
"不恰当的分块=给模型喂'坏数据'"
分块质量决定RAG性能的下限
在命令行输入这条命令
pip install langchain-text-splitters
1、固定长度分块
然后新建01固定长度分块.py，内容如下：
from langchain_text_splitters import CharacterTextSplitter
sample_text =(
"LangChain was created by Harrison Chase in 2022. It provides a framewonk for developing"
"powered by language models. The library is known for its modularity and ease of Use"
"One of its key components is the TextSplitter class, which helps in document chunking"
)
text_splitter = CharacterTextSplitter(
separator=" " , #按空格分割
chunk_size=100, #增大块大小
chunk_overlap=20, #调整重叠比例
length_function=len,
)
docs = text_splitter.create_documents([sample_text])
for i, doc in enumerate(docs):
print(f"---Chunk {i + 1} --")
print(len(doc.page_content))
print(doc.page_content)
运行这个文件输出：
2、递归字符分块
新建02递归字符分块.py，内容如下：
from langchain_text_splitters import RecursiveCharacterTextSplitter
sample_text =(
"LangChain was created by Harrison Chase in 2022. It provides a framewonk for developing"
"powered by language models. The library is known for its modularity and ease of Use"
"One of its key components is the TextSplitter class, which helps in document chunking"
)
#使用与上文相同的 sample_text
text_splitter = RecursiveCharacterTextSplitter(
chunk_size=100,
chunk_overlap=20,
#默认分隔符为["\n\n","\n"," ",""]
)
docs = text_splitter.create_documents([sample_text])
for i, doc in enumerate(docs):
print(f"---Chunk {i + 1} ---")
print(doc.page_content)
运行输出结果
3、结构化文本分块
新建04结构化文本分块.py，内容如下：
from langchain_text_splitters import MarkdownHeaderTextSplitter
markdown_document="""
#Chapter 1: The Beginning
## Section 1.1: The 0ld World
This is the story of a time long past.
## Section 1.2: A New Hope
A new hero emerges.
#Chapter 2: The Journey
## Section 2.1: The Call to Adventure
The hero receives a mysterious call.
"""
headers_to_split_on =[
("#","Header 1"),
("##","Header 2"),
]
markdown_splitter = MarkdownHeaderTextSplitter (headers_to_split_on=headers_to_split_on)
md_header_splits = markdown_splitter.split_text(markdown_document)
for split in md_header_splits:
print(f"Metadata: {split.metadata}")
print(split.page_content)
print("-" * 20)
4、对话式分块
新建 05对话式分块.py
dialogue=[
"Alice: Hi, I'm having trouble with my order",
"Bot: I can help with that. What's your order number?",
"Alice: It's 12345.",
"Alice: I haven't received any shipping updates.",
"Bot: Let me check.It seems your order was shipped yesterday."
"Alice: Oh, great! Thank you."
]
def chunk_dialogue(dialogue_lines, max_turns_per_chunk=3):
chunks = []
for i in range(0, len(dialogue_lines), max_turns_per_chunk):
chunk = "\n".join(dialogue_lines[i:i + max_turns_per_chunk])
chunks.append(chunk)
return chunks
chunks = chunk_dialogue (dialogue)
for i, chunk in enumerate(chunks):
print(f"--- Chunk {i + 1} ---")
print(chunk)
5、语义分块
在命令行安装包
pip install langchain-huggingface
pip install langchain-experimental
十三、RAG检索优化上
十四、RAG检索优化下
1、查询扩展.py
新建查询扩展.py
from langchain_classic.retrievers import MultiQueryRetriever
from langchain_openai import ChatOpenAI
import os
os.environ["HF_ENDPOINT"] = "https://hf-mirror.com"
#初始化大模型
llm = ChatOpenAI(
model="qwen-plus",
base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
api_key="sk-ws-H.REDERIE.QIkm.MEQCIFWoRnXDuiHOj3uDSEuzI9EmwvGFvKKYCh3B0Ff1O2ewAiAnoA-F7BXIHkcAUmDMUQlJme8obNDU6A_w8WHF4M1MjA",
temperature=0.7
)
from langchain_community.vectorstores import Chroma
from langchain_huggingface import HuggingFaceEmbeddings
# 正确模型名称
embeddings = HuggingFaceEmbeddings(
model_name="sentence-transformers/all-MiniLM-L6-v2",
model_kwargs={"device": "cpu"}, # 有显卡改成 "cuda"
encode_kwargs={"normalize_embeddings": True} # 向量归一化，检索常用
)
vectorstore = Chroma(
persist_directory="./chroma_db_qa", # 持久化存储文件夹
embedding_function=embeddings,
# 旧版需要 persist()，新版langchain-chroma自动持久化，无需手动调用
)
multiquery_retriever = MultiQueryRetriever.from_llm(
retriever=vectorstore.as_retriever(),
llm=llm
)
#2.使用原始查询进行调用
user_query ="RAG-Fusion是怎么工作的?"
retrieved_docs = multiquery_retriever.invoke(user_query)
#3。打印结果
print(retrieved_docs,f"查询扩展 (MultiQuery) 对 ‘{user_query}'的检索结果")
import logging
logging.basicConfig()
logging.getLogger("langchain.retrievers.multi_query").setLevel(logging.INFO)
retrieved_docs = multiquery_retriever.invoke(user_query)
运行结果
十五、什么事AI Agent?
Agent框架: LLM能力扩展的核心组件
1、LLM与Agent的本质差异
核心结论:Agent=LLM(基础能力)+规划+工具+记忆
2、Agent四大核心组件概述
1.规划(Planning)-任务执行的“大脑”
核心机制:将模糊需求拆解为可执行子任务流，动态调整执行路径
2.记忆(Memory)--任务执行的“知识库”
双层架构:短期记忆(任务上下文)+长期记忆(外部知识库)
3.工具使用(Tools)--与物理世界交互的“手”
工具矩阵:所有可API化的外部能力
4.执行(Action)-任务落地的“行动引擎”
执行逻辑:根据规划和记忆驱动具体动作，形成闭环
2、为什么Agent是LLM的必然进化?
核心价值: Agent让LLM从“知道怎么做”进化到“真的能做”，真正成为可落地的生产力工具。
十六、Agent认知与原理分析
智能家居Agent系统
适用系统:智能家居环境调控Agent
核心能力:动态感知需求智能规划精准执行闭环优化
十七、核心组件详解之规划
智能体规划能力与ReAct框架
智能体的核心规划能力
2.反思与改进
定义:Agent对过去的行动进行自我批评和反思，从错误中学习并改进未来的步骤，从而提高最终结果的质量
实践建议:构建高效规划智能体
3.提示词工程设计
4.应用场景推荐
十八、核心组件详解之工具使用
Agent 的四大核心组件之:工具使用(Tools/Toolkits)
核心理念
"工具是人类智能的延伸。"
正如人类通过创造、修改和使用外部工具来突破生理与认知的边界，智能体(Agent)也可以借助外部工具显著提升其能力边界。尤其对于基于预训练大语言模型(LLM)构建的Agent而言，工具使用能力是其从“静态知识库“迈向“动态智能体”的关键跃迁。
十九、核心组件详解之记忆功能
智能体中的记忆机制
Agent的记忆系统模拟人类认知，但以计算和工程方式实现:
二十、Agent技术框架-Plan-and-Execute
二十一、Agent技术框架-Self-Ask
二、方法流程
二十三、Agent实战-ReAct框架代码详讲
二十四、应用开发常用技术Langchain
Langchain文档
LangChain中文网: https://www.langchain.com.cn/
二十五、Langchain搭建通义大语言模型
1、创建虚拟环境
conda create -n agent_env python=3.12
2、安装Langchain包
pip install "langchain-community==0.3.27"
pip install dashscope==1.23.7
3、注册API的Key
不同的运营商，有不同的注册方式。在这以通义为例子。
大模型服务平台百炼控制台: https://bailian.console.aliyun.com/#/home
创建Key: https://bailian.console.aliyun.com/?tab=model#/api-key.
conda remove -n agent_env all 移除虚拟环境命令
pip list 能看到pip安装的包
conda info --envs 列出你电脑上所有 Conda 虚拟环境的清单，显示当前正在使用的是哪一个
where pip 在电脑里搜索所有叫 pip 的程序，并把它们所在的完整文件夹路径全部列出来
from langchain_community.llms import tongyi
key = 'sk-w'
llm = tongyi.Tongyi(api_key=key)
info = llm.invoke("夏天适合吃什么水果?回复几个水果名称就可以了!")
print(info)
运行结果
二十六、接入智普AI
安装智普AI模块
pip install pyjwt==2.10.1
新建一个python文件
from langchain_community.chat_models import ChatZhipuAI
from langchain_core.messages import AIMessage, HumanMessage, SystemMessage
import os
#智普AI
key= '8425'
os.environ["ZHIPUAI_API_KEY"] = key
chat = ChatZhipuAI(
model="glm-4",
temperature=0.5,
)
messages = [
AIMessage(content="Hi."),
SystemMessage(content="你用中文回复"),
HumanMessage(content="Write a short poem about AI in four lines.")
]
response = chat.invoke(messages)
print(response.content)
二十七、Langchain环境搭建_ollama模型加载
二十八、Langchain环境搭建_本地模型应用
二十九、关键对象_提示词模板
1、新建提示词1.py
内容如下：
import os
from langchain_community.chat_models import ChatZhipuAI
key= '84254c6ccea64a4'
os.environ["ZHIPUAI_API_KEY"] = key
chat = ChatZhipuAI(
model="glm-4",
temperature=0.5,
)
from langchain.prompts import PromptTemplate
#定义模板
template ='你是一个{role},请用{style}风格回答问题:{question}'
#创建模板对象
prompt_template = PromptTemplate.from_template(template)
#变量填充
filled_prompt = prompt_template.invoke({'role':'数学老师','style':'通俗易懂', 'question':'勾股定是什么?'})
#模型响应数据
ai_msg = chat.invoke(filled_prompt)
print(ai_msg.content)
2、新建提示词2.py，内容如下：
import os
from langchain_community.chat_models import ChatZhipuAI
key= '8254c6ccea64a48a48ec79a2b31ca93.rb7Ti1FDdmCaEpnM'
os.environ["ZHIPUAI_API_KEY"] = key
chat = ChatZhipuAI(
model="glm-4",
temperature=0.5,
)
from langchain_core.prompts import ChatPromptTemplate
#定义模板
sys_template="你是数学老师，请以{style}的风格回答问题"
user_template="请用简单易懂的方式解释:{question}"
#创建对话模板
prompt_template = ChatPromptTemplate.from_messages([
('system', sys_template),
('human', user_template)
])
#填充变量
prompt = prompt_template.format_messages(style='生动有趣',question='勾股定理是么?')
#获取响应
msg = chat.invoke(prompt)
print(msg.content)
三十、Langchain关键对象_输出格式化
新建输出格式化1.py，内容如下：
import os
from langchain_community.chat_models import ChatZhipuAI
key= '84ca93.rb7Ti1FDdmCaEpnM'
os.environ["ZHIPUAI_API_KEY"] = key
chat = ChatZhipuAI(
model="glm-4",
temperature=0.5,
)
from langchain.output_parsers import StructuredOutputParser, ResponseSchema
from langchain.prompts import PromptTemplate
#定义输出结构
response_schemas = [
ResponseSchema(name="name", description="人的姓名",type='string'),
ResponseSchema(name="age", description="人的的年龄",type='integer')
]
# 创建输出解析器
output_parser = StructuredOutputParser.from_response_schemas(response_schemas)
#创建提示模板，包含格式化指令
template="""你是一个信息提取助手，请从以下文本中提取姓名和年龄，并以 JSON 格式返回:
文本:{input_text}
{format_instructions}"""
prompt = PromptTemplate(
template=template,
partial_variables={"format_instructions": output_parser.get_format_instructions()}
)
#填充输入
input_text="张三今年25岁，来自北京。"
filled_prompt = prompt.format(input_text=input_text)
#获取输出
resp = chat.invoke(filled_prompt)
parsed_output = output_parser.parse(resp.content)
print(parsed_output)
输出结果如下
三十、Langchain关键对象_链式调用
新建链式调用.py，内容如下：
import os
from langchain_community.chat_models import ChatZhipuAI
key= '8254c6cceaa48a48ec79a2b31ca93.rb7Ti1FDdmCaEpnM'
os.environ["ZHIPUAI_API_KEY"] = key
chat = ChatZhipuAI(
model="glm-4",
temperature=0.5,
)
from langchain.output_parsers import StructuredOutputParser, ResponseSchema
from langchain.chains import LLMChain
from langchain.prompts import PromptTemplate
#定义输出结构
response_schemas = [
ResponseSchema(name="answer", description="问题的答案",type="string"),
ResponseSchema(name="confidence", description="答案的置信度", type="float")
]
output_parser = StructuredOutputParser.from_response_schemas(response_schemas)
#定义提示模板
template="""你是一名数学老师，请用{style}风格回答以下问题，并以JSON 格式返回答案和置信度:
问题:{question}
{format_instructions}"""
prompt = PromptTemplate(
template=template,
partial_variables={"format_instructions": output_parser.get_format_instructions()}
)
llm_chain = prompt | chat | output_parser #推荐写法
rs = llm_chain.invoke({
'style':'通俗易懂',
'question':'勾股定理是什么?'
})
print(rs)
三十一、Langchain流式输出
新建流式输出.py，内容如下：
from langchain_community.chat_models import ChatZhipuAI
from langchain_core.messages import AIMessage, HumanMessage, SystemMessage
import os
#智普AI
key= '864a48a48ec79a2b31ca93.rb7Ti1FDdmCaEpnM'
os.environ["ZHIPUAI_API_KEY"] = key
chat = ChatZhipuAI(
model="glm-4",
temperature=0.5,
)
from langchain.output_parsers import StructuredOutputParser, ResponseSchema
from langchain.prompts import PromptTemplate
#定义输出结构
response_schemas = [
ResponseSchema(name="answer",description="问题的答案",type="string"),
ResponseSchema(name="confidence",description="答案的置信度",type="float")
]
output_parser = StructuredOutputParser.from_response_schemas(response_schemas)
#定义提示模板
template="""你是一名数学老师，请用{style}风格回答以下问题，并以 JSoN 格式返回答案和置信度:
问题:{question}
{format_instructions}"""
prompt = PromptTemplate(
template=template,
partial_variables={"format_instructions": output_parser.get_format_instructions()}
)
#创建LLMChain
llm_chain =prompt | chat #推荐写法
chunks=[] #存储输出
for chunk in llm_chain.stream({'style':'通俗易懂','question':'勾股定理是什么?'}):
chunks.append(chunk) #存储每次输出
print(chunk,end='',flush=True)
三十二、Langchaini记忆系统-ConversationBufferMemory
新建ConversationBufferMemory.py，内容如下：
from langchain_community.chat_models import ChatZhipuAI
import os
# 新增导入
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain_core.runnables.history import RunnableWithMessageHistory
#智普AI
key= 'cea64a48a48ec79a2b31ca93.rb7Ti1FDdmCaEpnM'
os.environ["ZHIPUAI_API_KEY"] = key
chat = ChatZhipuAI(
model="glm-4",
temperature=0.5,
)
from langchain.memory import ConversationBufferMemory
#创建一个记忆系统（改拼写）
memory = ConversationBufferMemory(return_messages=True)
# 新版LCEL配置
prompt = ChatPromptTemplate.from_messages([
("system", "你是智能助手"),
MessagesPlaceholder("history"),
("human", "{input}")
])
base_chain = prompt | chat
def get_history(session_id):
return memory.chat_memory
conversation = RunnableWithMessageHistory(
base_chain,
get_history,
input_messages_key="input",
history_messages_key="history"
)
# 调用
res1 = conversation.invoke(
{"input": "你好，我是一名会计"},
config={"session_id": "test1"}
)
print(res1.content)
res2 = conversation.invoke(
{"input": "你是谁，擅长什么？"},
config={"session_id": "test1"}
)
print(res2.content)
res3 = conversation.invoke(
{"input": "我的职业你知道吗？"},
config={"session_id": "test1"}
)
print(res3.content)
更多推荐
7
0- 0
已为社区贡献2条内容
所有评论(0)