C++AI

文章目录

• 一、前言
• • 1. 项目介绍
  • 2. 最终效果
  • 3. gitee链接
• 二、 环境配置
• • 1. 依赖库安装命令
  • 2. cpp-httplib 配置（header-only 库）
  • 3. 安装SQLite
• 三、 项目实现
• • 1. 目录结构与开发顺序
  • • sdk开发顺序
    • ChatServer开发顺序
  • 2. common.hpp
  • 3. LLMProvider.hpp
  • 4. DeepSeekProvider类
  • • 全量响应
    • 流式响应
  • 5. 测试DeepSeek接口是否成功
  • 6. LLMManager类
  • 7. 不接入DataManager的SessionManager
  • 8. DataManager类
  • 9. 接入DataManager的SessionManager
  • 10. ChatSDK
  • 11. ChatSDK测试
  • 12. ChatServer类与前端

一、前言

1. 项目介绍

本项目带领大家从零实现C++AI大语言模型接入SDK，SDK核心特性如下： ✅统一的多模型接入：支持DeepSeek-V3.2-Exp、gemini-2.0-flash、gpt-4o-mini等主流模型；支持通过Ollama无缝接入本地模型(deepseek-r1:1.5b)，保障数据隐私与低延迟 ✅高效流式响应与解析：完整支持 Server-Sent Events 流式传输，实时解析模型返回的数据流，实现类似“逐字打印”效果 ✅完整的会话管理：自动维护多轮对话上下文；支持创建、删除、获取会话列表，历史会话信息查看；支持应用重启后会话状态恢复，实现"断点续聊" ✅开箱即用的SDK设计：清晰简洁的API接口，方便在项目中集成以及扩展本项目不仅提供了一个功能完备的SDK，还包含一个基于该SDK实现的智能聊天机器人，演示如何将SDK快速接入到自己项目中。

目前博主只是接入了一个deepseek，自己感兴趣还可以接入chatgpt、Gemini等等大模型，和deepseek的接入过程几乎一摸一样，大家感兴趣可以自己试试

2. 最终效果

3. gitee链接

gitee链接：https://gitee.com/qi-haozhe/ai-model-acess-tech 超链接 大家可以点击提交记录，就可以看我从零开始，先写的什么，后写的什么了。

二、 环境配置

博主是在云服务器上写的，建议大家如果要配置ubuntu环境的话，选择新一点的版本，这样安装各种依赖方便点。此处我的云服务器版本是ubuntu24.04

1. 依赖库安装命令

# 1. gflags 安装
sudo apt-get install libgflags-dev

# 2. spdlog 安装
sudo apt-get install libspdlog-dev

# 3. fmt 安装
sudo apt-get install fmt

# 4. jsoncpp 安装
sudo apt-get install libjsoncpp-dev

# 5. gtest 安装
sudo apt-get install libgtest-dev

# 6. ssl 安装
sudo apt-get install libssl-dev

# 7. cmake 安装
sudo apt-get install cmake

# 8. pkg-config 安装（编译时查找库文件工具）
sudo apt install pkg-config

# 9. curl 工具安装
sudo apt install curl

2. cpp-httplib 配置（header-only 库）

# 1. 下载库
git clone https://github.com/yhirose/cpp-httplib.git

# 2. 拷贝头文件到系统目录（全局可用）
sudo cp cpp-httplib/httplib.h /usr/include/

说明：cpp-httplib是单头文件库，代码中直接#include <httplib.h>即可使用

3. 安装SQLite

# 1. 安装sqlite3命令行工具（用于终端操作数据库）
sudo apt install sqlite3

# 2. 安装sqlite开发库（用于C/C++程序编译）
sudo apt install libsqlite3-dev

# 3. 查看开发库包含的文件及路径（可选）
dpkg -L libsqlite3-dev

• 头文件路径：/usr/include/sqlite3.h、/usr/include/sqlite3ext.h
• 静态库文件：/usr/lib/x86_64-linux-gnu/libsqlite3.a
• 动态库文件：/usr/lib/x86_64-linux-gnu/libsqlite3.so
• 配置文件：/usr/lib/x86_64-linux-gnu/pkgconfig/sqlite3.pc

编译时链接sqlite3库 Makefile中链接

g++ main.cpp -o my_program -lsqlite3

CMakeLists.txt中链接

target_link_libraries(${SDK_NAME} sqlite3)

三、 项目实现

1. 目录结构与开发顺序

最终目录结构如下图所示

编写顺序建议先写sdk目录下的所有内容，sdk的完成了再去写ChatServer 目录中的内容

sdk开发顺序

ChatServer开发顺序

2. common.hpp

这里面就定义一些基础的数据结构，以备后面需要。 Message定义消息结构体，用来表示每条消息记录 Config用来表示模型的配置信息 析构函数记得声明虚函数要不然可能会有问题 ModelInfo用来描述模型信息 Session描述每个会话的信息 这里的会话是指这个：

#pragma once
#include <vector>
#include <string>
#include <ctime>

namespace ai_chat_sdk{

struct Message{
std::string _messageId;
std::string _role; //表示这条消息是用户发的还是ai回复的
std::string _content;
std::time_t _timestamp;

Message(const std::string &role = "", const std::string &content = "")
: _role(role), _content(content), _timestamp(0)
{}
};

struct Config{
std::string _modelName;
double _temperature; //回答发散程度
int _maxTokens; //模型最大tokens，这个太小可能会导致模型回答不完一个问题就结束了

virtual ~Config() = default;
};

struct ApiConfig:public Config
{
std::string _apiKey;
};

struct OllamaConfig : public Config
{
std::string _modelName; // 模型名称
std::string _modelDesc; // 模型描述
std::string _endpoint; // 模型API endpoint base url
};

struct ModelInfo{
std::string _modelName;
std::string _modelDesc;
std::string _provider;
std::string _endPoint;
bool _isAvailable = false;

ModelInfo(const std::string& modelName = "", const std::string& modelDesc = "", const std::string& provider = "", const std::string& endpoint = "")
: _modelName(modelName), _modelDesc(modelDesc), _provider(provider), _endPoint(endpoint){}
};
struct Session{
std::string _sessionId;
std::string _modelName; //会话用的哪一个模型
std::vector<Message> _messages; //会话内的所有消息，包含用户问的和ai回复的
std::time_t _createTime;
std::time_t _updateTime;
Session(const std::string &modelName = "")
: _modelName(modelName)
{}
};
}// end ai_chat_sdk

3. LLMProvider.hpp

这个类就是一个抽象类，里面定义了一堆虚函数。后面所有要接入的模型都需要继承这一个类然后重写这些虚函数。也就是说你后面要接入DeepSeek、ChatGPT、Gemini的话都创建一个类，继承LLMProvider实现虚函数就行。算是一个策略类，以后把LLMProvider这个父类指针当作成员变量，想要什么模型就把什么子类指针赋值给父类指针就行，这里是利用了一下多态。 成员变量设置为protected，三个成员变量分别表示是否就绪、apikey和请求地址，比如deepseek的请求地址就是https://api.deepseek.com

#pragma once
#include <string>
#include <map>
#include <vector>
#include <functional>
#include "common.hpp"
namespace ai_chat_sdk {
class LLMProvider{
public:
// 初始化模型
virtual bool initModel(const std::map<std::string, std::string>& modelConfig) = 0;
//模型是否有效
virtual bool isAvailable() = 0;
// 获取模型名称
virtual std::string getModelName() const = 0;
// 获取模型描述
virtual std::string getModelDesc() const = 0;
// 发送消息并获取响应
virtual std::string sendMessage(const std::vector<Message>& messages,const std::map<std::string, std::string>& requestParams) = 0;
// 发送消息并获取流式响应
virtual std::string sendMessageStream(const std::vector<Message>& messages,
const std::map<std::string, std::string>& requestParams,
std::function<void(const std::string&, bool)> callback) = 0; // callback: 对模型返回的增量数据如何处理，第一个参数为增量数据，第二个参数为是否为最后一个增量数据)

protected:
bool _isAvailable = false;
std::string _apiKey;
std::string _endPoint;
};
}

