C++集成OpenAI API实战：liboai库核心设计与应用指南

1. 项目概述：一个现代、简洁的OpenAI API C++客户端

如果你正在用C++做项目，又想集成像GPT-4、DALL·E这样的AI能力，大概率会面临一个选择：是直接用官方的Python/Node.js SDK，然后费劲地搞语言绑定，还是自己从零开始封装HTTP请求、处理JSON、管理连接？前者引入了额外的复杂性和依赖，后者则意味着大量的重复劳动和潜在的坑。今天要聊的liboai，就是为了解决这个痛点而生的。它是一个用现代C++（C++17及以上）编写的、头文件库（header-only）形式的OpenAI API客户端，目标就是让你在C++项目里调用OpenAI服务，能像在Python里用openai库一样简单、直观。

我最初是在一个需要将AI对话能力嵌入到高性能C++后端服务的项目中接触到它的。当时评估了几个方案，包括cURL直接调用、一些早期的封装库，最终liboai以其清晰的接口设计、对现代C++特性的充分利用（比如协程支持）以及活跃的维护状态胜出。用了大半年，处理过各种模型调用、文件上传、流式响应，可以说它确实极大地简化了开发流程。这篇文章，我就结合自己的使用经验，深入拆解一下liboai的核心设计、怎么上手、有哪些高级用法，以及实际踩过的一些坑和应对技巧。无论你是想快速给现有C++程序加上AI功能，还是在设计一个以C++为核心的新AI应用，这份经验应该都能帮到你。

2. 核心设计哲学与架构拆解

2.1 为什么是“现代C++”与“头文件库”？

liboai选择现代C++（C++17/20）和头文件库的形式，背后有很强的实用主义考量。首先，现代C++标准引入了像std::filesystem（文件操作）、std::variant（类型安全联合体）、std::optional（可空值）、std::string_view（字符串视图）等组件，以及最重要的协程支持（C++20）。这些特性让库的作者能够写出更安全、更高效、更易于使用的代码，同时减少对第三方库的依赖。例如，处理多部分表单数据（用于文件上传）可以直接用std::filesystem来操作路径，比用老旧的C风格函数或者引入Boost要清爽得多。

头文件库（Header-only）则是为了极致的易用性和集成便利性。你不需要预先编译一个.so或.dll文件，也不需要复杂的构建系统配置。通常，只需要把liboai的include目录放到你的项目里，或者直接用像vcpkg、Conan这样的包管理器安装，然后在代码里#include <liboai/liboai.h>就行了。编译器会在编译你的源文件时，顺带把liboai的实现也编译进去。这消除了库的二进制兼容性问题，也使得跨平台部署变得非常简单。当然，头文件库的潜在缺点是可能会增加单个编译单元的编译时间，但对于大多数项目来说，这个代价相对于其带来的便利性是完全可以接受的。

2.2 核心组件与依赖关系

liboai的内部架构可以清晰地分为几个层次，理解这个有助于你更有效地使用和调试。

网络层：底层通信依赖于一个可靠的HTTP客户端库。liboai默认并推荐使用cpr（C++ Requests Library），这是一个受Pythonrequests库启发的、非常优雅的HTTP客户端库。cpr本身又基于libcurl，因此你最终需要确保系统上安装了libcurl及其开发文件。liboai通过抽象，将具体的HTTP请求细节（如构建请求头、处理响应）封装起来，向上提供统一的异步/同步调用接口。

核心对象模型：这一层定义了与OpenAI API资源一一对应的C++类。这是liboai的核心抽象，也是它用起来顺手的关键。

• liboai::OpenAI：这是最主要的入口类。它持有你的API密钥、组织ID（可选）等配置信息，并提供了访问所有API端点的方法。
• 模型类：例如liboai::Conversation、liboai::Image、liboai::Audio等。这些类并不直接对应某个API模型（如gpt-4），而是对应一类功能。比如Conversation类包含了创建聊天补全（create）、流式聊天补全等方法。这些类的方法通常接受一个参数对象。
• 参数对象：这是现代API库设计的精髓。例如，要调用聊天补全，你不会直接传一堆参数给函数，而是先构造一个liboai::Conversation::conversation对象（或者用liboai::Conversation的静态成员函数创建），设置好model、messages、temperature等属性，然后再将这个对象传给Conversation::create方法。这种方式类型安全，IDE的代码补全功能可以很好地工作，也避免了参数顺序错误的问题。

