大语言模型(LLM)应用开发平台Dify详细使用

Nova_CaoFc

已于 2025-04-30 12:50:48 修改

阅读量927

点赞数 30

分类专栏：技术博文分享文章标签：语言模型人工智能自然语言处理

于 2025-04-30 12:49:19 首次发布

本文链接：https://blog.csdn.net/shjwkzkzk/article/details/147629431

版权

技术博文分享专栏收录该内容

22 篇文章

订阅专栏

一、Dify的介绍

https://dify.ai/

Dify 是一个开源的大语言模型（LLM）应用开发平台，融合了后端即服务（Backend as Service）和 LLMOps 理念，旨在简化和加速生成式 AI 应用的创建、部署和管理，使开发者能够快速搭建生产级的 AI 应用，并让非技术人员也能参与到 AI 应用的定义和数据运营过程中。以其强大的功能、直观的界面和灵活的部署方式，为 AI 应用开发带来了全新的体验，在降低开发门槛的同时，也为开发者提供了更多的创新空间和可能性。

Dify 也是一款创新的智能生活助手应用，旨在为您提供便捷、高效的服务。通过人工智能技术，Dify 可以实现语音助手、智能家居控制、日程管理等功能，助您轻松应对生活琐事，享受智慧生活。简约的界面设计，让操作更加便捷；丰富的应用场景，满足您多样化的需求。Dify，让生活更简单！

二、Dify的安装方式

1. 在线体验

速度比较慢。不推荐

2. 本地部署

2.1 Docker安装

安装Docker环境

