对话历史持久化

使用 MySQL 保存聊天消息,让模型在服务重启后仍能读取历史并继续对话。

🎯 引言

前面使用 history 数组管理多轮对话时,消息保存在 Node.js 内存里。服务一旦重启,原来的聊天记录就无法找回。

这篇文章用已经学过的 MySQL 解决这个问题:保存用户与助手的消息;再次提问时,读取对应会话的历史,交给 Chat Completions。 我们会独立建立一个 Express 接口,按功能逐步写代码,最后验证重启服务后能否继续对话。


🧱 聊天记录怎样区分

同一个用户可能同时聊两个话题,不能把所有消息混在一起。我们用一个会话 ID(sessionId)来区分:

会话 ID(示意)rolecontent
Auser我正在学习 Vue 3
Aassistant你想先了解哪部分?
Auser先讲响应式
BuserNode.js 服务启动失败怎么办?

因此,数据库需要两张表:sessions 保存会话,messages 保存消息,并用 session_id 指明每条消息属于哪个会话。表中的 A、B 是为了演示,实际使用 UUID。

用户的问题和助手的回答都要保存。 比如助手先回答“常见的响应式 API 有 ref() 和 reactive()”,用户接着问“第一个怎么用?”,模型需要看到上一轮助手的回答,才能知道“第一个”指的是 ref()。


🛠 使用 MySQL 保存和读取消息

1. 建表与配置

在已有的 MySQL 中执行:

CREATE DATABASE IF NOT EXISTS ai_chat CHARACTER SET utf8mb4;
USE ai_chat;

CREATE TABLE IF NOT EXISTS sessions (
    id CHAR(36) PRIMARY KEY,
    title VARCHAR(100) NOT NULL
);

CREATE TABLE IF NOT EXISTS messages (
    id BIGINT PRIMARY KEY AUTO_INCREMENT,
    session_id CHAR(36) NOT NULL,
    role VARCHAR(20) NOT NULL,
    content TEXT NOT NULL,
    FOREIGN KEY (session_id) REFERENCES sessions(id)
);

messages.session_id 关联 sessions.id;查询某个会话时,只读取对应的消息。messages.id 用来确定本例中消息的保存顺序。

新建 ai-chat 项目目录,使用 Node.js 24.x,安装本篇需要的依赖:

npm init -y
npm install --save-exact express@5.1.0 openai@7.62.0 mysql2@3.24.6

创建 .env,填入实际配置:

AI_API_KEY=你的AIHubMix密钥
AI_BASE_URL=https://aihubmix.com/v1
AI_MODEL=gpt-4o-mini

DB_HOST=127.0.0.1
DB_PORT=3306
DB_USER=root
DB_PASSWORD=你的MySQL密码
DB_NAME=ai_chat

2. 创建会话

创建 09.store.mjs。先连接数据库,并实现创建会话、检查会话是否存在这两个操作:

import mysql from "mysql2/promise";
import { randomUUID } from "node:crypto";

const pool = mysql.createPool({
    host: process.env.DB_HOST,
    port: Number(process.env.DB_PORT),
    user: process.env.DB_USER,
    password: process.env.DB_PASSWORD,
    database: process.env.DB_NAME,
    connectionLimit: 5
});

export async function createSession() {
    const id = randomUUID();
    await pool.execute(
        "INSERT INTO sessions (id, title) VALUES (?, ?)",
        [id, "新对话"]
    );
    return id;
}

export async function hasSession(id) {
    const [rows] = await pool.execute(
        "SELECT id FROM sessions WHERE id = ?",
        [id]
    );
    return rows.length > 0;
}

createSession() 在 sessions 表中插入一条记录,并返回生成的 ID;hasSession() 用来避免对不存在的会话保存或读取消息。

3. 保存与读取消息

继续在 同一个 09.store.mjs 文件末尾 添加两个函数:

export async function addMessage(sessionId, role, content) {
    await pool.execute(
        "INSERT INTO messages (session_id, role, content) VALUES (?, ?, ?)",
        [sessionId, role, content]
    );
}

export async function getMessages(sessionId) {
    const [rows] = await pool.execute(
        "SELECT role, content FROM messages WHERE session_id = ? ORDER BY id ASC",
        [sessionId]
    );
    return rows;
}

