LangChain之工具Tools（下）

SQLDatabase工具

在 LangChain 中,SQLDatabase工具可以用来与SQL数据库进行交互。

SQLDatabase是数据库连接的包装器，为了与SQL数据库通信，它使用SQLAlchemy Core API 。

准备数据

这里先使用sqlite3数据库，创建一张user表，同时插入一些测试数据。

# 导入sqlite3库，一个Python内置的轻量级数据库
import sqlite3

print("------------------------连接数据库------------------------")
# 连接数据库
conn = sqlite3.connect('demo.db')
cursor = conn.cursor()

print("------------------------数据表创建------------------------")

# 执行SQL命令 创建User表
cursor.execute('''
        CREATE TABLE User (
            ID INTEGER PRIMARY KEY, 
            Name TEXT NOT NULL, 
            Age INT,
            Money REAL,
            CreateDate DATE DEFAULT CURRENT_DATE 
        );
    ''')

print("------------------------数据插入------------------------")
# 插入数据
users = [
    ('Java', 10, 20.5),
    ('Python', 20, 0),
    ('Vue', 33, 55.0),
    ('Go', 5, 100.55),
]

for user in users:
    cursor.execute('''
        INSERT INTO User (Name, Age, Money) 
        VALUES (?, ?, ?);
    ''', user)

print("------------------------查询数据------------------------")
users = cursor.execute("SELECT *  from User")
for row in users:
    print(row)

# 提交更改
conn.commit()

# 关闭数据库连接
conn.close()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

初始化数据库

首先连接到sqlite数据库，进行数据库初始化

from langchain_community.utilities import SQLDatabase
import sqlalchemy as sa

# 连接到demo数据库
db = SQLDatabase.from_uri("sqlite:///demo.db")
1
2
3
4
5

光标查询​

查询模式:cursor，将结果作为SQLAlchemy的CursorResult实例返回

result = db.run("SELECT * FROM User LIMIT 10;", fetch="cursor")
print(type(result))
print(list(result.mappings()))
1
2
3

<class 'sqlalchemy.engine.cursor.CursorResult'>
[{'ID': 1, 'Name': 'Java', 'Age': 10, 'Money': 20.5, 'CreateDate': '2024-04-14'},
{'ID': 2, 'Name': 'Python', 'Age': 20, 'Money': 0.0, 'CreateDate': '2024-04-14'}, 
{'ID': 3, 'Name': 'Vue', 'Age': 33, 'Money': 55.0, 'CreateDate': '2024-04-14'}, 
{'ID': 4, 'Name': 'Go', 'Age': 5, 'Money': 100.55, 'CreateDate': '2024-04-14'}]
1
2
3
4
5

字符串查询

查询模式：all 和one，以字符串格式返回结果。

result = db.run("SELECT * FROM User LIMIT 10;", fetch="all")
print(type(result))
print(result)
1
2
3

<class 'str'>
[(1, 'Java', 10, 20.5, '2024-04-14'), (2, 'Python', 20, 0.0, '2024-04-14'), (3, 'Vue', 33, 55.0, '2024-04-14'), (4, 'Go', 5, 100.55, '2024-04-14')]
1
2

带参数查询​

可以使用parameters可选参数，来绑定查询参数

result = db.run(
    "SELECT * FROM User WHERE Name LIKE :search;",
    parameters={"search": "P%"},
    fetch="cursor",
)
print(list(result.mappings()))
1
2
3
4
5
6

[{'ID': 2, 'Name': 'Python', 'Age': 20, 'Money': 0.0, 'CreateDate': '2024-04-14'}]
1

使用SQLAlchemy查询​

SQLDatabase工具除了使用纯文本SQL语句之外，其适配器还接受 SQLAlchemy 可选择项。

import sqlalchemy as sa
# 为了在sqlalchemy 的 Core API 上构建一个可选择的，需要一个表的定义。
metadata = sa.MetaData()
user = sa.Table(
    "User",
    metadata,
    sa.Column("Id", sa.INTEGER, primary_key=True),
    sa.Column("Name", sa.TEXT),
    sa.Column("Age", sa.INT),
    sa.Column("Money", sa.REAL),
)

# 构建一个查询语义
query = sa.select(user).where(user.c.Name.like("J%"))
# 执行查询
result = db.run(query, fetch="cursor")
print(list(result.mappings()))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

[{'Id': 1, 'Name': 'Java', 'Age': 10, 'Money': 20.5}]
1

使用自然语言查询数据库

LangChain提供了与SQL数据库交互的工具：

create_sql_query_chain：基于用户自然语言问题构建SQL查询

SQLDatabaseChain：使用链进行查询、创建和执行来查询SQL数据库

create_sql_agent：使用代理进行健壮和灵活的与SQL数据库交互
1
2
3
4
5

这里使用create_sql_query_chain链+SQLDatabase工具实现：将自然语言转换成数据库的SQL查询。

from langchain_community.utilities import SQLDatabase
from langchain.chains.sql_database.query import create_sql_query_chain

