LangChain的Model

LangChain把对模型的使用拆分为3块输入提示（Format）、调用模型（Predict）、输出解析（Parser）

1.LangChain的模版允许选择动态的输入，可以根据各种需求，动态的调整输入内容

2.LangChain提供通用的接口来调用不同类型的语言模型，提供灵活和便利

3.利用LangChain的输出解析功能，精准提取模型中输出的信息

这三块形成了一个整体，在LangChain中这个过程被统称为Model I/O。就是上一篇介绍中图中所对应的部分

针对输入提示、调用模型、输出解析的这每个环节，LangChain都提供了模板和工具，可以帮助快捷的调用各种语言模型的接口。

针对每块环节，LangChain都提供了模板和工具，可以帮助快捷的调用各种语言模型的接口，也就是说有了模版，那么我们给了他模版他只需要填关键字就行，非常方便使用。

1.提示模版

Prompt template 就是一个模板化的字符串，可以用来生成特定的提示（prompts）。你可以将变量插入到模板中，从而创建出不同的提示。这对重复生成相似格式的提示非常有用，例如在自动化任务中。

LangChain框架中包含以下几个模版类型

1.String提示模板。

2.聊天提示模板,用于组合各种角色的消息模板，传入聊天模型。消息模板包括： ChatMessagePromptTemplate、HumanMessagePromptTemplate、AIlMessagePromptTemplate、SystemMessagePromptTemplate。

3.样本提示模板 FewShotPromptTemplate：通过例子来教模型如何回答问题。

4.部分格式化提示模板：提示模板传入所需值的子集，以创建仅期望剩余值子集的新提示模板。

5.管道提示模板 PipelinePrompt： 用于把几个提示组合在一起使用。

6.自定义模板：允许基于其他模板类来定制自己的提示模板。

from langchain.prompts.prompt import PromptTemplate  # 导入用于创建通用字符串提示模板的类
from langchain.prompts import FewShotPromptTemplate  # 导入用于创建少样本提示模板的类，通过提供示例来指导模型
from langchain.prompts.pipeline import PipelinePromptTemplate  # 导入用于将多个提示模板组合成一个管道的模板类
from langchain.prompts import ChatPromptTemplate  # 导入用于创建结构化聊天消息提示的模板类
from langchain.prompts import (
    ChatMessagePromptTemplate,     # 导入用于创建通用聊天消息的模板类
    SystemMessagePromptTemplate,   # 导入用于创建系统角色消息的模板类
    AIMessagePromptTemplate,       # 导入用于创建AI助手角色消息的模板类
    HumanMessagePromptTemplate,    # 导入用于创建用户角色消息的模板类
)

1.String提示模板

# 导入LangChain中的OpenAI模型接口
from langchain_openai import ChatOpenAI
# 导入LangChain中的提示模板
from langchain.prompts import PromptTemplate
import os
from dotenv import load_dotenv

load_dotenv()

# 创建模型实例
model = ChatOpenAI(api_key=os.getenv("api_key"),
                   base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
                   model='qwen-plus')

prompt = PromptTemplate(
    template="您是一位专业的程序员。\n对于信息 {text} 进行简短描述"
)

# 输入提示
input = prompt.format(text="大模型langchain")

# 得到模型的输出
output = model.invoke(input)
# output = model.invoke("您是一位专业的程序员。对于信息 langchain 进行简短描述")

# 打印输出内容
print(output.content)

2.聊天提示模板

PromptTemplate创建字符串提示的模板。默认情况下，使用Python的str.format语法进行模板化。而ChatPromptTemplate是创建聊天消息列表的提示模板。创建一个ChatPromptTemplate提示模板，模板的不同之处是它们有对应的角色。

import os
from dotenv import load_dotenv
# 导入 ChatOpenAI 用于连接兼容 OpenAI 格式的模型（如通义千问）
from langchain_openai import ChatOpenAI
# 导入聊天提示词模板，用于构建结构化的消息
from langchain.prompts.chat import ChatPromptTemplate

# 1. 加载环境变量
# 读取 .env 文件中的配置，方便管理密钥
load_dotenv()

# 2. 获取配置信息
api_key = os.getenv("QW_KEY")       # 获取 API 密钥
base_url = os.getenv("QW_URL")      # 获取 API 的基础地址
model_name = 'qwen-turbo'           # 指定使用的模型名称

