《LLM大语言模型深度探索与实践：构建智能应用的新范式，融合代理与数据库的高级整合》

文章目录

- Langchain的定义
- Langchain的组成
- - 三个核心组件实现
  - 整个核心组成部分
- 为什么要使用Langchain
- Langchain的底层原理
- Langchain实战操作
- - LangSmith
  - - LangChain调用LLM
    - - 安装openAI库-国内镜像源
      - 代码
      - 运行结果
      - 小结
    - 使用Langchain的提示模板
    - 部署Langchain程序
    - - 安装langserve
      - 代码
      - 请求格式
  - Langchain构建聊天机器人
  - - 安装依赖
    - 代码
    - 运行结果
    - - 流式输出+历史记录
      - 运行结果
- LangChain构建向量数据库和检索器
- - - 导入向量数据库依赖
    - 做一个依赖更新对齐
    - 代码
    - - 运行结果
    - 检索器
    - - 运行结果
    - 检索器和模型结合
- LangChain构建代理
- - 目的
  - - 定义工具
    - - Tavily
      - 安转该工具依赖
        代码
        回答
      - Retriever
      - 代码
        运行结果
    - Agent代理使用语言模型选择工具
- LangChain读取数据库
- - 安装依赖
  - 测试数据库是否连接成功
  - 完整代码
  - - 运行结果
  - Agent整合数据库
  - - 运行结果
- 源代码下载

Langchain的定义

Langchain是一个用于由语言模型驱动的应用程序框架。

其实就是能给把大语言模型和外部的数据源（私有数据）进行结合。这个框架类似于SpringBoot框架，让用户能给直接通过它使用大语言模型。

Langchain的组成

三个核心组件实现

在这里插入图片描述

Compents组件：为LLMs提供封装接口、模版提示、信息检索索引，类似于jdbc的驱动程序
Chains链：将不同的组件组合起来解决特定的任务，比如在大量文本中查找信息
Agents代理：他们使得LLMs能与外部环境进行交互，例如通过API请求执行操作

整个核心组成部分

在这里插入图片描述

模型Models：模型包装器，允许你连接到各种大语言模型，如GPT4或Hugging Face也包括GLM提供的模型。
Prompt Template：这些模版让你避免硬编码文本输入。你可以动态输入提示词，发送给大语言模型。
Chains：链允许多个组件组合在一起，解决特定的任务，构建完整的语言模型应用程序
Agents：代理允许语言模型与外部API交互
Embedding：嵌入与向量存储。
Indexes：索引帮助你从语言模型中提取相关信息

为什么要使用Langchain

理由：

数据连接

Langchain允许你将大语言模型连接到你自己的数据源，比如数据库、pdf文件，可以连接你私有的数据中提取信息。

行动执行

不仅可以提取信息，Langchain还可以帮助你根据这些信息执行特定的动作，比如发送邮件。

Langchain的底层原理

在这里插入图片描述

Langchain实战操作

LangSmith

Langsmith是一个构建生产级LLM应用程序的平台，它提供了调试、测试、评估和监控基于任何LLM框架构建的链和智能代理的功能，并且能与LangChain无缝集成。

LangSmith是LangChain的一个子产品，是一个大模型应用开发平台。它提供了从原型到生产的全流程工具和服务，帮助开发者构建、测试、评估和监控基于LangChain或其他LLM框架的应用程序。

LangChain调用LLM

那接下来狐哥带大家进入实战环境。

使用的环境：

pycharm
python3.10

安装openAI库-国内镜像源

pip install langchain-openai -i http://mirrors.aliyun.com/pypi/simple/ --trusted-host mirrors.aliyun.com

代码

import getpass
import os

from langchain_core.messages import SystemMessage, HumanMessage
from langchain_openai import ChatOpenAI
os.environ["http_proxy"] = "127.0.0.1:7890"
os.environ["https_proxy"] = "127.0.0.1:7890"

os.environ["LANGCHAIN_TRACING_V2"] = "true"
os.environ["LANGCHAIN_API_KEY"] = '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'

#调用大语言模型
model = ChatOpenAI(model='gpt-4o-mini')

msg = [
    SystemMessage(content='请将以下的内容翻译成意大利语'),
    HumanMessage(content='你好，请问你要去哪里？')
]

result = model.invoke(msg)
print(result)

#简单的响应解析数据
parser = StrOutputParser()
print(parser.invoke(result))

运行结果

content='Ciao, dove stai andando?' additional_kwargs={'refusal': None} response_metadata={'token_usage': {'completion_tokens': 9, 'prompt_tokens': 30, 'total_tokens': 39, 'completion_tokens_details': {'accepted_prediction_tokens': 0, 'audio_tokens': 0, 'reasoning_tokens': 0, 'rejected_prediction_tokens': 0}, 'prompt_tokens_details': {'audio_tokens': 0, 'cached_tokens': 0}}, 'model_name': 'gpt-4o-mini-2024-07-18', 'system_fingerprint': 'fp_72ed7ab54c', 'finish_reason': 'stop', 'logprobs': None} id='run-4b3c8dc2-62ab-4a5e-b327-827cd0c3ecf5-0' usage_metadata={'input_tokens': 30, 'output_tokens': 9, 'total_tokens': 39}

