在 Cursor 中实现「对话式操作本地数据库」（自然语言→自动执行 SQL/CRUD），核心是借助 Cursor AI 的自然语言理解能力 + 本地数据库操作封装 + 对话式交互脚本，无需手动写代码，直接用中文 / 英文描述需求（如 “查询所有 25 岁以上用户”“添加用户张三，年龄 30”），即可自动执行操作并返回结果。以下是完整实现步骤：

核心原理

1. 先封装本地数据库的基础操作（连接、CRUD、SQL 执行），提供统一接口；
2. 用 Cursor AI 将用户的自然语言需求，转化为对应的数据库操作代码（如 SQL 语句、调用封装好的 CRUD 函数）；
3. 编写对话交互脚本，接收用户输入→调用 AI 生成操作代码→执行代码→返回结果，形成闭环。

前置准备

1. 环境：Cursor 已打开本地项目文件夹，本地数据库（SQLite/MySQL/PostgreSQL）已安装并可本地访问；
2. 依赖安装（根据数据库类型）：
   • SQLite：无需额外安装（Python 内置 sqlite3）；
   • MySQL：pip install pymysql；
   • PostgreSQL：pip install psycopg2-binary；
3. 提前准备数据库（如 SQLite 可在项目目录创建 ./data/user.db，或让 AI 自动创建）。

完整步骤（以 SQLite 为例，支持所有数据库）

步骤 1：让 AI 生成「数据库操作核心封装」（可复用）

先让 Cursor 生成一个封装文件，包含 “连接数据库、执行 SQL、CRUD 基础函数”，后续对话交互直接调用这些函数，无需重复写逻辑。

操作：

1. 新建文件 db_core.py；
2. 输入提示词，按 Alt+\ 让 AI 生成完整封装：

   # 提示词：帮我封装本地 SQLite 数据库操作核心函数，要求：
   # 1. 数据库路径：./data/user.db（不存在自动创建，自动创建 data 文件夹）；
   # 2. 封装函数：
   #    - get_conn()：获取数据库连接（自动处理路径、异常）；
   #    - execute_sql(sql, params=None)：执行 SQL（增删改），返回影响行数；
   #    - query_sql(sql, params=None)：执行查询 SQL，返回结果列表（字典格式）；
   #    - close_conn(conn)：关闭连接；
   # 3. 自动创建 User 表（id 主键自增，username 唯一，age 整数，create_time 时间戳）；
   # 4. 包含完整异常处理和日志输出。
   

生成的 db_core.py 代码（直接可用）：

import sqlite3
import os
import datetime
from typing import Optional, List, Dict, Tuple

# 确保 data 文件夹存在
os.makedirs("./data", exist_ok=True)
DB_PATH = "./data/user.db"

def get_conn() -> Optional[sqlite3.Connection]:
    """获取数据库连接，自动创建数据库文件"""
    try:
        conn = sqlite3.connect(DB_PATH, check_same_thread=False)
        conn.row_factory = sqlite3.Row  # 结果以字典格式返回
        print(f"✅ 数据库连接成功（路径：{DB_PATH}）")
        return conn
    except Exception as e:
        print(f"❌ 数据库连接失败：{str(e)}")
        return None

def close_conn(conn: sqlite3.Connection):
    """关闭数据库连接"""
    if conn:
        conn.close()
        print("🔌 数据库连接已关闭")

def execute_sql(sql: str, params: Optional[Tuple] = None) -> int:
    """执行增删改 SQL，返回影响行数"""
    conn = get_conn()
    if not conn:
        return 0
    try:
        cursor = conn.cursor()
        cursor.execute(sql, params or ())
        conn.commit()
        affected_rows = cursor.rowcount
        print(f"✅ SQL 执行成功，影响行数：{affected_rows}")
        return affected_rows
    except Exception as e:
        conn.rollback()
        print(f"❌ SQL 执行失败：{str(e)}（SQL：{sql}，参数：{params}）")
        return 0
    finally:
        close_conn(conn)

