从零构建 C++ AI 大模型接入 SDK

ChatServer 开发顺序

1. 编写 ChatServer.hpp 和 .cc。
2. 编写 main.cc 启动服务器。
3. 前端界面对接（可直接参考示例或使用 AI 生成）。

2. common.hpp

定义基础数据结构，包括消息、配置、会话信息等。注意析构函数需声明为虚函数。

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

namespace ai_chat_sdk {
struct Message {
    std::string _messageId;
    std::string _role; // user/assistant/system
    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;
    virtual ~Config() = default;
};

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

struct Session {
    std::string _sessionId;
    std::string _modelName;
    std::vector<Message> _messages;
    std::time_t _createTime;
    std::time_t _updateTime;
    Session(const std::string &modelName = "") : _modelName(modelName) {}
};
} // namespace ai_chat_sdk

3. LLMProvider.hpp

这是一个抽象策略类，所有要接入的模型都需要继承它并重写虚函数。利用多态，上层只需持有父类指针即可切换不同模型。

#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;
protected:
    bool _isAvailable = false;
    std::string _apiKey;
    std::string _endPoint;
};
} // namespace ai_chat_sdk

4. DeepSeekProvider 类

继承 LLMProvider 实现具体逻辑。重点在于全量响应与流式响应的 HTTP 处理。

全量响应

构造 JSON 请求体，发起 POST 请求，解析返回的 JSON 提取内容。

std::string DeepSeekProvider::sendMessage(const std::vector<Message>& messages,
                                          const std::map<std::string, std::string>& requestParams) {
    if (!isAvailable()) 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"));

    // 构建历史消息数组
    Json::Value messageArray(Json::arrayValue);
    for (const auto& msg : messages) {
        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);

    // 发起 HTTP 请求
    httplib::Client cli(_endPoint.c_str());
    cli.set_connection_timeout(30);
    cli.set_read_timeout(60);
    httplib::Headers headers = {{"Authorization", "Bearer " + _apiKey},
                                {"Content-Type", "application/json"}};
    auto res = cli.Post("/v1/chat/completions", headers, requestBodyStr, "application/json");

    if (!res || res->status != 200) return "";

    // 解析响应
    Json::Value responseBody;
    Json::CharReaderBuilder readerBuilder;
    std::istringstream responseStream(res->body);
    std::string parseError;
    if (Json::parseFromStream(readerBuilder, responseStream, &responseBody, &parseError)) {
        if (responseBody.isMember("choices") && responseBody["choices"].isArray() && !responseBody["choices"].empty()) {
            auto choice = responseBody["choices"][0];
            if (choice.isMember("message") && choice["message"].isMember("content")) {
                return choice["message"]["content"].asString();
            }
        }
    }
    return "";
}

流式响应

使用 SSE 协议，设置 Accept: text/event-stream，并通过回调函数处理分块数据。

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()) return "";

    // ... 参数解析与请求体构建同上 ...
    requestBody["stream"] = true;

    httplib::Client client(_endPoint.c_str());
    client.set_connection_timeout(30, 0);
    client.set_read_timeout(300, 0); // 流式响应需要更长超时

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

    httplib::Request req;
    req.method = "POST";
    req.path = "/v1/chat/completions";
    req.headers = headers;
    req.body = requestBodyStr;

    std::string buffer;
    std::string fullResponse;
    bool streamFinish = false;

    // 响应头回调：校验状态码
    req.response_handler = [&](const httplib::Response& res) {
        if (res.status != 200) return false;
        return true;
    };

    // 数据体回调：处理 SSE 流
    req.content_receiver = [&](const char* data, size_t len, size_t offset, size_t totalLength) {
        buffer.append(data, len);
        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::istringstream modelDataStream(modelData);
                if (Json::parseFromStream(reader, modelDataStream, &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();
                        fullResponse += content;
                        callback(content, false);
                    }
                }
            }
        }
        return true;
    };

    auto result = client.send(req);
    if (!result) return "";
    if (!streamFinish) callback("", true);
    return fullResponse;
}

5. 测试接口

运行前请设置环境变量 export deepseek_apikey="你的 key"。

CMake 配置示例：