addMessage() 每次保存一条消息,getMessages() 按顺序取出当前会话的消息。查询只返回 role 和 content,因为本篇普通文本对话传给 Chat Completions 的 messages 正好需要这两个字段。SQL 中的 ? 使用参数绑定,避免拼接用户输入。


🛠 逐步建立聊天接口

下面创建 09.server.mjs,每个代码块都是往同一个文件末尾继续添加,不需要重复复制已经写过的内容。

1. 初始化 Express 与模型客户端

先在 09.server.mjs 中写入:

import express from "express";
import OpenAI from "openai";
import { createSession, hasSession, addMessage, getMessages } from "./09.store.mjs";

const app = express();
const client = new OpenAI({
    apiKey: process.env.AI_API_KEY,
    baseURL: process.env.AI_BASE_URL
});

app.use(express.json({ limit: "16kb" }));

数据库操作来自刚写好的 09.store.mjs。接下来只需要把它们放进对应的接口。

2. 创建会话接口

在 09.server.mjs 末尾添加:

app.post("/api/sessions", async (req, res) => {
    try {
        const id = await createSession();
        res.status(201).json({ id });
    } catch (error) {
        console.error(error);
        res.status(500).json({ error: "创建会话失败" });
    }
});

浏览器先调用 POST /api/sessions,拿到一个 id。之后在这个会话中提问,都携带同一个 sessionId,后端才能找到对应的历史。

3. 处理模型的流式回答

聊天接口要把模型返回的文字逐段转发给浏览器,但不能把每个片段都保存为单独的数据库消息。因此先增加一个处理函数:向浏览器发送每段文字,同时把文本拼接成一条完整的助手回答,结束后再保存。

继续在 09.server.mjs 末尾添加:

async function streamReply(sessionId, history, res, signal) {
    const stream = await client.chat.completions.create({
        model: process.env.AI_MODEL,
        messages: history,
        stream: true
    }, { signal });

    res.setHeader("Content-Type", "application/x-ndjson; charset=utf-8");
    res.setHeader("Cache-Control", "no-cache, no-transform");
    res.setHeader("X-Accel-Buffering", "no");

    let answer = "";
    let finishReason = null;

    for await (const chunk of stream) {
        const choice = chunk.choices[0];
        if (!choice) continue;

        const text = choice.delta?.content;
        if (text) {
            answer += text;
            res.write(JSON.stringify({ type: "delta", text }) + "\n");
        }
        if (choice.finish_reason != null) {
            finishReason = choice.finish_reason;
        }
    }

    if (finishReason === null) {
        throw new Error("模型流未正常结束");
    }

    if (answer) {
        await addMessage(sessionId, "assistant", answer);
    }
    res.write(JSON.stringify({ type: "done", finishReason }) + "\n");
    res.end();
}

这里沿用流式输出的读取方式。真正新增的是 answer += text 和最后的 addMessage():前者收集本轮回答,后者把它作为一条助手消息保存。 如果模型因为长度限制结束,保存的是实际收到的内容,不一定是完整回答。

4. 接收问题、读取历史并调用模型

现在添加 POST /api/chat。收到 sessionId 和用户问题后,先确认会话存在,然后把问题存入 MySQL,再读取历史交给 streamReply()。

继续在 09.server.mjs 末尾添加:

app.post("/api/chat", async (req, res) => {
    const { sessionId, message } = req.body ?? {};

    if (typeof sessionId !== "string" || !sessionId.trim()) {
        return res.status(400).json({ error: "缺少会话 ID" });
    }
    if (typeof message !== "string" || !message.trim() || message.length > 2000) {
        return res.status(400).json({ error: "请输入 1~2000 个字符的消息" });
    }

    const controller = new AbortController();
    res.on("close", () => {
        if (!res.writableEnded) controller.abort();
    });

    try {
        if (!await hasSession(sessionId)) {
            return res.status(404).json({ error: "会话不存在" });
        }

        await addMessage(sessionId, "user", message);
        const history = await getMessages(sessionId);
        await streamReply(sessionId, history, res, controller.signal);
    } catch (error) {
        if (controller.signal.aborted || res.destroyed) return;
        console.error(error);

        if (!res.headersSent) {
            res.status(502).json({ error: "聊天请求失败" });
        } else {
            res.write(JSON.stringify({ type: "error", message: "生成中断" }) + "\n");
            res.end();
        }
    }
});

