【LangChain Model I/O 02】

介绍

Modle I/O模块是与语言模型（LLMs）进行交互的核心组件，包括：输入提示（Pormat）、调用模型（Predict）、输出解析（Parse）；简单来说就是输入、模型处理、输出这三个步骤

针对每个环节，LangChain都提供了模版和工具，可以快捷的调用各种语言模型的接口

一、模型调用

1、Model I/O 调用模型

LangChain作为一个工具，不提供任何LLMs，而是依赖与第三方集成的各种大模型

1）模型调用的分类

简单来讲，就是用谁家的API已什么方式调用那种类型的大模型

角度1：按照模型功能的不同

非对话模型（LLMs、Text Model）
- LLMs也叫Text Model、非对话模型，是许多语言模型应用程序的支柱。主要特点：
- 输入：接受文本字符串或者PromptValue对象
- 输出：总是返回文本字符串
- 使用场景：仅需单次文本生成任务（如：摘要生成、翻译、代码生成、单次问答）或对接不支持消息结构的旧模型（如部分本地部署模型）
- 不支持多轮对话上下文，每次调用单独处理输入，无法自动关联历史对话（需要手动拼接历史文本）
- 局限性：无法处理角色分工或复杂对话逻辑
对话模型（Chat Model）（推荐）
- 大语言模型调用，以ChatModel为主，主要特点：
- 输入：接收消息列表List[BaseMessage]或PromptValue，每条消息需指定角色（如：SystemMessage、HumanMessage、AIMessage）
- 输出：总是返回带角色的消息对象（BaseMessage子类），通常是AIMessage
- 原生支持多轮对话。通过消息列表维护上下文，模型可基于完整对话历史生成回复
- 适用场景：对话系统（如客服机器人、长期交互的AI助手）
嵌入模型（Embedding Models）
- 也叫文本嵌入模型，这些模型将文本作为输入并返回浮点数列表，也就是Embedding

角度2：模型调用时，重要参数存放的位置不同（api-key、base_url、model-name）

硬编码：写在代码文件中
使用环境变量
使用配置文件（推荐）

角度3：具体调用的API