异步与协程支持：这是liboai的亮点之一。对于网络IO密集型操作，异步可以极大提升程序效率。liboai利用C++20的协程，提供了co_await风格的异步接口。如果你的编译器支持（如MSVC、GCC/Clang with-fcoroutines），你可以用非常同步化的写法来执行异步调用，代码清晰度直线上升。当然，它也提供了传统的基于std::future的异步接口和同步接口。

序列化/反序列化：OpenAI API的请求和响应都是JSON格式。liboai内部使用nlohmann/json这个广受欢迎的C++ JSON库来处理数据的序列化和反序列化。你通常不需要直接操作它，但当你需要处理一些非常定制化的响应，或者想直接操作返回的JSON对象时，这个知识就有用了。

注意：liboai的依赖（cpr,nlohmann/json）通常可以通过包管理器自动解决。但如果你手动集成，需要确保这些依赖的版本与liboai兼容。项目README或CMakeLists.txt里会有明确说明。

3. 从零开始：环境配置与第一个请求

3.1 安装与项目集成

最推荐的方式是使用包管理器，这里以vcpkg为例（假设你已经在系统上安装并配置好了vcpkg）：

# 安装 liboai，它会自动拉取并编译 cpr 和 nlohmann/json vcpkg install liboai

然后，在你的CMake项目中，使用find_package来引入：

cmake_minimum_required(VERSION 3.10) project(MyAICppProject) find_package(liboai CONFIG REQUIRED) add_executable(my_app main.cpp) target_link_libraries(my_app PRIVATE liboai::liboai)

如果你不用CMake，或者想直接集成源码，也可以从GitHub克隆仓库，将其include目录添加到你的头文件搜索路径中，并确保你的项目链接了libcurl（以及cpr和nlohmann/json，如果它们没有被包含为子模块的话）。不过，包管理器的方式能省去大量处理依赖关系的麻烦。

3.2 初始化客户端与同步调用

一切就绪后，让我们写一个最简单的程序，用同步方式调用GPT-3.5-turbo模型。

#include <iostream> #include <liboai/liboai.h> // 核心头文件 int main() { // 1. 创建 OpenAI 客户端实例，传入你的API密钥 // 重要：不要将密钥硬编码在代码中！应从环境变量或配置文件中读取。 liboai::OpenAI oai("your-api-key-here"); try { // 2. 构建聊天请求参数 auto conversation = liboai::Conversation::conversation(); conversation.SetModel("gpt-3.5-turbo"); conversation.SetMessages({ { "user", "用C++写一个简单的Hello World程序。" } }); // 可以设置其他参数，如 temperature, max_tokens 等 // conversation.SetTemperature(0.7); // conversation.SetMaxTokens(100); // 3. 发起同步调用 auto response = oai.ChatCompletion->create(conversation); // 4. 提取并输出回复内容 std::string reply = response["choices"][0]["message"]["content"]; std::cout << "AI回复: " << reply << std::endl; // 5. 你也可以获取完整的响应JSON（用于调试或获取其他信息如token用量） // std::cout << "完整响应: " << response.dump(2) << std::endl; } catch (const std::exception& e) { // 异常处理：网络错误、API错误（如额度不足）、JSON解析错误等都会抛出异常 std::cerr << "请求失败: " << e.what() << std::endl; return 1; } return 0; }

关键点解析：

1. 密钥管理："your-api-key-here"一定要替换成你自己的OpenAI API密钥。生产环境中，务必通过环境变量（如OPENAI_API_KEY）或安全的配置服务来获取。liboai::OpenAI构造函数也支持从环境变量读取。
2. 参数构建：liboai::Conversation::conversation()创建一个参数对象。使用SetXXX方法链式设置参数，代码可读性很高。messages的格式是一个std::vector，里面是键值对，角色可以是"system","user","assistant"。
3. 调用方式：oai.ChatCompletion->create(...)是同步调用，会阻塞直到收到响应或超时。返回的是一个nlohmann::json对象。
4. 结果提取：响应结构遵循OpenAI API规范。response["choices"][0]["message"]["content"]是获取第一条回复的文本内容。使用.dump(2)可以漂亮地打印整个JSON对象，调试时非常有用。
5. 错误处理：liboai会抛出std::exception或其子类的异常。务必用try-catch块包裹API调用，以处理网络问题、认证失败、参数错误、服务器错误等情况。