在这里插入图片描述

小结

其实上面的步骤可以总结一下，用更简单的方式实现，通用的步骤：

import getpass
import os

from langchain_core.messages import SystemMessage, HumanMessage
from langchain_core.output_parsers import StrOutputParser
from langchain_openai import ChatOpenAI
os.environ["http_proxy"] = "127.0.0.1:7890"
os.environ["https_proxy"] = "127.0.0.1:7890"

os.environ["LANGCHAIN_TRACING_V2"] = "true"
os.environ["LANGCHAIN_API_KEY"] = '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'

#调用大语言模型
#1、创建大模型
model = ChatOpenAI(model='gpt-4o-mini')

#2、准备提示
msg = [
    SystemMessage(content='请将以下的内容翻译成意大利语'),
    HumanMessage(content='你好，请问你要去哪里？')
]

result = model.invoke(msg)
# print(result)

#3、创建返回数据的解析器 简单的响应解析数据
parser = StrOutputParser()
# print(parser.invoke(result))

#4、得到链
chain = model | parser

#5、直接使用chain来调用
print(chain.invoke(msg))

创建大模型
准备提示
创建返回数据的解析器
得到链
直接使用chain来调用

使用Langchain的提示模板

import getpass
import os

from langchain_core.messages import SystemMessage, HumanMessage
from langchain_core.output_parsers import StrOutputParser
from langchain_core.prompts import ChatPromptTemplate
from langchain_openai import ChatOpenAI
os.environ["http_proxy"] = "127.0.0.1:7890"
os.environ["https_proxy"] = "127.0.0.1:7890"

os.environ["LANGCHAIN_TRACING_V2"] = "true"
os.environ["LANGCHAIN_API_KEY"] = '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'

#调用大语言模型
#1、创建大模型
model = ChatOpenAI(model='gpt-4o-mini')

#2、准备提示
msg = [
    SystemMessage(content='请将以下的内容翻译成意大利语'),
    HumanMessage(content='你好，请问你要去哪里？')
]

result = model.invoke(msg)
# print(result)

#3、创建返回数据的解析器 简单的响应解析数据
parser = StrOutputParser()
# print(parser.invoke(result))

# 定义提示模板
prompt_template = ChatPromptTemplate.from_messages([
    ('system','请将下面的内容翻译成{language}'),
    ('user','{text}')
])

#4、得到链
chain = prompt_template | model | parser

#5、直接使用chain来调用
# print(chain.invoke(msg))
print(chain.invoke({
    'language': 'English',
    'text': '你好，请问你要去哪里？'
}))

部署Langchain程序

安装langserve

pip install "langserve[all]"

代码

import getpass
import os

from fastapi import FastAPI
from langchain_core.messages import SystemMessage, HumanMessage
from langchain_core.output_parsers import StrOutputParser
from langchain_core.prompts import ChatPromptTemplate
from langchain_openai import ChatOpenAI
from langserve import add_routes

os.environ["http_proxy"] = "127.0.0.1:7890"
os.environ["https_proxy"] = "127.0.0.1:7890"

os.environ["LANGCHAIN_TRACING_V2"] = "true"
os.environ["LANGCHAIN_API_KEY"] = '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'

#调用大语言模型
#1、创建大模型
model = ChatOpenAI(model='gpt-4o-mini')

#2、准备提示
# msg = [
#     SystemMessage(content='请将以下的内容翻译成意大利语'),
#     HumanMessage(content='你好，请问你要去哪里？')
# ]
#
# result = model.invoke(msg)
# print(result)

#3、创建返回数据的解析器 简单的响应解析数据
parser = StrOutputParser()
# print(parser.invoke(result))

# 定义提示模板
prompt_template = ChatPromptTemplate.from_messages([
    ('system','请将下面的内容翻译成{language}'),
    ('user','{text}')
])

#4、得到链
chain = prompt_template | model | parser

#5、直接使用chain来调用
# print(chain.invoke(msg))
print(chain.invoke({
    'language': 'English',
    'text': '你好，请问你要去哪里？'
}))

# 把我们的程序部署成服务
# 创建FastAPI应用
app = FastAPI(title='我的Langchain服务',version='1.0',description='这是一个Langchain服务-翻译任何语句的服务')
add_routes(
    app,
    chain,
    path="/chain",
)

if __name__ == '__main__':
    import uvicorn
    uvicorn.run(app, host="localhost", port=8000)

请求格式

POST

http://localhost:8000/chain/invoke，其中invoke不能少！

{
    "input":
    {
        "language":"English",
        "text":"我要去上课了，明天和你聊天"
    }
}

运行结果：

在这里插入图片描述

Langchain构建聊天机器人

构建一个聊天机器人的重点是：

ChatHistory：允许聊天机器人能给记住过去的互动
流式输出：一个token一个token的输出

安装依赖

pip install langchain_community -i https://pypi.tuna.tsinghua.edu.cn/simple/

代码

import getpass
import os
from langchain_community.chat_message_histories import ChatMessageHistory
from fastapi import FastAPI
from langchain_core.messages import SystemMessage, HumanMessage
from langchain_core.output_parsers import StrOutputParser
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain_core.runnables import RunnableWithMessageHistory
from langchain_openai import ChatOpenAI
from langserve import add_routes

