ollama serve

curl http://localhost:11434/api/version
# 預(yù)期輸出: {"version":"0.6.0"}

ollama pull llama3.2

sudo apt-get install libcurl4-openssl-dev nlohmann-json3-dev libssl-dev

#include <iostream>
#include <string>
#include <curl/curl.h>
#include <nlohmann/json.hpp>
using json = nlohmann::json;
// libcurl 寫回調(diào)函數(shù)
size_t WriteCallback(void* contents, size_t size, size_t nmemb, std::string* output) {
    size_t totalSize = size * nmemb;
    output->append(static_cast<char*>(contents), totalSize);
    return totalSize;
}
std::string callOllamaGenerate(const std::string& model, 
                                const std::string& prompt,
                                bool stream = false) {
    CURL* curl = curl_easy_init();
    if (!curl) {
        throw std::runtime_error("Failed to initialize libcurl");
    }
    // 構(gòu)造 JSON 請求體
    json requestBody = {
        {"model", model},
        {"prompt", prompt},
        {"stream", stream}
    };
    std::string jsonStr = requestBody.dump();
    std::string responseData;
    struct curl_slist* headers = nullptr;
    headers = curl_slist_append(headers, "Content-Type: application/json");
    curl_easy_setopt(curl, CURLOPT_URL, "http://localhost:11434/api/generate");
    curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
    curl_easy_setopt(curl, CURLOPT_POSTFIELDS, jsonStr.c_str());
    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteCallback);
    curl_easy_setopt(curl, CURLOPT_WRITEDATA, &responseData);
    CURLcode res = curl_easy_perform(curl);
    curl_slist_free_all(headers);
    curl_easy_cleanup(curl);
    if (res != CURLE_OK) {
        throw std::runtime_error(curl_easy_strerror(res));
    }
    json responseJson = json::parse(responseData);
    return responseJson.contains("response") ? 
           responseJson["response"].get<std::string>() : "";
}
int main() {
    try {
        std::string result = callOllamaGenerate("llama3.2", 
                                                  "What is the capital of France?",
                                                  false);
        std::cout << result << std::endl;
    } catch (const std::exception& e) {
        std::cerr << "Error: " << e.what() << std::endl;
    }
    return 0;
}

#include <vector>
struct Message {
    std::string role;
    std::string content;
};
std::string callOllamaChat(const std::string& model, 
                            const std::vector<Message>& messages) {
    json requestBody;
    requestBody["model"] = model;
    requestBody["stream"] = false;
    json messagesArray = json::array();
    for (const auto& msg : messages) {
        messagesArray.push_back({
            {"role", msg.role},
            {"content", msg.content}
        });
    }
    requestBody["messages"] = messagesArray;
    // 發(fā)送請求（代碼同 generate 端點(diǎn)的 HTTP 發(fā)送邏輯）
    // ...
    json responseJson = json::parse(responseData);
    return responseJson["message"]["content"];
}
int main() {
    std::vector<Message> conversation = {
        {"system", "You are a helpful assistant."},
        {"user", "Tell me about C++ templates."}
    };
    std::string reply = callOllamaChat("llama3.2", conversation);
    std::cout << "Assistant: " << reply << std::endl;
    // 繼續(xù)對話：將回復(fù)加入上下文
    conversation.push_back({"assistant", reply});
    conversation.push_back({"user", "Can you give me an example?"});
    reply = callOllamaChat("llama3.2", conversation);
    std::cout << "Assistant: " << reply << std::endl;
}

#include "ollama.hpp"
int main() {
    // 基礎(chǔ)生成：一行代碼完成
    std::cout << ollama::generate("llama3:8b", "Why is the sky blue?") << std::endl;
    return 0;
}

#include "ollama.hpp"
void onToken(const std::string& token) {
    std::cout << token << std::flush;  // 實時打印每個 token
}
int main() {
    ollama::Ollama::getInstance().setOnToken(onToken);
    ollama::GenerateOptions opts;
    opts.model = "llama3.2";
    opts.prompt = "Write a short poem about programming.";
    std::string fullResponse = ollama::generate(opts);
    std::cout << std::endl << "Done." << std::endl;
    return 0;
}