def query_sql(sql: str, params: Optional[Tuple] = None) -> List[Dict]:
    """执行查询 SQL，返回结果列表（字典格式）"""
    conn = get_conn()
    if not conn:
        return []
    try:
        cursor = conn.cursor()
        cursor.execute(sql, params or ())
        rows = cursor.fetchall()
        result = [dict(row) for row in rows]
        print(f"✅ 查询成功，返回 {len(result)} 条数据")
        return result
    except Exception as e:
        print(f"❌ 查询失败：{str(e)}（SQL：{sql}，参数：{params}）")
        return []
    finally:
        close_conn(conn)

def init_db():
    """初始化数据库，创建 User 表（若不存在）"""
    create_table_sql = """
    CREATE TABLE IF NOT EXISTS User (
        id INTEGER PRIMARY KEY AUTOINCREMENT,
        username TEXT NOT NULL UNIQUE,
        age INTEGER,
        create_time TIMESTAMP DEFAULT CURRENT_TIMESTAMP
    );
    """
    execute_sql(create_table_sql)
    print("✅ 数据库初始化完成（User 表已创建或已存在）")

# 初始化数据库（首次运行自动执行）
if __name__ == "__main__":
    init_db()

步骤 2：让 AI 生成「对话式交互核心脚本」（自然语言→SQL→执行）

核心是编写一个脚本，接收用户的自然语言输入，让 Cursor AI 将其转化为对应的 SQL 或函数调用，然后自动执行并返回结果。

操作：

1. 新建文件 db_chat.py；
2. 输入提示词，让 AI 生成完整交互逻辑（重点：借助 Cursor 的 AI 能力动态转化需求）：

   # 提示词：帮我写一个对话式数据库操作脚本，要求：
   # 1. 依赖上面的 db_core.py（调用 execute_sql、query_sql 等函数）；
   # 2. 支持用户输入自然语言（如“查询所有 25 岁以上的用户”“添加用户李四，年龄 28”“删除用户名是张三的用户”）；
   # 3. 核心逻辑：
   #    - 接收用户输入→调用 Cursor AI 将自然语言转化为对应的 SQL 语句；
   #    - 自动判断 SQL 类型（查询/增删改），调用 db_core 对应的函数执行；
   #    - 格式化输出执行结果（查询结果用表格展示，增删改显示影响行数）；
   # 4. 支持退出指令（输入“quit”“退出”结束对话）；
   # 5. 包含异常处理（如 AI 生成无效 SQL 时提示用户重新描述）。
   

生成的 db_chat.py 代码（关键部分含注释）：

from db_core import execute_sql, query_sql
import json

def natural_language_to_sql(natural_text: str) -> Optional[str]:
    """将自然语言转化为 SQL 语句（借助 Cursor AI）"""
    # 构造提示词，引导 AI 生成标准 SQL（适配 SQLite User 表）
    prompt = f"""
    你是数据库 SQL 生成专家，需将用户的自然语言需求转化为标准 SQLite SQL 语句，仅返回 SQL 文本（不要其他内容）。
    数据库表结构：
    表名：User
    字段：id（INT 主键自增）、username（TEXT 唯一）、age（INT）、create_time（TIMESTAMP 自动生成）
    规则：
    1. 生成的 SQL 必须合法、可执行，无需解释；
    2. 新增用户时，无需指定 id 和 create_time（自动生成）；
    3. 条件判断必须明确（如“25 岁以上”→ age > 25）；
    4. 若无法转化需求，返回“无法识别需求，请重新描述”。
    
    用户需求：{natural_text}
    """
    
    # 调用 Cursor AI 生成 SQL（Cursor 内置 AI 直接调用，无需额外 API 密钥）
    from langchain_community.chat_models import ChatCursor  # Cursor 内置 LangChain 集成
    llm = ChatCursor(model="gpt-4o")
    response = llm.invoke(prompt)
    sql = response.content.strip()
    
    # 过滤无效响应
    if "无法识别需求" in sql or len(sql) < 5:
        return None
    return sql

