LangChain之数据库操作：通过链Chain和代理Agent查询数据库信息

Chain和Agent查询数据库

在LangChain，其提供了SQL Chain链和SQL Agent代理，他们支持基于自然语言提示构建和运行SQL查询，以此来操作数据库，并且与SQLAlchemy支持的任何SQL版本兼容。（例如，MySQL，PostgreSQL，Oracle SQL，Databricks，SQLite）。

可以用来完成以下任务：

基于自然语言问题生成能运行的SQL查询

创建可以基于数据库数据回答问题的聊天机器人

根据用户想要分析的见解构建自定义仪表板

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

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

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

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

准备数据库、表

使用LangChain中的SQLDatabase工具来与SQL数据库进行交互，首先准备一些测试数据。

基于SQLite数据库

基于SQLite数据库进行基本操作：创建表、插入测试数据以及查询插入数据

# 导入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()

基于MySQL数据库

创建数据库：demo

CREATE DATABASE demo
  CHARACTER SET utf8mb4
  COLLATE utf8mb4_general_ci;

创建数据表：tb_users

CREATE TABLE `tb_users` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `name` varchar(255) NOT NULL,
  `age` int(11) DEFAULT NULL,
  `money` varchar(255) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=12 DEFAULT CHARSET=utf8

插入几条测试数据

INSERT INTO `demo`.`tb_users` (`id`, `name`, `age`, `money`) VALUES (1, 'Java', 22, '100');
INSERT INTO `demo`.`tb_users` (`id`, `name`, `age`, `money`) VALUES (2, 'Python', 30, '200');
INSERT INTO `demo`.`tb_users` (`id`, `name`, `age`, `money`) VALUES (3, 'Goi', 11, '300');

SQLDatabase工具

在 LangChain 中,SQLDatabase工具可以用来与SQL数据库进行交互。SQLDatabase是数据库连接的包装器，为了与SQL数据库通信，它使用SQLAlchemy Core API 。

初始化数据库

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

from langchain_community.utilities import SQLDatabase
import sqlalchemy as sa

# 连接到demo数据库
db = SQLDatabase.from_uri("sqlite:///demo.db")

光标查询​

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

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

<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'}]

字符串查询

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

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

<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')]

带参数查询​

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

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

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

使用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()))

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

create_sql_query_chain：查询数据库

create_sql_query_chain是一个根据自然语言创建生成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)

执行测试

SQLDatabaseChain：查询数据库

langchain-experimental库包含实验性的LangChain新功能，这里使用该库的SQLDatabaseChain来实现查询数据库信息

需要安装langchain-experimental库

pip install langchain-experimental

示例代码

# 导入OpenAI信息
import os

os.environ["OPENAI_BASE_URL"] = "https://xxx.com/v1"
os.environ["OPENAI_API_KEY"] = "sk-fDqouTlU62yjkBhF46284543Dc8f42438a9529Df74B4Ce65"

# 导入langchain的实用工具和相关的模块
from langchain_community.utilities import SQLDatabase
from langchain_experimental.sql import SQLDatabaseChain

# 连接到demo数据库
db = SQLDatabase.from_uri("sqlite:///demo.db")

from langchain_openai import ChatOpenAI

# 创建LLM
llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0, verbose=True)

# # 创建一个生成 SQL 查询的链
db_chain = SQLDatabaseChain.from_llm(llm, db, verbose=True)

# 运行查询问题
response = db_chain.invoke("总共有多少用户？")
print(response)

response = db_chain.invoke({"query": "哪个用户的年龄最大？"})
print(response)

response = db_chain.invoke({"query": "所有用户的金额合计是多少？"})
print(response)

执行测试

执行日志如下，回答的非常好

> Entering new SQLDatabaseChain chain...
总共有多少用户？
SQLQuery:SELECT COUNT(*) FROM "User"
SQLResult: [(4,)]
Answer:总共有4个用户。
> Finished chain.
{'query': '总共有多少用户？', 'result': '总共有4个用户。'}