4. DeepSeekProvider类

DeepSeekProvider类就是继承LLMProvider抽象类重写虚函数而已。 前四个都比较简单，我们重点说一下最后两个虚函数具体如何实现：

// 发送消息并获取响应 std::string sendMessage(const std::vector&messages,const std::map<std::string, std::string>& requestParams); //发送消息并获取流式响应 std::string sendMessageStream(const std::vector&messages, const std::map<std::string, std::string>& requestParams, std::function<void(const std::string&, bool)> callback);

//DeepSeekProvider.hpp
#pragma once
#include "LLMProvider.hpp"

namespace ai_chat_sdk {
class DeepSeekProvider : public LLMProvider {
public:
// 初始化模型
bool initModel(const std::map<std::string, std::string>& modelConfig);
//模型是否有效
bool isAvailable();
// 获取模型名称
std::string getModelName() const;
// 获取模型描述
std::string getModelDesc() const;
// 发送消息并获取响应
std::string sendMessage(const std::vector<Message>& messages,const std::map<std::string, std::string>& requestParams);
// 发送消息并获取流式响应
std::string sendMessageStream(const std::vector<Message>& messages,
const std::map<std::string, std::string>& requestParams,
std::function<void(const std::string&, bool)> callback);

};

} // end ai_chat_sdk

全量响应

这个函数的主要功能就是拼凑json格式的请求消息，然后通过httplib构造http请求，去deepseek官网根据你设置的deepseek_apikey鉴权，然后获取响应消息，解析响应消息然后返回字符串就行，这个返回的字符串未来就是前端显示的字符串。

拼装请求JSON → 发起HTTP POST请求 → 接收HTTP响应 → 校验响应有效性 → 解析响应JSON → 精准提取AI回复内容 → 返回纯文本结果

这个函数就主要是全量响应，意思是你发送请求后，只有当获取到全部的响应之后才会返回到前端，给人的感觉就是你前端问了一个问题，然后等了几秒钟，然后突然所有结果全都展现出来了，与之对应的就是流式响应，现在的ai都是流式响应。

先从传入的requestParams中读取配置参数，没有传参则使用默认值，不影响协议和格式，只影响模型生成策略：

double temperature = 0.7; // 默认温度值，控制回复随机性
int maxTokens = 2048; // 默认最大生成长度
// 解析外部传入的参数覆盖默认值
if(requestParams.find("temperature") != requestParams.end()) temperature = std::stod(requestParams.at("temperature"));
if(requestParams.find("max_tokens") != requestParams.end()) maxTokens = std::stoi(requestParams.at("max_tokens"));

然后是构造请求消息，请求的http body字段就是下面这个表格，这几个字段是必填项，我们按照格式拼接就行。

大模型需要上下文，所以每次请求的时候我们需要把传入的std::vector<Message>历史消息列表，转成JSON数组格式：

Json::Value messageArray(Json::arrayValue); // 创建JSON数组对象
for(const auto &msg : messages){
Json::Value messageJson; // 单个消息的JSON对象
messageJson["role"] = msg._role; // 填充角色：user/assistant/system
messageJson["content"] = msg._content; // 填充消息内容：用户提问/AI回复
messageArray.append(messageJson); // 单个消息对象加入数组
}

拼装后的messageArray JSON结构示例：

[
{"role":"user","content":"你好"},
{"role":"assistant","content":"您好，有什么可以帮您？"},
{"role":"user","content":"给我整理一份C++库清单"}
]

组装完整的请求JSON根对象按 DeepSeek 官方接口规范，拼接顶层必填字段，缺一不可：

Json::Value requestJson; // JSON根对象
requestJson["model"] = getModelName(); // 必填：模型名称 deepseek-chat
requestJson["messages"] = messageArray; // 必填：历史消息数组
requestJson["temperature"] = temperature; // 可选：随机性参数
requestJson["max_tokens"] = maxTokens; // 可选：最大生成token数

JSON对象 → 无缩进的纯字符串（请求体最终格式）

Json::StreamWriterBuilder writerBuilder;
writerBuilder["indentation"] = ""; // 关键：设置空缩进，生成紧凑的JSON字符串，减少传输体积
std::string requestBodyStr = Json::writeString(writerBuilder, requestJson);

最终拼接完成的requestBodyStr 标准请求体（纯字符串），直接作为HTTP POST的请求体发送：

{"model":"deepseek-chat","messages":[{"role":"user","content":"你好"},{"role":"assistant","content":"您好"},{"role":"user","content":"整理C++库清单"}],"temperature":0.7,"max_tokens":2048}

发起HTTP POST请求（cpp-httplib实现）

httplib::Client cli(_endPoint.c_str()); // 创建HTTP客户端，_endPoint是DeepSeek的接口域名/地址
cli.set_connection_timeout(30); // 连接超时30秒
cli.set_read_timeout(60); // 读取响应超时60秒

// 设置HTTP请求头（重中之重，2个必填请求头，缺一不可）
httplib::Headers headers = {
{"Authorization", "Bearer " + _apiKey}, // 身份认证：接口鉴权，格式固定 Bearer+空格+APIKey
{"Content-Type", "application/json"} // 告诉服务端：本次请求体是JSON格式
};

// 发起POST请求：【接口路径 + 请求头 + 请求体字符串 + 请求体格式】
auto res = cli.Post("/v1/chat/completions", headers, requestBodyStr, "application/json");

然后就是获取响应解析响应了：

响应会有如下字段，我们只需要把choices->message->content提取到就行，也就是说我们只要这个content字段，根据json的语法去获取之后再校验一下就行。

{
"id": "chatcmpl-xxx",
"object": "chat.completion",
"created": 1735620000,
"model": "deepseek-chat",
"choices": [ // 核心数组，固定只有1个元素
{
"index": 0,
"message": { // 核心对象
"role": "assistant",
"content": "这是AI给你的最终回复内容，纯文本格式" // ✅ 我们要的最终数据
},
"finish_reason": "stop"
}
],
"usage": {"prompt_tokens": 10, "completion_tokens": 20, "total_tokens": 30}
}

Json::Value responseBody; // 存储解析后的JSON对象
Json::CharReaderBuilder readerBuilder; // JsonCpp解析器
std::string parseError; // 解析失败的错误信息
std::istringstream responseStream(res->body); // 把响应字符串转成输入流

// 核心解析API：把响应流解析到responseBody对象中
bool parseOk = Json::parseFromStream(readerBuilder, responseStream, &responseBody, &parseError);

对应的提取代码（和上面的JSON结构完全一一对应）

if(parseOk){ // 第一步：判断JSON解析是否成功
// 第二步：判断是否有choices字段 + 是数组 + 数组非空
if(responseBody.isMember("choices") && responseBody["choices"].isArray() && !responseBody["choices"].empty()){
auto choice = responseBody["choices"][0]; // 取choices数组的第一个元素（固定只有1个）
// 第三步：判断choice里有message字段 + message里有content字段
if(choice.isMember("message") && choice["message"].isMember("content")){
// ✅ 最终提取：拿到AI回复的纯文本内容
std::string replyContent = choice["message"]["content"].asString();
INFO("DeepSeekProvider response text: {}", replyContent);
return replyContent; // 返回结果，结束函数
}
}
}

完整代码：