os.environ["http_proxy"] = "127.0.0.1:7890"
os.environ["https_proxy"] = "127.0.0.1:7890"

os.environ["LANGCHAIN_TRACING_V2"] = "true"
os.environ["LANGCHAIN_PROJECT"] = "langchainDemo"
os.environ["LANGCHAIN_API_KEY"] = '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'

#聊天机器人案例
#1、创建大模型
model = ChatOpenAI(model='gpt-4o-mini')



# 定义提示模板
prompt_template = ChatPromptTemplate.from_messages([
    ('system','你是一个非常乐于助人的助手，请用{language}尽可能回答所有问题。'),
    MessagesPlaceholder(variable_name='my_msg')
])

#4、得到链
chain = prompt_template | model

#保存历史聊天记录
store = {} #所有用户的聊天记录都保存在store里。key:sessionId ，value：历史聊天记录对象

#此函数预期将接受一个session_id，并返回一个包含所有历史聊天记录对象
def get_session_history(session_id:str):
    if session_id not in store:
        store[session_id] = ChatMessageHistory()#创建一个空的历史聊天记录对象
    return store[session_id]

do_message = RunnableWithMessageHistory(
    chain,
    get_session_history,
    input_messages_key='my_msg'#每次聊天的时候发送msg的key
)

config = {'configurable':{'session_id':'zs123'}}#给当前会话顶一个session_id

#第一轮聊天发出去的信息
resp = do_message.invoke(
    {
        'my_msg':[HumanMessage(content='你好，我是令狐！')],
        'language':'中文'
    },
    config=config
)

print(resp.content)

#第二轮聊天发出去的信息
resp = do_message.invoke(
    {
        'my_msg':[HumanMessage(content='请问我的名字是什么？')],
        'language':'中文'
    },
    config=config
)

print(resp.content)

运行结果

在这里插入图片描述

流式输出+历史记录

import getpass
import os
from langchain_community.chat_message_histories import ChatMessageHistory
from fastapi import FastAPI
from langchain_core.messages import SystemMessage, HumanMessage
from langchain_core.output_parsers import StrOutputParser
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain_core.runnables import RunnableWithMessageHistory
from langchain_openai import ChatOpenAI
from langserve import add_routes

os.environ["http_proxy"] = "127.0.0.1:7890"
os.environ["https_proxy"] = "127.0.0.1:7890"

os.environ["LANGCHAIN_TRACING_V2"] = "true"
os.environ["LANGCHAIN_PROJECT"] = "langchainDemo"
os.environ["LANGCHAIN_API_KEY"] = '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'

#聊天机器人案例
#1、创建大模型
model = ChatOpenAI(model='gpt-4o-mini')



# 定义提示模板
prompt_template = ChatPromptTemplate.from_messages([
    ('system','你是一个非常乐于助人的助手，请用{language}尽可能回答所有问题。'),
    MessagesPlaceholder(variable_name='my_msg')
])

#4、得到链
chain = prompt_template | model

#保存历史聊天记录
store = {} #所有用户的聊天记录都保存在store里。key:sessionId ，value：历史聊天记录对象

#此函数预期将接受一个session_id，并返回一个包含所有历史聊天记录对象
def get_session_history(session_id:str):
    if session_id not in store:
        store[session_id] = ChatMessageHistory()#创建一个空的历史聊天记录对象
    return store[session_id]

do_message = RunnableWithMessageHistory(
    chain,
    get_session_history,
    input_messages_key='my_msg'#每次聊天的时候发送msg的key
)

config = {'configurable':{'session_id':'zs123'}}#给当前会话顶一个session_id

#第一轮聊天发出去的信息
resp = do_message.invoke(
    {
        'my_msg':[HumanMessage(content='你好，我是令狐！')],
        'language':'中文'
    },
    config=config
)

print(resp.content)

#第二轮聊天发出去的信息
resp = do_message.invoke(
    {
        'my_msg':[HumanMessage(content='请问我的名字是什么？')],
        'language':'中文'
    },
    config=config
)

print(resp.content)

#重新换一轮对话
config = {'configurable':{'session_id':'ls123'}}#给当前会话顶一个session_id
#第三轮聊天发出去的信息,每一次resp都是你一个token
for resp in do_message.stream(
    {
        'my_msg':[HumanMessage(content='请给我讲一个笑话')],
        'language':'English'
    },
    config=config
):
    print(resp.content,end='-')#每一次resp都是你一个token

运行结果

在这里插入图片描述

LangChain构建向量数据库和检索器

支持从向量数据库和其他来源检索数据，方便与LLM大语言模型工作流程集成。

**注：在这里我换了，我使用了阿里的灵积模型！**OpenAI太难用了，有速率限制。

from langchain_community.embeddings import DashScopeEmbeddings

工作流程如下：

文档
向量存储
检索器

导入向量数据库依赖

pip install langchain-chroma -i http://pypi.doubanio.com/simple/ --trusted-host pypi.doubanio.com

做一个依赖更新对齐

为啥要做呢，因为中间搭建过程Chroma 报错，Process finished with exit code…

大家做个下面的依赖更新就好了：

pip install chromadb==0.5.3 -i http://pypi.doubanio.com/simple/ --trusted-host pypi.doubanio.com