LangChain的统一方式调用API（推荐）
OpenAI提供的API
- 可以使用CloseAI(https://www.closeai-asia.com/)注册和充值
其他大模型自家提供的API

结合角度1、2、3代码示例:

在实际的工作中，常常使用的是配置文件+对话模型的形式

import os
from dotenv import load_dotenv
from langchain_openai import ChatOpenAI
load_dotenv()
'''
采用配置文件的方式加载对话模型
1、在项目根目录创建.env文件，添加如下配置项
OPENAI_API_BASE_URLL=你的openai api base url
OPENAI_API_KEYY=你的openai api key
2、在代码中通过os.getenv()方法获取配置项的值
3、将获取到的值传递给ChatOpenAI类的base_url和api_key参数
'''

llm=ChatOpenAI(
    model="gpt-4o-mini",
    base_url=os.getenv("OPENAI_API_BASE_URLS"),
    api_key= os.getenv("OPENAI_API_KEY1"),
    temperature=0.7,
    max_tokens=200
)

res=llm.invoke("RAG技术的核心流程")
print(res.content)

# 当然可以给os内部环境变量赋值 -->如果model采用默认的模型，ChatOpenAI()初始化时可以不传base_url和api_key参数

os.environ["OPENAI_BASE_URL"]=os.getenv("OPENAI_BASE_URLS")
os.environ["OPENAI_API_KEY"]=os.getenv("OPENAI_API_KEY1")

chat = ChatOpenAI()
response = chat.invoke("请简要介绍一下RAG技术的核心流程")
print(response.content)

2、Model I/O 调用模型2

1）关于对话模型的Message(消息)

对话模型除了将字符串作为输入后，还可以使用“聊天信息”作为输入，并返回聊天信息作为输出

LangChain有一些内置的消息类型：

SystemMessage：设定AI行为规则或背景信息。比如设定AI的初始状态，行为模式或对话的总体目标。比如：作为一个代码专家，或者返回json格式。通常作为输入信息序列中的第一个传递
HumanMessage：表示来自用户输入。比如：实现一个快速排序方法
AIMessage：存储AI回复的内容。这可以是文本，也可以是调用工具的请求
ChatMessage：可以自定义角色的通用信息类型
FunctionMessage/ToolMessage：函数调用/工具消息，用于函数调用结果的消息类型

注意：
FunctionMessage和ToolMessage分别是在函数调⽤和⼯具调⽤场景下才会使⽤的特殊消息类
型，HumanMessage、AIMessage和SystemMessage才是最常⽤的消息类型。

举例：

from langchain_core.messages import SystemMessage, HumanMessage
from langchain_openai import ChatOpenAI
import os
import dotenv

dotenv.load_dotenv()
base_url = os.getenv("OPENAI_BASE_URLS")
api_key = os.getenv("OPENAI_API_KEY1")

chat = ChatOpenAI(
    model="gpt-4o-mini",
    base_url=base_url,
    api_key=api_key
)

message = [
    SystemMessage(content="你是一个擅长人工智能的相关学科的专家"),
    HumanMessage(content="请用中文解释一下什么是机器学习")
]
response = chat.invoke(message)
print(response.content)
print(type(response)) #打印查看到大模型执行后返回的对象类型=AIMessage

2）关于模型调用的方法

LangChain组件实现了Runnable协议，也就是一个类，它实现了包括聊天模型、提示词模版、输出解析器、代理（智能体）等

Runnable类定义公共的调用方法如下：

invoke：处理单条输入、等待LLM完全推理完成后在返回调用结果
stream：流式响应，逐字输出LLM的响应结果
- 非流式输出：即当用户发出请求后，系统在后台等待模型生成完整响应，然后一次将全部结果返回
- 流式输出：即当用户发出请求后，用户不需要等待完整答案，而是能看到模型逐个token地实时返回内容---->langchain中通过streaming=True启动流式输出
batch：处理批量输入

这些也也有相应的异步方法，应该与asyncio和await语法一起使用以实现并发：

astream : 异步流式响应
ainvoke : 异步处理单条输入
abatch : 异步处理批量输入
astream_log : 异步流式返回中间步骤，以及最终响应
astream_events : （测试版）异步流式返回链中发生的事件（在 langchain-core 0.1.14 中引入）

|-- 流式输出案例：

from langchain_core.messages import SystemMessage, HumanMessage
from langchain_openai import ChatOpenAI
import os
import dotenv

dotenv.load_dotenv() #加载配置文件
base_url = os.getenv("OPENAI_BASE_URLS")
api_key = os.getenv("OPENAI_API_KEY1")

chat = ChatOpenAI(
    model="gpt-4o-mini",
    base_url=base_url,
    api_key=api_key,
    streaming=True
)

message = [
    SystemMessage(content="你是一个擅长编程的专家"),
    HumanMessage(content="请用Python写一个冒泡排序的代码")
]
# 流式输出，模型执行返回的结果是一个生成器对象，所以可以使用for循环进行迭代输出
response = chat.stream(message)
for chunk in response:
    print(chunk.content, end='', flush=True)
print(type(response)) #打印查看到大模型执行后返回的对象类型=Generator

|-- 批量处理

#批量处理
from langchain_core.messages import SystemMessage, HumanMessage
from langchain_openai import ChatOpenAI
import os
import dotenv

dotenv.load_dotenv() #加载配置文件
base_url = os.getenv("OPENAI_BASE_URLS")
api_key = os.getenv("OPENAI_API_KEY1")

chat = ChatOpenAI(
    model="gpt-4o-mini",
    base_url=base_url,
    api_key=api_key
)

message1 = [
    SystemMessage(content="你是一个擅长编程的专家"),
    HumanMessage(content="请用Python写一个冒泡排序的代码")
]
message2 = [
    SystemMessage(content="你是一个擅长历史的专家"),
    HumanMessage(content="请简要介绍一下二战的起因")
]
messages = [message1, message2]
response=chat.batch(messages)  #批量处理多个输入

print(type(response)) #打印查看到大模型执行后返回的对象类型<class 'list'>

for chunk in response:
    print(chunk.content)

二、Model I/O之Prompt Template 提示词模版

1、介绍与分类

prompt Template 提示词模版，接受用户的输入，返回一个信息传递给LLM

在实际的开发应用中，传递一个固定的提示词本身就是不够灵活也很局限，所以prompt Template是一个模版化的字符串，可以将变量插入到模版中，从而创建出不同的提示词

调用时：

已字典作为输入
已PromptValue输出，传递给LLM或ChatModle，并且还可以转换为字符串或消息列表

分类：

promptTemplate：LLM提示词模版，用于生成字符串提示。它使用python的字符串来模版提示
ChatPromptTemplate：聊天提示模版，用于组合各种角色的消息模版，传入聊天模型xxxMessagePromptTemplate：消息提示词模版，包括：SystemMessagePromptTemplate、HumanMessagePromptTemplate、AIMessagePromptTemplate、ChatMessagePromptTemplate等

FewShotPromptTemplate ：样本提示词模板，通过示例来教模型如何回答
PipelinePrompt ：管道提示词模板，用于把几个提示词组合在一起使用。
自定义模板：允许基于其它模板类来定制自己的提示词模板。

2、promptTemplate使用

2.1、使用说明：

PromptTemplate类，用于快速构建包含变量的提示词模版，并通过传入不同的参数值，生成自定义的提示词

主要参数：

template：定义提示词模版的字符串，其中包含文本和变量占位符
input_variables：列表，指定了模版中使用的变量名称，在调用模版时被替换
partial_variables：字典，用于定义模版中的一些固定的变量名，这些值不需要再每次调用时被替换

函数介绍：

forma()：给input_variables变量赋值，并返回提示词。利用format()进行格式化时就一定要赋值，否则会报错。当在template中未设置input_variables，则会自动忽略

2.2、PromptTemplate如何获取实例

from langchain_core.prompts import PromptTemplate

## 方式一：使用构造方法

# 1、定义模版
tempalte=PromptTemplate(
    template="请用中文介绍一下{product}。",
    input_variables=["product"],
)
# 2、传入多个变量，生成最终的提示词
final_prompt=tempalte.format(product="LangChain")
final_prompt1 = tempalte.format(product="大模型")

print(final_prompt+'\n'+final_prompt1) # 执行结果: 请用中文介绍一下LangChain。
print(type(final_prompt)) # 执行结果: <class 'str'>

## 方式二：使用from_template类方法
# 1、定义模版
prompt_tempalte=PromptTemplate.from_template(
    template="你是一个{role}专家，请用{language}介绍一下{product}。"
)
# 2、传入模版中的变量名
prompt=prompt_tempalte.format(role="人工智能", language="中文", product="机器学习")

print(prompt) # 执行结果: 你是一个人工智能专家，请用中文介绍一下机器学习。
print(type(prompt)) # 执行结果: <class 'str'>

区别：使用from_template方法，可以在定义模版时不需要通过input_variables指定变量名称，更加的方便

2.3、两种特殊结构的使用(部分提示词模版的使用，组合提示词的使用)

部分提示词模版：在生成prompt前就已经提前通过partial_variables初始化部分变量提示词，在导入模版时只导入除初始化以外的变量即可

#方式一： 实例化过程中使用partial_variables参数
partial_prompt=PromptTemplate.from_template(
    template="你是一个{role}专家，请用{language}介绍一下{product}。",
    partial_variables={"role":"人工智能"}
)
prompt = partial_prompt.format(language = '中文', product='深度学习')
print(prompt) # 执行结果: 你是一个人工智能专家，请用中文介绍一下深度学习。

# 方式二：使用PromptTemplate.partial方法创建部分提示模版
base_prompt=PromptTemplate.from_template(
    template="你是一个{role}专家，请用{language}介绍一下{product}。",
)
partial_prompt=base_prompt.partial(role="编程")
prompt=partial_prompt.format(language="Python", product="函数式编程")
print(prompt) # 执行结果: 你是一个编程专家，请用Python介绍一下函数式编程。

组合提示词模版

from langchain_core.prompts import PromptTemplate
template = (
    PromptTemplate.from_template("Tell me a joke about {topic}")
    + ", make it funny"
    + "\n\nand in {language}"
)
prompt = template.format(topic="sports", language="spanish")
print(prompt)

2.4、给变量赋值的两种方式（fromat()、invoke()）

fromat()：返回值为字符串类型

invoke()：传入的是字典，返回值为PromptValue类型，接着调用to_string()返回字符串

tempalte = PromptTemplate.from_template("告诉我一段关于{topic}的历史")
prompt = tempalte.invoke({"topic": "二战"}) #传入的是一个字典 
print(prompt)
print(type(prompt)) #执行结果：<class 'langchain_core.prompt_values.StringPromptValue'>

2.5、结合大模型的使用

from langchain_core.messages import SystemMessage, HumanMessage
from langchain_openai import ChatOpenAI
import os
import dotenv

# 1.加载环境配置文件
dotenv.load_dotenv()
base_url = os.getenv("OPENAI_BASE_URLS")
api_key = os.getenv("OPENAI_API_KEY1")

# 2.创建大模型对象   
chat = ChatOpenAI(
    model = "gpt-4o-mini",
    base_url= base_url,
    api_key= api_key
)

# 3.创建提示词模版并传入变量生成最终提示词
tempalte = PromptTemplate.from_template("请{name}告诉我一段关于{topic}的畅想")
prompt = tempalte.invoke({"name": "马斯克","topic": "移民火星"}) 

# 4.调用大模型的invoke方法进行问答
message = [
    SystemMessage(content="你是一个擅长历史的专家"),
    HumanMessage(content=prompt.to_string())
]   
response = chat.invoke(message)
print(response.content)

3、ChatPromptTemplate

3.1、使用说明

ChatPromptTemplate是创建聊天信息列表的提示模版。它比普通PromptTemplate更适合处理多角色、多轮次的对话场景

特点：

支持System /Human /AI 等不同角色的消息模版
对话历史维护

参数类型：列表参数格式tuple类型（role：str content：str 组合最常用）

元组的格式为：(role: str | type, content: str | list[dict] | list[object])

其中role是：字符串（如：system、Human、ai）

3.2、实例化的2种方式

3.2.1 使用构造方法

from langchain_core.prompts import ChatPromptTemplate


chat_prompt_template=ChatPromptTemplate(
    [
        ("system", "你是一个乐于助人的助手,你的名字是{name}。"),
        ("human", "我的问题是{question}。"),
    ]
)
responses = chat_prompt_template.invoke(input={"name":"小明", "question":"你是谁？"})
print(responses.to_string())
print(type(responses)) #<class 'langchain_core.prompt_values.ChatPromptValue'>

3.2.2 使用from_message()

from langchain_core.prompts import ChatPromptTemplate
chat_prompt=ChatPromptTemplate.from_messages(
    [
        ("system", "你是一个乐于助人的助手,你的名字是{name}。"),
        ("human", "我的问题是{question}。"),
    ]
)
template = chat_prompt.invoke(input={"name":"小红", "question":"你是谁？"})
print(template.to_string())
print(type(template))

3.3、调用提示词模版的几种方法: invoke()、format()、format_message()、format_prompt()

'''
invoke()方法 :传入的是字典，返回的是ChatPromptValue对象
format()方法：传入变量的值，返回的是字符串
format_message()方法：传入变量的值，返回的是消息对象列表List[Message]
format_prompt()方法：传入变量的值，返回的是ChatPromptValue对象
'''
#如何实现ChatPromptValue与list[Message]、String 之间的转换

from langchain_core.prompts import ChatPromptTemplate
chat_prompt=ChatPromptTemplate.from_messages(
    [
        ("system", "你是一个乐于助人的助手,你的名字是{name}。"),
        ("human", "我的问题是{question}。"),
    ]
)
template = chat_prompt.invoke(input={"name":"小红", "question":"你是谁？"}) # 返回的是ChatPromptValue对象

# ChatPromptValue 转换成 str类型 ---->to_string()函数
str_prompt = template.to_string() 
print(str_prompt)   
print(type(str_prompt))     

# ChatPromptValue 转换成 List[Message]类型 ---->to_messages()函数  
message_prompt = template.to_messages() 
print(message_prompt)   
print(type(message_prompt))

调用提示词模版的这几个方法，其实只需要记住一个即可，然后想转换成string类型，就用to_String()转换，想转换成list类型就用to_message()转换

3.4、更丰富的实例化参数类型

参数是列表类型，列表的元素可以是字符串、字典、字符串构成的元组、消息类型、提示词模版类型、消息提示词模版类型等

3.5、插入消息列表：MessagePlaceholder 后再结合LLM

MessagePlaceholder作用：当你不确定消息提示模版使用什么角色或者希望在格式化过程中插入消息列表时，可以使用MessagePlaceholder占位符在提示词模版中预留一个位置，后续可以动态插入消息列表
使用场景：多轮对话系统存储历史消息以及Agent的中间步骤处理此功能非常有用

from langchain_core.prompts.chat import MessagesPlaceholder
from langchain_core.messages import AIMessage, HumanMessage
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
import os
import dotenv

#1、加载环境配置文件
dotenv.load_dotenv()
base_url = os.getenv("OPENAI_BASE_URLS")
api_key = os.getenv("OPENAI_API_KEY1")

#2、创建大模型对象
chat = ChatOpenAI(
    model = "gpt-4o-mini",
    base_url= base_url,
    api_key= api_key
)

#3、创建ChatPromptTemplate提示词模版并传入变量生成最终提示词
chat_prompt_template=ChatPromptTemplate.from_messages(
    [
        ("system", "你是一个精通{role}的帮助助手，擅长回答各种问题。"),
        MessagesPlaceholder("history"),
        ("human", "{question}"),
    ]
)
prompt = chat_prompt_template.format_messages(
    role="数学",
    history=[
        HumanMessage(content="1+2*3等于多少？"),
        AIMessage(content="1+2*3等于7。"),
    ],
    question = "我刚才的问题是什么"
)
for context in prompt:
    print(context.content)

#4、调用大模型的invoke方法进行问答
response = chat.invoke(prompt)
print("\n"+response.content)

4、少量样本示例提示词模版

在构建prompt时，可以通过构建一个少量示例列表去进一步格式化prompt，这是一种简单但强大的指导生成的方式，在某些情况下可以显著提高模型性能

少量示例提示模版可以由一组示例活一个负责从定义的集合选择一部分示例的示例选择器构建

前者：使用FewShotPromptTemplate或 FewShotChatMeessagePromptTemplate
后者：使用Example selectors(示例选择器)

每个示例的结构都是一个字典，其中键是输入变量，值是输入变量的值

4.1、FewShotPromptTemplate的使用【非对话式】

作用：与PromptTemplate结合着使用，目的是用提示词模版，然后给到大模型一个实例，然后把这2者统一放到FewShotPromptTemplate对象中，让大模型去依据模版及实例去理解以便能更加准确的输出，减少幻觉

from langchain_core.prompts import FewShotPromptTemplate, PromptTemplate
from langchain_openai import ChatOpenAI
import os
import dotenv


#1）创建提示模版，将一个示例格式化为字符串
prompt_template = "你是一个数学专家，输入:{input} 输出:{output} 描述:{description}"
prompt_template = PromptTemplate.from_template(prompt_template)

#2）提供实例
examples = [
    {"input": "2+2", "output": "4", "description": "加法运算"},
    {"input": "2x2", "output": "4", "description": "乘法运算"},
]

# 3）创建FewShotPromptTemplate对象
few_template = FewShotPromptTemplate(
    examples=examples, # 提供示例   
    example_prompt=prompt_template, # 指定示例的提示模版
    suffix="请你仿照上面的示例，根据：{input}，给出相应的output值和description描述。", #要放到示例模版后面的要求
    input_variables=["input"], # 用户输入变量
)

# 4) 提示词结合LLM使用
dotenv.load_dotenv()
base_url = os.getenv("OPENAI_BASE_URLS")
api_key = os.getenv("OPENAI_API_KEY1")

chat = ChatOpenAI(
    model="gpt-4o-mini",
    base_url=base_url,
    api_key=api_key,
)

res = chat.invoke(few_template.invoke({"input": "10-2"})) # 调用FewShotPromptTemplate的invoke方法，传入用户输入
print(res.content)

4.2、FewShotChatMessagePromptTemplate的使用【对话式】

作用：与ChatMessagePromptemplate结合使用，FewShotChatMessagePromptTemplate是专门为聊天对话场景设计的少样本（few-shot）提示模版，它继承自FewShotPromptTemplate，但针对聊天信息的格式进行了优化

特点：

自动将示例格式化为聊天信息（HumanMessage / AIMessage等）
输出结构化聊天消息（List[BaseMessage]）
保留对话轮次结构

from langchain_core.prompts import FewShotChatMessagePromptTemplate, ChatPromptTemplate
from langchain_openai import ChatOpenAI
import os
import dotenv

# 目标：让模型先从示例中“归纳 🐦 这个运算符代表什么”，再用同一规则去算 10🐦2。

#1）创建示例组
examples = [
    {"input": "2🐦2", "output": "4"},
    {"input": "2🐦3", "output": "6"},
    {"input": "10🐦0", "output": "10"},
]

#2）创建示例用的 ChatPromptTemplate提示词模版（一问一答对齐风格）
example_chat_prompt = ChatPromptTemplate.from_messages(
    [
        ("human", "表达式：{input}"),
        ("ai", "结果：{output}"),
    ]
)

#3）Few-shot 示例消息
few_shot = FewShotChatMessagePromptTemplate(
    example_prompt=example_chat_prompt,
    examples=examples,
)

#4）最终提示：要求模型输出『规则』+『结果』+『推理』
final_prompt = ChatPromptTemplate.from_messages(
    [
        (
            "system",
            "你是一个严谨的数学符号归纳助手。你会从给定示例中推断一个未知二元运算符的含义，并用该规则计算新表达式。",
        ),
        few_shot,
        (
            "human",
            "上面给了若干条『表达式 -> 结果』示例。请你完成两个任务：\n"
            "1) 归纳运算符 🐦 的含义（尽量用标准运算符 +、-、*、/ 或清晰的函数规则描述）。\n"
            "2) 使用你归纳出的规则，计算：{input}\n\n"
            "请严格按如下格式输出：\n"
            "规则：...\n"
            "结果：...\n"
            "推理：...",
        ),
    ]
)

# 5) 提示词结合LLM使用
dotenv.load_dotenv()
base_url = os.getenv("OPENAI_BASE_URLS")
api_key = os.getenv("OPENAI_API_KEY1")

chat = ChatOpenAI(
    model="gpt-4o-mini",
    base_url=base_url,
    api_key=api_key,
)

res = chat.invoke(final_prompt.invoke({"input": "10🐦2"}))
print(res.content)

执行结果：

　　规则：运算符 🐦 表示取第一个数与第二个数的乘积，即 \( a \, \text{🐦} \, b = a \times b \)。
　　结果：20
　　推理：根据规则，10🐦2 等价于 10 × 2，因此结果是 20。

4.3、 Example selectors(示例选择器)

前面FewShotPromptTemplate的特点是，无论询问什么问题，提示词都会包含所有的示例，这样消耗的token是相当大的，所以在实际的开发中，我们可以根据当前输入，使用示例选择器，从大量的候选示例中选取相关最相关的示例

关键的技术点：

定义示例选择器：SemanticSimilarityExampleSelector.from_examples()
1. 示例列表组
2. 嵌入模型
3. 向量数据库
4. 选择示例的个数
关键技术点如何使用: 使用嵌入模型把示例转换成向量，然后存储到向量数据库，然后根据用户的提问去向量数据库中寻找最相近的示例，然后进行输出(输出几个需要按照定义的个数)

# 第一步: 安装向量数据库 pip install chromadb
# 第二步：编写示例选择器代码

# 1.导入相关包
from langchain_community.vectorstores import Chroma
from langchain_core.example_selectors import SemanticSimilarityExampleSelector
import os
import dotenv
from langchain_openai import OpenAIEmbeddings
dotenv.load_dotenv()
# 2.定义嵌入模型
os.environ['OPENAI_API_KEY'] = os.getenv("OPENAI_API_KEY1")
os.environ['OPENAI_BASE_URL'] = os.getenv("OPENAI_BASE_URLS")
embeddings_model = OpenAIEmbeddings(
    model="text-embedding-3-small"
)
# 3.定义示例组
examples = [
            {
            "question": "谁活得更久，穆罕默德·阿里还是艾伦·图灵?",
            "answer": """
            接下来还需要问什么问题吗？
            追问：穆罕默德·阿里去世时多大年纪？
            中间答案：穆罕默德·阿里去世时享年74岁。
            """,
            },
            {
            "question": "craigslist的创始人是什么时候出生的？",
            "answer": """
            接下来还需要问什么问题吗？
            追问：谁是craigslist的创始人？
            中级答案：Craigslist是由克雷格·纽马克创立的。
            """,
            },
            {
            "question": "谁是乔治·华盛顿的外祖父？",
            "answer": """
            接下来还需要问什么问题吗？
            追问：谁是乔治·华盛顿的母亲？
            中间答案：乔治·华盛顿的母亲是玛丽·鲍尔·华盛顿。
            """,
            },
            {
            "question": "《大白鲨》和《皇家赌场》的导演都来自同一个国家吗？",
            "answer": """
            接下来还需要问什么问题吗？
            追问：《大白鲨》的导演是谁？
            中级答案：《大白鲨》的导演是史蒂文·斯皮尔伯格。
            """,
            },
        ]
# 4.定义示例选择器
example_selector = SemanticSimilarityExampleSelector.from_examples(
    # 这是可供选择的示例列表
    examples,
    # 嵌入模型，用于将示例转换为向量
    embeddings_model,
    # 向量数据库，用于存储和检索示例向量
    Chroma,
    # 这是要生成的示例数量
    k=1,
)
# 选择与输入最相似的示例
question = "玛丽·鲍尔·华盛顿的父亲是谁?"
selected_examples = example_selector.select_examples({"question": question})
print(f"与输入最相似的示例：{selected_examples}")

4.4、从文档中加载Prompt

支持两种：yaml和json格式的文件

目的和使用场景：

为了便于共享、存储和加强对prompt的版本控制
当我们的prompt模版数据较大时，我们可以使用外部导入的方式进行管理和维护

加载yaml和json的关键函数:load_prompt

prompt.yaml

_type:
    "prompt"
input_variables:
    ["name","what"]
template:
    "请给{name}讲一个关于{what}的故事"

## 调用yaml文件代码
from langchain_core.prompts import load_prompt
from dotenv import load_dotenv
load_dotenv()
prompt = load_prompt("prompt.yaml", encoding="utf-8")
# print(prompt)
print(prompt.format(name="年轻人", what="滑稽"))

prompt.json文件

{
  "_type": "prompt",
  "input_variables": [
    "name",
    "what"
  ],
  "template": "请{name}讲一个{what}的故事,"

## 调用json文件代码

from langchain_core.prompts import load_prompt
from dotenv import load_dotenv
load_dotenv()
prompt = load_prompt("prompt.json",encoding="utf-8")
print(prompt.format(name="张三",what="搞笑的"))

三、Model I/O之Output Parsers

大模型通常返回的是字符串的格式，但在实际开发过程中需要返回更加直观和格式化的内容，所以就用到了langchain提供的输出解析器

输出解析器（Output Parsers）负责获取LLM的输出并将其转换为更合适的格式。这一特性在应用开发中尤其重要

1、输出解析器的分类

LangChain有许多不同类型的输出解析器

StrOutputParser ：字符串解析器
JsonOutputParser ：JSON解析器，确保输出符合特定JSON对象格式
XMLOutputParser ：XML解析器，允许以流行的XML格式从LLM获取结果
CommaSeparatedListOutputParser ：CSV解析器，模型的输出以逗号分隔，以列表形式返回输出
DatetimeOutputParser ：日期时间解析器，可用于将 LLM 输出解析为日期时间格式

除了上述常用的输出解析器之外，还有：

EnumOutputParser ：枚举解析器，将LLM的输出，解析为预定义的枚举值
StructuredOutputParser ：将非结构化文本转换为预定义格式的结构化数据（如字典）
OutputFixingParser ：输出修复解析器，用于自动修复格式错误的解析器，比如将返回的不符合
预期格式的输出，尝试修正为正确的结构化数据（如 JSON）
RetryOutputParser ：重试解析器，当主解析器（如 JSONOutputParser）因格式错误无法解析
LLM 的输出时，通过调用另一个 LLM 自动修正错误，并重新尝试解析

2、具体解析器的使用

2.1、字符串解析器 StrOutputParser

可以简单的将任何输入转换成字符串。它是一个简单的解析器，从结果中提取content字段

案例：此案例采用了数据流向：用户输入 -> Prompt模板(自动检索示例+组装) -> Chat模型 -> 输出解析器 -> 纯文本的思路

## 字符串解析器 StrOutputParser

from langchain_core.example_selectors import SemanticSimilarityExampleSelector
from langchain_core.messages import SystemMessage, HumanMessage
from langchain_openai import ChatOpenAI, OpenAIEmbeddings
from langchain_core.prompts import ChatPromptTemplate, FewShotChatMessagePromptTemplate
import os
import dotenv
from openai import base_url, api_key
from langchain_community.vectorstores import Chroma
from langchain_core.output_parsers import StrOutputParser


#1、加载环境配置文件
dotenv.load_dotenv()
base_url = os.getenv("OPENAI_BASE_URLS")
api_key = os.getenv("OPENAI_API_KEY1")

#2、创建大模型对象
chat = ChatOpenAI(
    model="gpt-4o-mini",
    base_url=base_url,
    api_key=api_key,
)
#3、接入示例提示词来创建最终提示词模版
embeddings =  OpenAIEmbeddings(  #定义嵌入模型
    model="text-embedding-3-small",
    base_url=base_url,
    api_key=api_key,
)

examples = [ # 定义示例组
    {
            "question": "2025年AI技术取得了哪些重大突破？",
            "answer": """
            接下来还需要问什么问题吗？
            追问：2026年AI技术可能会有哪些新的发展方向？
            中间答案：2026年AI技术可能会在太空AI，机器人自主学习等领域取得新的突破。
            """,
    },
    {
            "question": "谁是乔治·华盛顿的外祖父？",
            "answer": """
            接下来还需要问什么问题吗？
            追问：谁是乔治·华盛顿的母亲？
            中间答案：乔治·华盛顿的母亲是玛丽·鲍尔·华盛顿。
            """,
    },
    {
            "question": "《大白鲨》和《皇家赌场》的导演都来自同一个国家吗？",
            "answer": """
            接下来还需要问什么问题吗？
            追问：《大白鲨》的导演是谁？
            中级答案：《大白鲨》的导演是史蒂文·斯皮尔伯格。
            """,
    }
]
example_selector = SemanticSimilarityExampleSelector.from_examples( #示例选择器把示例存入向量数据库
    examples,
    embeddings,
    Chroma,
    k=1
)

#4、调用大模型的invoke方法进行问答
# 定义示例在对话中的格式
example_prompt = ChatPromptTemplate.from_messages(
    [
        ("human", "{question}"),
        ("ai", "{answer}"),
    ]
)

# 直接把 example_selector 传给 PromptTemplate，这样它会自动根据用户的新输入，去向量库里检索最相关的示例，然后填入 Prompt
few_shot_prompt = FewShotChatMessagePromptTemplate(
    example_selector=example_selector,  # 传入选择器，而不是写死的 examples 列表
    example_prompt=example_prompt,
)

# 构建最终的对话提示模版
final_prompt = ChatPromptTemplate.from_messages(
    [
        ("system", "你是一个智能问答助手。"),
        few_shot_prompt,
        ("human", "{question}"),
    ]
)

# 5、结合输出解析器 (Output Parser)
output_parser = StrOutputParser()

# 使用 LCEL (LangChain Expression Language) 链式调用
# 数据流向：用户输入 -> Prompt模板(自动检索示例+组装) -> Chat模型 -> 输出解析器 -> 纯文本
chain = final_prompt | chat | output_parser

res_text = chain.invoke(
    {"question": "马斯克和黄仁勋对话谈论2025年AI发展取得的成就以及2026年AI的发展前景"}
)

print(type(res_text))
print(res_text)

2.2、JSON解析器 JsonOutputParser

顾名思义：将大模型输出的内容转换成JSON格式的数据

适用场景：特别适用于需要严格结构化输出的场景，比如API的调用，数据存储或者下游任务处理

实现方式：

方式1：用户自己通过提示词指明返回Json格式
方式2：借助JsonOutputParser的get_format_instrucion() 生成格式说明，指导模型输出JSON结构

## Json解析器 JsonOutputParser
from langchain_core.output_parsers import JsonOutputParser
from langchain_core.prompts import PromptTemplate


dotenv.load_dotenv()
base_url = os.getenv("OPENAI_BASE_URLS")
api_key = os.getenv("OPENAI_API_KEY1")

chat = ChatOpenAI(
    model="gpt-4o-mini",
    base_url=base_url,
    api_key=api_key,
)

query = '请给我讲一个笑话'

#定义json输出解析器对象
json_parser  = JsonOutputParser()

# 定义提示词模版 -->关键点： template给到了2个变量：format_instructions 和 query，而partial_variables把format_instructions变量固定为json_parser.get_format_instructions()的值,所以用户只需要传入query这一个变量变量
prompt = PromptTemplate.from_template(
    template="回答用户的问题\n{format_instructions}\n{query}\n",
    partial_variables={"format_instructions": json_parser.get_format_instructions()}
)


# 使用LCEL链式调用: 提示词-->大模型 --> json输出解析器 【 | 叫管道符】
chain = prompt | chat | json_parser

res_json = chain.invoke({"query": query})

print(res_json)

2.4、列表解析器CommaSeparatedListOutputParser

列表解析器：利用此解析器可以将模型的文本响应转换为一个用逗号分隔的列表（List[str]）

关键：

# 创建解析器
output_parser = CommaSeparatedListOutputParser()

2.5、日期解析器DatetimeOOutputParser

利用此解析器可以最直接将LLM输出解析为日期时间格式

get_format_instructions()： 获取日期解析的格式化指令，指令为："Write a datetime string
that matches the following pattern: '%Y-%m-%dT%H:%M:%S.%fZ'。

posted @ 2025-11-03 15:37 尘封~~ 阅读(11) 评论(0) 收藏举报

刷新页面返回顶部

朝九晚五浪迹江湖