1. 项目概述：当C++遇见本地大模型

作为一名在C++领域摸爬滚打了十多年的老程序员，我最近一直在琢磨，怎么才能让我们这些“古典”的C++开发者，也能轻松玩转现在火得不行的AI大模型。毕竟，看着Python、JavaScript的同行们用着各种现成的库，几行代码就能和GPT们谈笑风生，心里多少有点痒痒。

问题的核心在于通信协议。现在绝大多数大模型服务，无论是云端的OpenAI API，还是本地的Ollama，都遵循一套被称为“OpenAI兼容协议”的HTTP API。这套协议本质上就是一组定义好的JSON格式的HTTP请求和响应。对于我们C++程序员来说，这其实是个好消息——HTTP通信，这可是我们的老朋友了。第一时间想到的，自然是那个久经沙场的libcurl库。

但直接用libcurl去手动拼接JSON、处理HTTP头、解析响应，虽然可行，但效率太低，代码也显得臃肿。好在开源社区总有惊喜，我找到了一个名为openai-cpp的宝藏项目。它用C++11/14的现代语法，将libcurl和JSON处理（用的是著名的nlohmann/json库）封装了起来，提供了一个简洁的、面向对象的接口来调用OpenAI兼容的API。而Ollama，这个能让你在本地电脑上轻松运行Llama 2、Qwen、Mistral等开源大模型的工具，恰好也完美支持这套协议。

所以，这个项目的目标就非常明确了：利用openai-cpp这个C++库，通过标准的OpenAI协议，与本地部署的Ollama服务进行通信，从而让我们的C++程序具备与AI大模型对话的能力。这不仅仅是调用一个API那么简单，它意味着你可以将大模型的智能无缝集成到你的C++桌面应用、游戏、服务器后端，甚至是嵌入式系统中，而无需依赖任何Python环境或复杂的桥接。

2. 环境准备与核心库解析

在动手写代码之前，我们需要把“战场”打扫干净，把必要的“武器”准备好。整个过程可以分为两大块：Ollama的部署与模型准备，以及C++开发环境的搭建。

2.1 Ollama部署与模型拉取

Ollama的安装非常简单，几乎是一键式的。你可以从它的官网下载对应你操作系统（Windows、macOS、Linux）的安装包。安装完成后，打开终端（或命令提示符/PowerShell），Ollama服务会自动在后台启动，默认监听http://127.0.0.1:11434。

接下来是选择模型。Ollama支持众多开源模型，对于初次尝试，我强烈推荐从较小的模型开始，比如qwen:7b（通义千问7B版本）或llama3.2:3b。它们对硬件要求相对友好，在消费级显卡甚至纯CPU上也能跑起来。

在终端里执行：

ollama run qwen:7b

第一次运行这个命令，Ollama会从它的仓库下载模型文件。这个过程可能会比较耗时，取决于你的网速和模型大小（qwen:7b大约4-5GB）。下载完成后，它会进入一个交互式聊天界面，这证明你的Ollama和模型都已经就绪了。你可以按Ctrl+D退出这个界面，Ollama服务会继续在后台运行，等待我们的C++程序来连接。

注意：国内网络拉取模型慢的问题这是几乎所有开发者都会遇到的第一个坑。Ollama默认的镜像源在国外，下载速度可能非常慢甚至失败。解决方法是配置国内镜像源。对于Linux/macOS，可以在~/.bashrc或~/.zshrc中添加：

export OLLAMA_HOST=0.0.0.0 # 可选，允许远程连接

更关键的是模型拉取加速。目前有一些社区维护的国内镜像，但请注意甄别其安全性和稳定性。一个常见的方法是在拉取模型时，通过环境变量指定镜像站（如果该镜像站支持）。最稳妥的方式，还是找一个网络条件好的环境先下载好模型文件（位于~/.ollama/models目录下），然后拷贝到目标机器。Ollama也支持从本地文件加载模型，具体命令可查阅其官方文档。

2.2 C++项目依赖：curl与openai-cpp

我们的C++项目核心依赖两个库：

1. libcurl: 负责底层的HTTP/HTTPS通信。它是跨平台的，我们需要它的开发库（头文件和链接库）。
2. openai-cpp: 这是我们今天的主角，一个纯头文件的C++库，封装了OpenAI API的调用。它内部又依赖了nlohmann/json（也是一个纯头文件库）来处理JSON。

对于Windows平台（以Qt Creator + MinGW为例）：