> Entering new SQLDatabaseChain chain...
哪个用户的年龄最大？
SQLQuery:SELECT "Name", MAX("Age") FROM "User"
SQLResult: [('Vue', 33)]
Answer:Vue
> Finished chain.
{'query': '哪个用户的年龄最大？', 'result': 'Vue'}


> Entering new SQLDatabaseChain chain...
所有用户的金额合计是多少？
SQLQuery:SELECT SUM("Money") FROM "User"
SQLResult: [(176.05,)]
Answer:所有用户的金额合计是176.05。
> Finished chain.
{'query': '所有用户的金额合计是多少？', 'result': '所有用户的金额合计是176.05。'}

自定义prompt提示模板

可以自定义所使用的prompt提示模板，这是使用官方的一个prompt示例

# 导入langchain的实用工具和相关的模块
from langchain_community.utilities import SQLDatabase
from langchain_experimental.sql import SQLDatabaseChain

# 连接到demo数据库
db = SQLDatabase.from_uri("sqlite:///demo.db")

from langchain_openai import ChatOpenAI

# 创建LLM
llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0, verbose=True)

from langchain_core.prompts import PromptTemplate

template = '''Given an input question, first create a syntactically correct {dialect} query to run, then look at the results of the query and return the answer.
Use the following format:

Question: "Question here"
SQLQuery: "SQL Query to run"
SQLResult: "Result of the SQLQuery"
Answer: "Final answer here"

Only use the following tables:

{table_info}.

Question: {input}'''

prompt = PromptTemplate(
    input_variables=["dialect", "table_info", "input"],
    template=template
)
# 创建一个生成 SQL 查询的链
db_chain = SQLDatabaseChain.from_llm(llm, db, prompt=prompt, verbose=True)

# 运行查询问题
response = db_chain.invoke("总共有多少用户？")
print(response)

response = db_chain.invoke({"query": "哪个用户的年龄最大？"})
print(response)

response = db_chain.invoke({"query": "所有用户的金额合计是多少？"})
print(response)

> Entering new SQLDatabaseChain chain...
总共有多少用户？
SQLQuery:SELECT COUNT(*) FROM User
SQLResult: [(4,)]
Answer:Final answer here: 4
> Finished chain.
{'query': '总共有多少用户？', 'result': 'Final answer here: 4'}

> Entering new SQLDatabaseChain chain...
哪个用户的年龄最大？
SQLQuery:SELECT Name FROM User ORDER BY Age DESC LIMIT 1
SQLResult: [('Vue',)]
Answer:Final answer here: Vue
> Finished chain.
{'query': '哪个用户的年龄最大？', 'result': 'Final answer here: Vue'}


> Entering new SQLDatabaseChain chain...
所有用户的金额合计是多少？
SQLQuery:SELECT SUM(Money) FROM User
SQLResult: [(176.05,)]
Answer:Final answer here: 176.05
> Finished chain.
{'query': '所有用户的金额合计是多少？', 'result': 'Final answer here: 176.05'}

使用查询检查器

有时语言模型可能生成带��小错误的无效SQL，这些错误可以尝试使用use_query_checker=True参数让LLM修复SQL。

# # 创建一个生成 SQL 查询的链
db_chain = SQLDatabaseChain.from_llm(llm, db, verbose=True, use_query_checker=True)

返回中间步骤

可以使用return_intermediate_steps=True参数返回 SQLDatabaseChain 的中间步骤，这允许访问生成的 SQL 语句以及针对 SQL 数据库运行该语句的结果。

# 创建一个生成 SQL 查询的链
db_chain = SQLDatabaseChain.from_llm(llm, db, prompt=prompt, return_intermediate_steps=True)

# 运行查询问题
response = db_chain.invoke({"query": "总共有多少用户？"})
print(response["intermediate_steps"])

