一.  Model之提示模板

1. LLM调用过程拆解

  (1) 输入提示：LangChain的模板允许动态选择输入，根据实际需求调整输入内容，适用于各种特定任务和应用

  (2) 语言模型：LangChain 提供通用接口调用不同类型的语言模型，提升了灵活性和使用便利性。

  (3) 输出解析：利用 LangChain 的输出解析功能，将非结构化文本转换为可处理的结构化数据，提高信息处理效率。

2. 提示词模板

  PromptTemplates 是LangChain中的一个概念，通过接收原始用户输入，并返回一个准备好传递给语言模型的信息。

  常用的提示词模板如下：

(1) String提示模板

代码分享

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

load_dotenv()

# 创建模型实例
model = ChatOpenAI(api_key=os.getenv("api_key"), base_url=os.getenv("base_url"), model_name=os.getenv("model1"))
Prompt = PromptTemplate(template='你是一个专业的程序员, 对{test}进行表述')
myInput = Prompt.format(test='python')
print(myInput)
resource = model.invoke(myInput)
print(resource)

(2) 聊天提示模板

代码分享

import os
from dotenv import load_dotenv
from langchain_core.prompts.chat import ChatPromptTemplate
from langchain_openai import ChatOpenAI

load_dotenv()

model = ChatOpenAI(api_key=os.getenv("api_key"), base_url=os.getenv("base_url"), model_name=os.getenv("model1"))
# template = "你是一个数学家，你可以计算任何算式"
template = "你是一个翻译专家,擅长将 {language1} 语言翻译成 {language2}语言."
chat_prompt = ChatPromptTemplate.from_messages([("system", template), ("human", "{text}")])
# 输入提示
# messages = chat_prompt.format_messages(text="我今年18岁，我的舅舅今年38岁，我的爷爷今年72岁，我和舅舅一共多少岁了？")  # 该msg与上述设置无关，调用报错
messages = chat_prompt.format_messages(
    language1="英文",
    language2="中文",
    text="I love Large Language Model.",
)
print(messages)
# 调用
output = model.invoke(messages)
print(f"AI输出：{output.content}")

角色聊天代码分享

from langchain_core.prompts import ChatPromptTemplate, SystemMessagePromptTemplate, HumanMessagePromptTemplate
from langchain_openai import ChatOpenAI
from dotenv import load_dotenv
import os

load_dotenv()

# 1. 系统模板的构建
system_template = "你是一个翻译专家,擅长将 {input_language} 语言翻译成 {output_language}语言."
system_message_prompt = SystemMessagePromptTemplate.from_template(system_template)
# 2. 用户模版的构建
human_template = "{text}"
human_message_prompt = HumanMessagePromptTemplate.from_template(human_template)
# 3.组装成最终模版
prompt_template = ChatPromptTemplate.from_messages([system_message_prompt, human_message_prompt])
# 4. 格式化提示消息生成提示
prompt = prompt_template.format_prompt(input_language="英文", output_language="中文", text="I love Large Language Model.").to_messages()
# 打印模版
print("prompt:", prompt)
# # 创建模型实例
model = ChatOpenAI(api_key=os.getenv("api_key"), base_url=os.getenv("base_url"), model_name=os.getenv("model1"))
# 调用模型并输出
result = model.invoke(prompt)
print("AI输出:", result.content)

(3) 少量提示词模板

代码分享

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

load_dotenv()

llm = langchain_openai.ChatOpenAI(api_key=os.getenv("api_key"), base_url=os.getenv("base_url"), model_name=os.getenv("model1"))

# 创建示例
examples = [
    {"input": "2+2", "output": "4", "description": "加法运算"},
    {"input": "5-2", "output": "3", "description": "减法运算"},
]
# 创建提示模板，配置一个提示模板，将一个示例格式化为字符串
prompt_template = "你是一个数学专家,算式： {input} 值： {output} 使用： {description} "
# 这是一个提示模板，用于设置每个示例的格式  字符串提示词模版
prompt_sample = PromptTemplate.from_template(prompt_template)