bash <(curl -sSl https://cdn.jsdelivr.net/gh/SuperManito/LunuxMirrors@main/DockerInstallation.sh)

安装Docker Compose

 curl -L "https://github.com/docker/compose/releases/latest/download/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose && chmod +x /usr/local/bin/docker-compose

执行查看Docker-compose版本

 docker-compose --version

docker-compse拉取镜像很慢

tee /etc/docker/daemon.json <<-'EOF'
 {
      "registry-mirrors": [
          "https://do.nark.eu.org",
          "https://dc.j8.work",
          "https://docker.m.daocloud.io",
          "https://dockerproxy.com",
          "https://docker.mirrors.ustc.edu.cn",
          "https://docker.nju.edu.cn"
      ]
 }
 EOF

执行上面的代码

 systemctl daemon-reload    # 重新加载 systemd 的配置文件
 systemctl restart docker        # 重启docker

然后去GitHub上拉取dify的代码。解压后进入到docker目录中

https://github.com/langgenius/dify/tree/main/docker

 docker-compose up -d

执行即可

2.2 DockerDeskTop

在Windows环境下我们可以通过DockerDesktop 来安装。直接去官网下载对应的版本即可。同样的我们需要拉取dify的GitHub的代码。然后进入到Docker目录，同样的执行这个代码

 docker-compose up

然后在地址栏中输入 http://localhost/install 就可以访问了

我们先设置管理员的相关信息。设置后再登录

3. Ollama

Ollama

我们已经把Dify在本地部署了。然后我们可以通过Ollama在本地部署对应的大模型，比如 deepseek-r1:1.5b 这种小模型

Ollama 是一个让你能在本地运行大语言模型的工具，为用户在本地环境使用和交互大语言模型提供了便利，具有以下特点：

1）多模型支持：Ollama 支持多种大语言模型，比如 Llama 2、Mistral 等。这意味着用户可以根据自己的需求和场景，选择不同的模型来完成各种任务，如文本生成、问答系统、对话交互等。

2）易于安装和使用：它的安装过程相对简单，在 macOS、Linux 和 Windows 等主流操作系统上都能方便地部署。用户安装完成后，通过简洁的命令行界面就能与模型进行交互，降低了使用大语言模型的技术门槛。

3）本地运行：Ollama 允许模型在本地设备上运行，无需依赖网络连接来访问云端服务。这不仅提高了数据的安全性和隐私性，还能减少因网络问题导致的延迟，实现更快速的响应。

搜索Ollama进入官网Download Ollama on macOS，选择安装MAC版本的安装包，点击安装即可

下载完成后直接双击安装即可

命令：ollama,出现下面内容，说明安装成功

启动Ollama服务

输入命令【ollama serve】，浏览器打开，显示running，说明启动成功

安装 deepseek-r1:1.5b模型

在deepseek-r1:1.5b 搜索deepseek-R1,跳转到下面的页面，复制这个命令，在终端执行，下载模型

cmd中执行这个命令

4.Dify关联Ollama

Dify 是通过Docker部署的，而Ollama 是运行在本地电脑的，得让Dify能访问Ollama 的服务。

在Dify项目-docker-找到.env文件，在末尾加上下面的配置：

 # 启用自定义模型
 CUSTOM_MODEL_ENABLED=true
 # 指定 Olama 的 API地址（根据部署环境调整IP）
 OLLAMA_API_BASE_URL=host.docker.internal:11434

然后在模型中配置

在Dify的主界面 http://localhost/apps ，点击右上角用户名下的【设置】

在设置页面--Ollama--添加模型，如下：

添加成功后的

模型添加完成以后，刷新页面，进行系统模型设置。步骤：输入“http://localhost/install”进入Dify主页，用户名--设置--模型供应商，点击右侧【系统模型设置】，如下：

这样就关联成功了！！！

三、Dify应用讲解

1. 创建空白应用

我们通过Dify来创建我们的第一个简单案例，智能聊天机器人

进入Dify 主界面，点击【创建空白应用】，如下图：

选择【聊天助手】，输入自定义应用名称和描述，点击【创建】

右上角选择合适的模型，进行相关的参数配置

输入有相关的回复了。此时说明Dify 与本地部署的DeepSeek大模型已经连通了。

上面的机器人有个不足之处就是无法回答模型训练后的内容和专业垂直领域的内容，这时我们可以借助本地知识库来解决专业领域的问题。

2. 创建本地知识库

2.1 向量模型

 Embedding模型是一种将数据转换为向量表示的技术，核心思想是通过学习数据的内在结构和语义信息，将其映射到一个低维向量空间中，使得相似的数据点在向量空间中的位置相近，从而通过计算向量之间的相似度来衡量数据之间的相似性。
 
 Embedding模型可以将单词、句子或图像等数据转换为低维向量，使得计算机能够更好地理解和处理这些数据。在NLP领域，Embedding模型可以将单词、句子或文档转换为向量，用于文本分类、情感分析。机器翻译等任务。在计算机视觉中，Embedding模型可以用于图像识别和检索等任务。

2.2 添加Embedding模型

点击右上角用户名--设置--模型供应商--右上角【添加模型】，填写相关配置信息如下：

2.3 创建知识库

在Dify主界面，点击上方的【知识库】，点击【创建知识库】

导入已有文本，上传资料，点击【下一步】

Embedding模型默认是前面配置的模型，参数信息配置完，点击保存即可

此时系统会自动对上传的文档进行解析和向量化处理，需要耐心等待几分钟。

创建成功以后，如下图，可以点击【前往文档】，查看分段信息，如下图：

点击具体的文档可以看到具体的分割信息

3. 知识库应用

3.1 添加知识库

在Dify主界面，回到刚才的应用聊天页面，工作室--智能聊天机器人--添加知识库，如下图：

选择前面上面的知识库作为对话的上下文，保存当前应用设置，就可以进行测试了

3.2 测试

此时输入问题，就可以看到相关的回复了。

4. AI图片生成工具

随着图像生成技术的兴起，涌现了许多优秀的图像生成产品，比如 Dall-e、Flux、Stable Diffusion 等，我们借助Stable Diffusion来在dify中构建一个智能生成图片的Agent。

4.1 首先获取Stable Diffusion

Stability AI - Developer Platform 去官网获取授权key。如果没注册需要先注册下

4.2 下载 Stable 工具

然后我们需要进入dify的工具市场下载安装 Stable 插件。

4.3 创建Agent

然后我们就可以创建一个空白的Agent。输入对应的提示词

 根据用户的提示，使用工具 stability_text2image 绘画指定内容

然后选择对应的工具并添加授权码

然后就可以测试效果了

注意这个是一个付费的工具。提供的有一个免费的，后面需要付费购买了：Stability AI - Developer Platform

5.SQL执行器

我们可以通过工作流来创建一个SQL语句的执行器，也就是我们可以输入相关的SQL语句然后通过工作流来连接数据库执行对应的SQL代码，具体的设计如下：

这里的核心是代码执行模块。这块我们是调用了我们自己创建的接口来执行数据库的操作，所以我们需要先创建这么一个接口，接口我们通过Flask这个轻量的web框架来实现。需要先安装Flask的依赖库

 pip install flask

然后创建接口代码

from flask import Flask, request, jsonify
import pymysql

app = Flask(__name__)
def execute_sql(sql,connection_info):
    """
    执行传入的 SQL 语句，并返回查询结果。

    参数:
        sql: 要执行的 SQL 语句（字符串）。
        connection_info: 一个字典，包含数据库连接所需的信息：
            - host: 数据库地址（如 "localhost"）
            - user: 数据库用户名
            - password: 数据库密码
            - database: 数据库名称
            - port: 数据库端口（可选，默认为 3306）
            - charset: 字符编码（可选，默认为 "utf8mb4"）

    返回:
        如果执行的是 SELECT 查询，则返回查询结果的列表；
        如果执行的是 INSERT/UPDATE/DELETE 等非查询语句，则提交事务并返回受影响的行数。
        如果执行过程中出错，则返回 None。
    """
    connection = None
    try:
        # 从 connection_info 中获取各项参数，设置默认值
        host = connection_info.get("host", "localhost")
        user =  connection_info.get("user")
        password = connection_info.get("password")
        database = connection_info.get("database")
        port = connection_info.get("port", 3306)
        charset = connection_info.get("charset", "utf8mb4")

        # 建立数据库连接
        connection = pymysql.connect(
            host=host,
            user=user,
            password=password,
            database=database,
            port=port,
            charset=charset,
            cursorclass=pymysql.cursors.Cursor  # 可改为 DictCursor 返回字典格式结果
        )

        with connection.cursor() as cursor:
            cursor.execute(sql)
            # 判断是否为 SELECT 查询语句
            if sql.strip().lower().startswith("select"):
                result = cursor.fetchall()
            else:
                connection.commit()  # 非查询语句需要提交事务
                result = cursor.rowcount  # 返回受影响的行数

        return result

    except Exception as e:
        print("执行 SQL 语句时出错：", e)
        return None

    finally:
        if connection:
            connection.close()


@app.route('/execute_sql', methods=['POST'])
def execute_sql_api():
    """
    接口示例：通过 POST 请求传入 SQL 语句和连接信息，返回执行结果。
    请求示例 (JSON):
    {
        "sql": "SELECT * FROM your_table;",
        "connection_info": {
            "host": "localhost",
            "user": "your_username",
            "password": "your_password",
            "database": "your_database"
        }
    }
    """
    data = request.get_json()
    if not data:
        return jsonify({"error": "无效的请求数据"}), 400

    sql = data.get("sql")
    connection_info = data.get("connection_info")
    if not sql or not connection_info:
        return jsonify({"error": "缺少sql语句或数据库连接信息"}), 400

    result = execute_sql(sql, connection_info)
    return jsonify({"result": result})


if __name__ == '__main__':
    # 开发环境下可以设置 debug=True，默认在本地5000端口启动服务
    app.run(debug=True)

这个接口需要接收一个sql语句和一个包含数据库连接信息的json对象，我们可以编写对应的测试代码来看看

import json
import requests


def call_execute_sql_api(sql, connection_info):
    """
    通过 requests 调用执行 SQL 的接口服务

    参数:
        sql: 要执行的 SQL 语句字符串
        connection_info: 数据库连接信息字典，例如：
            {
                "host": "localhost",
                "user": "your_username",
                "password": "your_password",
                "database": "your_database",
                "port": 3306  # 可选
            }

    返回:
        接口返回的结果数据（字典格式），如果请求失败则返回 None
    """
    url = "http://127.0.0.1:5000/execute_sql"
    # 构造请求体
    payload = {
        "sql": sql,
        "connection_info": connection_info
    }

    headers = {
        "Content-Type": "application/json"
    }

    try:
        response = requests.post(url, json=payload, headers=headers)
        if response.status_code == 200:
            try:
                return {"result":str(response.json()["result"])}
            except Exception as e:
                return {"result": f"解析响应 JSON 失败: {str(e)}"}
        else:
            return {"result": f"请求失败，状态码: {response.status_code}"}
    except Exception as e:
        return {"result": str(e)}


# 示例调用
if __name__ == "__main__":
    sql_query = "select * from candidates where id = 1"  # 替换为你的实际 SQL 语句
    conn_info = {
        "host": "localhost",
        "user": "root",
        "password": "123456",
        "database": "ibms",
        "port": 3306
    }

    result = call_execute_sql_api(sql_query, conn_info)
    print("接口返回结果：", result)

执行后可以看到对应的结果

然后可以在工作流中来设置我们的代码

代码的内容

import json
import requests

def main(sql: str) -> dict:
    url = "http://host.docker.internal:5000/execute_sql"
    connection_info = {
        "host": "localhost",
        "user": "root",
        "password": "123456",
        "database": "ibms"
    }
    # 构造请求体
    payload = {
        "sql": sql,
        "connection_info": connection_info
    }

    headers = {
        "Content-Type": "application/json"
    }

    try:
        response = requests.post(url, json=payload, headers=headers)
        if response.status_code == 200:
            try:
                return {"result":str(response.json()["result"])}
            except Exception as e:
                return {"result": f"解析响应 JSON 失败: {str(e)}"}
        else:
            return {"result": f"请求失败，状态码: {response.status_code}"}
    except Exception as e:
        return {"result": str(e)}

注意上面的url中我们需要写

 http://host.docker.internal:5000/execute_sql

不然执行的时候会出现503的错误。

如果调用接口的组件是 urllib3 的话有可能出现上面的问题，这个原因可能是版本兼容的问题，这里推进用的是requests组件。

6.SEO翻译

我们在写文章的时候需要想一个满足SEO要求的标题，这样有可能被更多的人检索到，有时候我们可能需要把文章翻译为英文，这时标题同样比较重要，这时我们可以在dify中创建这样的一个工具来帮助我们实现这个功能。

对应模型的提示词

 This GPT will convert input titles or content into SEO-friendly English URL slugs. The slugs will clearly convey the original meaning while being concise and not exceeding 60 characters. If the input content is too long, the GPT will first condense it into an English phrase within 60 characters before generating the slug. If the title is too short, the GPT will prompt the user to input a longer title. Special characters in the input will be directly removed.

对应中文含义

这个GPT可以将输入的标题或内容转换为对SEO友好的英文URL片段。这些片段将清晰地传达原始含义，同时保持简洁，且不超过60个字符。如果输入内容过长，GPT将首先将其缩减为一个不超过60个字符的英文短语，然后生成片段。如果标题过短，GPT将提示用户输入更长的标题。输入中的特殊字符将被直接移除。

7.自然语言生成SQL

演示的效果

具体工作流设计

帮我设计一个电商系统的数据库。
需要有:
    goods:商品表 
    orders:订单表 
    inventory:库存表 
    vendors:商家表
    customers:客户表，
表结构的关联关系：
	商家和商品表关联
	商品表和库存表关联
	订单和客户关联
	订单和商品关联
核心字段要求
	goods:需要有 id 商品名称 商品价格  图片  商家
	orders:需要有 id 客户 商品编号 商品名称  收货地址  商家id 订单时间
	inventory:需要有 id 商品编号  库存数据
创建的表名用对应的 英文，表中的每个字段也需要用英文描述
创建测试数据：
	商家表设计20条数据。
	商品表设计50条记录，
	库存信息设计30条记录，
	订单按照时间生成最近半年的销售记录。每个月生成30~50条记录。
	客户生成20条记录。
设计数据的时候注意表结构直接的关联关系。生成的sql语句需要满足mysql的语法要求

可以通过大模型帮我们生成对应的SQL语句

CREATE TABLE vendors (
    id INT AUTO_INCREMENT PRIMARY KEY,
    NAME VARCHAR(255) NOT NULL,
    contact_info VARCHAR(255)
);

CREATE TABLE customers (
    id INT AUTO_INCREMENT PRIMARY KEY,
    NAME VARCHAR(255) NOT NULL,
    email VARCHAR(255),
    address VARCHAR(255)
);

CREATE TABLE goods (
    id INT AUTO_INCREMENT PRIMARY KEY,
    NAME VARCHAR(255) NOT NULL,
    price DECIMAL(10,2) NOT NULL,
    image_url VARCHAR(255),
    vendor_id INT,
    FOREIGN KEY (vendor_id) REFERENCES vendors(id)
);

CREATE TABLE inventory (
    id INT AUTO_INCREMENT PRIMARY KEY,
    goods_id INT,
    stock INT NOT NULL,
    FOREIGN KEY (goods_id) REFERENCES goods(id)
);

CREATE TABLE orders (
    id INT AUTO_INCREMENT PRIMARY KEY,
    customer_id INT,
    goods_id INT,
    goods_name VARCHAR(255),
    shipping_address VARCHAR(255),
    vendor_id INT,
    order_time DATETIME,
    FOREIGN KEY (customer_id) REFERENCES customers(id),
    FOREIGN KEY (goods_id) REFERENCES goods(id),
    FOREIGN KEY (vendor_id) REFERENCES vendors(id)
);

-- 插入商家数据 (20 条记录)
INSERT INTO vendors (NAME, contact_info) VALUES
("Vendor1", "vendor1@example.com"),
("Vendor2", "vendor2@example.com"),
("Vendor3", "vendor3@example.com"),
("Vendor4", "vendor4@example.com"),
("Vendor5", "vendor5@example.com"),
("Vendor6", "vendor6@example.com"),
("Vendor7", "vendor7@example.com"),
("Vendor8", "vendor8@example.com"),
("Vendor9", "vendor9@example.com"),
("Vendor10", "vendor10@example.com"),
("Vendor11", "vendor11@example.com"),
("Vendor12", "vendor12@example.com"),
("Vendor13", "vendor13@example.com"),
("Vendor14", "vendor14@example.com"),
("Vendor15", "vendor15@example.com"),
("Vendor16", "vendor16@example.com"),
("Vendor17", "vendor17@example.com"),
("Vendor18", "vendor18@example.com"),
("Vendor19", "vendor19@example.com"),
("Vendor20", "vendor20@example.com");

-- 插入商品数据 (50 条记录，随机分配商家)
INSERT INTO goods (NAME, price, image_url, vendor_id) VALUES
("Product1", 10.99, "img1.jpg", 1),
("Product2", 20.99, "img2.jpg", 2),
("Product3", 30.99, "img3.jpg", 3),
("Product4", 40.99, "img4.jpg", 4),
("Product5", 50.99, "img5.jpg", 5),
("Product6", 15.49, "img6.jpg", 6),
("Product7", 25.49, "img7.jpg", 7),
("Product8", 35.49, "img8.jpg", 8),
("Product9", 45.49, "img9.jpg", 9),
("Product10", 55.49, "img10.jpg", 10);

-- 插入库存数据 (30 条记录，随机选择商品)
INSERT INTO inventory (goods_id, stock) VALUES
(1, 100),
(2, 150),
(3, 200),
(4, 250),
(5, 300);

-- 插入客户数据 (20 条记录)
INSERT INTO customers (NAME, email, address) VALUES
("Customer1", "cust1@example.com", "Address1"),
("Customer2", "cust2@example.com", "Address2"),
("Customer3", "cust3@example.com", "Address3"),
("Customer4", "cust4@example.com", "Address4"),
("Customer5", "cust5@example.com", "Address5");

-- 插入订单数据 (最近半年，每月 30~50 条记录)
INSERT INTO orders (customer_id, goods_id, goods_name, shipping_address, vendor_id, order_time) VALUES
(1, 1, "Product1", "Address1", 1, NOW()),
(2, 2, "Product2", "Address2", 2, NOW()),
(3, 3, "Product3", "Address3", 3, NOW()),
(4, 4, "Product4", "Address4", 4, NOW()),
(5, 5, "Product5", "Address5", 5, NOW());

然后我们可以创建对应的工作流

对应的表结构的说明

 以下是每张表的数据结构说明：  
 
 ### **商家表（vendors）**  
 - **id**：商家ID，整数类型，主键，自增。  
 - **name**：商家名称，字符串类型，非空。  
 - **contact_info**：联系方式，字符串类型，可为空。  
 
 ### **客户表（customers）**  
 - **id**：客户ID，整数类型，主键，自增。  
 - **name**：客户名称，字符串类型，非空。  
 - **email**：电子邮件，字符串类型，可为空。  
 - **address**：收货地址，字符串类型，可为空。  
 
 ### **商品表（goods）**  
 - **id**：商品ID，整数类型，主键，自增。  
 - **name**：商品名称，字符串类型，非空。  
 - **price**：商品价格，十进制(10,2)类型，非空。  
 - **image_url**：商品图片URL，字符串类型，可为空。  
 - **vendor_id**：商家ID，整数类型，外键，关联 `vendors(id)`。  
 
 ### **库存表（inventory）**  
 - **id**：库存ID，整数类型，主键，自增。  
 - **goods_id**：商品ID，整数类型，外键，关联 `goods(id)`。  
 - **stock**：库存数量，整数类型，非空。  
 
 ### **订单表（orders）**  
 - **id**：订单ID，整数类型，主键，自增。  
 - **customer_id**：客户ID，整数类型，外键，关联 `customers(id)`。  
 - **goods_id**：商品ID，整数类型，外键，关联 `goods(id)`。  
 - **goods_name**：商品名称，字符串类型，冗余存储，便于查询。  
 - **shipping_address**：收货地址，字符串类型，非空。  
 - **vendor_id**：商家ID，整数类型，外键，关联 `vendors(id)`。  
 - **order_time**：订单时间，日期时间类型，非空。  
 
 这样，每张表的数据结构清晰，符合关系型数据库的设计规范。你需要进一步优化或者修改吗？

第一个LLM中的提示词内容

System

 你是一位精通SQL语言的数据库专家，熟悉MySQL数据库。你的任务是根据用户的自然语言输入，编写出可直接执行的SQL查询语句。输出内容必须是可以执行的SQL语句，不能包含任何多余的信息。
 
 核心规则：
 1. 根据用户的查询需求，确定涉及的表和字段。
 2. 确保SQL语句的语法符合MySQL的规范。
 3. 输出的SQL语句必须完整且可执行，不包含注释或多余的换行符。
 
 关键技巧：
 - WHERE 子句： 用于过滤数据。例如，`WHERE column_name = 'value'`。
 - 日期处理： 使用`STR_TO_DATE`函数将字符串转换为日期类型。例如，`STR_TO_DATE('2025-03-14', '%Y-%m-%d')`。
 - 聚合函数：如`COUNT`、`SUM`、`AVG`等，用于计算汇总信息。
 - 除法处理： 在进行除法运算时，需考虑除数为零的情况，避免错误。
 - 日期范围示例：查询特定日期范围的数据时，使用`BETWEEN`关键字。例如，`WHERE date_column BETWEEN '2025-01-01' AND '2025-12-31'`。
 
 注意事项：
 1. 确保字段名和表名的正确性，避免拼写错误。
 2. 对于字符串类型的字段，使用单引号括起来。例如，`'sample_text'`。
 3. 在使用聚合函数时，如果需要根据特定字段分组，使用`GROUP BY`子句。
 4. 在进行除法运算时，需判断除数是否为零，以避免运行时错误。
 5. 生成的sql语句 不能有换行符 比如 \n
 6. 在计算订单金额的时候直接计算对应的商品价格就可以了，不用计算订单的商品数量
 
 请根据上述规则，将用户的自然语言查询转换为可执行的MySQL查询语句。

user部分的提示词

 数据库结构：
 商家表（vendors）
 id：商家ID，整数类型，主键，自增。
 name：商家名称，字符串类型，非空。
 contact_info：联系方式，字符串类型，可为空。
 客户表（customers）
 id：客户ID，整数类型，主键，自增。
 name：客户名称，字符串类型，非空。
 email：电子邮件，字符串类型，可为空。
 address：收货地址，字符串类型，可为空。
 商品表（goods）
 id：商品ID，整数类型，主键，自增。
 name：商品名称，字符串类型，非空。
 price：商品价格，十进制(10,2)类型，非空。
 image_url：商品图片URL，字符串类型，可为空。
 vendor_id：商家ID，整数类型，外键，关联 vendors(id)。
 库存表（inventory）
 id：库存ID，整数类型，主键，自增。
 goods_id：商品ID，整数类型，外键，关联 goods(id)。
 stock：库存数量，整数类型，非空。
 订单表（orders）
 id：订单ID，整数类型，主键，自增。
 customer_id：客户ID，整数类型，外键，关联 customers(id)。
 goods_id：商品ID，整数类型，外键，关联 goods(id)。
 goods_name：商品名称，字符串类型，冗余存储，便于查询。
 shipping_address：收货地址，字符串类型，非空。
 vendor_id：商家ID，整数类型，外键，关联 vendors(id)。
 order_time：订单时间，日期时间类型，非空。
 
 问题：{{#1741938398688.sql#}}}

代码执行部分是通过Python代码调用对应的接口来执行SQL操作,这部分在前面的案例中有介绍的。

 import json
 import requests
 
 def main(sql: str) -> dict:
     url = "http://host.docker.internal:5000/execute_sql"
     connection_info = {
         "host": "localhost",
         "user": "root",
         "password": "123456",
         "database": "llm_shop"
     }
     # 构造请求体
     payload = {
         "sql": sql,
         "connection_info": connection_info
     }
 
     headers = {
         "Content-Type": "application/json"
     }
 
     try:
         response = requests.post(url, json=payload, headers=headers)
         if response.status_code == 200:
             try:
                 return {"result":str(response.json()["result"])}
             except Exception as e:
                 return {"result": f"解析响应 JSON 失败: {str(e)}"}
         else:
             return {"result": f"请求失败，状态码: {response.status_code}"}
     except Exception as e:
         return {"result": str(e)}

然后就是数据的整理。通过代码执行获取到对应的结果。然后处理成为我们需要的数据展示

对应的提示词内容

System

 你是电商行业数据分析专家，分析JSON格式的sql查询结果，回答用户问题。
 关键规则：
 1.所有数据已符合用户问题中的条件
 2.直接使用提供的数据分析，不质疑数据是否符合条件
 3.不需要再次筛选或确认数据类别/时间范围
 4.数据为[]或空或者None时直接回复"没有查询到相关数据"，不得编造数据

User

 数据是:{{#1741938410121.result#}}
 问题是：{{#1741938398688.sql#}}
 回答要求：
  1.列出详细数据，优先以表格方式列出数据
  2.识别趋势、异常，并提供分析和建议
  3.分析SQL语句{{#1741938410121.result#}}和用户的问题{{#1741938398688.sql#}}是否匹配
 4.最后附上查询的sql语

四、结语

本文参考B站大佬`AI大模型教程大全`。

特别感谢大佬的课件

https://b23.tv/Aow90f0?share_medium=android&share_source=qq&bbid=XU1E5841313D14EADEC030A2EB75F4CC8590D&ts=1745849889911