3.3 异步调用与协程（C++20）

如果你的项目基于异步模型（比如游戏主循环、GUI应用、高性能服务器），或者你只是想避免同步调用阻塞线程，那么异步接口是你的首选。下面是使用C++20协程的示例：

#include <iostream> #include <liboai/liboai.h> #include <cppcoro/sync_wait.hpp> // 需要一个协程库来“等待”协程，这里以cppcoro为例 #include <cppcoro/task.hpp> cppcoro::task<> asyncChatExample(liboai::OpenAI& oai) { auto conversation = liboai::Conversation::conversation(); conversation.SetModel("gpt-3.5-turbo"); conversation.SetMessages({ { "user", "解释一下C++中的RAII" } }); try { // 使用 co_await 进行异步调用，语法非常简洁 auto response = co_await oai.ChatCompletion->create_async(conversation); std::string reply = response["choices"][0]["message"]["content"]; std::cout << "异步回复: " << reply << std::endl; } catch (const std::exception& e) { std::cerr << "异步请求失败: " << e.what() << std::endl; } } int main() { liboai::OpenAI oai("your-api-key-here"); // 使用cppcoro的sync_wait来运行这个顶层的协程任务 cppcoro::sync_wait(asyncChatExample(oai)); return 0; }

要点：

• 你需要一个支持C++20协程的编译器（如MSVC/std:c++latest， GCC/Clang-std=c++20 -fcoroutines）。
• liboai提供了create_async这样的协程版本方法。它们返回一个可被co_await的Task（通常是std::future或自定义的awaiter）。
• 在普通的函数中调用协程，需要一个“调度器”或像cppcoro::sync_wait这样的工具来驱动它。在实际的异步框架（如Asio）中，你可以将liboai的协程任务无缝集成到事件循环里。

实操心得：对于简单的脚本或一次性任务，同步调用就足够了。但对于需要高并发、高吞吐的服务端应用，或者需要保持UI响应的桌面应用，务必使用异步接口。协程写法能让异步代码的逻辑清晰度接近同步代码，是未来的趋势。如果你的环境暂时不支持C++20协程，liboai也提供了返回std::future的异步方法（如create_async返回std::future<nlohmann::json>），你可以用.get()或.wait()来获取结果，但这仍然会阻塞调用线程。

4. 进阶功能与实战场景解析

4.1 流式响应（Streaming）处理

当模型生成很长的文本时，等待整个响应完成再返回给用户体验很差。流式响应允许你像接收视频流一样，逐片段（token）地接收AI的回复。liboai对流式响应的支持做得不错。

#include <iostream> #include <liboai/liboai.h> int main() { liboai::OpenAI oai("your-api-key-here"); auto conversation = liboai::Conversation::conversation(); conversation.SetModel("gpt-4"); conversation.SetMessages({ { "user", "写一篇关于量子计算的短文。" } }); conversation.SetStream(true); // 关键：开启流式传输 conversation.SetMaxTokens(500); try { // 注意：对于流式响应，create方法的行为有所不同。 // 它可能返回一个用于迭代响应的对象，或者你需要提供一个回调。 // 这里以类似事件回调的方式说明（具体API请查阅最新文档）。 // 假设我们使用一个lambda来接收数据块 oai.ChatCompletion->create(conversation, [](const std::string& chunk) { // 每个chunk是一个JSON字符串片段 // 需要解析chunk，提取 "choices[0].delta.content" std::cout << "收到数据块..." << std::endl; // 模拟处理：在实际中，你需要解析JSON并拼接content // 流式响应的结束会有一个特殊的 "[DONE]" 数据块 if (chunk.find("[DONE]") != std::string::npos) { std::cout << "\n流式传输结束。" << std::endl; } } ); // 注意：同步流式调用可能会阻塞直到所有流数据接收完毕。 // 真正的生产环境更推荐使用异步流式接口。 } catch (const std::exception& e) { std::cerr << "流式请求失败: " << e.what() << std::endl; } return 0; }

流式处理的核心：