# 3. 定义提示词模板
# 系统提示词：设定 AI 的人设和任务（这里留了语言参数的占位符）
templeta = '你是一个翻译专家，擅长将{input_language}语言翻译为{output_language}'

# 用户提示词：留出了具体文本内容的占位符
human_template = "{text}"

# 4. 构建聊天提示词对象
# 将系统指令和用户输入组合成一个完整的消息结构
chat_prompt = ChatPromptTemplate.from_messages([
    ("system", templeta),   # 角色设定
    ("human", human_template) # 用户输入
])

# 5. 初始化模型实例
model = ChatOpenAI(
    api_key=api_key,
    base_url=base_url,
    model=model_name,
)

# 6. 格式化消息
# 将具体的参数填入模板的占位符中
# input_language='zh' (中文), output_language='en' (英文), text="我爱你中国！"
message = chat_prompt.format_messages(
    input_language='zh', 
    output_language='en', 
    text="我爱你中国！"
)

# 7. 调用模型并获取结果
# 将格式化好的消息发送给模型
output = model.invoke(message)

# 8. 打印结果
# .content 属性用于提取模型回复的具体文本内容
print(output.content)

LangChain提供不同类型的MessagePromptTemplate.最常用的是AIMessagePromptTemplate、 SystemMessagePromptTemplate和HumanMessagePromptTemplate，分别创建人工智能消息、系统消息和人工消息。

# 1. 导入必要的类
# ChatPromptTemplate: 用于组合消息
# SystemMessagePromptTemplate: 专门处理系统指令（人设）
# HumanMessagePromptTemplate: 专门处理用户输入
from langchain.prompts import (
    ChatPromptTemplate,
    SystemMessagePromptTemplate,
    HumanMessagePromptTemplate,
)
from langchain_openai import ChatOpenAI
import os
from dotenv import load_dotenv

# 2. 加载环境变量
load_dotenv()

# 3. 配置模型参数
api_key = os.getenv("QW_KEY")
base_url = os.getenv("QW_URL")
model_name = 'qwen-turbo'  # 变量名改为 model_name，避免混淆

# 4. 定义系统提示词（人设）
# 这里的 {calc} 是个占位符，稍后填入具体的技能描述
system_template = "你是一个数学家，擅长{calc}"
system_message = SystemMessagePromptTemplate.from_template(system_template)

# 5. 定义用户提示词（输入）
human_template = "{text}"
human_message = HumanMessagePromptTemplate.from_template(human_template)

# 6. 组合成完整的聊天提示词
prompt_template = ChatPromptTemplate.from_messages([
    system_message,
    human_message
])

# 7. 格式化提示词
# 这里填入具体的参数：
# calc="计算" -> 替换系统提示词里的 {calc}
# text="..." -> 替换用户提示词里的 {text}
prompt = prompt_template.format_prompt(
    calc="计算",
    text="我今年18岁，我的舅舅今年38岁，我的爷爷今年72岁，我和舅舅一共多少岁了？"
)

# 8. 初始化模型实例
# 变量名改为 llm，代表 Large Language Model
llm = ChatOpenAI(
    api_key=api_key,
    base_url=base_url,
    model=model_name
)

# 9. 调用模型
result = llm.invoke(prompt)

# 10. 打印结果
print(result.content)

3.少量样板提示

基于LLM模型与聊天模型，可分别使用FewShotPromptTemplate或FewShotChatMessagePromptTemplate，两者使用一致

创建示例集：创建一些提示样本，每个示例都是一个字典，其中键是输入变量，值是输入变量的值

examples = [
    {"input": "2+2", "output": "4", "description": "加法运算"},
    {"input": "5-2", "output": "3", "description": "减法运算"},
]

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

# 1. 加载环境变量
load_dotenv()

# 2. 获取配置信息
api_key = os.getenv("QW_KEY")
base_url = os.getenv("QW_URL")
model_name = 'qwen-turbo'  # 变量名改为 model_name 避免与模型实例混淆

# 3. 创建少样本示例
# 这里定义了模型可以参考的“例题”
examples = [
    {"input": "2+2", "output": "4", "description": "加法运算"},
    {"input": "5-2", "output": "3", "description": "减法运算"},
]