std::string DeepSeekProvider::sendMessage(const std::vector<Message> &messages, const std::map<std::string, std::string> &requestParams)
{
if(!isAvailable()){
ERROR("DeepSeekProvider sendMessage model not available");
return "";
}

double temperature = 0.7;
int maxTokens = 2048;

if(requestParams.find("temperature") != requestParams.end()){
temperature = std::stod(requestParams.at("temperature"));
}
if(requestParams.find("max_tokens") != requestParams.end()){
maxTokens = std::stoi(requestParams.at("max_tokens"));
}

//根据以前的messages构建历史消息记录
Json::Value messageArray(Json::arrayValue);
for(const auto &msg : messages){
//INFO("Role: {}, Content: {}", msg._role, msg._content);
Json::Value messageJson;
messageJson["role"] = msg._role;
messageJson["content"] = msg._content;
messageArray.append(messageJson);
}

Json::Value requestJson;
requestJson["model"] = getModelName();
requestJson["messages"] = messageArray;
requestJson["temperature"] = temperature;
requestJson["max_tokens"] = maxTokens;

Json::StreamWriterBuilder writerBuilder;
writerBuilder["indentation"] = "";
std::string requestBodyStr = Json::writeString(writerBuilder, requestJson);
INFO("DeepSeekProvider sendMessage requestBody: {}", requestBodyStr);

httplib::Client cli(_endPoint.c_str());
cli.set_connection_timeout(30); // 连接超时30秒
cli.set_read_timeout(60); // 读取超时60秒

// 设置请求头
httplib::Headers headers = {
{"Authorization", "Bearer " + _apiKey},
{"Content-Type", "application/json"}
};
auto res = cli.Post("/v1/chat/completions", headers, requestBodyStr, "application/json");
if(!res){
ERROR("DeepSeekProvider sendMessage request failed, error: {}", httplib::to_string(res.error()));
return "";
}
INFO("DeepSeekProvider sendMessage POST request success, status : {}", res->status);
INFO("DeepSeekProvider sendMessage POST request success, body : {}", res->body);

// 检测响应是否成功
if(res->status != 200){
return "";
}

Json::Value responseBody;
Json::CharReaderBuilder readerBuilder;
std::string parseError;
std::istringstream responseStream(res->body);
if(Json::parseFromStream(readerBuilder, responseStream, &responseBody, &parseError)){
// 获取message数组
if(responseBody.isMember("choices") && responseBody["choices"].isArray() && !responseBody["choices"].empty()){
auto choice = responseBody["choices"][0];
if(choice.isMember("message") && choice["message"].isMember("content")){
std::string replyContent = choice["message"]["content"].asString();
INFO("DeepSeekProvider response text: {}", replyContent);
return replyContent;
}
}
}

// 8. json解析失败
ERROR("DeepSeekProvider sendMessage POST response body parse failed, error");
return "deepseek response json parse failed";

}

//DeepSeekProvider.cc
#include "../include/DeepSeekProvider.hpp"
#include "../include/util/myLog.hpp"
#include "../include/DeepSeekProvider.hpp"
#include <jsoncpp/json/json.h>
#include "../include/httplib.h"
#include <jsoncpp/json/reader.h>
namespace ai_chat_sdk
{
bool DeepSeekProvider::initModel(const std::map<std::string, std::string> &modelConfig){
auto it = modelConfig.find("api_key");
if(it != modelConfig.end()){
_apiKey = it->second;
} else {
ERROR("DeepSeekProvider initModel api_key not found");
return false;
}

it = modelConfig.find("end_point");
if(it != modelConfig.end()){
_endPoint = it->second;
} else {
_endPoint = "https://api.deepseek.com";
}
_isAvailable = true;
INFO("DeepSeekProvider initModel success, endpoint: {}",_endPoint);
return true;
}
bool DeepSeekProvider::isAvailable()
{
return _isAvailable;
}
std::string DeepSeekProvider::getModelName() const
{
return "deepseek-chat";
}
std::string DeepSeekProvider::getModelDesc() const{
return "一款实用性强、中文优化的通用对话助手，适合日常问答与创作";
}

std::string DeepSeekProvider::sendMessage(const std::vector<Message> &messages, const std::map<std::string, std::string> &requestParams)
{
if(!isAvailable()){
ERROR("DeepSeekProvider sendMessage model not available");
return "";
}

double temperature = 0.7;
int maxTokens = 2048;

if(requestParams.find("temperature") != requestParams.end()){
temperature = std::stod(requestParams.at("temperature"));
}
if(requestParams.find("max_tokens") != requestParams.end()){
maxTokens = std::stoi(requestParams.at("max_tokens"));
}

//根据以前的messages构建历史消息记录
Json::Value messageArray(Json::arrayValue);
for(const auto &msg : messages){
//INFO("Role: {}, Content: {}", msg._role, msg._content);
Json::Value messageJson;
messageJson["role"] = msg._role;
messageJson["content"] = msg._content;
messageArray.append(messageJson);
}

Json::Value requestJson;
requestJson["model"] = getModelName();
requestJson["messages"] = messageArray;
requestJson["temperature"] = temperature;
requestJson["max_tokens"] = maxTokens;

Json::StreamWriterBuilder writerBuilder;
writerBuilder["indentation"] = "";
std::string requestBodyStr = Json::writeString(writerBuilder, requestJson);
INFO("DeepSeekProvider sendMessage requestBody: {}", requestBodyStr);

httplib::Client cli(_endPoint.c_str());
cli.set_connection_timeout(30); // 连接超时30秒
cli.set_read_timeout(60); // 读取超时60秒

// 设置请求头
httplib::Headers headers = {
{"Authorization", "Bearer " + _apiKey},
{"Content-Type", "application/json"}
};
auto res = cli.Post("/v1/chat/completions", headers, requestBodyStr, "application/json");
if(!res){
ERROR("DeepSeekProvider sendMessage request failed, error: {}", httplib::to_string(res.error()));
return "";
}
INFO("DeepSeekProvider sendMessage POST request success, status : {}", res->status);
INFO("DeepSeekProvider sendMessage POST request success, body : {}", res->body);

// 检测响应是否成功
if(res->status != 200){
return "";
}

Json::Value responseBody;
Json::CharReaderBuilder readerBuilder;
std::string parseError;
std::istringstream responseStream(res->body);
if(Json::parseFromStream(readerBuilder, responseStream, &responseBody, &parseError)){
// 获取message数组
if(responseBody.isMember("choices") && responseBody["choices"].isArray() && !responseBody["choices"].empty()){
auto choice = responseBody["choices"][0];
if(choice.isMember("message") && choice["message"].isMember("content")){
std::string replyContent = choice["message"]["content"].asString();
INFO("DeepSeekProvider response text: {}", replyContent);
return replyContent;
}
}
}

// 8. json解析失败
ERROR("DeepSeekProvider sendMessage POST response body parse failed, error");
return "deepseek response json parse failed";

}
std::string DeepSeekProvider::sendMessageStream(const std::vector<Message> &messages,
const std::map<std::string, std::string> &requestParams,
std::function<void(const std::string &, bool)> callback)
{
if(!isAvailable()){
ERROR("DeepSeekProvider sendMessageStream model not available");
return "";
}

// 2. 构造请求参数
double temperature = 0.7;
int maxTokens = 2048;
if(requestParams.find("temperature") != requestParams.end()){
temperature = std::stod(requestParams.at("temperature"));
}
if(requestParams.find("max_tokens") != requestParams.end()){
maxTokens = std::stoi(requestParams.at("max_tokens"));
}

// 构造历史消息
Json::Value messageArray(Json::arrayValue);
for(const auto& message : messages){
Json::Value messageObject;
messageObject["role"] = message._role;
messageObject["content"] = message._content;
messageArray.append(messageObject);
}

// 3. 构造请求体
Json::Value requestBody;
requestBody["model"] = getModelName();
requestBody["messages"] = messageArray;
requestBody["temperature"] = temperature;
requestBody["max_tokens"] = maxTokens;
requestBody["stream"] = true;

// 4. 序列化
Json::StreamWriterBuilder writerBuilder;
writerBuilder["indentation"] = "";
std::string requestBodyStr = Json::writeString(writerBuilder, requestBody);
INFO("DeepSeekProvider sendMessageStream requestBody: {}", requestBodyStr);

// 5. 使用cpp-httplib库构造HTTP客户端
httplib::Client client(_endPoint.c_str());
client.set_connection_timeout(30, 0); // 连接超时时间为30秒
client.set_read_timeout(300, 0); // 流式响应需要更长的时间，设置超时时间为300秒

// 设置请求头
httplib::Headers headers = {
{"Authorization", "Bearer " + _apiKey},
{"Content-Type", "application/json"},
{"Accept", "text/event-stream"}
};

// 流式处理变量
std::string buffer; // 接受流式响应的数据块
bool gotError = false; // 标记响应是否成功
std::string errorMsg; // 错误描述符
int statusCode = 0; // 响应状态码
bool streamFinish = false; // 标记流式响应是否完成
std::string fullResponse; // 累积完整的响应

// 创建请求对象
httplib::Request req;
req.method = "POST";
req.path = "/v1/chat/completions";
req.headers = headers;
req.body = requestBodyStr;
// 设置响应处理器
req.response_handler = [&](const httplib::Response& res) {
if(res.status != 200){
gotError = true;
errorMsg = "HTTP status code: " + std::to_string(res.status);
return false; // 终止请求
}
return true; // 继续接收后续数据
};

// 设置数据接收处理器–解析流式响应的每个块的数据
req.content_receiver = [&](const char* data, size_t len, size_t offset, size_t totalLength){
// 验证响应头是否错误，如果出错就不需要再继续接收数据
if(gotError){
return false;
}

// 追加数据到buffer
buffer.append(data, len);
INFO("DeepSeekProvider sendMessageStream buffer: {}", buffer);

// 处理所有的流式响应的数据块，注意：数据块之间是一个\\n\\n分隔
size_t pos= 0;
while((pos = buffer.find("\\n\\n")) != std::string::npos){
// 截取当前找到的数据块
std::string chunk = buffer.substr(0, pos);
buffer.erase(0, pos + 2);

// 解析该块响应数据的中模型返回的有效数据
// 处理空行和注释，注意：以:开头的行是注释行，需要忽略
if(chunk.empty() || chunk[0] == ':'){
continue;
}

// 获取模型返回的有效数据
if(chunk.compare(0, 6, "data: ") == 0){
std::string modelData = chunk.substr(6);

// 检测是否为结束标记
if(modelData == "[DONE]"){
callback("", true);
streamFinish = true;
return true;
}

// 反序列化
Json::Value modelDataJson;
Json::CharReaderBuilder reader;
std::string errors;
std::istringstream modelDataStream(modelData);
if(Json::parseFromStream(reader, modelDataStream, &modelDataJson, &errors)){
// 模型返回的json格式的数据现在就保存在modelDataJson
if(modelDataJson.isMember("choices") &&
modelDataJson["choices"].isArray() &&
!modelDataJson["choices"].empty() &&
modelDataJson["choices"][0].isMember("delta") &&
modelDataJson["choices"][0]["delta"].isMember("content")){
std::string content = modelDataJson["choices"][0]["delta"]["content"].asString();
// 处理deltaContent，例如追加到fullResponse
fullResponse += content;

// 将本次解析出的模型返回的有效数据转给调用sendMessageStraem函数的用户使用—callback
callback(content, false);
}
}else{
WARN("DeepSeekProvider sendMessageStream parse modelDataJson error: {}", errors);
}
}
}
return true;
};

// 给模型发送请求
auto result = client.send(req);
if(!result){
// 请求发送失败，出现网络问题，比如DNS解析失败、连接超时
ERROR("Network error {}", to_string(result.error()));
return "";
}

// 确保流式操作正确结束
if(!streamFinish){
WARN("stream ended without [DONE] marker");
callback("", true);
}

return fullResponse;
}
} // end ai_chat_sdk