1. 设置stream: true：这是告诉OpenAI API你需要流式响应的关键参数。
2. 处理数据块：API不会返回一个完整的JSON，而是返回一系列以data:开头的Server-Sent Events (SSE)格式的数据行。每个有效数据行是一个包含部分生成结果的JSON对象。最后一个数据行是data: [DONE]。
3. liboai的封装：liboai应该会帮你处理SSE的解析，将每个有效的JSON数据块通过回调函数传递给你。你需要在这个回调函数中解析chunk（它已经是解析好的nlohmann::json对象或字符串），提取choices[0].delta.content字段（如果有的话），并实时拼接和展示给用户。
4. 异步是更佳选择：由于流式响应可能持续很长时间，使用同步调用会长时间阻塞线程。liboai的异步接口（协程或std::future）结合流式回调，是实现实时交互体验的标准做法。

4.2 文件上传与处理（例如Fine-tuning, Assistants API）

OpenAI的很多功能，比如微调（Fine-tuning）、文件搜索（Assistants with File Search），都需要上传文件。liboai通过liboai::File类和相关方法支持了多部分表单（multipart/form-data）上传。

#include <iostream> #include <liboai/liboai.h> #include <filesystem> // C++17 文件系统库 namespace fs = std::filesystem; int main() { liboai::OpenAI oai("your-api-key-here"); std::string file_path = "./training_data.jsonl"; // 你的训练数据文件 std::string purpose = "fine-tune"; // 文件用途，如 "fine-tune", "assistants", "batch" try { // 1. 上传文件 auto upload_response = oai.File->upload( file_path, // 文件路径，liboai会利用std::filesystem读取 purpose ); std::string file_id = upload_response["id"]; std::cout << "文件上传成功，ID: " << file_id << std::endl; // 2. 检查文件状态（例如，等待文件被处理完毕，用于assistants） // 文件上传后，OpenAI后台可能需要一些时间处理（特别是assistants用途）。 bool is_processed = false; while (!is_processed) { auto file_info = oai.File->retrieve(file_id); std::string status = file_info["status"]; std::cout << "文件状态: " << status << std::endl; if (status == "processed") { is_processed = true; std::cout << "文件已处理完成，可用于Assistants。" << std::endl; } else if (status == "failed") { std::cerr << "文件处理失败。" << std::endl; break; } std::this_thread::sleep_for(std::chrono::seconds(5)); // 等待5秒再检查 } // 3. 使用文件（例如，创建使用此文件的Assistant） if (is_processed) { auto assistant = liboai::Assistant::assistant(); assistant.SetModel("gpt-4-turbo"); assistant.SetName("My File Assistant"); assistant.SetInstructions("你是一个基于我提供文件的知识助手。"); // 假设我们使用Assistants API，并启用文件搜索 assistant.SetTools({ { "type", "file_search" } }); // 注意：将文件与Assistant关联的API可能有所不同，请参考最新OpenAI文档。 // 可能是通过 `file_ids` 参数，或者单独的 `AssistantFile` 端点。 // auto create_resp = oai.Assistant->create(assistant); } // 4. 使用完毕后，可以删除文件（可选） // auto delete_resp = oai.File->del(file_id); // std::cout << "文件已删除。" << std::endl; } catch (const std::exception& e) { std::cerr << "文件操作失败: " << e.what() << std::endl; // 可以检查e.what()的内容，常见错误：文件不存在、purpose不正确、无权限等。 } return 0; }

文件操作注意事项：

• 文件格式：确保你的文件格式符合OpenAI要求。例如，用于微调的训练数据必须是JSONL格式，每行是一个训练样例。
• 文件大小与类型限制：OpenAI对上传文件有大小和类型限制，具体请查阅官方文档。liboai在上传时会进行基本检查，但最好自己先确认。
• 异步上传：对于大文件，上传可能耗时。liboai的文件上传方法本身可能是同步的（会阻塞直到上传完成）。在生产环境中，对于大文件操作，应考虑在单独的线程或使用异步接口执行，避免阻塞主线程。
• 错误处理：文件上传和处理可能因网络、格式、服务器问题而失败。务必进行详细的异常捕获和状态检查。

4.3 配置与高级客户端选项

liboai::OpenAI对象在构造时和构造后都可以进行丰富的配置，以适应不同的环境需求。