// 使用 oai-api 庫的示意（實際項目需參考具體 API）
#include <oai_api/client.hpp>
int main() {
    oai_api::Client client("http://localhost:11434/v1");
    auto response = client.chat.completions.create({
        .model = "llama3.2",
        .messages = {
            {.role = "system", .content = "You are a helpful assistant."},
            {.role = "user", .content = "Hello!"}
        }
    });
    std::cout << response.choices[0].message.content << std::endl;
    return 0;
}

// 流式讀取回調(diào)（逐 token）
size_t StreamWriteCallback(void* contents, size_t size, size_t nmemb, std::string* buffer) {
    size_t totalSize = size * nmemb;
    std::string chunk(static_cast<char*>(contents), totalSize);
    // 解析 NDJSON 行
    std::istringstream iss(chunk);
    std::string line;
    while (std::getline(iss, line)) {
        if (line.empty()) continue;
        auto jsonChunk = json::parse(line);
        if (jsonChunk.contains("response")) {
            std::cout << jsonChunk["response"].get<std::string>();
            std::cout.flush();
        }
        if (jsonChunk.value("done", false)) {
            std::cout << std::endl;
        }
    }
    return totalSize;
}

json schema = {
    {"type", "object"},
    {"properties", {
        {"name", {{"type", "string"}}},
        {"age", {{"type", "integer"}}},
        {"city", {{"type", "string"}}}
    }},
    {"required", {"name", "age"}}
};
json requestBody = {
    {"model", "llama3.2"},
    {"prompt", "Extract user info: My name is John, I'm 28 years old and live in Paris."},
    {"format", "json"},  // 或傳入完整 schema 對象
    {"stream", false}
};

std::vector<float> getEmbedding(const std::string& model, const std::string& input) {
    json requestBody = {
        {"model", model},
        {"input", input}
    };
    // 發(fā)送 POST 請求到 /api/embeddings
    // ...
    json responseJson = json::parse(responseData);
    return responseJson["embedding"].get<std::vector<float>>();
}

// 列出本地模型
json requestBody = {};
// GET http://localhost:11434/api/tags
// 拉取模型（下載）
json pullBody = {
    {"model", "llama3.2:latest"},
    {"stream", false}  // 可設(shè)為 true 獲取下載進(jìn)度
};
// 刪除模型
// DELETE http://localhost:11434/api/delete
json deleteBody = {{"model", "llama3.2:latest"}};

json requestBody = {
    {"model", "llama3.2"},
    {"prompt", "Hello"},
    {"keep_alive", "5m"}  // 保持 5 分鐘，設(shè)為 "0" 立即卸載
};

json options = {
    {"num_ctx", 4096}   // 根據(jù)場景調(diào)整
};

class OllamaClient {
public:
    enum class Endpoint {
        Generate,
        Chat,
        Embeddings
    };
    struct Config {
        std::string baseUrl = "http://localhost:11434";
        int timeoutMs = 30000;
        bool reuseConnection = true;
    };
    explicit OllamaClient(const Config& cfg);
    // 同步調(diào)用
    std::string generate(const std::string& model, 
                         const std::string& prompt,
                         const GenerateOptions& opts = {});
    // 流式調(diào)用（通過回調(diào)）
    void generateStream(const std::string& model,
                        const std::string& prompt,
                        std::function<void(const std::string&)> onToken,
                        std::function<void()> onComplete);
    // 異常安全：使用 RAII 管理 CURL 句柄資源
    ~OllamaClient();
private:
    struct Impl;
    std::unique_ptr<Impl> pImpl;  // Pimpl 慣用法隱藏實現(xiàn)細(xì)節(jié)
};

enum class OllamaError {
    ConnectionFailed,
    Timeout,
    ModelNotFound,
    InvalidRequest,
    ServerError
};
class OllamaException : public std::runtime_error {
public:
    OllamaError errorCode;
    explicit OllamaException(const std::string& msg, OllamaError code)
        : std::runtime_error(msg), errorCode(code) {}
};