流式响应

关于流式响应我们这里用的是SSE协议，流式响应在这里的使用方法就是客户端一次请求，服务端分多次把完整的数据发过来，即所谓的流式，具体介绍如下：

/v1/chat/completions + stream=true 是 text/event-stream (简称SSE) 协议，这是大模型流式输出的事实标准协议（OpenAI/DeepSeek/Anthropic 全用它），不是普通的HTTP JSON响应，这是理解流式的前提：

cpp-httplib 实现流式响应的核心：两个回调函数 cpp-httplib 是一个轻量但功能完整的C++ HTTP客户端库，它对流式HTTP响应的支持，完全依赖两个核心回调， 回调1：req.response_handler —— 响应头回调（只执行1次）

req.response_handler = [&](const httplib::Response& res) {
if(res.status != 200){
gotError = true;
errorMsg = "HTTP status code: " + std::to_string(res.status);
return false; // 终止请求
}
return true; // 继续接收后续数据
};

作用&执行时机

回调2：req.content_receiver —— 流式数据体回调（核心！执行N次）

req.content_receiver = [&](const char* data, size_t len, size_t offset, size_t totalLength){
// 流式数据解析逻辑
};

服务端返回的流式数据体会被拆分成多个二进制数据块，每收到一小块数据，这个回调就会被执行一次，直到：

• 服务端推送完所有数据、主动关闭连接；
• 回调内部返回 false 主动终止；
• 超时/网络异常中断。

比如大模型返回100个字，会拆成10次推送，这个回调就执行10次，每次拿到10个字左右的二进制数据。

回到我们的代码中： 先要设置http头部字段，要设置流式字段

// 设置请求头
httplib::Headers headers = {
{"Authorization", "Bearer " + _apiKey},
{"Content-Type", "application/json"},
{"Accept", "text/event-stream"} //设置流式响应
};

后面就是设置了两个关键的回调函数： 这个是首次返回的时候执行一次的会回调函数，用于决定是否继续接收后面的信息，返回true表示继续接收反之直接停止，不再接收。下面的函数就是判断返回的htto状态码是不是 200，是则继续接收，反之停止。

// 设置响应处理器
req.response_handler = [&](const httplib::Response& res) {
if(res.status != 200){
gotError = true;
errorMsg = "HTTP status code: " + std::to_string(res.status);
return false; // 终止请求
}
return true; // 继续接收后续数据
};

下面这个是第二个重要回调，用于每次收到服务端发来的消息片段的处理。 这个回调函数就是把全量返回获取响应消息中的message的流程干了一边，然后每次提取到消息之后执行一下函数形参设置的回调函数而已，这个回调函数其实就是ChatServer用来流式发给前端的。

// 设置数据接收处理器–解析流式响应的每个块的数据
req.content_receiver = [&](const char* data, size_t len, size_t offset, size_t totalLength){
// 验证响应头是否错误，如果出错就不需要再继续接收数据
if(gotError){
return false;
}

// 追加数据到buffer
buffer.append(data, len);
INFO("DeepSeekProvider sendMessageStream buffer: {}", buffer);

// 处理所有的流式响应的数据块，注意：数据块之间是一个\\n\\n分隔
size_t pos= 0;
while((pos = buffer.find("\\n\\n")) != std::string::npos){
// 截取当前找到的数据块
std::string chunk = buffer.substr(0, pos);
buffer.erase(0, pos + 2);

// 解析该块响应数据的中模型返回的有效数据
// 处理空行和注释，注意：以:开头的行是注释行，需要忽略
if(chunk.empty() || chunk[0] == ':'){
continue;
}

// 获取模型返回的有效数据
if(chunk.compare(0, 6, "data: ") == 0){
std::string modelData = chunk.substr(6);

// 检测是否为结束标记
if(modelData == "[DONE]"){
callback("", true);
streamFinish = true;
return true;
}

// 反序列化
Json::Value modelDataJson;
Json::CharReaderBuilder reader;
std::string errors;
std::istringstream modelDataStream(modelData);
if(Json::parseFromStream(reader, modelDataStream, &modelDataJson, &errors)){
// 模型返回的json格式的数据现在就保存在modelDataJson
if(modelDataJson.isMember("choices") &&
modelDataJson["choices"].isArray() &&
!modelDataJson["choices"].empty() &&
modelDataJson["choices"][0].isMember("delta") &&
modelDataJson["choices"][0]["delta"].isMember("content")){
std::string content = modelDataJson["choices"][0]["delta"]["content"].asString();
// 处理deltaContent，例如追加到fullResponse
fullResponse += content;

// 将本次解析出的模型返回的有效数据转给调用sendMessageStraem函数的用户使用—callback
callback(content, false);
}
}else{
WARN("DeepSeekProvider sendMessageStream parse modelDataJson error: {}", errors);
}
}
}
return true;
};