def format_result(sql: str, result: list or int):
    """格式化输出执行结果"""
    print("\n" + "="*50)
    print(f"执行的 SQL：{sql}")
    print("-"*50)
    if isinstance(result, list):
        # 查询结果：表格形式展示
        if not result:
            print("结果：无匹配数据")
            return
        # 打印表头
        headers = result[0].keys()
        print("\t".join(headers))
        print("-"*50)
        # 打印数据
        for row in result:
            print("\t".join(str(value) for value in row.values()))
    else:
        # 增删改结果：显示影响行数
        print(f"结果：执行成功，影响行数 {result} 行")
    print("="*50 + "\n")

def db_chat_interactive():
    """对话式数据库操作主函数"""
    print("=== 对话式本地数据库操作工具（输入 'quit' 或 '退出' 结束）===")
    print("支持需求示例：")
    print("1. 查询所有 25 岁以上的用户")
    print("2. 添加用户李四，年龄 28")
    print("3. 修改用户李四的年龄为 30")
    print("4. 删除用户名是张三的用户")
    print("5. 统计用户总数")
    print("-"*50)
    
    while True:
        # 接收用户输入
        user_input = input("请输入你的数据库操作需求：")
        if user_input.lower() in ["quit", "退出"]:
            print("👋 工具已退出！")
            break
        if not user_input.strip():
            print("❌ 请输入有效需求！")
            continue
        
        # 1. 自然语言→SQL
        sql = natural_language_to_sql(user_input)
        if not sql:
            print("❌ 无法识别你的需求，请重新描述（如“查询所有 25 岁以上的用户”）\n")
            continue
        
        # 2. 判断 SQL 类型，执行对应操作
        sql_upper = sql.strip().upper()
        try:
            if sql_upper.startswith(("SELECT", "PRAGMA")):
                # 查询操作
                result = query_sql(sql)
                format_result(sql, result)
            elif sql_upper.startswith(("INSERT", "UPDATE", "DELETE")):
                # 增删改操作
                affected_rows = execute_sql(sql)
                format_result(sql, affected_rows)
            else:
                print("❌ 仅支持 SELECT/INSERT/UPDATE/DELETE 操作\n")
        except Exception as e:
            print(f"❌ 操作执行失败：{str(e)}\n")

if __name__ == "__main__":
    db_chat_interactive()

步骤 3：运行对话工具，直接用自然语言操作数据库

操作：

1. 先运行 db_core.py 初始化数据库（创建 User 表）：

   python db_core.py
   

   输出：✅ 数据库初始化完成（User 表已创建或已存在）

2. 运行 db_chat.py 启动对话工具：

   python db_chat.py
   

3. 直接输入自然语言需求，即可自动执行操作，示例交互流程：

   === 对话式本地数据库操作工具（输入 'quit' 或 '退出' 结束）===
   支持需求示例：
   1. 查询所有 25 岁以上的用户
   2. 添加用户李四，年龄 28
   3. 修改用户李四的年龄为 30
   4. 删除用户名是张三的用户
   5. 统计用户总数
   --------------------------------------------------
   请输入你的数据库操作需求：添加用户张三，年龄 25
   
   ==================================================
   执行的 SQL：INSERT INTO User (username, age) VALUES ('张三', 25)
   --------------------------------------------------
   结果：执行成功，影响行数 1 行
   ==================================================
   
   请输入你的数据库操作需求：查询所有用户
   
   ==================================================
   执行的 SQL：SELECT * FROM User
   --------------------------------------------------
   id      username        age     create_time
   --------------------------------------------------
   1       张三    25      2025-11-15 10:30:00
   ==================================================
   
   请输入你的数据库操作需求：修改张三的年龄为 26
   
   ==================================================
   执行的 SQL：UPDATE User SET age = 26 WHERE username = '张三'
   --------------------------------------------------
   结果：执行成功，影响行数 1 行
   ==================================================
   
   请输入你的数据库操作需求：统计 25 岁以上的用户数
   
   ==================================================
   执行的 SQL：SELECT COUNT(*) AS total FROM User WHERE age > 25
   --------------------------------------------------
   total
   --------------------------------------------------
   1
   ==================================================
   