代码

from langchain_core.documents import Document

# 构造文档
documents = [
    Document(
        page_content="狗是很好的伴侣，以忠诚和友善而闻名。",
        metadata={"source": "mammal-pets-doc"},
    ),
    Document(
        page_content="猫是独立的宠物，经常享受自己的空间。",
        metadata={"source": "mammal-pets-doc"},
    ),
    Document(
        page_content="金鱼是深受初学者欢迎的宠物，需要相对简单的护理。",
        metadata={"source": "fish-pets-doc"},
    ),
    Document(
        page_content="鹦鹉是一种聪明的鸟类，能够模仿人类的语言。",
        metadata={"source": "bird-pets-doc"},
    ),
    Document(
        page_content="兔子是群居动物，需要足够的空间来跳跃。",
        metadata={"source": "mammal-pets-doc"},
    ),
]



from langchain_chroma import Chroma
from langchain_community.embeddings import DashScopeEmbeddings

#实例化一个向量数据库=向量空间
vectorstore = Chroma.from_documents(
    documents,
    embedding=DashScopeEmbeddings(),
)

#相似度查询:返回相似的分数，分数越低相似度越高
result = vectorstore.similarity_search_with_score("猫")
print(result)

运行结果

[(Document(id='bca6c27d-f9ec-4ef4-912c-1b5da9d37be2', metadata={'source': 'mammal-pets-doc'}, page_content='猫是独立的宠物，经常享受自己的空间。'), 6132.1220703125), (Document(id='86c5141f-7af9-4c9a-8164-06f07ed8e5f0', metadata={'source': 'mammal-pets-doc'}, page_content='狗是很好的伴侣，以忠诚和友善而闻名。'), 9821.1064453125), (Document(id='72a6ac79-b714-4430-aec3-ba032534d913', metadata={'source': 'mammal-pets-doc'}, page_content='兔子是群居动物，需要足够的空间来跳跃。'), 12847.7138671875), (Document(id='92827b7f-b7fc-43df-bd5d-39723a09590d', metadata={'source': 'bird-pets-doc'}, page_content='鹦鹉是一种聪明的鸟类，能够模仿人类的语言。'), 13557.162109375)]

在这里插入图片描述

相似度查询:返回相似的分数，分数越低相似度越高

检索器

选取相似度最高的结果返回。

#相似度查询:返回相似的分数，分数越低相似度越高
retriever = RunnableLambda(vectorstore.similarity_search).bind(k=1)#选择顶部结果

from langchain_core.documents import Document
from langchain_core.runnables import RunnableLambda
import os
os.environ["DASHSCOPE_API_KEY"] = 'sk-5bc0688c5761427cadb9df012e589136'


# 构造文档
documents = [
    Document(
        page_content="狗是很好的伴侣，以忠诚和友善而闻名。",
        metadata={"source": "mammal-pets-doc"},
    ),
    Document(
        page_content="猫是独立的宠物，经常享受自己的空间。",
        metadata={"source": "mammal-pets-doc"},
    ),
    Document(
        page_content="金鱼是深受初学者欢迎的宠物，需要相对简单的护理。",
        metadata={"source": "fish-pets-doc"},
    ),
    Document(
        page_content="鹦鹉是一种聪明的鸟类，能够模仿人类的语言。",
        metadata={"source": "bird-pets-doc"},
    ),
    Document(
        page_content="兔子是群居动物，需要足够的空间来跳跃。",
        metadata={"source": "mammal-pets-doc"},
    ),
]



from langchain_chroma import Chroma
from langchain_community.embeddings import DashScopeEmbeddings

#实例化一个向量数据库=向量空间
vectorstore = Chroma.from_documents(
    documents,
    embedding=DashScopeEmbeddings(),
)

#相似度查询:返回相似的分数，分数越低相似度越高
retriever = RunnableLambda(vectorstore.similarity_search).bind(k=1)#选择顶部结果

result = retriever.batch(["猫","鲨鱼"])
print(result)

运行结果