prompt = FewShotPromptTemplate(
    examples=examples,  # 用到的模版
    example_prompt=prompt_sample,
    suffix="你是一个数学专家,算式: {input}  值: {output} ",  # 后缀输出    告诉大模型按照这个格式输出
    input_variables=["input", 'output'],
)
print(prompt.format(input="2*5", output="10"))
result = llm.invoke(prompt.format(input="2*5", output="10"))
print(result.content)  # 使用: 乘法运算

二. Model之模型

1. 说明

   LangChain支持的模型分为三类：

   (1) 大语言模型(LLM)：模型将文本字符串作为输入，并返回文本字符串作为输出

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

   (3) 文本嵌入模型(Embedding Model)：将文本作为输入并返回浮点数列表(向量)，也就是Embedding。

2. 大语言模型(LLM)

 LangChain的核心组件是大型语言模型（LLM），它提供一个标准接口以字符串作为输入并返回字符串的形式与多个不同的LLM进行交互。

   文本补全-千问也支持，只是不如DeepSeek

   代码分享：

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

load_dotenv()
# LLM纯文本补全模型
# 千问也支持qwen-turbo ，但是不如 deepseek-v3 支持的好
llm = ChatTongyi(api_key=os.getenv("api_key"), base_url=os.getenv("base_url"), model='deepseek-v3.2')

text = "我爱你,就像（帮我补全这个文本）"
res = llm.invoke(text)
print(res.content)

3. 聊天模型

 聊天模型是LangChain的核心组件，使用聊天消息作为输入并返回聊天消息作为输出。

 LangChain有一些内置的消息类型

• SystemMessage:用于启动 AI 行为，通常作为输入消息序列中的第一个传递。

• HumanMessage:表示来自与聊天模型交互的人的消息。

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

   代码分享：

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

load_dotenv()

system_text = "你是一个强大的助手，你的名字叫Tony"
human_text = "你好啊"
# 聊天模型
chat_model = ChatOpenAI(api_key=os.getenv("DASHSCOPE_API_KEY"), base_url=os.getenv("DASHSCOPE_BASE_URL"), model="qwen-plus")

# 直接调用
# messages = [HumanMessage(content=human_text)]
# messages = [SystemMessage(content=system_text), HumanMessage(content=human_text)]  # 聊天模型支持多个消息作为输入
# res = chat_model.invoke(messages)
# print(res.content)

print("===== AI 智能助手已启动 =====")
print("输入 exit 即可退出\n")
# 无限循环：一问一答
while True:
    # 手动输入问题
    user_input = input("你：")
    # 如果输入 exit 就退出循环
    if user_input.lower() == "exit":
        print("Tony：再见！")
        break
    # 构造消息
    messages = [SystemMessage(content=system_text), HumanMessage(content=user_input)]
    # AI 回答
    res = chat_model.invoke(messages)
    # 打印回答
    print("AI：" + res.content + "\n")

4. 文本嵌入模型

  Embedding类是一个用于与嵌入进行交互的类。

(1) 调用本地模型向量化

import os
from langchain_community.embeddings import DashScopeEmbeddings
from dotenv import load_dotenv

load_dotenv()
embeddings = DashScopeEmbeddings(dashscope_api_key=os.getenv("api_key"), model='text-embedding-v3')
text = '大模型'

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

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

(2) 阿里百炼向量模型

import os
from langchain_community.embeddings import DashScopeEmbeddings
from dotenv import load_dotenv

load_dotenv()
embeddings = DashScopeEmbeddings(dashscope_api_key=os.getenv("api_key"), model=os.getenv("model2"))
text = '大模型'

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

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

(3) 向量chroma向量存储

"""
    本节：向量话调用的是阿里的模型，Chroma使用的是langchain_community.vectorstores中的
"""