完整代码：

std::string DeepSeekProvider::sendMessageStream(const std::vector<Message> &messages,
const std::map<std::string, std::string> &requestParams,
std::function<void(const std::string &, bool)> callback)
{
if(!isAvailable()){
ERROR("DeepSeekProvider sendMessageStream model not available");
return "";
}

// 2. 构造请求参数
double temperature = 0.7;
int maxTokens = 2048;
if(requestParams.find("temperature") != requestParams.end()){
temperature = std::stod(requestParams.at("temperature"));
}
if(requestParams.find("max_tokens") != requestParams.end()){
maxTokens = std::stoi(requestParams.at("max_tokens"));
}

// 构造历史消息
Json::Value messageArray(Json::arrayValue);
for(const auto& message : messages){
Json::Value messageObject;
messageObject["role"] = message._role;
messageObject["content"] = message._content;
messageArray.append(messageObject);
}

// 3. 构造请求体
Json::Value requestBody;
requestBody["model"] = getModelName();
requestBody["messages"] = messageArray;
requestBody["temperature"] = temperature;
requestBody["max_tokens"] = maxTokens;
requestBody["stream"] = true;

// 4. 序列化
Json::StreamWriterBuilder writerBuilder;
writerBuilder["indentation"] = "";
std::string requestBodyStr = Json::writeString(writerBuilder, requestBody);
INFO("DeepSeekProvider sendMessageStream requestBody: {}", requestBodyStr);

// 5. 使用cpp-httplib库构造HTTP客户端
httplib::Client client(_endPoint.c_str());
client.set_connection_timeout(30, 0); // 连接超时时间为30秒
client.set_read_timeout(300, 0); // 流式响应需要更长的时间，设置超时时间为300秒

// 设置请求头
httplib::Headers headers = {
{"Authorization", "Bearer " + _apiKey},
{"Content-Type", "application/json"},
{"Accept", "text/event-stream"}
};

// 流式处理变量
std::string buffer; // 接受流式响应的数据块
bool gotError = false; // 标记响应是否成功
std::string errorMsg; // 错误描述符
int statusCode = 0; // 响应状态码
bool streamFinish = false; // 标记流式响应是否完成
std::string fullResponse; // 累积完整的响应

// 创建请求对象
httplib::Request req;
req.method = "POST";
req.path = "/v1/chat/completions";
req.headers = headers;
req.body = requestBodyStr;
// 设置响应处理器
req.response_handler = [&](const httplib::Response& res) {
if(res.status != 200){
gotError = true;
errorMsg = "HTTP status code: " + std::to_string(res.status);
return false; // 终止请求
}
return true; // 继续接收后续数据
};

// 设置数据接收处理器–解析流式响应的每个块的数据
req.content_receiver = [&](const char* data, size_t len, size_t offset, size_t totalLength){
// 验证响应头是否错误，如果出错就不需要再继续接收数据
if(gotError){
return false;
}

// 追加数据到buffer
buffer.append(data, len);
INFO("DeepSeekProvider sendMessageStream buffer: {}", buffer);

// 处理所有的流式响应的数据块，注意：数据块之间是一个\\n\\n分隔
size_t pos= 0;
while((pos = buffer.find("\\n\\n")) != std::string::npos){
// 截取当前找到的数据块
std::string chunk = buffer.substr(0, pos);
buffer.erase(0, pos + 2);

// 解析该块响应数据的中模型返回的有效数据
// 处理空行和注释，注意：以:开头的行是注释行，需要忽略
if(chunk.empty() || chunk[0] == ':'){
continue;
}

// 获取模型返回的有效数据
if(chunk.compare(0, 6, "data: ") == 0){
std::string modelData = chunk.substr(6);

// 检测是否为结束标记
if(modelData == "[DONE]"){
callback("", true);
streamFinish = true;
return true;
}

// 反序列化
Json::Value modelDataJson;
Json::CharReaderBuilder reader;
std::string errors;
std::istringstream modelDataStream(modelData);
if(Json::parseFromStream(reader, modelDataStream, &modelDataJson, &errors)){
// 模型返回的json格式的数据现在就保存在modelDataJson
if(modelDataJson.isMember("choices") &&
modelDataJson["choices"].isArray() &&
!modelDataJson["choices"].empty() &&
modelDataJson["choices"][0].isMember("delta") &&
modelDataJson["choices"][0]["delta"].isMember("content")){
std::string content = modelDataJson["choices"][0]["delta"]["content"].asString();
// 处理deltaContent，例如追加到fullResponse
fullResponse += content;

// 将本次解析出的模型返回的有效数据转给调用sendMessageStraem函数的用户使用—callback
callback(content, false);
}
}else{
WARN("DeepSeekProvider sendMessageStream parse modelDataJson error: {}", errors);
}
}
}
return true;
};

// 给模型发送请求
auto result = client.send(req);
if(!result){
// 请求发送失败，出现网络问题，比如DNS解析失败、连接超时
ERROR("Network error {}", to_string(result.error()));
return "";
}

// 确保流式操作正确结束
if(!streamFinish){
WARN("stream ended without [DONE] marker");
callback("", true);
}

return fullResponse;
}

5. 测试DeepSeek接口是否成功

这是当时测试的cmake和main.cc以及运行结果截图，不多赘述，大家可以自己测一测： 运行前记得设置自己的deepseek apikey环境变量，各位可以去deepseek官网弄一下，比较简单不多说了。

终端执行：

export deepseek_apikey="你的deepseek apikey"

cmake:

# 设置Cmake的最小版本
cmake_minimum_required(VERSION 3.10)

# 项目名称
project(testLLM)

# 设置C++标准
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)

# 设置构建类型Debug
set(CMAKE_BUILD_TYPE Debug)

# 添加可执行文件
add_executable(testLLM testLLM.cc
../sdk/src/util/myLog.cc
../sdk/src/DeepSeekProvider.cc
)

# 设置输出目录
set(EXECUTABLE_OUTPUT_PATH ${CMAKE_BINARY_DIR})

# 添加头文件搜索路劲
include_directories(${CMAKE_SOURCE_DIR}/../sdk/include)

find_package(OpenSSL REQUIRED)
include_directories(${OPENSSL_INCLUDE_DIR})

# 添加CPPHTTPLIB_OPENSSL_SUPPORT定义
target_compile_definitions(testLLM PRIVATE CPPHTTPLIB_OPENSSL_SUPPORT)

# 链接库
target_link_libraries(testLLM pthread jsoncpp fmt spdlog gtest OpenSSL::SSL OpenSSL::Crypto)

testLLM.cc:

#include "../sdk/include/DeepSeekProvider.hpp"
#include <iostream>
#include <gtest/gtest.h>
#include "../sdk/include/util/myLog.hpp"
TEST(DeepSeekProviderTest, sendMessage){
auto provider = std::make_shared<ai_chat_sdk::DeepSeekProvider>();
ASSERT_TRUE(provider != nullptr);

std::map<std::string, std::string> modelParam;
modelParam["api_key"] = std::getenv("deepseek_apikey");
modelParam["endpoint"] = "https://api.deepseek.com";

provider->initModel(modelParam);
ASSERT_TRUE(provider->isAvailable());

std::map<std::string, std::string> requestParam = {
{"temperature", "0.7"},
{"max_tokens", "2048"}
};
std::vector<ai_chat_sdk::Message> messages;
messages.push_back({"user", "你是谁？"});

// 实例化DeepSeekProvider的对象
// 调用sendMessage方法
std::string response = provider->sendMessage(messages, requestParam);
ASSERT_FALSE(response.empty());
INFO("fulldata : {}", response);
// auto writeChunk = [&](const std::string& chunk, bool last){
// INFO("chunk : {}", chunk);
// if(last){
// INFO("[DONE]");
// }
// };
// std::string fullData = provider->sendMessageStream(messages, requestParam, writeChunk);
// ASSERT_FALSE(fullData.empty());
// INFO("response : {}", fullData);
}
int main(int argc, char **argv) {
lg::Logger::initLogger("testLLM", "stdout", spdlog::level::debug);
::testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}