#include <liboai/liboai.h> int main() { // 方式1：通过构造函数一次性配置 liboai::OpenAI oai( "sk-...", // api_key "org-...", // organization_id (可选) "https://api.openai.com/v1", // base_url (可用于指向代理或自定义端点) 60000, // connect_timeout (毫秒) 60000, // read_timeout (毫秒) "MyCppApp/1.0" // user_agent (自定义User-Agent) ); // 方式2：通过环境变量（更安全） // 在程序外部设置环境变量 OPENAI_API_KEY 和 OPENAI_ORG_ID // liboai::OpenAI oai; // 无参构造，会自动从环境变量读取 // 方式3：构造后动态设置 liboai::OpenAI oai2; oai2.auth.SetKey("sk-..."); oai2.auth.SetOrg("org-..."); // 设置代理（如果需要通过公司代理或自定义网关访问） oai2.proxy = "http://your-proxy-server:port"; // 或者更细粒度的代理设置（如果cpr支持） // oai2.SetProxies({{"http", "http://proxy:port"}, {"https", "http://proxy:port"}}); // 设置自定义请求头（例如，用于某些需要额外认证的代理网关） // oai2.SetHeader({{"X-Custom-Header", "Value"}}); // 超时设置调整 oai2.SetTimeout(std::chrono::seconds(120)); // 总超时 oai2.SetConnectTimeout(std::chrono::seconds(30)); // 连接超时 oai2.SetReadTimeout(std::chrono::seconds(90)); // 读取超时 // 启用/禁用SSL验证（仅用于测试环境，生产环境切勿禁用！） // oai2.SetVerifySsl(false); return 0; }

配置要点：

• 密钥安全：永远不要将API密钥提交到版本控制系统（如Git）。使用环境变量是行业最佳实践。liboai支持从OPENAI_API_KEY和OPENAI_ORG_ID环境变量自动读取。
• 超时设置：根据你的网络状况和请求的复杂性（如流式响应、大文件上传）合理设置超时。默认超时可能不适合所有场景。
• 代理支持：在企业内网或特定地区，可能需要配置HTTP/HTTPS代理才能访问OpenAI API。liboai通过底层的cpr库支持代理设置。
• Base URL：这个参数非常有用。除了指向官方端点，你还可以将它指向：
  • 你自行部署的OpenAI API兼容服务（如某些开源模型的服务端）。
  • 用于负载均衡或审计的API网关。
  • Azure OpenAI Service的端点（注意，Azure OpenAI的API路径和参数可能与OpenAI官方略有不同，可能需要额外调整）。
• SSL验证：在开发测试时，如果遇到自签名证书问题，可以临时禁用SSL验证（SetVerifySsl(false)），但上线前一定要改回来，否则会面临中间人攻击风险。

5. 常见问题、性能调优与排查技巧

5.1 编译与链接问题

问题1：找不到liboai头文件或链接错误。

• 排查：确保你的编译器和构建系统正确配置了包含路径和库路径。如果使用vcpkg，记得在CMake中指定工具链文件（-DCMAKE_TOOLCHAIN_FILE=[path/to/vcpkg]/scripts/buildsystems/vcpkg.cmake）。
• 解决：检查liboai的依赖（cpr,nlohmann/json,libcurl）是否已正确安装。cpr可能对libcurl的版本有要求。可以尝试手动编译并安装这些依赖。

问题2：关于C++17/C++20标准的编译错误。

• 排查：错误信息中可能提示std::filesystem、std::optional或协程关键字未定义。
• 解决：在CMake中显式设置C++标准：set(CMAKE_CXX_STANDARD 17)（或20）。对于GCC/Clang，编译标志需要加上-std=c++17和-fcoroutines（如果使用协程）。对于MSVC，确保使用/std:c++17或/std:c++latest。

5.2 运行时错误与API错误

问题1：抛出异常，提示“Invalid API Key”或“Incorrect API key provided”。

• 排查：首先确认API密钥字符串是否正确，是否包含了多余的空格或换行符。确认密钥是否有访问相应API的权限（例如，某些密钥可能不能访问GPT-4）。
• 解决：从OpenAI平台重新生成一个密钥。使用环境变量来传递密钥，避免硬编码。检查是否设置了正确的organization_id（如果你属于多个组织）。

问题2：网络超时或连接错误。

• 排查：可能是网络不通、代理设置不正确、或者OpenAI服务暂时不可用。错误信息通常会包含cpr或libcurl的相关错误码。
• 解决：
  • 增加超时时间：oai.SetTimeout(std::chrono::seconds(120))。
  • 检查并正确配置代理（如果需要）。
  • 实现重试机制（见下文“性能与健壮性”部分）。
  • 使用try-catch捕获异常，并根据异常类型（如网络异常、HTTP状态码异常）进行不同处理。

问题3：API返回内容解析错误（JSON解析异常）。