import os
from langchain_community.embeddings import DashScopeEmbeddings
from langchain_community.vectorstores import Chroma
from langchain_community.document_loaders import PyPDFLoader
from langchain_text_splitters import RecursiveCharacterTextSplitter
from dotenv import load_dotenv

load_dotenv()

loader = PyPDFLoader("../财务管理文档.pdf")  # 读取文件
pages = loader.load_and_split()

text_splitter = RecursiveCharacterTextSplitter(
    chunk_size=200,
    chunk_overlap=100,
    length_function=len,
    add_start_index=True,
)
# 1. 将数据进行切割成块
paragraphs = text_splitter.create_documents([page.page_content for page in pages if pages])
# print(paragraphs)

# 2. 创建chroma数据库，并将文本数据逐个向量化，然后存入 [一行代码搞定!!!!]
embeddings = DashScopeEmbeddings(dashscope_api_key=os.getenv('api_key'), model=os.getenv("model2"))
# 注：指定persist_directory，则存放本地；不指定则存在内存中
# db = Chroma.from_documents(documents=paragraphs, embedding=embeddings)  # 存放内存
# 第一次运行：创建 + 保存
db = Chroma.from_documents(paragraphs, embeddings, persist_directory="chroma_db1")
# 之后每次运行：直接加载
# db = Chroma(embedding_function=embeddings, persist_directory="chroma_db1")

# 3. 在数据库中进行搜索
query = "会计核算基础规范"
docs = db.similarity_search(query, k=3)  # 相似度最高的前3的数据  [一行代码搞定!!!!]
for doc in docs:
    print(f"{doc}\n-------\n")

(4) 向量chroma向量存储+本地模型调用

"""
    本节：向量化调用的本地模型，Chroma使用的是langchain_chroma中的
"""

from langchain_chroma import Chroma
from langchain_community.document_loaders import PyPDFLoader
from langchain_text_splitters import RecursiveCharacterTextSplitter
from langchain_huggingface.embeddings import HuggingFaceEmbeddings


loader = PyPDFLoader("../财务管理文档.pdf")  # 读取文件
pages = loader.load_and_split()

text_splitter = RecursiveCharacterTextSplitter(
    chunk_size=200,
    chunk_overlap=100,
    length_function=len,
    add_start_index=True,
)
# 1. 将数据进行切割成块
paragraphs = text_splitter.create_documents([page.page_content for page in pages if pages])
# print(paragraphs)

# 2. 向量化并存入DB
# 2.1 本地模型向量化
embeddings = HuggingFaceEmbeddings(model_name=r'E:\LLM\bge-large-zh-v1.5')
# 2.2 初始化db，并写入数据
# 注：指定persist_directory，则存放本地；不指定则存在内存中
# 第一次运行：创建 + 保存
db = Chroma.from_documents(paragraphs, embeddings, persist_directory="chroma_db1")
# 之后每次运行：直接加载
# db = Chroma(embedding_function=embeddings, persist_directory="chroma_db1")

# 3. 在数据库中进行搜索
query = "会计核算基础规范"
docs = db.similarity_search(query, k=3)  # 相似度最高的前3的数据  [一行代码搞定!!!!]
for doc in docs:
    print(f"{doc}\n-------\n")

5. 输出解释器

 输出解析器负责获取 LLM 的输出并将其转换为更合适的格式。借助LangChain的输出解析器重构程序，使模型能够生成结构化回应，并可以直接解析这些回应

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

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

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

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

   代码分享：

from langchain_core.prompts import ChatPromptTemplate
from langchain_openai import ChatOpenAI
# 创建解析器
from langchain_core.output_parsers import JsonOutputParser, StrOutputParser, XMLOutputParser
from dotenv import load_dotenv
import os

load_dotenv()

model = ChatOpenAI(api_key=os.getenv("api_key"), base_url=os.getenv("base_url"), model_name=os.getenv("model1"))

# output_parser = StrOutputParser()
# output_parser = XMLOutputParser()
output_parser = JsonOutputParser()

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