• 获取libcurl：去curl官网的下载页面，选择“Windows”版本，下载那个包含bin,include,lib目录的压缩包（例如curl-8.6.0_4-win64-mingw.zip）。解压后，你会得到完整的开发文件。
• 获取openai-cpp：直接从GitHub克隆或下载openai-cpp仓库的源码。我们只需要其中的openai.hpp头文件以及它依赖的nlohmann目录（里面是json.hpp）。

项目结构建议：在你的Qt项目目录下，可以这样组织：

YourProject/ ├── YourProject.pro ├── main.cpp ├── curl/ # 从curl压缩包解压出来的 │ ├── include/ │ └── lib/ ├── openai-cpp/ # 从GitHub下载的 │ ├── openai.hpp │ └── nlohmann/ │ └── json.hpp └── (其他源文件)

Qt项目文件(.pro)配置：这是将外部库引入Qt项目的关键。你需要告诉Qt编译器去哪里找头文件和链接哪个库文件。

# 你的项目.pro文件 QT -= gui # 如果是控制台程序 CONFIG += c++17 console CONFIG -= app_bundle # 1. 包含路径：告诉编译器去哪里找.h文件 INCLUDEPATH += $$PWD/curl/include INCLUDEPATH += $$PWD/openai-cpp INCLUDEPATH += $$PWD/openai-cpp/nlohmann # 2. 库路径：告诉链接器去哪里找.lib或.a文件 LIBS += -L$$PWD/curl/lib # 3. 链接库：指定要链接的库名 # Windows MinGW下，通常链接 libcurl.dll.a LIBS += -lcurl # 如果是MSVC编译器，可能需要 -llibcurl # LIBS += -llibcurl # 4. 确保运行时能找到DLL（仅Windows动态链接时需要） # 将curl/bin目录下的libcurl.dll复制到你的可执行文件同级目录，或者将其路径加入系统PATH。 SOURCES += \ main.cpp

实操心得：区分静态库与动态库libcurl在Windows上通常提供两种库：静态库（如libcurl.a）和动态库的导入库（如libcurl.dll.a）。-lcurl默认会寻找libcurl.a或libcurl.dll.a。如果你使用动态库（DLL），除了链接libcurl.dll.a，还必须确保程序运行时能libcurl.dll。最简单的方法就是把curl/bin下的libcurl.dll复制到你的.exe文件旁边。使用静态库可以避免DLL依赖，但可能会增大最终可执行文件的体积，并需要注意许可证问题。

3. 核心代码实现与OpenAI协议详解

环境搭好了，库也引进了，现在让我们深入代码，看看如何用几行C++就能和AI对话。openai-cpp的设计非常简洁，核心类就是openai::OpenAI。

3.1 初始化与连接Ollama

一切始于初始化。我们需要告诉openai-cpp，我们的“OpenAI”服务在哪里。

#include "openai.hpp" #include <nlohmann/json.hpp> #include <iostream> int main() { // 关键初始化步骤 auto& openai = openai::start("ollama", // 随便填，在Ollama中不起作用 "optional_organization", // 随便填 true, // 是否验证SSL证书？本地HTTP服务设为false，HTTPS设为true "http://127.0.0.1:11434/v1/" // Ollama的OpenAI兼容端点 ); // ... 后续代码 }

• openai::start函数返回一个openai::OpenAI对象的引用，我们后续所有操作都基于它。
• 前两个参数api_key和organization是OpenAI官方API需要的，但对于Ollama来说，它们被忽略了，可以任意填写。
• 第三个参数verify控制SSL证书验证。由于我们在本地使用HTTP（而非HTTPS）连接Ollama，必须将其设为false，否则libcurl会因无法验证证书而失败。如果将来你将Ollama部署在远程服务器并使用HTTPS，这里应设为true并妥善处理证书。
• 第四个参数base_url是核心，必须指向Ollama服务的/v1/路径。127.0.0.1:11434是本地默认地址。

3.2 构建聊天请求：理解OpenAI协议格式

OpenAI的聊天接口核心是一个结构化的JSON请求体。openai-cpp内部使用nlohmann::json，我们可以非常方便地构建它。