• 排查：这通常发生在流式响应或网络传输不完整时，收到的数据不是有效的JSON。也可能是OpenAI API返回了非JSON的错误信息（如HTML格式的5xx错误页面）。
• 解决：
  • 对于流式响应，确保你的回调函数能正确处理data:前缀和[DONE]标记。
  • 在调试时，先打印出原始的响应字符串（在liboai内部解析之前可能需要一些技巧，或者查看cpr的Response.text），看看实际收到了什么。
  • 实现更健壮的解析，比如用try-catch包裹nlohmann::json::parse()。

问题4：速率限制错误（429 Too Many Requests）。

• 排查：OpenAI对免费用户和付费用户都有每分钟/每天的请求次数（RPM）和令牌数（TPM）限制。错误响应中通常会包含rate_limit相关的头信息，提示你何时可以重试。
• 解决：
  • 捕获429错误，并解析响应头中的retry-after（秒数），等待相应时间后自动重试。
  • 在你的客户端实现请求队列和速率控制逻辑，主动将请求频率控制在限制以下。
  • 考虑升级你的API套餐以获得更高的限额。

5.3 性能与健壮性优化建议

1. 客户端复用：liboai::OpenAI对象是线程安全的吗？根据cpr的文档，cpr::Session通常不是线程安全的。liboai的底层可能为每个请求创建新的会话或进行内部同步。为了最佳性能和多线程安全，一个常见的模式是为每个线程创建独立的liboai::OpenAI实例，或者使用一个客户端实例但外加互斥锁进行保护。不要在多线程间无保护地共享同一个实例的create等方法。

2. 实现重试机制：网络请求天生可能失败。对于非幂等的操作（如聊天补全，重试可能导致重复消费和扣费）要谨慎，但对于获取模型列表、查询文件状态等操作，实现指数退避重试能大大提高健壮性。

   #include <chrono> #include <thread> #include <liboai/liboai.h> nlohmann::json robustRequest(liboai::OpenAI& oai, int max_retries = 3) { int retry_count = 0; while (retry_count < max_retries) { try { auto conversation = liboai::Conversation::conversation(); // ... 设置参数 return oai.ChatCompletion->create(conversation); } catch (const liboai::exception::OpenAIException& e) { // 检查是否是速率限制或网络错误 if (e.what()包含 "429" || e.what()包含 "network") { retry_count++; int wait_seconds = std::pow(2, retry_count) + rand() % 3; // 指数退避加抖动 std::this_thread::sleep_for(std::chrono::seconds(wait_seconds)); continue; } else { // 其他错误（如认证错误、参数错误）直接抛出 throw; } } catch (const std::exception& e) { // 其他标准异常，也考虑重试 retry_count++; if (retry_count >= max_retries) throw; std::this_thread::sleep_for(std::chrono::seconds(1 * retry_count)); } } throw std::runtime_error("Max retries exceeded"); }

3. 资源管理：及时删除不再需要的上传文件，避免占用配额。对于长时间运行的流式会话，注意在程序退出或异常时关闭连接。

4. 日志与监控：在生产环境中，记录所有API请求的耗时、状态码、token使用量以及发生的异常。这有助于你监控成本、性能瓶颈和错误趋势。你可以包装liboai的调用方法，在调用前后加入日志记录。

5. 异步与并发：对于需要高并发的服务，务必使用异步接口（协程）。结合像libuv、Boost.Asio或seastar这样的异步I/O框架，可以轻松实现同时处理成千上万个并发的AI请求，而不会创建大量线程。liboai的协程支持使得它与这些框架的集成变得相对自然。

5.4 调试技巧

• 启用详细日志：cpr库支持设置详细日志输出，这能帮你看到原始的HTTP请求和响应头、体。查看liboai或cpr的文档，看如何启用CURLOPT_VERBOSE。注意，这可能会在日志中输出你的API密钥，因此仅用于本地调试。
• 检查响应JSON：在捕获到异常或得到意外结果时，将response.dump(2)或response.dump()打印出来。完整的JSON响应包含了大量信息，包括错误详情、token用量、模型指纹等。
• 隔离测试：如果遇到复杂问题，尝试写一个最小的、只包含liboai调用的测试程序，排除项目其他部分的干扰。
• 查阅源码：liboai是开源项目。当文档不清晰或遇到奇怪行为时，直接去GitHub仓库查看相关方法的实现，往往能最快找到答案。