对话历史持久化
🎯 引言
前面使用 history 数组管理多轮对话时,消息保存在 Node.js 内存里。服务一旦重启,原来的聊天记录就无法找回。
这篇文章用已经学过的 MySQL 解决这个问题:保存用户与助手的消息;再次提问时,读取对应会话的历史,交给 Chat Completions。 我们会独立建立一个 Express 接口,按功能逐步写代码,最后验证重启服务后能否继续对话。
🧱 聊天记录怎样区分
同一个用户可能同时聊两个话题,不能把所有消息混在一起。我们用一个会话 ID(sessionId)来区分:
| 会话 ID(示意) | role | content |
|---|---|---|
| A | user | 我正在学习 Vue 3 |
| A | assistant | 你想先了解哪部分? |
| A | user | 先讲响应式 |
| B | user | Node.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 已启动、建表 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 进程结束而消失;继续提问时,模型也能参考这些历史。
❓ 知识问答
Q:为什么不直接把整个 history 数组存成一条数据库记录?
这种做法也能保存简单的聊天记录,但每次新增消息都要更新整份数据。这里按消息逐条存储,可以直接追加新消息,也方便按会话查询。
🧪 小练习
分别创建“Vue”和“Node.js”两个会话,在各自会话中提问。重启服务后,使用两个会话 ID 查询历史,再任选一个会话继续提问。
验证标准: 两个会话的记录不会混在一起;重启后仍能读取旧消息;模型只参考当前会话的历史。
🎉 现在,你已经完成了对话记录的保存、读取和恢复,并让模型能够在服务重启后继续原来的对话。