步骤 4：优化与扩展（让对话更精准）

1. 提升 SQL 生成准确性

如果 AI 生成的 SQL 有误（如字段名错误、条件缺失），可在 natural_language_to_sql 函数的 prompt 中补充更详细的表结构说明，示例：

prompt = f"""
你是数据库 SQL 生成专家，需将用户的自然语言需求转化为标准 SQLite SQL 语句，仅返回 SQL 文本（不要其他内容）。
数据库表结构（严格遵循）：
- 表名：User（大小写敏感）
- 字段：
  id: INT 主键自增，无需手动插入
  username: TEXT 唯一，非空，如 '张三'（必须加单引号）
  age: INT 非负整数
  create_time: TIMESTAMP 自动生成，无需手动插入
规则：
1. 新增用户仅需指定 username 和 age，如 INSERT INTO User (username, age) VALUES ('李四', 28)；
2. 查询时优先返回所有字段（SELECT *），除非用户指定字段；
3. 条件判断必须用正确的运算符（大于>、小于<、等于=）；
4. 字符串值必须加单引号，数字不加；
5. 若无法转化需求，仅返回“无法识别需求，请重新描述”。

用户需求：{natural_text}
"""

2. 支持复杂需求（联表查询、分页、排序）

直接在对话中描述复杂需求，AI 会自动生成对应 SQL，示例：

• 用户输入：“查询年龄大于 25 的用户，按创建时间倒序排列，只显示前 10 条”
• AI 生成 SQL：SELECT * FROM User WHERE age > 25 ORDER BY create_time DESC LIMIT 10

3. 适配 MySQL/PostgreSQL

仅需修改 db_core.py 的连接和 SQL 语法（让 AI 自动适配）：

1. 修改 db_core.py 的提示词，示例（MySQL 适配）：

   # 提示词：将这个 SQLite 数据库封装改为 MySQL 适配，连接参数：host=127.0.0.1，port=3306，user=root，password=123456，database=test_db，使用 pymysql 库，SQL 语法适配 MySQL
   

2. 重新生成 db_core.py 后，db_chat.py 无需修改，直接运行即可支持 MySQL 对话操作。

步骤 5：调试与问题处理

1. AI 生成无效 SQL

• 现象：输入需求后提示 “SQL 执行失败”；
• 解决：选中报错信息，在 AI 侧边栏输入：“用户需求是‘XXX’，生成的 SQL 是‘XXX’，执行失败，帮我修正 SQL 并优化自然语言转 SQL 的提示词”，AI 会给出修正后的 SQL 和优化方案。

2. 数据库连接失败

• 现象：提示 “数据库连接失败”；
• 解决：检查数据库是否启动（如 MySQL 需手动启动服务）、连接参数是否正确（如密码、数据库名），让 AI 帮你排查：“MySQL 连接失败，提示‘Access denied’，帮我修改 db_core.py 的连接函数”。

3. 需求无法识别

• 现象：提示 “无法识别你的需求”；
• 解决：让用户更具体描述需求，示例：
  • 模糊需求：“添加用户”→ 精准需求：“添加用户王五，年龄 32，用户名唯一”；
  • 模糊需求：“查询用户”→ 精准需求：“查询 username 包含‘张’字的用户，显示用户名和年龄”。

核心总结

在 Cursor 中实现「对话式操作本地数据库」的核心是「封装基础操作 + AI 自然语言转 SQL + 交互脚本闭环」，步骤可简化为：

1. 让 AI 生成数据库操作封装（db_core.py）；
2. 让 AI 生成对话交互脚本（db_chat.py）；
3. 运行脚本，直接用自然语言输入需求，自动执行。

关键优势：无需懂 SQL、无需写代码，非技术人员也能操作本地数据库；借助 Cursor 的 MCP 协议，所有操作都在本地完成，数据安全无泄露；AI 自动适配需求，支持从简单增删改查到复杂统计查询。