运行结果：

6. LLMManager类

LLMManager 是AI聊天SDK的核心管理类、统一入口类，采用管理者设计模式，对底层各类大模型提供商（如DeepSeekProvider）做统一封装与调度，向上层提供标准化的大模型调用接口，屏蔽不同大模型的底层实现差异，是整个SDK的调度中枢。

核心作用：统一管理所有大模型的注册、初始化、可用性校验，以及统一转发全量/流式消息请求，提供极简、统一的调用入口，该类主要是放到ChatSDK类里面使用的，ChatSDK里面会有一个 LLMManager对象，要调用什么模型直接通过这个对象调用就行。

以下是所有业务：

以下是简要介绍，不是很难，不多赘述，

这样设计的优势 该类是上层业务与底层大模型的中间层，上层业务无需关注具体大模型的对接细节，只需通过该类的统一接口即可完成所有操作，做到一次调用、适配所有模型，极大降低上层接入成本。

调用逻辑 业务层调用流程：注册模型 → 初始化模型 → 校验可用性 → 发起全量/流式请求，所有操作均通过该类完成，逻辑闭环且职责单一。

完整代码：

#pragma once
#include <map>
#include <memory>
#include "LLMProvider.hpp"

namespace ai_chat_sdk {
class LLMManager {
public:
bool registerProvider(const std::string& providerName,std::unique_ptr<LLMProvider> provider);

bool initModel(const std::string& providerName, const std::map<std::string, std::string>& modelParam);

std::vector<ModelInfo> getAvailableModels()const;

bool isModelAvailable(const std::string& modelName)const;

std::string sendMessage(const std::string& modelName, const std::vector<Message>& messages, const std::map<std::string, std::string>& requestParam);

std::string sendMessageStream(const std::string& modelName, const std::vector<Message>& messages, const std::map<std::string, std::string>& requestParam, std::function<void(const std::string&, bool)>& callback);

LLMManager() = default;

private:
std::map<std::string, std::unique_ptr<LLMProvider>> _providers;
std::map<std::string, ModelInfo> _modelInfos;
};
} // end ai_chat_sdk

#include "../include/LLMManager.hpp"
#include "../include/util/myLog.hpp"
#include "../include/common.hpp"

namespace ai_chat_sdk {
// 注册LLM提供者
bool LLMManager::registerProvider(const std::string& modelName, std::unique_ptr<LLMProvider> provider){
// 参数检测
if(!provider){
ERROR("cannot register nullptr provider, modelName = {}", modelName);
return false;
}

// 注意：unique_ptr是防拷贝的，此处只能通过move的方式将资源转移给当前对象
_providers[modelName] = std::move(provider);

// 添加模型信息
_modelInfos[modelName] = ModelInfo(modelName);

// 模型初始化成功
INFO("register provider success, modelName = {}", modelName);
return true;
}

// 初始化指定模型
bool LLMManager::initModel(const std::string& modelName, const std::map<std::string, std::string>& modelParam){
// 检测模型是否注册
auto it = _providers.find(modelName);
if(it == _providers.end()){
ERROR("model provider not found, modelName = {}", modelName);
return false;
}

// 模型已经注册成功，可以初始化该模型
bool isSuccess = it->second->initModel(modelParam);
if(!isSuccess){
ERROR("init model failed, modelName = {}", modelName);
}else{
INFO("init model success, modelName = {}", modelName);
_modelInfos[modelName]._modelDesc = it->second->getModelDesc();
_modelInfos[modelName]._isAvailable = true;
}

return isSuccess;
}

// 获取可用模型
std::vector<ModelInfo> LLMManager::getAvailableModels()const{
std::vector<ModelInfo> models;
for(const auto& pair : _modelInfos){
if(pair.second._isAvailable){
models.push_back(pair.second);
}
}
return models;
}

// 检查模型是否可用
bool LLMManager::isModelAvailable(const std::string& modelName)const{
auto it = _modelInfos.find(modelName);
if(it == _modelInfos.end()){
return false;
}

return it->second._isAvailable;
}

// 发送消息给指定模型
std::string LLMManager::sendMessage(const std::string& modelName, const std::vector<Message>& messages, const std::map<std::string, std::string>& requestParam){
// 检测模型是否注册
auto it = _providers.find(modelName);
if(it == _providers.end()){
ERROR("model provider not found, modelName = {}", modelName);
return "";
}

// 检测模型是否可用
if(!it->second->isAvailable()){
ERROR("model not available, modelName = {}", modelName);
return "";
}

// 模型已经注册，并且已经初始化成功
return it->second->sendMessage(messages, requestParam);
}

// 发送消息流给指定模型
std::string LLMManager::sendMessageStream(const std::string& modelName, const std::vector<Message>& messages, const std::map<std::string, std::string>& requestParam, std::function<void(const std::string&, bool)>& callback){
// 检测模型是否注册
auto it = _providers.find(modelName);
if(it == _providers.end()){
ERROR("model provider not found, modelName = {}", modelName);
return "";
}

// 检测模型是否可用
if(!it->second->isAvailable()){
ERROR("model not available, modelName = {}", modelName);
return "";
}

// 模型已经注册，并且已经初始化成功
return it->second->sendMessageStream(messages, requestParam, callback);
}
}

7. 不接入DataManager的SessionManager

这里的SessionManager即会话管理，这里的会话就是大家每次用ai的时候这个对话用完想要新建一个对话的对话（这里表述好像有点小绕），看图片一目了然如图：就这个东西。 所有的一切都是围绕这个展开的，具体包括会话的获取、创建、删除、更新时间戳、清空以及增加消息。

所谓不接入DataManager的SessionManager就是没接入数据库，所有操作都是在内存中进行的，后续我们写完DataManager之后再完善这个类。 具体实现就不多介绍了，都很简单，也没啥陌生的语法。

全部代码：

#pragma once
#include <atomic>
#include <unordered_map>
#include <mutex>
#include <memory>
#include <map>
#include "DataManager.hpp"
#include "common.hpp"
namespace ai_chat_sdk {
class SessionManager {
public:
static SessionManager& getInstance() {
static SessionManager instance;
return instance;
}
std::string createSession(const std::string& modelName);
std::shared_ptr<Session> getSession(const std::string& sessionId);
bool addMessage(const std::string& sessionId, const Message& message);
std::vector<Message> getHistroyMessages(const std::string& sessionId) const;
std::vector<std::string> getSessionLists() const;
bool deleteSession(const std::string& sessionId);
void updateSessionTimestamp(const std::string& sessionId);
void clearAllSessions();
size_t getSessionCount() const;

private:
SessionManager() = default;
SessionManager(const SessionManager&) = delete;
SessionManager &operator=(const SessionManager &) = delete;
// ⽣成唯⼀会话id 返回会话id
std::string generateSessionId();
// ⽣成唯⼀消息id 返回消息id
std::string generateMessageId();

private:
std::unordered_map<std::string, std::shared_ptr<Session>> _sessions;
mutable std::mutex _mutex; // 在const成员函数中，可能会修改所的状态，因此需要
static std::atomic<int64_t> _message_counter; // 记录所有会话中消息总数
static std::atomic<int64_t> _session_counter; // 记录会话总数
};
} // end ai_chat_sdk