# 4. 定义示例的格式模板
# 决定每个示例在提示词中如何展示
example_template = "算式：{input}，结果：{output}，类型：{description}"
example_prompt = PromptTemplate.from_template(example_template)

# 5. 构建少样本提示词模板
prompt = FewShotPromptTemplate(
    examples=examples,           # 传入示例列表
    example_prompt=example_prompt, # 传入示例模板
    suffix="请计算：{input}",    # 修正：后缀只包含需要模型处理的新输入
    input_variables=["input"],   # 修正：只保留 input 变量，output 是示例里的
    prefix="你是一个数学专家，请参考以下示例进行计算：" # 增加前缀指令
)

# 6. 初始化大语言模型
llm = ChatOpenAI(
    api_key=api_key,
    base_url=base_url,
    model=model_name
)

# 7. 格式化提示词并调用模型
# 注意：这里只传入 input，让模型自己去预测 output
final_prompt_text = prompt.format(input="2*5")
result = llm.invoke(final_prompt_text)

# 8. 打印结果
print(result.content)

2.Model模型

LangChain支持的模型有三大类

1.大语言模型（LLM） ，也叫Text Model，这些模型将文本字符串作为输入，并返回文本字符串作为输出。

2.聊天模型（Chat Model），主要代表Open AI的ChatGPT系列模型。这些模型通常由语言模型支持，但它们的API更加结构化。具体来说，这些模型将聊天消息列表作为输入，并返回聊天消息。

3.文本嵌入模型（Embedding Model），这些模型将文本作为输入并返回浮点数列表，也就是Embedding。

聊天模型通常由大语言模型支持，但专门调整为对话场景。重要的是，它们的提供商API使用不同于纯文本模型的接口。输入被处理为聊天消息列表，输出为AI生成的消息。

1.大模型

LangChain的核心组件是大型语言模型（LLM），提供一个标准接口以字符串作为输入并返回字符串的形式与多个不同的LLM进行交互。这一接口为诸如OpenAI、Hugging Face等多家LLM供应商提供标准化的对接方法。

from langchain_community.chat_models import ChatTongyi
from dotenv import load_dotenv
import os

load_dotenv()

# LLM纯文本补全模型
llm = ChatTongyi(api_key=os.getenv("api_key"),base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",model='deepseek-v3')

text = "我的真的好想（帮我补全这个文本）"
res = llm.invoke(text)
print(res.content)

2.聊天模型

聊天模型也是LangChain的核心组件，使用聊天消息作为输入并返回聊天消息作为输出，有一些内置的消息类型

1.SystemMessage:用来启动 AI 行为，通俗的意思就是你告诉他AI大模型现在是什么角色，他可以是厨师、数学家、专家等等。

2.HumanMessage:表示来自与聊天模型交互的人的消息，就是你。

3.AIMessage:表示来自聊天模型的消息。这可以是文本，也可以是调用工具的请求。

3.文本嵌入模型

Embedding 类是一个用于与嵌入进行交互的类。有许多嵌入提供商（OpenAI、Cohere、Hugging Face等)- 这个类旨在为所有这些提供商提供一个标准接口。

import os

from langchain_community.embeddings import DashScopeEmbeddings
from dotenv import load_dotenv

load_dotenv()
# 初始化 DashScopeEmbeddings实例
embeddings = DashScopeEmbeddings(dashscope_api_key=os.getenv("api_key"), model='text-embedding-v3')


# 获取文本嵌入向量
text = '大模型'

# 嵌入文档 把文档内容转换为向量 他支持多个文档列表形式
doc_res = embeddings.embed_documents([text])
print(doc_res)

# 嵌入查询  把问题嵌入向量  一般都是一个问题
res = embeddings.embed_query(text)
print(res)

3.文本嵌入模型-Huggingface本地

国内的镜像地址：
魔塔：

from langchain_huggingface import HuggingFaceEmbeddings

# 1. 配置本地模型路径
# 注意：这里使用的是绝对路径，指向你本地存储的 BGE 模型文件夹
model_name = '/Users/yuxl/3.Resources/Demo/llm/embdding/bge-large-zhv15/BAAI/bge-large-zh-v1___5'