add_executable(testLLM testLLM.cc ../sdk/src/util/myLog.cc ../sdk/src/DeepSeekProvider.cc)
target_link_libraries(testLLM pthread jsoncpp fmt spdlog gtest OpenSSL::SSL OpenSSL::Crypto)

6. 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);
private:
    std::map<std::string, std::unique_ptr<LLMProvider>> _providers;
    std::map<std::string, ModelInfo> _modelInfos;
};
} // namespace ai_chat_sdk

7. SessionManager 类

负责会话的生命周期管理。初期基于内存实现，后续接入数据库。

#pragma once
#include <atomic>
#include <unordered_map>
#include <mutex>
#include <memory>
#include "common.hpp"

namespace ai_chat_sdk {
class SessionManager {
public:
    static SessionManager& getInstance();
    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;
    std::string generateSessionId();
    std::string generateMessageId();
    std::unordered_map<std::string, std::shared_ptr<Session>> _sessions;
    mutable std::mutex _mutex;
    static std::atomic<int64_t> _message_counter;
    static std::atomic<int64_t> _session_counter;
};
} // namespace ai_chat_sdk

8. DataManager 类

基于 SQLite3 实现数据的持久化存储，包含会话表和消息表，支持外键级联删除。

#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();
    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);
    std::vector<std::string> getAllSessionIds() const;
    std::vector<std::shared_ptr<Session>> getAllSessions() const;
    bool clearAllSessions();
    size_t getSessionCount() const;
    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();
    bool executeSQL(const std::string &sql);
    sqlite3 *_db;
    std::string _dbName;
    mutable std::mutex _mutex;
};
} // namespace ai_chat_sdk

9. 接入 DataManager 的 SessionManager

将 DataManager 成员变量加入 SessionManager，在内存操作前后同步数据库，实现断点续聊。

// 构造函数初始化
SessionManager::SessionManager():_dataManager("chatDB.db"){
    auto sessions = _dataManager.getAllSessions();
    for(auto& session : sessions){ _sessions[session->_sessionId]= session;}
}

// 创建会话示例
std::string SessionManager::createSession(const std::string &modelName){
    std::string sessionId = generateSessionId();
    auto session = std::make_shared<Session>(modelName);
    session->_sessionId = sessionId;
    _sessions[sessionId]= session;
    _dataManager.insertSession(*session); // 持久化
    return sessionId;
}

10. ChatSDK 类

作为统一顶层入口，封装模型管理与会话管理，对外提供极简调用接口。

核心功能：

1. 模型初始化：注册并初始化多类大模型。
2. 会话管理：委托给 SessionManager。
3. 消息交互：提供同步与流式两种发送接口。
4. 基础能力：获取可用模型列表。

11. ChatServer 类与前端

ChatServer 充当前后端交互媒介，基于 httplib 实现 RESTful API。

接口列表：

• GET /api/sessions: 获取会话列表
• GET /api/models: 获取可用模型
• POST /api/session: 新建会话
• DELETE /api/session/{id}: 删除会话
• GET /api/session/{id}/history: 获取历史消息
• POST /api/message: 发送消息（全量）
• POST /api/message/async: 发送消息（流式 SSE）

流式响应实现要点： 使用 set_chunked_content_provider 配合 SSE 格式输出。

response.set_header("Cache-Control","no-cache");
response.set_header("Connection","keep-alive");
response.set_header("Access-Control-Allow-Origin","*");
response.set_chunked_content_provider("text/event-stream", [this, sessionId, message](size_t offset, httplib::DataSink &dataSink)->bool{
    auto writeChunk = [&](const std::string &chunk, bool last){
        std::string sseData = "data: " + Json::valueToQuotedString(chunk.c_str()) + "\n\n";
        dataSink.write(sseData.c_str(), sseData.size());
        if(last){
            dataSink.write("data: [DONE]\n\n");
            dataSink.done();
            return false;
        }
        return true;
    };
    _chatSDK->sendMessageStream(sessionId, message, writeChunk);
    return false;
});

启动配置： 主程序支持通过命令行参数或配置文件指定端口、日志级别及 API Key。

DEFINE_string(host,"0.0.0.0","服务器绑定的地址");
DEFINE_int32(port,50090,"服务器绑定的端口号");
// ... 其他配置

前端部分可直接参考示例代码，修改 JS 中的 IP 与端口配置即可运行。