#include "../include/SessionManager.hpp"
#include "../include/util/myLog.hpp"
#include <iomanip>
#include <sstream>
namespace ai_chat_sdk
{
std::atomic<int64_t> SessionManager::_message_counter{0};
std::atomic<int64_t> SessionManager::_session_counter{0};
std::string SessionManager::createSession(const std::string &modelName){
std::unique_lock<std::mutex> lock(_mutex);
std::string sessionId = generateSessionId();
auto session = std::make_shared<Session>(modelName);
session->_sessionId = sessionId;
_sessions[sessionId] = session;
INFO("create session, session_id: {}, model_name: {}", sessionId,modelName);
return sessionId;
}
std::shared_ptr<Session> SessionManager::getSession(const std::string &sessionId){
std::unique_lock<std::mutex> lock(_mutex);
auto it = _sessions.find(sessionId);
if (it != _sessions.end()) {
return it->second;
}
return nullptr;
}
bool SessionManager::addMessage(const std::string &sessionId, const Message &message){
std::unique_lock<std::mutex> lock(_mutex);
auto it = _sessions.find(sessionId);
if (it != _sessions.end()) {
Message msg = message;
msg._messageId = generateMessageId();
msg._timestamp = std::time(nullptr);
it->second->_messages.push_back(msg);
it->second->_updateTime = std::time(nullptr);
INFO("add message, session_id: {}, message_id: {}", sessionId, msg._messageId);
return true;
}
return false;
}
std::vector<Message> SessionManager::getHistroyMessages(const std::string &sessionId) const{
std::unique_lock<std::mutex> lock(_mutex);
auto it = _sessions.find(sessionId);
if (it != _sessions.end()) {
return it->second->_messages;
}
return {};
}
std::vector<std::string> SessionManager::getSessionLists() const
{
std::unique_lock<std::mutex> lock(_mutex);
std::vector<std::pair<std::time_t, std::shared_ptr<const Session>>> temp;
temp.reserve(_sessions.size());
// 填充临时会话
for (const auto &pair : _sessions)
{
const auto &sessionPtr = pair.second;
temp.emplace_back(sessionPtr->_updateTime, sessionPtr);
}
// 按更新时间排序, > 排降序
std::sort(temp.begin(), temp.end(), [](const auto &a, const auto &b)
{ return a.first > b.first; });
// 构造返回列表
std::vector<std::string> session_ids;
session_ids.reserve(temp.size());
for (const auto &item : temp)
{
session_ids.push_back(item.second->_sessionId);
}
return session_ids;
}
bool SessionManager::deleteSession(const std::string &sessionId)
{
std::unique_lock<std::mutex> lock(_mutex);
auto it = _sessions.find(sessionId);
if (it != _sessions.end()) {
_sessions.erase(it);
INFO("delete session, session_id: {}", sessionId);
return true;
}
INFO("session {} not found for delete", sessionId);
return false;
}
void SessionManager::updateSessionTimestamp(const std::string &sessionId){
std::unique_lock<std::mutex> lock(_mutex);
auto it = _sessions.find(sessionId);
if (it != _sessions.end()) {
it->second->_updateTime = std::time(nullptr);
INFO("update session timestamp, session_id: {}", sessionId);
}
}
void SessionManager::clearAllSessions(){
std::unique_lock<std::mutex> lock(_mutex);
_sessions.clear();
INFO("clear all sessions");
}
size_t SessionManager::getSessionCount() const{
std::unique_lock<std::mutex> lock(_mutex);
return _sessions.size();
}

// ⽣成唯⼀会话id 返回会话id
std::string SessionManager::generateSessionId()
{
// 会话计数⾃增
_session_counter.fetch_add(1);
std::time_t time = std::time(nullptr);
// 会话id格式：session_时间戳_会话计数
std::ostringstream os;
os << "session_" << time << "_" << std::setfill('0') << std::setw(8) << _session_counter;
return os.str();
}
// ⽣成唯⼀消息id 返回消息id
std::string SessionManager::generateMessageId()
{
// 消息计数⾃增
_message_counter.fetch_add(1);
std::time_t time = std::time(nullptr);
// 消息id格式：msg_时间戳_消息计数
std::ostringstream os;
os << "msg_" << time << "_" << std::setfill('0') << std::setw(8) << _message_counter;
return os.str();
}
} // end ai_chat_sdk

8. DataManager类

DataManager类是基于sqlite3原生C接口实现的 会话+消息 数据库持久化管理类，是AI聊天SDK的本地数据层，负责会话、聊天消息的增删改查。

成员变量：

• 私有成员：sqlite3* _db(数据库句柄)、std::string _dbName(数据库文件路径)、mutable std::mutex _mutex(线程安全锁，所有操作加锁，支持多线程调用)
• 构造函数：打开指定sqlite数据库文件，调用initDataBase()初始化表结构；析构函数安全关闭数据库句柄。

数据库表设计：

• sessions 会话表：主键session_id，存储会话ID、模型名、创建时间、更新时间；
• messages 消息表：主键message_id，外键session_id关联会话表，存储消息ID、角色(role)、消息内容、时间戳；
• 外键特性：ON DELETE CASCADE 级联删除 → 删除会话时，关联的所有消息自动删除，无需手动删消息。

工具函数：

• initDataBase()：创建会话/消息两张表（CREATE TABLE IF NOT EXISTS 幂等创建，避免重复建表报错）；
• executeSQL()：执行无返回值的原生SQL（建表/清空表等），封装sqlite3_exec，包含错误日志与内存释放。

封装会话全量CRUD：插入会话、查询单个会话（自动加载关联消息）、更新会话时间戳、删除会话、查询所有会话ID/会话列表、统计会话数、清空所有会话；

封装消息全量CRUD：插入消息（插入时自动更新会话最新时间戳）、查询指定会话的所有消息、删除指定会话的消息；

再细的具体实现大家就直接看代码吧，也不难。

全部代码：

#pragma once
#include <string>
#include <vector>
#include <memory>
#include <mutex>
#include <sqlite3.h>
#include "common.hpp"
namespace ai_chat_sdk
{
class DataManager
{
public:
DataManager(const std::string &dbName);
~DataManager();

// Session相关操作
// 插入新会话
bool insertSession(const Session &session);
// 获取指定会话信息
std::shared_ptr<Session> getSession(const std::string &sessionId) const;
// 更新指定会话的时间戳
bool updateSessionTimestamp(const std::string &sessionId, std::time_t timestamp);
// 删除指定会话–注意：删除会话时，也需要删除该会话中管理的所有的消息
bool deleteSession(const std::string &sessionId);
// 获取所有会话id
std::vector<std::string> getAllSessionIds() const;
// 获取所有会话信息
std::vector<std::shared_ptr<Session>> getAllSessions() const;
// 删除所有会话
bool clearAllSessions();
// 获取会话总数
size_t getSessionCount() const;
////////////////////////////////////////////////////////////////////
// Message相关操作
// 插入新消息–注意：插入消息时，需要更新会话的时间戳
bool insertMessage(const std::string &sessionId, const Message &message);
// 获取指定会话的历史消息
std::vector<Message> getSessionMessages(const std::string &sessionId) const;
// 删除指定会话的所有消息
bool deleteSessionMessages(const std::string &sessionId);

private:
// 初始化数据库 — 创建数据库表
bool initDataBase();
// 执行SQL语句的工具函数
bool executeSQL(const std::string &sql);

private:
sqlite3 *_db;
std::string _dbName;
mutable std::mutex _mutex;
};
} // end ai_chat_sdk