using json = nlohmann::json; json create_chat_request(const std::string& model, const std::string& user_message, const std::vector<json>& history = {}) { json request; request["model"] = model; // 指定Ollama中的模型名，如 "qwen:7b" request["stream"] = false; // 是否使用流式响应。我们先从简单的非流式开始。 // messages数组是对话的核心 json messages = json::array(); // 1. 添加上下文历史（如果有） for (const auto& msg : history) { messages.push_back(msg); } // 2. 添加当前用户消息 json user_msg; user_msg["role"] = "user"; user_msg["content"] = user_message; messages.push_back(user_msg); request["messages"] = messages; // 3. 重要参数：控制生成行为 request["max_tokens"] = 512; // 限制模型回答的最大token数。太小会截断回答。 request["temperature"] = 0.7; // 温度，控制随机性。0.0最确定，2.0最随机。 request["top_p"] = 0.9; // 核采样，另一种控制随机性的方式，通常与temperature二选一。 return request; }

参数深度解析：

• model: 必须与Ollama中拉取的模型标签完全一致。通过ollama list命令可以查看已安装的模型。
• messages: 一个对象数组，每个对象必须有role和content字段。role可以是"system"（设定AI行为）、"user"（用户输入）、"assistant"（AI之前的回答）。对话的上下文就是通过维护这个数组来实现的。如果你想实现多轮对话，就需要把之前的问答对都按顺序放进去。
• max_tokens: 这是新手最容易踩的坑。它限制了本次生成的最大token数量（可以粗略理解为字数）。如果你发现AI的回答突然在中途截断了，十有八九是这个值设得太小。对于一般对话，设为512或1024是安全的起点。模型本身也有上下文长度限制，不能超过。
• temperature与top_p: 控制生成文本的“创造性”。
  • temperature（温度）：值越高（接近2.0），输出越随机、越有创意，但也可能更不连贯。值越低（接近0.0），输出越确定、越保守，对于事实性问答，设为0.1-0.3可能更好。设为0时，对于相同的输入，模型几乎总是给出相同的输出。
  • top_p（核采样）：选择累积概率超过p的最小token集合进行采样。通常temperature和top_p不建议同时调整，调整一个即可。OpenAI官方建议是只改其中一个。

3.3 发送请求与处理响应

构建好请求JSON后，发送请求就一行代码：

// 假设我们已经构建好了json格式的request对象 auto response = openai.chat.create(request);

response变量是一个nlohmann::json对象，包含了Ollama返回的完整响应。我们需要从中提取出我们关心的AI回复内容。

OpenAI协议的标准响应格式大致如下：

{ "id": "chatcmpl-xxx", "object": "chat.completion", "created": 1677652288, "model": "qwen:7b", "choices": [ { "index": 0, "message": { "role": "assistant", "content": "你好！我是通义千问..." // 这就是我们要的回复！ }, "finish_reason": "stop" } ], "usage": { "prompt_tokens": 10, "completion_tokens": 20, "total_tokens": 30 } }

因此，提取内容的代码是：

// 检查响应状态和结构 if (response.contains("choices") && !response["choices"].empty()) { auto choice = response["choices"][0]; if (choice.contains("message") && choice["message"].contains("content")) { std::string ai_reply = choice["message"]["content"]; std::cout << "AI: " << ai_reply << std::endl; // 如果你想维护上下文，需要把这次AI的回复也加入到历史中 json assistant_msg; assistant_msg["role"] = "assistant"; assistant_msg["content"] = ai_reply; // 将assistant_msg加入到你的history数组中，用于下一次请求 } else { std::cerr << "响应格式错误，未找到message.content" << std::endl; } } else { std::cerr << "请求失败或choices为空" << std::endl; // 可以打印整个response看看错误信息 std::cerr << "完整响应: " << response.dump(2) << std::endl; }

3.4 实现一个简单的交互式聊天循环

将以上代码组合起来，我们就能实现一个简单的命令行聊天程序：

#include "openai.hpp" #include <nlohmann/json.hpp> #include <iostream> #include <string> #include <vector> using json = nlohmann::json; int main() { // 初始化 auto& openai = openai::start("ollama", "org", false, "http://127.0.0.1:11434/v1/"); std::string model_name = "qwen:7b"; std::vector<json> conversation_history; // 用于保存对话上下文 std::string user_input; std::cout << "与 " << model_name << " 开始对话 (输入 'quit' 退出)" << std::endl; while (true) { std::cout << "\nYou: "; std::getline(std::cin, user_input); if (user_input == "quit" || user_input == "exit") { break; } // 1. 构建当前请求的messages（历史 + 最新输入） json messages = json::array(); for (const auto& msg : conversation_history) { messages.push_back(msg); } json current_msg; current_msg["role"] = "user"; current_msg["content"] = user_input; messages.push_back(current_msg); // 2. 构建完整请求 json request; request["model"] = model_name; request["messages"] = messages; request["max_tokens"] = 1024; request["temperature"] = 0.8; request["stream"] = false; try { // 3. 发送请求 auto response = openai.chat.create(request); // 4. 解析回复 if (response.contains("choices") && !response["choices"].empty()) { auto ai_content = response["choices"][0]["message"]["content"].get<std::string>(); std::cout << "\nAI: " << ai_content << std::endl; // 5. 更新上下文历史 // 添加用户消息 conversation_history.push_back(current_msg); // 添加AI回复消息 json ai_msg; ai_msg["role"] = "assistant"; ai_msg["content"] = ai_content; conversation_history.push_back(ai_msg); // （可选）简单限制历史长度，避免上下文过长 // 大模型有token数限制，历史太长会导致请求失败。 const size_t max_history_length = 10; // 保留最近5轮对话（10条消息） if (conversation_history.size() > max_history_length) { conversation_history.erase(conversation_history.begin(), conversation_history.begin() + (conversation_history.size() - max_history_length)); } } else { std::cout << "AI没有返回有效内容。" << std::endl; } } catch (const std::exception& e) { std::cerr << "请求发生异常: " << e.what() << std::endl; // 可能是网络错误、Ollama服务未启动、模型未加载等 } } std::cout << "对话结束。" << std::endl; return 0; }

这个程序已经具备了核心功能：连接本地Ollama、发送问题、获取回答、并维护一个简单的对话上下文。编译并运行它，你就拥有了一个用C++写的、属于你自己的AI聊天客户端。

4. 高级功能与性能优化

掌握了基础对话后，我们可以探索一些更高级的功能和优化技巧，让集成更强大、更高效。

4.1 流式响应处理

上面的例子中，我们使用了"stream": false，这意味着我们要等待模型生成完整的回答后，才能一次性收到所有内容。对于长文本，等待时间会很长，用户体验不连贯。

OpenAI协议支持流式响应（"stream": true）。在这种模式下，服务器会返回一个text/event-stream格式的数据流，模型每生成一小段（一个token或几个token）就立即发送过来。openai-cpp库也支持流式处理，但需要以回调函数的方式接收数据片段。

request["stream"] = true; // 启用流式 std::string full_response; openai.chat.create(request, [&full_response](const std::string& data, bool is_complete) { // 这个lambda函数会被多次调用，每次传入一部分数据 if (!data.empty()) { try { auto chunk = json::parse(data); if (chunk.contains("choices") && !chunk["choices"].empty() && chunk["choices"][0].contains("delta") && chunk["choices"][0]["delta"].contains("content")) { auto content_delta = chunk["choices"][0]["delta"]["content"].get<std::string>(); std::cout << content_delta << std::flush; // 逐段打印，不换行 full_response += content_delta; } } catch (const json::parse_error& e) { // 忽略解析错误，可能是流结束的特定标记 } } if (is_complete) { std::cout << std::endl << "[流式传输结束]" << std::endl; // 此时full_response包含了完整的回复 } return true; // 返回false可以中途取消 } );

流式传输的优势：

1. 极低的响应延迟：用户几乎在提问后立刻就能看到AI开始“思考”和“打字”。
2. 更自然的交互体验：模仿了真人聊天的感觉。
3. 便于处理超长内容：可以在生成过程中就进行处理或显示，无需等待全部完成。

注意事项：

• 流式响应的数据处理逻辑更复杂，需要妥善处理JSON解析可能遇到的错误（因为收到的可能是不完整的JSON片段）。
• 网络连接需要保持稳定，任何中断都可能导致流结束。

4.2 错误处理与重试机制

网络请求不可能永远成功。我们必须编写健壮的代码来处理各种异常。

#include <chrono> #include <thread> bool send_chat_request_with_retry(openai::OpenAI& openai, const json& request, json& response, int max_retries = 3) { int retry_count = 0; while (retry_count < max_retries) { try { response = openai.chat.create(request); // 检查HTTP状态码或响应中的错误字段（如果Ollama返回的话） // openai-cpp在HTTP错误时会抛出异常，所以能走到这里通常意味着成功 return true; } catch (const std::exception& e) { retry_count++; std::cerr << "请求失败 (尝试 " << retry_count << "/" << max_retries << "): " << e.what() << std::endl; if (retry_count >= max_retries) { std::cerr << "达到最大重试次数，放弃请求。" << std::endl; return false; } // 指数退避策略：等待一段时间再重试 int wait_seconds = 1 << retry_count; // 2, 4, 8秒... std::cout << "等待 " << wait_seconds << " 秒后重试..." << std::endl; std::this_thread::sleep_for(std::chrono::seconds(wait_seconds)); } } return false; }

常见错误类型及处理：

1. 连接失败/超时：检查Ollama服务是否启动（ollama serve），端口11434是否被占用，防火墙是否阻止。
2. 模型未加载：Ollama虽然服务在运行，但指定的模型可能未被加载。可以先用ollama list确认，或通过代码先调用Ollama的管理API（如GET /api/tags）列出可用模型。
3. 上下文长度超限：如果conversation_history积累得太长，加上新的问题，总token数可能超过模型的最大上下文长度（如4096）。解决方案是实施“上下文窗口滑动”，只保留最近N轮对话，或者使用更高级的“摘要”技术，将久远的历史压缩成一段摘要。
4. 内存不足：在资源有限的机器上运行大模型，可能因内存不足导致Ollama进程崩溃。需要选择更小的模型（如3B、1.8B），或调整Ollama的运行参数（如OLLAMA_NUM_GPU等环境变量）。

4.3 集成到GUI应用（以Qt为例）

将大模型能力集成到桌面应用是C++的强项。这里以Qt为例，展示如何将聊天逻辑封装到一个类中，并与UI线程安全地交互。

ChatWorker.h (后台工作线程)

#pragma once #include <QObject> #include <QThread> #include <string> #include <vector> #include "openai.hpp" #include <nlohmann/json.hpp> class ChatWorker : public QObject { Q_OBJECT public: explicit ChatWorker(const std::string& model, QObject *parent = nullptr); ~ChatWorker(); public slots: void sendMessage(const QString& message); void setModel(const QString& modelName); signals: void responseReceived(const QString& response); void errorOccurred(const QString& error); void streamChunkReceived(const QString& chunk); // 用于流式传输 private: void run(); std::unique_ptr<openai::OpenAI> m_openai; std::string m_model; std::vector<nlohmann::json> m_history; // 添加线程同步机制，如QMutex，如果多线程访问历史记录 };

ChatWorker.cpp

#include "ChatWorker.h" #include <QDebug> ChatWorker::ChatWorker(const std::string& model, QObject *parent) : QObject(parent), m_model(model) { // 注意：openai::start 的调用最好在worker线程内进行，避免阻塞UI } void ChatWorker::sendMessage(const QString& message) { // 在实际实现中，这里应该将任务提交到工作线程的队列中 // 这里简化处理，直接在当前线程（假设是工作线程）执行 QString stdMessage = message.toStdString(); nlohmann::json request; request["model"] = m_model; request["max_tokens"] = 1024; request["temperature"] = 0.7; request["stream"] = false; // 或 true，配合streamChunkReceived信号 // 构建messages... nlohmann::json::array_t messages; for (const auto& h : m_history) { messages.push_back(h); } nlohmann::json user_msg; user_msg["role"] = "user"; user_msg["content"] = stdMessage.toStdString(); messages.push_back(user_msg); request["messages"] = messages; try { auto response = m_openai->chat.create(request); // ... 解析response std::string ai_reply = /* 从response提取 */; m_history.push_back(user_msg); nlohmann::json ai_msg; ai_msg["role"] = "assistant"; ai_msg["content"] = ai_reply; m_history.push_back(ai_msg); emit responseReceived(QString::fromStdString(ai_reply)); } catch (const std::exception& e) { emit errorOccurred(QString("请求失败: %1").arg(e.what())); } }

在Qt的主UI线程中，你只需要连接ChatWorker的信号到UI控件的槽函数上，就可以实现非阻塞的、响应式的AI聊天界面了。

5. 实战问题排查与性能调优

在实际开发和部署中，你肯定会遇到各种各样的问题。下面是我踩过的一些坑和总结的经验。

5.1 编译与链接问题

问题1：undefined reference to链接错误。这通常是因为链接器找不到libcurl或openai-cpp中使用的符号。

• 检查.pro文件：确认LIBS += -L$$PWD/curl/lib -lcurl路径正确。-L指定库目录，-l指定库名（去掉lib前缀和.a或.dll.a后缀）。
• 检查编译器位数：确保你下载的libcurl库（x86或x64）与你的Qt编译器（MinGW 32-bit vs 64-bit）匹配。
• 检查库文件：去curl/lib目录下看看，是否存在libcurl.a或libcurl.dll.a文件。

问题2：运行时提示缺少libcurl.dll或其他DLL。

• 方案A（推荐）：将curl/bin目录下的libcurl.dll复制到你的可执行文件（.exe）所在的目录。
• 方案B：将curl/bin目录的路径添加到系统的PATH环境变量中。

问题3：SSL证书验证错误。错误信息可能包含SSL certificate problem。

• 本地HTTP：如我们之前所做，在openai::start中将第三个参数设为false。
• 远程HTTPS：如果连接远程安全的Ollama服务，需要设为true。如果遇到自签名证书问题，可能需要通过libcurl的选项指定CA证书包路径，这涉及到更深入的libcurl配置，openai-cpp库可能没有暴露相关接口，此时可能需要修改库源码或寻找其他支持更全配置的C++ OpenAI客户端。

5.2 模型推理与响应问题

问题1：AI回答不完整，突然中断。

• 首要怀疑对象：max_tokens参数设置过小。尝试将其增加到1024或2048。
• 次要原因：模型本身的生成长度限制。每个模型都有其最大输出token数，请查阅对应模型的文档。
• 网络超时：libcurl或Ollama服务端设置了超时。对于长文本生成，需要增加超时时间。openai-cpp库可能没有直接提供设置，但你可以通过修改其内部使用的cURL句柄配置来实现（这需要修改库源码）。

问题2：AI回答总是重复或陷入循环。

• 调整生成参数：提高temperature值（如从0.7调到1.2）可以增加多样性，减少重复。也可以尝试调整top_p。
• 检查上下文：可能是上下文历史中包含了导致循环的模式。尝试清空conversation_history重新开始，或者在每轮对话中引入一些随机性的系统提示（role: system）。
• 模型本身问题：某些小模型或训练数据有偏的模型更容易出现重复。尝试换一个模型。

问题3：中文回答乱码。

• 控制台编码：在Windows命令提示符（cmd）默认是GBK编码，而我们的程序输出是UTF-8。这会导致中文显示乱码。解决方案是使用支持UTF-8的终端（如Windows Terminal），或者更改控制台代码页：在程序开头调用system("chcp 65001 > nul");（仅Windows）。在Qt中，使用qDebug()或QTextStream配合QString可以很好地处理UTF-8。
• 字符串处理：确保在整个代码流程中（从std::cin读取、JSON构建、网络传输、输出）都使用UTF-8编码。nlohmann::json和libcurl默认都支持UTF-8。

5.3 性能优化建议

1. 连接复用：openai-cpp在内部可能已经实现了libcurl句柄的复用。确保你的openai::OpenAI对象是单例或长期存在的，避免每次请求都创建新的连接，这能显著减少TCP握手和SSL协商的开销。
2. 异步非阻塞调用：对于GUI应用，绝对不能在UI线程中进行同步网络请求，这会导致界面卡死。必须使用工作线程（如QThread）或异步库（如Boost.Asio）来执行openai.chat.create调用。上文Qt示例给出了基本思路。
3. 上下文管理策略：随着对话轮数增加，conversation_history会越来越长，每次请求发送的数据量也越大，消耗的token也越多（可能产生费用，如果是云端API）。实现一个智能的上下文窗口：
   • 固定长度窗口：只保留最近N条消息。
   • 基于Token数的窗口：估算历史消息的token总数（可以使用简单的启发式方法，如字数 * 0.75），当超过阈值时，丢弃最早的消息。
   • 摘要压缩：这是更高级的技术。当历史过长时，可以调用一次模型本身，让它对之前的对话历史生成一个简短的摘要，然后用这个摘要代替详细历史，作为新的“系统”消息或上下文开头。
4. 批量处理：如果你有大量独立的文本需要处理（例如分类、摘要），可以考虑将它们组合成一个批处理请求（如果Ollama或后端API支持），或者使用线程池并发发送多个请求，但要注意不要压垮本地Ollama服务。

最后，别忘了Ollama本身也提供了一些性能调优参数，比如通过环境变量OLLAMA_NUM_GPU控制GPU层数，OLLAMA_KEEP_ALIVE控制模型在内存中的驻留时间等。根据你的硬件情况和应用场景进行调整，可以在响应速度和资源占用之间找到最佳平衡点。