这里的顺序值得注意:先保存本次问题,再查询历史。例如数据库原来已有一轮问答,此时用户输入“先讲响应式”,查询结果会包含之前的问答和这次的问题,不需要额外拼接本次消息。

模型不会主动查询 MySQL。getMessages() 取出的 history 会由 streamReply() 传给 Chat Completions,模型才能参考之前的对话。若请求失败,已保存的用户消息仍可能留在数据库;这里不扩展失败重试。

5. 提供读取历史的接口

最后让页面能够根据会话 ID 找回聊天记录。在 09.server.mjs 末尾添加:

app.get("/api/sessions/:id/messages", async (req, res) => {
    try {
        if (!await hasSession(req.params.id)) {
            return res.status(404).json({ error: "会话不存在" });
        }
        res.json({ messages: await getMessages(req.params.id) });
    } catch (error) {
        console.error(error);
        res.status(500).json({ error: "读取历史失败" });
    }
});

app.listen(3000, "127.0.0.1", () => {
    console.log("http://127.0.0.1:3000");
});

到这里,09.server.mjs 已经写完。它可以创建会话、在指定会话里提问,以及读取已保存的消息;不需要再把前面的代码汇总展示一遍。

MySQL 可以长期保存完整历史,但实际应用中不一定每次都要把全部历史传给模型。长会话可以按之前学过的上下文管理方式控制 Token 开销。

🧪 验证服务重启后能否恢复对话

确保 MySQL 已启动、建表 SQL 已执行,在项目根目录启动服务:

node --env-file=.env 09.server.mjs

如果你的模型请求需要本地代理,使用:

HTTPS_PROXY=http://127.0.0.1:7890 NODE_USE_ENV_PROXY=1 node --env-file=.env 09.server.mjs

第一步:创建会话。

curl -s -X POST http://127.0.0.1:3000/api/sessions

会返回 {"id":"..."}。复制实际 ID,并替换下面命令中的 你的会话ID。

第二步:使用同一个会话 ID 提问两次。

curl -N -X POST http://127.0.0.1:3000/api/chat \
    -H 'Content-Type: application/json' \
    -d '{"sessionId":"你的会话ID","message":"我正在学习 Vue 3"}'
curl -N -X POST http://127.0.0.1:3000/api/chat \
    -H 'Content-Type: application/json' \
    -d '{"sessionId":"你的会话ID","message":"我刚才说正在学习什么?"}'

第三步:查看保存的历史。

curl http://127.0.0.1:3000/api/sessions/你的会话ID/messages

如果两次模型调用都成功,返回结构类似如下(助手的回答仅为示意):

{
    "messages": [
        { "role": "user", "content": "我正在学习 Vue 3" },
        { "role": "assistant", "content": "好的,我们可以从 Vue 3 开始。" },
        { "role": "user", "content": "我刚才说正在学习什么?" },
        { "role": "assistant", "content": "你刚才说正在学习 Vue 3。" }
    ]
}

第四步:停止并重启服务,再次查询同一个会话 ID。消息仍在,就证明数据没有随着 Node.js 进程结束而消失;继续提问时,模型也能参考这些历史。

本例仅供本地学习:会话 ID 不是登录凭证。公开部署前,需要校验会话归属并限制模型调用额度。

❓ 知识问答

Q:为什么不直接把整个 history 数组存成一条数据库记录?

这种做法也能保存简单的聊天记录,但每次新增消息都要更新整份数据。这里按消息逐条存储,可以直接追加新消息,也方便按会话查询。


🧪 小练习

分别创建“Vue”和“Node.js”两个会话,在各自会话中提问。重启服务后,使用两个会话 ID 查询历史,再任选一个会话继续提问。

验证标准: 两个会话的记录不会混在一起;重启后仍能读取旧消息;模型只参考当前会话的历史。


🎉 现在,你已经完成了对话记录的保存、读取和恢复,并让模型能够在服务重启后继续原来的对话。