[{'input': '总共有多少用户？\nSQLQuery:', 'top_k': '5', 'dialect': 'sqlite', 'table_info': '\nCREATE TABLE "User" (\n\t"ID" INTEGER, \n\t"Name" TEXT NOT NULL, \n\t"Age" INTEGER, \n\t"Money" REAL, \n\t"CreateDate" DATE DEFAULT CURRENT_DATE, \n\tPRIMARY KEY ("ID")\n)\n\n/*\n3 rows from User table:\nID\tName\tAge\tMoney\tCreateDate\n1\tJava\t10\t20.5\t2024-04-14\n2\tPython\t20\t0.0\t2024-04-14\n3\tVue\t33\t55.0\t2024-04-14\n*/', 'stop': ['\nSQLResult:']}, 'SELECT COUNT(*) FROM User', {'sql_cmd': 'SELECT COUNT(*) FROM User'}, '[(4,)]', {'input': '总共有多少用户？\nSQLQuery:SELECT COUNT(*) FROM User\nSQLResult: [(4,)]\nAnswer:', 'top_k': '5', 'dialect': 'sqlite', 'table_info': '\nCREATE TABLE "User" (\n\t"ID" INTEGER, \n\t"Name" TEXT NOT NULL, \n\t"Age" INTEGER, \n\t"Money" REAL, \n\t"CreateDate" DATE DEFAULT CURRENT_DATE, \n\tPRIMARY KEY ("ID")\n)\n\n/*\n3 rows from User table:\nID\tName\tAge\tMoney\tCreateDate\n1\tJava\t10\t20.5\t2024-04-14\n2\tPython\t20\t0.0\t2024-04-14\n3\tVue\t33\t55.0\t2024-04-14\n*/', 'stop': ['\nSQLResult:']}, 'Final answer here: 4']

限制返回的行数

可以使用top_k参数来选择查询表中要获取的最大结果数（默认为10），这可以避免查询结果超出提示最大长度或不必要地消耗token。

db_chain = SQLDatabaseChain.from_llm(llm, db, verbose=True, use_query_checker=True, top_k=2)

create_sql_agent：查询数据库

概述

LangChain的SQL代理，它提供了比SQLDatabaseChain更灵活的与SQL数据库交互方式。相比SQLDatabaseChain，SQL代理有以下优点：

根据数据库架构和内容回答问题，例如检索特定表的描述。

具有纠错能力，能够捕获执行生成的查询时遇到的错误，并正确重新生成并执行新的查询。

通过create_sql_agent函数初始化代理，创建的SQL Agent。需使用到SQLDatabaseToolkit工具箱，其中包含以下工具：

创建并执行查询

检查查询语法

检索数据表描述

借助这些工具，代理可以借助LLM完成SQL查询任务

代理使用ReAct风格的提示，通过思考确定下一个action，并逐层前进，直到得到答案。

示例代码

from langchain_community.utilities import SQLDatabase
from langchain_openai import OpenAI
from langchain.agents import create_sql_agent
from langchain_community.agent_toolkits import SQLDatabaseToolkit
from langchain.agents.agent_types import AgentType

# 连接到FlowerShop数据库
db = SQLDatabase.from_uri("sqlite:///demo.db")
llm = OpenAI(temperature=0, verbose=True)

# 创建SQL Agent
agent_executor = create_sql_agent(
    llm=llm,
    toolkit=SQLDatabaseToolkit(db=db, llm=llm),
    verbose=True,
    agent_type=AgentType.ZERO_SHOT_REACT_DESCRIPTION,
)

# 使用Agent执行SQL查询
questions = [
    "总共有多少用户？",
    "哪个用户的年龄最大？",
    "所有用户的金额合计是多少？",
]

# 循环提问
for question in questions:
    response = agent_executor.invoke(question)
    print(response)

执行测试

如何学习大模型 AI ？

由于新岗位的生产效率，要优于被取代岗位的生产效率，所以实际上整个社会的生产效率是提升的。

但是具体到个人，只能说是：