# 将提示和模型合并以进行调用
# chain = prompt | model | output_parser
chain = prompt | model | output_parser

# 输出的数据的类型是输出解释器提供的（即解释器是什么格式，默认就是什么格式）
res = chain.invoke({"input": "langchain是什么? 请用json格式输出"})
# res = chain.invoke({"input": "大模型中的langchain是什么?"})
# res = chain.invoke({"input": "langchain是什么? 使用xml格式输出"})
print(res)

三. Langchain数据检索

1. Document loaders 文档加载模块

   LangChain封装了一系列类型的文档加载模块，例如PDF、CSV、HTML、JSON、Markdown、File Directory等

   代码分享：

"""
 必须先安装：pip install pypdf -i https://pypi.tuna.tsinghua.edu.cn/simple
 然后再使用langchain框架读取
"""

from langchain_community.document_loaders import PyPDFLoader

loader = PyPDFLoader(r'财务管理文档.pdf')
# print(loader)
pages = loader.load()
print(pages[1].page_content)  # 查看第二页内容

#  分割读取
# pages = loader.load_and_split()
# print(f"第0页：\n{pages[0]}")  ## 也可通过 pages[0].page_content只获取本页内容

2. 文档切分模块

  LangChain提供了许多不同类型的文本切分器

 

   代码分享：

from langchain_community.document_loaders import PyPDFLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter

loader = PyPDFLoader("财务管理文档.pdf")
pages = loader.load_and_split()
# print(f"第0页：\n{pages[0].page_content}")
# print(pages)

"""
    #  chunk_size：每一段文本最多30个字符，你设置多少，就是多少
    #  chunk_overlap：两段之间重叠的字数，主要是为了防止语义被切断，这里10表示：第一段末尾 10 个字 = 第二段开头 10 个字
    #  length_function=len ：表示按字符个数计算（中文、英文、数字都算 1 个）
"""
text_splitter = RecursiveCharacterTextSplitter(chunk_size=200, chunk_overlap=100, length_function=len)
aa = text_splitter.create_documents([page.page_content.replace('\n', '').replace(' ', '') for page in pages if pages])
for i in aa:
    print(i.page_content, len(i.page_content))

3. Retrievers检索器

     检索器帮助你找到与特定查询最相关的文档，检索器接受字符串查询作为输入，并返回文档列表作为输出。

     LangChain检索器提供的检索类型如下：

   代码分享：

"""
  速度明显比05-向量存储1快
"""

import os
from langchain_community.embeddings import DashScopeEmbeddings
from langchain_community.vectorstores import Chroma
from langchain_community.document_loaders import PyPDFLoader
from langchain_text_splitters import RecursiveCharacterTextSplitter
from dotenv import load_dotenv

load_dotenv()
# 1. 读取pdf文件
loader = PyPDFLoader("财务管理文档.pdf")
pages = loader.load_and_split()
# 2. 将数据进行切割成块
text_splitter = RecursiveCharacterTextSplitter(
    chunk_size=200,  # 每段最多 200 字
    chunk_overlap=100,  # 两段重叠 100 字（上下文不丢失）
    length_function=len,  # 按字数算长度
    add_start_index=True,  # 给每段打上起始位置编号
)
paragraphs = text_splitter.create_documents([page.page_content for page in pages if pages])

# 3. 创建chroma数据库，并将文本数据逐个向量化存入
db = Chroma.from_documents(paragraphs, DashScopeEmbeddings(dashscope_api_key=os.getenv('api_key')))  # 一行代码搞定

# 4. 实例化一个检索器
retriever = db.as_retriever()
# retriever = db.as_retriever(search_kwargs={"k": 1})  # 我们还可以限制检索器返回的文档数量

# 5. 获取问题相关文档
docs = retriever.invoke("会计核算基础规范")
for doc in docs:
    print(f"{doc.page_content}\n-------\n")