#include "../include/DataManager.hpp"
#include "../include/util/myLog.hpp"
namespace ai_chat_sdk
{
DataManager::DataManager(const std::string &dbName)
: _dbName(dbName), _db(nullptr)
{
// 创建并打开数据库
int rc = sqlite3_open(dbName.c_str(), &_db);
if (rc != SQLITE_OK)
{
ERROR("打开数据库失败：{}", sqlite3_errmsg(_db));
}
INFO("打开数据库成功：{}", dbName);

// 初始化数据库表 – 创建会话表和消息表
if (!initDataBase())
{
sqlite3_close(_db);
_db = nullptr;
ERROR("初始化数据库表失败");
}
}

DataManager::~DataManager()
{
if (_db)
{
sqlite3_close(_db);
}
}

// 初始化数据库
bool DataManager::initDataBase()
{
// 创建会话表
std::string createSessionTable = R"(
CREATE TABLE IF NOT EXISTS sessions (
session_id TEXT PRIMARY KEY,
model_name TEXT NOT NULL,
create_time INTEGER NOT NULL,
update_time INTEGER NOT NULL
);
)";

// 执行创建Sessions表的SQL语句
if (!executeSQL(createSessionTable))
{
return false;
}

// 创建消息表
std::string createMessageTable = R"(
CREATE TABLE IF NOT EXISTS messages (
message_id TEXT PRIMARY KEY,
session_id TEXT NOT NULL,
role TEXT NOT NULL,
content TEXT NOT NULL,
timestamp INTEGER NOT NULL,
FOREIGN KEY (session_id) REFERENCES sessions(session_id) ON DELETE CASCADE
);
)";

// 执行创建Messages表的SQL语句
if (!executeSQL(createMessageTable))
{
return false;
}

return true;
}

bool DataManager::executeSQL(const std::string &sql)
{
if (!_db)
{
ERROR("数据库未初始化");
return false;
}

char *errMsg = nullptr;
int rc = sqlite3_exec(_db, sql.c_str(), nullptr, nullptr, &errMsg);
if (rc != SQLITE_OK)
{
ERROR("执行SQL语句失败: {}", errMsg);
sqlite3_free(errMsg);
return false;
}

return true;
}

// 插入会话
bool DataManager::insertSession(const Session &session)
{
std::lock_guard<std::mutex> lock(_mutex);

// 构建SQL语句
std::string insertSQL = R"(
INSERT INTO sessions (session_id, model_name, create_time, update_time)
VALUES (?, ?, ?, ?);
)";

// 准备SQL语句
sqlite3_stmt *stmt;
int rc = sqlite3_prepare_v2(_db, insertSQL.c_str(), –1, &stmt, nullptr);
if (rc != SQLITE_OK)
{
ERROR("insertSession – 准备语句失败：{}", sqlite3_errmsg(_db));
return false;
}

// 绑定参数
sqlite3_bind_text(stmt, 1, session._sessionId.c_str(), –1, SQLITE_TRANSIENT);
sqlite3_bind_text(stmt, 2, session._modelName.c_str(), –1, SQLITE_TRANSIENT);
sqlite3_bind_int64(stmt, 3, static_cast<int64_t>(session._createTime));
sqlite3_bind_int64(stmt, 4, static_cast<int64_t>(session._updateTime));

// 执行SQL语句
rc = sqlite3_step(stmt);
if (rc != SQLITE_DONE)
{
ERROR("insertSession – 执行语句失败：{}", sqlite3_errmsg(_db));
sqlite3_finalize(stmt);
return false;
}
// 释放语句
sqlite3_finalize(stmt);
INFO("insertSession – 插入会话成功：{}", session._sessionId);
return true;
}

// 获取指定sessionId的会话信息
std::shared_ptr<Session> DataManager::getSession(const std::string &sessionId) const
{

std::lock_guard<std::mutex> lock(_mutex);

// 构建SQL语句
std::string selectSQL = R"(
SELECT model_name, create_time, update_time FROM sessions WHERE session_id = ?;
)";

// 准备SQL语句
sqlite3_stmt *stmt;
int rc = sqlite3_prepare_v2(_db, selectSQL.c_str(), –1, &stmt, nullptr);
if (rc != SQLITE_OK)
{
ERROR("getSession – 准备语句失败：{}", sqlite3_errmsg(_db));
return nullptr;
}

// 绑定参数
sqlite3_bind_text(stmt, 1, sessionId.c_str(), –1, SQLITE_TRANSIENT);

// 执行SQL语句
rc = sqlite3_step(stmt);
if (rc != SQLITE_DONE)
{
ERROR("getSession – 执行语句失败：{}", sqlite3_errmsg(_db));
sqlite3_finalize(stmt);
return nullptr;
}

// 从结果集中提取数据
std::string modelName = reinterpret_cast<const char *>(sqlite3_column_text(stmt, 0));
int64_t createTime = sqlite3_column_int64(stmt, 1);
int64_t updateTime = sqlite3_column_int64(stmt, 2);

// 创建会话对象
auto session = std::make_shared<Session>(modelName);
session->_sessionId = sessionId;
session->_createTime = static_cast<std::time_t>(createTime);
session->_updateTime = static_cast<std::time_t>(updateTime);

// 释放语句
sqlite3_finalize(stmt);
INFO("getSession – 获取会话成功：{}", sessionId);

// 获取该会话的所有消息
session->_messages = getSessionMessages(sessionId);

return session;
}

// 更新指定会话的时间戳
bool DataManager::updateSessionTimestamp(const std::string &sessionId, std::time_t timestamp)
{
std::lock_guard<std::mutex> lock(_mutex);

// 构建SQL语句
std::string updateSQL = R"(
UPDATE sessions SET update_time = ? WHERE session_id = ?;
)";

// 准备SQL语句
sqlite3_stmt *stmt;
int rc = sqlite3_prepare_v2(_db, updateSQL.c_str(), –1, &stmt, nullptr);
if (rc != SQLITE_OK)
{
ERROR("updateSessionTimestamp – 准备语句失败：{}", sqlite3_errmsg(_db));
return false;
}

// 绑定参数
sqlite3_bind_int64(stmt, 1, static_cast<int64_t>(timestamp));
sqlite3_bind_text(stmt, 2, sessionId.c_str(), –1, SQLITE_TRANSIENT);

// 执行SQL语句
rc = sqlite3_step(stmt);
if (rc != SQLITE_DONE)
{
ERROR("updateSessionTimestamp – 执行语句失败：{}", sqlite3_errmsg(_db));
sqlite3_finalize(stmt);
return false;
}

// 释放语句
sqlite3_finalize(stmt);
INFO("updateSessionTimestamp – 更新会话时间戳成功：{}", sessionId);
return true;
}

// 删除指定会话
bool DataManager::deleteSession(const std::string &sessionId)
{
std::lock_guard<std::mutex> lock(_mutex);

// 构建SQL语句
std::string deleteSQL = R"(
DELETE FROM sessions WHERE session_id = ?;
)";

// 准备SQL语句
sqlite3_stmt *stmt;
int rc = sqlite3_prepare_v2(_db, deleteSQL.c_str(), –1, &stmt, nullptr);
if (rc != SQLITE_OK)
{
ERROR("deleteSession – 准备语句失败：{}", sqlite3_errmsg(_db));
return false;
}

// 绑定参数
sqlite3_bind_text(stmt, 1, sessionId.c_str(), –1, SQLITE_TRANSIENT);

// 执行SQL语句
rc = sqlite3_step(stmt);
if (rc != SQLITE_DONE)
{
ERROR("deleteSession – 执行语句失败：{}", sqlite3_errmsg(_db));
sqlite3_finalize(stmt);
return false;
}

// 释放语句
sqlite3_finalize(stmt);
INFO("deleteSession – 删除会话成功：{}", sessionId);
return true;
}

// 获取所有会话id
std::vector<std::string> DataManager::getAllSessionIds() const
{
std::lock_guard<std::mutex> lock(_mutex);

// 构建SQL语句
std::string selectSQL = R"(
SELECT session_id FROM sessions ORDER BY update_time DESC;
)";

// 准备SQL语句
sqlite3_stmt *stmt;
int rc = sqlite3_prepare_v2(_db, selectSQL.c_str(), –1, &stmt, nullptr);
if (rc != SQLITE_OK)
{
ERROR("getAllSessionIds – 准备语句失败：{}", sqlite3_errmsg(_db));
return {};
}

std::vector<std::string> sessionIds;
while (sqlite3_step(stmt) == SQLITE_ROW)
{
std::string sessionId = reinterpret_cast<const char *>(sqlite3_column_text(stmt, 0));
sessionIds.push_back(sessionId);
}