# 连接 MySQL 数据库
db_user = "root"
db_password = "12345678"
db_host = "IP"
db_port = "3306"
db_name = "demo"
db = SQLDatabase.from_uri(f"mysql+pymysql://{db_user}:{db_password}@{db_host}:{db_port}/{db_name}")

print("数据库方言：", db.dialect)
print("获取数据表：", db.get_usable_table_names())

# 执行查询
res = db.run("SELECT count(*) FROM tb_users;")
print(type(res))
print("查询结果：", res)

from langchain_openai import ChatOpenAI

# 初始化大模型
llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0)
chain = create_sql_query_chain(llm=llm, db=db)
response = chain.invoke({"question": "查询数据表tb_users中的用户,要求年龄大于20"})
print("Chain执行结果："+ response)

# 删除response无用部分
sql = response.replace("sql: ", "").replace("```sql", "").replace("```", "")
print("自然语言转SQL：" + sql)
res = db.run(sql)
print("查询结果：", res)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

执行结果如下:

使用其他工具

Tavily Search工具

Tavily的搜索API是一个专门为人工智能代理(llm)构建的搜索引擎，可以快速提供实时、准确和真实的结果。

配置环境变量

访问Tavily（用于在线搜索）注册账号并登录，获取API 密钥

设置OpenAI和TAVILY的API密钥

import os

# 设置OpenAI的BASE_URL、API_Key
os.environ["OPENAI_BASE_URL"] = "https://xxx.com/v1"
os.environ["OPENAI_API_KEY"] = "sk-BGFnOL9Q4c1234fsfsdaf9b4813bc437B82c2"

# 设置tavily
os.environ["TAVILY_API_KEY"] = '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'
1
2
3
4
5
6
7
8

应用示例

from langchain import hub
from langchain.agents import AgentExecutor, create_openai_tools_agent
from langchain_community.tools.tavily_search import TavilySearchResults
from langchain_openai import ChatOpenAI

#  使用Tavily搜索工具
tools = [TavilySearchResults(max_results=1)]

# 获取要使用的提示
prompt = hub.pull("hwchase17/openai-tools-agent")

# 初始化大模型
llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0)

# 构建 OpenAI 工具代理
agent = create_openai_tools_agent(llm, tools, prompt)

# 通过传入代理和工具创建代理执行程序
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)

# 运行代理
agent_executor.invoke({"input": "目前市场上黄金的平均售价是多少？"})
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

Dall-E图像生成工具

OpenAI的Dall-E是使用深度学习方法开发的文本到图像模型，可从自然语言描述（提示）生成数字图像。

使用感受：效果不咋滴。

import os

# 设置OpenAI的BASE_URL、API_Key
os.environ["OPENAI_BASE_URL"] = "https://xxx.com/v1"
os.environ["OPENAI_API_KEY"] = "sk-BGFnOL9Q4c1234fsfsdaf9b4813bc437B82c2"

from langchain.chains import LLMChain
from langchain_community.utilities.dalle_image_generator import DallEAPIWrapper
from langchain_core.prompts import PromptTemplate
from langchain_openai import OpenAI

llm = OpenAI(temperature=0.9)

# prompt = PromptTemplate(
#     input_variables=["image_desc"],
#     template="根据描述生成图像: {image_desc}",
# )
# chain = LLMChain(llm=llm, prompt=prompt)
# image_url = DallEAPIWrapper().run(chain.run("Create an image of a halloween night at a haunted museum"))
# print(image_url)

from langchain.agents import  load_tools, initialize_agent

tools = load_tools(["dalle-image-generator"])
agent = initialize_agent(tools, llm, agent="zero-shot-react-description")
image_url = agent.run("Create an image of a halloween night at a haunted museum")
print(image_url)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

ArXiv工具

在LangChain中，ArXiv工具是一个用于与arXiv.org（一个收集物理学、数学、计算机科学、量子生物学和统计学等领域的学术论文的网站）交互的工具。

Arxiv工具是围绕Arxiv.org的封装工具，可用于回答关于各领域科学文章的问题，适用于物理学、数学、计算机科学等领域。输入应该是搜索查询内容。

安装arxiv python包

pip install arxiv
1

假设你是一名计算机科学专业的学生，正在研究深度学习在图像识别领域的最新进展。你可以使用ArXiv工具来搜索相关论文。

from langchain_openai import ChatOpenAI
from langchain.agents import load_tools, create_react_agent, AgentExecutor

# 初始化模型和工具
llm = ChatOpenAI(temperature=0.0)
tools = load_tools(
    ["arxiv"],
)

# 获取提示模板
prompt = hub.pull("hwchase17/react")
# 初始化Agent
agent = create_react_agent(llm, tools, prompt)
# 创建agent_executor
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)

# 定义搜索关键字：深度学习在图像识别领域的最新进展
keywords = "Recent advances in deep learning in image recognition"
# 运行链
res = agent_executor.invoke({"input": keywords})
print(res)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

输出：