# 2. 配置编码参数
# normalize_embeddings: True 表示对生成的向量进行归一化处理（使向量模长为1）。
# 这对于计算余弦相似度非常有用，也是向量数据库检索的标准做法。
encode_kwargs = {'normalize_embeddings': True}

# 3. 初始化 Embedding 对象
embeddings = HuggingFaceEmbeddings(
    model_name=model_name,      # 指定模型路径
    encode_kwargs=encode_kwargs # 传入归一化配置
)

# 4. 准备待处理的文本
text = "学习langchain"

# 5. 将文本转换为向量
# embed_query 专门用于处理单个查询文本（如果是处理文档列表，通常用 embed_documents）
query_result = embeddings.embed_query(text)

# 6. 打印结果预览
# 向量维度通常很高（如1024维），这里只打印前5个数字看看效果
print(query_result[:5])

4.文本嵌入模型-Huggingface在线

通过Hugging Face官方包，就可以通过简单的api调用就能在langchain中轻松使用Hugging Face上各类流行的开源大语言模型以及各类AI工具

import os
from dotenv import load_dotenv
from langchain_huggingface import HuggingFaceEndpoint

# 1. 加载环境变量
load_dotenv()

# 2. 配置参数
# 注意：如果是调用 Hugging Face 公共模型，请使用 repo_id
MODEL_REPO_ID = "HuggingFaceH4/zephyr-7b-beta"
HF_TOKEN = os.getenv('HF_TOKEN')

# 3. 初始化 LLM
llm = HuggingFaceEndpoint(
    repo_id=MODEL_REPO_ID,          # 修正：使用 repo_id 指定模型名称
    # endpoint_url="...",           # 如果你有自己的专用端点链接，才使用这个参数
    max_new_tokens=512,             # 建议：适当增加生成长度，30 个 token 可能说不完一句话
    temperature=0.01,               # 低温度让输出更确定、更精准
    typical_p=0.95,                 # 控制多样性
    repetition_penalty=1.03,        # 防止复读机
    huggingfacehub_api_token=HF_TOKEN
)

# 4. 调用模型
try:
    response = llm.invoke("解释 langchain 是什么？")
    print(response)
except Exception as e:
    print(f"发生错误: {e}")

3.输出解析器

输出解析器负责获取 LLM 的输出并将其转换为更合适的格式。借助LangChain的输出解析器重构程序，使模型能够生成结构化回应，并可以直接解析这些回应，LangChain有许多不同类型的输出解析器，具体的用法参考基本使用里面已经写了对应demo

1.CSV解析器: CommaSeparatedListOutputParser,模型的输出以逗号分隔，以列表形式返回输出

2.JSON解析器: JsonOutputParser,确保输出符合特定JSON对象格式。

3.XML解析器: XMLOutputParser,允许以流行的XML格式从LLM获取结果

import os
from dotenv import load_dotenv
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
# 导入 JSON 输出解析器，用于将模型输出转换为 Python 字典
from langchain_core.output_parsers import JsonOutputParser

# 1. 加载环境变量
# verbose=True 会在加载成功时打印日志，方便调试
load_dotenv(verbose=True)

# 2. 获取配置信息
api_key = os.getenv("QW_KEY")
base_url = os.getenv("QW_URL")
model_name = 'qwen-turbo'

# 3. 初始化大语言模型
llm = ChatOpenAI(
    api_key=api_key,
    base_url=base_url,
    model=model_name
)

# 4. 初始化输出解析器
# JsonOutputParser 会自动在提示词中注入“请以 JSON 格式输出”的指令
output_parser = JsonOutputParser()

# 5. 构建提示词模板
prompt = ChatPromptTemplate.from_messages([
    ("system", "你是一个专业的程序员"),
    ("user", "{input}")
])

# 6. 构建处理链 (LCEL)
# 流程：提示词 -> 模型 -> 解析器
# 解析器会自动把模型返回的 JSON 字符串转换成 Python 字典对象
chain = prompt | llm | output_parser

# 7. 调用链并获取结果
# 这里的 input 会替换模板中的 {input}
res = chain.invoke({"input": "langchain是什么？"})

# 8. 打印结果
# 此时 res 已经是一个字典(dict)，不再是字符串
print(res)