D:\CompanyWork\Environment\python3.10\python.exe D:\PersonWork\Projects\PythonProjects\lang-chain-demo\demo05.py 
D:\CompanyWork\Environment\python3.10\lib\site-packages\langchain\__init__.py:30: UserWarning: Importing debug from langchain root module is no longer supported. Please use langchain.globals.set_debug() / langchain.globals.get_debug() instead.
  warnings.warn(
[[Document(id='7eaa6607-e462-40c2-9cc1-268c0b6f986e', metadata={'source': 'mammal-pets-doc'}, page_content='猫是独立的宠物，经常享受自己的空间。')], [Document(id='a27dfea6-1b2f-41f7-ad7a-91861ff0bcd1', metadata={'source': 'fish-pets-doc'}, page_content='金鱼是深受初学者欢迎的宠物，需要相对简单的护理。')]]

Process finished with exit code 0

在这里插入图片描述

检索器和模型结合

from langchain_core.documents import Document
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.runnables import RunnableLambda, RunnablePassthrough
import os

from demo02 import model

os.environ["DASHSCOPE_API_KEY"] = 'sk-5bc0688c5761427cadb9df012e589136'
os.environ["OPENAI_API_KEY"] = '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'


# 构造文档
documents = [
    Document(
        page_content="狗是很好的伴侣，以忠诚和友善而闻名。",
        metadata={"source": "mammal-pets-doc"},
    ),
    Document(
        page_content="猫是独立的宠物，经常享受自己的空间。",
        metadata={"source": "mammal-pets-doc"},
    ),
    Document(
        page_content="金鱼是深受初学者欢迎的宠物，需要相对简单的护理。",
        metadata={"source": "fish-pets-doc"},
    ),
    Document(
        page_content="鹦鹉是一种聪明的鸟类，能够模仿人类的语言。",
        metadata={"source": "bird-pets-doc"},
    ),
    Document(
        page_content="兔子是群居动物，需要足够的空间来跳跃。",
        metadata={"source": "mammal-pets-doc"},
    ),
]


# 构造 prompt
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.runnables import RunnablePassthrough

message = """
仅使用提供的上下文回答此问题。
{question}

上下文:
{context}
"""
prompt = ChatPromptTemplate.from_messages([("human", message)])


from langchain_chroma import Chroma
from langchain_community.embeddings import DashScopeEmbeddings
# 创建 Chroma 向量存储
vectorstore = Chroma.from_documents(
    documents,
    embedding=DashScopeEmbeddings(),
)

# 查询向量存储
retriever = vectorstore.as_retriever(
    search_type="similarity",
    search_kwargs={"k": 1},
)

# 使用 Tongyi LLM，并设置温度为 1，代表模型会更加随机，但也会更加不确定
from langchain_community.llms import Tongyi
llm = Tongyi(temperature=1)

# 构建 RAG 链
rag_chain = {"context": retriever, "question": RunnablePassthrough()} | prompt | llm

# 使用 RAG 链并打印结果
response = rag_chain.invoke("告诉我关于猫的事")
print(response)

在这里插入图片描述

LangChain构建代理

语言模型本身无法执行动作，它们只能输出文本。LangChain的一个重要用例是创建代理。代理是使用大型语言模型（LLM）作为推理引擎来确定要执行的操作以及这些操作的输入应该是什么。然后，这些操作的结果可以反馈到代理中，代理将决定是否需要更多的操作，或者是否可以结束。

目的

在本教程中，我们将构建一个可以与多种不同工具交互的代理：一个是本地数据库，另一个是搜索引擎。你将能够向这个代理提问，观察它调用工具，并与它进行对话。

定义工具

本教程我们使用到的工具有两个：

Tavily
本地索引的检索器

Tavily

LangChain内置了一个工具，可以轻松地使用Tavily搜索引擎作为工具。

Tavily是一个为大型语言模型（LLMs）和检索增强生成（RAG）优化的搜索引擎，旨在提供高效、快速且持久的搜索结果。

访问链接：

https://aishenqi.net/tool/tavily

安转该工具依赖

pip install -U langchain-community tavily-python langgraph

代码

import os
os.environ["TAVILY_API_KEY"] = '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'
from langchain_community.tools.tavily_search import TavilySearchResults

search = TavilySearchResults(max_results=1)

result = search.invoke("今天秦皇岛的天气预报")
print(result)

回答

[{'url': 'https://hebeim.weather.com.cn/mweather1d/101091101.shtml', 'content': '秦皇岛天气预报，及时准确发布中央气象台天气信息，便捷查询北京今日天气，秦皇岛周末天气，秦皇岛一周天气预报，秦皇岛15日天气预报，秦皇岛40日天气预报，秦皇岛天气预报还提供秦皇岛各区县的生活指数、健康指数、交通指数、旅游指数，及时发布秦皇岛气象预警信号、各类气象资讯。'}]

Retriever

在自定义的数据上去构建一个检索器。

安装依赖

pip install faiss-cpu -i http://pypi.doubanio.com/simple/ --trusted-host pypi.doubanio.com

pip install bs4 -i http://pypi.doubanio.com/simple/ --trusted-host pypi.doubanio.com

代码

from langchain_community.document_loaders import WebBaseLoader
from langchain_community.vectorstores import FAISS
from langchain_community.embeddings import DashScopeEmbeddings
from langchain_text_splitters import RecursiveCharacterTextSplitter
import os
os.environ["DASHSCOPE_API_KEY"] = 'sk-5bc0688c5761427cadb9df012e589136'

loader = WebBaseLoader("https://help.aliyun.com/zh/dashscope/product-overview/concepts-and-glossary?spm=a2c4g.11186623.0.0.63955491NXmvJ5")
docs = loader.load()
documents = RecursiveCharacterTextSplitter(
    chunk_size=1000, chunk_overlap=200
).split_documents(docs)
vector = FAISS.from_documents(documents, DashScopeEmbeddings())
retriever = vector.as_retriever()

result = retriever.invoke("灵积模型是什么？")
print(result)

运行结果

[
    {
        "id": "ec94332a-57f9-4a31-9dd3-8d2733402292",
        "metadata": {
            "source": "https://help.aliyun.com/zh/dashscope/product-overview/concepts-and-glossary?spm=a2c4g.11186623.0.0.63955491NXmvJ5",
            "title": "什么是DashScope灵积模型服务_模型服务灵积(DashScope)-阿里云帮助中心",
            "description": "DashScope通过标准化的API提供“模型即服务”（Model-as-a-Service，MaaS）。不同于以往以任务为中心的AI API，DashScope构建在面向未来的、以模型为中心的理念下，因此也引入了一些新的概念和术语。开发者可以通过本文了解DashScope的有关概念和术语，从而更好...",
            "language": "zh"
        },
        "page_content": "什么是DashScope灵积模型服务_模型服务灵积(DashScope)-阿里云帮助中心\n\n\n\n\n\n\n\n\n\n\n\n\n大模型产品解决方案文档与社区权益中心定价云市场合作伙伴支持与服务了解阿里云AI 助理备案控制台\n文档输入文档关键字查找\n模型服务灵积\n\n\n\n\n产品概述\n\n\n\n\n\n快速入门\n\n\n\n\n\n操作指南\n\n\n\n\n\n开发参考\n\n\n\n\n\n实践教程\n\n\n\n\n\n服务支持\n\n\n\n首页\n\n\n\n模型服务灵积\n\n\n\n产品概述"
    },
    {
        "id": "12f0a6b3-4cd0-4652-aa7e-9e55e5f3fb4f",
        "metadata": {
            "source": "https://help.aliyun.com/zh/dashscope/product-overview/concepts-and-glossary?spm=a2c4g.11186623.0.0.63955491NXmvJ5",
            "title": "什么是DashScope灵积模型服务_模型服务灵积(DashScope)-阿里云帮助中心",
            "description": "DashScope通过标准化的API提供“模型即服务”（Model-as-a-Service，MaaS）。不同于以往以任务为中心的AI API，DashScope构建在面向未来的、以模型为中心的理念下，因此也引入了一些新的概念和术语。开发者可以通过本文了解DashScope的有关概念和术语，从而更好...",
            "language": "zh"
        },
        "page_content": "模型服务灵积-Chat\n\n\n通义千问计量计费说明\n\n\n通过API使用通义千问\n\n\n模型体验中心\n\n\nAPI-KEY的获取与配置\n\n\n模型服务灵积产品升级通知\n\n\n快速入门\n\n\n使用异步任务\n\n\n\n文档内容是否对您有帮助？是否反馈\n为什么选择阿里云什么是云计算全球基础设施技术领先稳定可靠安全合规分析师报告产品和定价全部产品免费试用产品动态产品定价价格计算器云上成本管理解决方案技术解决方案文档与社区文档开发者社区天池大赛培训与认证权益中心免费试用高校计划企业扶持计划推荐返现计划支持与服务基础服务企业增值服务迁云服务官网公告健康看板信任中心关注阿里云关注阿里云公众号或下载阿里云APP，关注云资讯，随时随地运维管控云服务联系我们：4008013260法律声明Cookies政策廉正举报安全举报联系我们加入我们友情链接阿里巴巴集团淘宝网天猫全球速卖通阿里巴巴国际交易市场1688阿里妈妈飞猪阿里云计算AliOS万网高德UC友盟优酷钉钉支付宝达摩院淘宝海外阿里云盘饿了么© 2009-2025 Aliyun.com 版权所有 增值电信业务经营许可证： 浙B2-20080101 域名注册服务机构许可： 浙D3-20210002浙公网安备 33010602009975号浙B2-20080101-4"
    },
    {
        "id": "da3f0056-02de-480f-8a4c-e25f67c8cc26",
        "metadata": {
            "source": "https://help.aliyun.com/zh/dashscope/product-overview/concepts-and-glossary?spm=a2c4g.11186623.0.0.63955491NXmvJ5",
            "title": "什么是DashScope灵积模型服务_模型服务灵积(DashScope)-阿里云帮助中心",
            "description": "DashScope通过标准化的API提供“模型即服务”（Model-as-a-Service，MaaS）。不同于以往以任务为中心的AI API，DashScope构建在面向未来的、以模型为中心的理念下，因此也引入了一些新的概念和术语。开发者可以通过本文了解DashScope的有关概念和术语，从而更好...",
            "language": "zh"
        },
        "page_content": "上一篇：产品简介下一篇：产品计费 \n文档推荐"
    },
    {
        "id": "e7727ea5-fcd0-446a-9ba7-e87a81fece7c",
        "metadata": {
            "source": "https://help.aliyun.com/zh/dashscope/product-overview/concepts-and-glossary?spm=a2c4g.11186623.0.0.63955491NXmvJ5",
            "title": "什么是DashScope灵积模型服务_模型服务灵积(DashScope)-阿里云帮助中心",
            "description": "DashScope通过标准化的API提供“模型即服务”（Model-as-a-Service，MaaS）。不同于以往以任务为中心的AI API，DashScope构建在面向未来的、以模型为中心的理念下，因此也引入了一些新的概念和术语。开发者可以通过本文了解DashScope的有关概念和术语，从而更好...",
            "language": "zh"
        },
        "page_content": "基本概念\n基本概念更新时间：产品详情我的收藏"
    }
]

具体应用场景：
未使用工具：直接调用语言模型，例如问候语 “你好”。
建议使用工具：search_dashscope_knowledge：当需要搜索特定知识时，例如 “灵积模型是什么”。
建议使用工具：multiply：当需要计算数学问题时，例如 “计算 10 的 5 倍”。
通过这种方式，代码可以根据不同的输入选择合适的工具，从而提高回答的准确性和效率。

Agent代理使用语言模型选择工具

import os
os.environ["TAVILY_API_KEY"] = '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'
os.environ["DASHSCOPE_API_KEY"] = 'sk-5bc0688c5761427cadb9df012e589136'
from langchain_community.tools.tavily_search import TavilySearchResults
search = TavilySearchResults(max_results=1)


from langchain_community.document_loaders import WebBaseLoader
from langchain_community.vectorstores import FAISS
from langchain_community.embeddings import DashScopeEmbeddings
from langchain_text_splitters import RecursiveCharacterTextSplitter
loader = WebBaseLoader("https://help.aliyun.com/zh/dashscope/product-overview/concepts-and-glossary?spm=a2c4g.11186623.0.0.63955491NXmvJ5")
docs = loader.load()
documents = RecursiveCharacterTextSplitter(
    chunk_size=1000, chunk_overlap=200
).split_documents(docs)
vector = FAISS.from_documents(documents, DashScopeEmbeddings())
retriever = vector.as_retriever()


from langchain.tools.retriever import create_retriever_tool
retriever_tool = create_retriever_tool(
    retriever,
    "search_dashscope_knowledge",
    "当需要搜索灵积模型相关知识的时候必须使用该工具",
)

from langchain_core.tools import tool
@tool
def multiply(first_int: int, second_int: int) -> int:
    """两个数的乘积."""
    return first_int * second_int


# 创建工具列表
toolList = [search, retriever_tool, multiply]

from langchain_community.chat_models.tongyi import ChatTongyi
llm = ChatTongyi(model="qwen-max")
llm_with_tools = llm.bind_tools([search, retriever_tool, multiply])

# 未使用工具
msg = llm.invoke("你好")
print(msg)

# 建议使用工具：search_dashscope_knowledge
msg = llm_with_tools.invoke("灵积模型是什么")
print(msg)

# 建议使用工具：multiply
msg = llm_with_tools.invoke("计算 10 的 5 倍")
print(msg)

这还没有调用那个工具——大模型只是告诉我们建议使用哪个工具。为了真正调用它，下面我们需要创建我们的代理。

import os
from langchain_core.messages import HumanMessage
os.environ["TAVILY_API_KEY"] = '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'
os.environ["DASHSCOPE_API_KEY"] = 'sk-5bc0688c5761427cadb9df012e589136'
from langchain_community.tools.tavily_search import TavilySearchResults
search = TavilySearchResults(max_results=1)
from langchain_community.document_loaders import WebBaseLoader
from langchain_community.vectorstores import FAISS
from langchain_community.embeddings import DashScopeEmbeddings
from langchain_text_splitters import RecursiveCharacterTextSplitter
loader = WebBaseLoader("https://help.aliyun.com/zh/dashscope/product-overview/concepts-and-glossary?spm=a2c4g.11186623.0.0.63955491NXmvJ5")
docs = loader.load()
documents = RecursiveCharacterTextSplitter(
    chunk_size=1000, chunk_overlap=200
).split_documents(docs)
vector = FAISS.from_documents(documents, DashScopeEmbeddings())
retriever = vector.as_retriever()


from langchain.tools.retriever import create_retriever_tool
retriever_tool = create_retriever_tool(
    retriever,
    "search_dashscope_knowledge",
    "当需要搜索灵积模型相关知识的时候必须使用该工具",
)

from langchain_core.tools import tool
@tool
def multiply(first_int: int, second_int: int) -> int:
    """两个数的乘积."""
    return first_int * second_int


# 创建工具列表
toolList = [search, retriever_tool, multiply]

from langchain_community.chat_models.tongyi import ChatTongyi
llm = ChatTongyi(model="qwen-max")
llm_with_tools = llm.bind_tools([search, retriever_tool, multiply])

# # 未使用工具
# msg = llm.invoke("你好")
# print(msg)
#
# # 建议使用工具：search_dashscope_knowledge
# msg = llm_with_tools.invoke("灵积模型是什么")
# print(msg)
#
# # 建议使用工具：multiply
# msg = llm_with_tools.invoke("计算 10 的 5 倍")
# print(msg)


from langgraph.prebuilt import create_react_agent
#创建一个代理
agent_executor = create_react_agent(llm,toolList)

#该提问没有调用工具
print("====没有调用工具的情况=====")
msg = agent_executor.invoke(
    {"messages": [HumanMessage(content="你好")]}
)
print(msg)
print("====使用工具：search_dashscope_knowledge的情况=====")
# 建议使用工具：search_dashscope_knowledge
msg = agent_executor.invoke(
    {"messages": [HumanMessage(content="灵积模型是什么")]}
)
print(msg)
print("====使用工具：multiply的情况=====")
# 建议使用工具：multiply
msg = llm_with_tools.invoke("计算 10 的 5 倍等于的结果")
print(msg)

上面的代码中，代理agent_executor会根据content的内容变化而自动选择工具去执行。

LangChain读取数据库

安装依赖

需要安装的工具：

mysqlclient
pymsql

pip install mysqlclient

pip install pymysql

测试数据库是否连接成功

from langchain_community.utilities import SQLDatabase

HOSTNAME = '127.0.0.1'
PORT = '3306'
DATABASE = 'mybatis_plus'
USERNAME = 'root'
PASSWORD = '123456'
MYSQL_URI = f'mysql+pymysql://{USERNAME}:{PASSWORD}@{HOSTNAME}:{PORT}/{DATABASE}'

db = SQLDatabase.from_uri(MYSQL_URI)

#测试连接是否成功
print(db.get_usable_table_names())
print(db.run('select * from t_user limit 10;'))

在这里插入图片描述

完整代码

from operator import itemgetter

from langchain.chains.sql_database.query import create_sql_query_chain
from langchain_community.tools import QuerySQLDatabaseTool
from langchain_community.utilities import SQLDatabase
from langchain_community.chat_models.tongyi import ChatTongyi
import os

from langchain_core.output_parsers import StrOutputParser
from langchain_core.prompts import PromptTemplate
from langchain_core.runnables import RunnablePassthrough

os.environ["TAVILY_API_KEY"] = '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'
os.environ["DASHSCOPE_API_KEY"] = 'sk-5bc0688c5761427cadb9df012e589136'
##创建大模型
llm = ChatTongyi(model="qwen-max")
HOSTNAME = '127.0.0.1'
PORT = '3306'
DATABASE = 'mybatis_plus'
USERNAME = 'root'
PASSWORD = '123456'
MYSQL_URI = f'mysql+pymysql://{USERNAME}:{PASSWORD}@{HOSTNAME}:{PORT}/{DATABASE}'

db = SQLDatabase.from_uri(MYSQL_URI)

#测试连接是否成功
# print(db.get_usable_table_names())
# print(db.run('select * from t_user limit 10;'))

#直接使用大模型和数据库整合
test_chain = create_sql_query_chain(llm, db)
#生成sql语句
# print(test_chain.invoke({'question': '请问:用户表里有多少人？'}))

answer_prompt = PromptTemplate.from_template("""
    给定以下用户问题、SQL语句和SQL执行后的结果，回答用户的问题。
    Question: {question}
    SQL Query: {query}
    SQL Result: {result}
    回答："""
)
#创建一个执行sql语句的工具
execute_sql_tool = QuerySQLDatabaseTool(db=db)

#1、生成SQL；2、执行SQL
chain = (
    RunnablePassthrough.assign(query=lambda x: test_chain.invoke(x).replace('SQLQuery: ', '').strip().replace("`", ""))
    | RunnablePassthrough.assign(result=lambda x: execute_sql_tool.invoke({"query": x["query"]}))
    | answer_prompt
    | llm
    | StrOutputParser()
)

print(chain.invoke({'question': '请问:用户表里有多少人？'}))

运行结果

在这里插入图片描述

Agent整合数据库

其实上面整合数据库的方法过于复杂，现在用一种简单的方式进行整合------Agent

from langchain_core.messages import SystemMessage, HumanMessage
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langgraph.prebuilt import create_react_agent
from langchain_community.chat_models.tongyi import ChatTongyi
from langchain_community.utilities import SQLDatabase
from langchain_community.agent_toolkits import SQLDatabaseToolkit
import os
os.environ["TAVILY_API_KEY"] = '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'
os.environ["DASHSCOPE_API_KEY"] = 'sk-5bc0688c5761427cadb9df012e589136'

# 创建大模型
llm = ChatTongyi(model="qwen-max")

# 数据库连接信息
HOSTNAME = '127.0.0.1'
PORT = '3306'
DATABASE = 'mybatis_plus'
USERNAME = 'root'
PASSWORD = '123456'
MYSQL_URI = f'mysql+pymysql://{USERNAME}:{PASSWORD}@{HOSTNAME}:{PORT}/{DATABASE}'

# 连接数据库
db = SQLDatabase.from_uri(MYSQL_URI)

# 创建工具
toolkit = SQLDatabaseToolkit(db=db, llm=llm)
tools = toolkit.get_tools()

system_prompt = """
您是一个被设计用来与SQL数据库交互的智能助手。
您的任务是：
1. **分析用户问题**，并创建一个 **正确的 SQL 查询**。
2. **执行 SQL 查询** 并返回相应的 **查询结果**。
3. **解读查询结果**，用 **自然语言** 向用户反馈答案。
4. **限制查询数据量**，除非用户明确指定，否则默认最多返回 10 条数据。
5. **不得执行任何修改数据库的操作（INSERT、UPDATE、DELETE 等）**。
6. **先查看数据库中的表结构**，然后再执行查询，以确保 SQL 语句的正确性。
"""

# **使用 ChatPromptTemplate 来支持 system_message**
prompt = ChatPromptTemplate.from_messages([
    SystemMessage(content=system_prompt),
    MessagesPlaceholder(variable_name="messages")
])

# **正确创建 agent**
agent_executor = create_react_agent(llm, tools, prompt=prompt)

# 发送查询请求
resp = agent_executor.invoke(
    {
        "messages": [HumanMessage(content="请问:员工表中有多少人？")]
    }
)

# 获取返回的消息列表
result = resp['messages']

# 输出最终答案
print(result)
print(len(result))
print(result[-1])  # 最后一个消息是最终答案