“最先掌握AI的人，将会比较晚掌握AI的人有竞争优势”。

这句话，放在计算机、互联网、移动互联网的开局时期，都是一样的道理。

我在一线互联网企业工作十余年里，指导过不少同行后辈。帮助很多人得到了学习和成长。

我意识到有很多经验和知识值得分享给大家，也可以通过我们的能力和经验解答大家在人工智能学习中的很多困惑，所以在工作繁忙的情况下还是坚持各种整理和分享。但苦于知识传播途径有限，很多互联网行业朋友无法获得正确的资料得到学习提升，故此将并将重要的AI大模型资料包括AI大模型入门学习思维导图、精品AI大模型学习书籍手册、视频教程、实战学习等录播视频免费分享出来。

第一阶段（10天）：初阶应用

该阶段让大家对大模型 AI有一个最前沿的认识，对大模型 AI 的理解超过 95% 的人，可以在相关讨论时发表高级、不跟风、又接地气的见解，别人只会和 AI 聊天，而你能调教 AI，并能用代码将大模型和业务衔接。

• 大模型 AI 能干什么？
• 大模型是怎样获得「智能」的？
• 用好 AI 的核心心法
• 大模型应用业务架构
• 大模型应用技术架构
• 代码示例：向 GPT-3.5 灌入新知识
• 提示工程的意义和核心思想
• Prompt 典型构成
• 指令调优方法论
• 思维链和思维树
• Prompt 攻击和防范
• …

第二阶段（30天）：高阶应用

该阶段我们正式进入大模型 AI 进阶实战学习，学会构造私有知识库，扩展 AI 的能力。快速开发一个完整的基于 agent 对话机器人。掌握功能最强的大模型开发框架，抓住最新的技术进展，适合 Python 和 JavaScript 程序员。

• 为什么要做 RAG
• 搭建一个简单的 ChatPDF
• 检索的基础概念
• 什么是向量表示（Embeddings）
• 向量数据库与向量检索
• 基于向量检索的 RAG
• 搭建 RAG 系统的扩展知识
• 混合检索与 RAG-Fusion 简介
• 向量模型本地部署
• …

第三阶段（30天）：模型训练

恭喜你，如果学到这里，你基本可以找到一份大模型 AI相关的工作，自己也能训练 GPT 了！通过微调，训练自己的垂直大模型，能独立训练开源多模态大模型，掌握更多技术方案。

到此为止，大概2个月的时间。你已经成为了一名“AI小子”。那么你还想往下探索吗？

• 为什么要做 RAG
• 什么是模型
• 什么是模型训练
• 求解器 & 损失函数简介
• 小实验2：手写一个简单的神经网络并训练它
• 什么是训练/预训练/微调/轻量化微调
• Transformer结构简介
• 轻量化微调
• 实验数据集的构建
• …

第四阶段（20天）：商业闭环

对全球大模型从性能、吞吐量、成本等方面有一定的认知，可以在云端和本地等多种环境下部署大模型，找到适合自己的项目/创业方向，做一名被 AI 武装的产品经理。

• 硬件选型
• 带你了解全球大模型
• 使用国产大模型服务
• 搭建 OpenAI 代理
• 热身：基于阿里云 PAI 部署 Stable Diffusion
• 在本地计算机运行大模型
• 大模型的私有化部署
• 基于 vLLM 部署大模型
• 案例：如何优雅地在阿里云私有部署开源大模型
• 部署一套开源 LLM 项目
• 内容安全
• 互联网信息服务算法备案
• …

学习是一个过程，只要学习就会有挑战。天道酬勤，你越努力，就会成为越优秀的自己。

如果你能在15天内完成所有的任务，那你堪称天才。然而，如果你能完成 60-70% 的内容，你就已经开始具备成为一名大模型 AI 的正确特征了。

这份完整版的大模型 AI 学习资料已经上传CSDN，朋友们如果需要可以微信扫描下方CSDN官方认证二维码免费领取【保证100%免费】