ChatGLM.cpp

基于 ChatGLM-6B、ChatGLM2-6B、ChatGLM3 和 GLM-4(V) 的 C++ 实现，可在您的 MacBook 上进行实时对话。

特性

亮点：

• 基于 ggml 的纯 C++ 实现，工作方式与 llama.cpp 相同。
• 通过 int4/int8 量化、优化的 KV 缓存和并行计算，实现加速且内存高效的 CPU 推理。
• 支持 P-Tuning v2 和 LoRA 微调模型。
• 具有打字机效果的流式生成。
• 提供 Python 绑定、Web 演示、API 服务器等多种可能性。

支持矩阵：

• 硬件：x86/arm CPU、NVIDIA GPU、Apple Silicon GPU
• 平台：Linux、MacOS、Windows
• 模型：ChatGLM-6B、ChatGLM2-6B、ChatGLM3、GLM-4(V)、CodeGeeX2

快速入门

准备工作

将 ChatGLM.cpp 仓库克隆到本地：

git clone --recursive https://github.com/li-plus/chatglm.cpp.git && cd chatglm.cpp

如果您在克隆仓库时忘记使用 --recursive 标志，请在 chatglm.cpp 文件夹中运行以下命令：

git submodule update --init --recursive

模型量化

安装加载和量化 Hugging Face 模型所需的必要包：

python3 -m pip install -U pip
python3 -m pip install torch tabulate tqdm transformers accelerate sentencepiece

使用 convert.py 将 ChatGLM-6B 转换为量化后的 GGML 格式。例如，要将 fp16 原始模型转换为 q4_0（量化为 int4）GGML 模型，运行：

python3 chatglm_cpp/convert.py -i THUDM/chatglm-6b -t q4_0 -o models/chatglm-ggml.bin

原始模型 (-i <model_name_or_path>) 可以是 Hugging Face 模型名称，也可以是你预先下载的模型的本地路径。目前支持的模型包括：

• ChatGLM-6B：THUDM/chatglm-6b、THUDM/chatglm-6b-int8、THUDM/chatglm-6b-int4
• ChatGLM2-6B：THUDM/chatglm2-6b、THUDM/chatglm2-6b-int4、THUDM/chatglm2-6b-32k、THUDM/chatglm2-6b-32k-int4
• ChatGLM3-6B：THUDM/chatglm3-6b、THUDM/chatglm3-6b-32k、THUDM/chatglm3-6b-128k、THUDM/chatglm3-6b-base
• ChatGLM4(V)-9B：THUDM/glm-4-9b-chat、THUDM/glm-4-9b-chat-1m、THUDM/glm-4-9b、THUDM/glm-4v-9b
• CodeGeeX2：THUDM/codegeex2-6b、THUDM/codegeex2-6b-int4

您可以自由尝试以下任何一种量化类型，只需指定 -t <type>：

对于 LoRA 模型，添加 -l <lora_model_name_or_path> 标志，即可将 LoRA 权重合并到基础模型中。例如，运行 python3 chatglm_cpp/convert.py -i THUDM/chatglm3-6b -t q4_0 -o models/chatglm3-ggml-lora.bin -l shibing624/chatglm3-6b-csc-chinese-lora，即可合并来自 Hugging Face 的公开 LoRA 权重。

对于使用 官方微调脚本 的 P-Tuning v2 模型，convert.py 会自动检测额外的权重。如果输出权重列表中包含 past_key_values，则表示 P-Tuning 检查点已成功转换。

构建与运行

使用 CMake 编译项目：

cmake -B build
cmake --build build -j --config Release

现在您可以通过运行以下命令与量化后的 ChatGLM-6B 模型对话：

./build/bin/main -m models/chatglm-ggml.bin -p 你好
# 你好👋！我是人工智能助手 ChatGLM-6B，很高兴见到你，欢迎问我任何问题。

若要在交互模式下运行模型，请添加 -i 标志。例如：

./build/bin/main -m models/chatglm-ggml.bin -i

在交互模式下，您的聊天记录将作为下一轮对话的上下文。

运行 ./build/bin/main -h 以了解更多选项！

尝试其他模型

python3 chatglm_cpp/convert.py -i THUDM/chatglm2-6b -t q4_0 -o models/chatglm2-ggml.bin
./build/bin/main -m models/chatglm2-ggml.bin -p 你好 --top_p 0.8 --temp 0.8
# 你好👋！我是人工智能助手 ChatGLM2-6B，很高兴见到你，欢迎问我任何问题。

python3 chatglm_cpp/convert.py -i THUDM/chatglm3-6b -t q4_0 -o models/chatglm3-ggml.bin
./build/bin/main -m models/chatglm3-ggml.bin -p 你好 --top_p 0.8 --temp 0.8
# 你好👋！我是人工智能助手 ChatGLM3-6B，很高兴见到你，欢迎问我任何问题。

./build/bin/main -m models/chatglm3-ggml.bin -p 你好 -s "你是一个由智谱 AI 训练的大语言模型 ChatGLM3。请仔细遵循用户的指示，并以 Markdown 格式作答。"

# 你好👋！我是 ChatGLM3，有什么问题可以帮您解答吗？

$ ./build/bin/main -m models/chatglm3-ggml.bin --top_p 0.8 --temp 0.8 --sp examples/system/function_call.txt -i
系统   > 请尽你所能回答以下问题。你可以使用以下工具：...
提示   > 生成一个随机数
ChatGLM3 > random_number_generator
```python
tool_call(seed=42, range=(0, 100))
```
工具调用   > 请手动调用函数 `random_number_generator`，参数为 `tool_call(seed=42, range=(0, 100))`，并将结果提供在下方。
观测值 > 23
ChatGLM3 > 根据您的要求，我使用随机数生成器API生成了一个随机数。根据API返回结果，生成的随机数为23。

$ ./build/bin/main -m models/chatglm3-ggml.bin --top_p 0.8 --temp 0.8 --sp examples/system/code_interpreter.txt -i
系统   > 你是一位智能AI助手，你叫ChatGLM，你连接着一台电脑，但请注意不能联网。在使用Python解决任务时，你可以运行代码并得到结果，如果运行结果有错误，你需要尽可能对代码进行改进。你可以处理用户上传到电脑上的文件，文件默认存储路径是/mnt/data/。
提示   > 列出100以内的所有质数
ChatGLM3 > 好的，我会为您列出100以内的所有质数。
```python
def is_prime(n):
   """检查一个数是否为质数。"""
   if n <= 1:
       return False
   if n <= 3:
       return True
   if n % 2 == 0 or n % 3 == 0:
       return False
   i = 5
   while i * i <= n:
       if n % i == 0 or n % (i + 2) == 0:
           return False
       i += 6
   return True

primes_upto_100 = [i for i in range(2, 101) if is_prime(i)]
primes_upto_100
```

代码解释器 > 请手动运行代码，并将结果提供在下方。
观测值      > [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]
ChatGLM3 > 100以内的所有质数为：

$$
2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97 
$$

python3 chatglm_cpp/convert.py -i THUDM/glm-4-9b-chat -t q4_0 -o models/chatglm4-ggml.bin
./build/bin/main -m models/chatglm4-ggml.bin -p 你好 --top_p 0.8 --temp 0.8
# 你好👋！有什么可以帮助你的吗？

python3 chatglm_cpp/convert.py -i THUDM/glm-4v-9b -t q4_0 -vt q4_0 -o models/chatglm4v-ggml.bin
./build/bin/main -m models/chatglm4v-ggml.bin --image https://oss.gittoolsai.com/images/li-plus_chatglm.cpp_readme_f52c51021b38.jpg -p "这张图片有什么不寻常的地方" --temp 0
# 这张图片中不寻常的地方在于，男子正在一辆黄色出租车后面熨衣服。通常情况下，熨衣是在家中或洗衣店进行的，而不是在车辆上。此外，出租车在行驶中，男子却能够稳定地熨衣，这增加了场景的荒诞感。

$ python3 chatglm_cpp/convert.py -i THUDM/codegeex2-6b -t q4_0 -o models/codegeex2-ggml.bin
$ ./build/bin/main -m models/codegeex2-ggml.bin --temp 0 --mode generate -p "\
# language: Python
# write a bubble sort function
"


def bubble_sort(lst):
    for i in range(len(lst) - 1):
        for j in range(len(lst) - 1 - i):
            if lst[j] > lst[j + 1]:
                lst[j], lst[j + 1] = lst[j + 1], lst[j]
    return lst


print(bubble_sort([5, 4, 3, 2, 1]))

使用BLAS

BLAS库可以集成进来进一步加速矩阵乘法。然而，在某些情况下，使用BLAS可能会导致性能下降。是否启用BLAS应取决于基准测试的结果。

Accelerate框架

Accelerate框架在macOS上会自动启用。若要禁用它，需添加CMake标志 -DGGML_NO_ACCELERATE=ON。

OpenBLAS

OpenBLAS可以在CPU上提供加速。添加CMake标志 -DGGML_OPENBLAS=ON 即可启用。

cmake -B build -DGGML_OPENBLAS=ON && cmake --build build -j

CUDA

CUDA可以在NVIDIA GPU上加速模型推理。添加CMake标志 -DGGML_CUDA=ON 即可启用。

cmake -B build -DGGML_CUDA=ON && cmake --build build -j

默认情况下，所有内核都会针对所有可能的CUDA架构进行编译，这需要一些时间。若要在特定类型的设备上运行，可以指定 CMAKE_CUDA_ARCHITECTURES 来加快nvcc编译速度。例如：

cmake -B build -DGGML_CUDA=ON -DCMAKE_CUDA_ARCHITECTURES="80"       # 用于A100
cmake -B build -DGGML_CUDA=ON -DCMAKE_CUDA_ARCHITECTURES="70;75"    # 兼容V100和T4

要了解你的GPU设备的CUDA架构，可以查看NVIDIA GPU计算能力。

Metal

MPS（Metal性能着色器）允许计算在强大的Apple Silicon GPU上运行。添加CMake标志 -DGGML_METAL=ON 即可启用。

cmake -B build -DGGML_METAL=ON && cmake --build build -j

Python绑定

Python绑定提供了与原始Hugging Face ChatGLM(2)-6B类似的高级chat和stream_chat接口。

安装

推荐从PyPI安装：这将在你的平台上触发编译。

pip install -U chatglm-cpp

若要在NVIDIA GPU上启用CUDA：

CMAKE_ARGS="-DGGML_CUDA=ON" pip install -U chatglm-cpp

若要在Apple硅芯片设备上启用Metal：

CMAKE_ARGS="-DGGML_METAL=ON" pip install -U chatglm-cpp

你也可以从源码安装。为获得加速效果，需添加相应的CMAKE_ARGS。

# 从GitHub上托管的最新源码安装
pip install git+https://github.com/li-plus/chatglm.cpp.git@main

# 或者在 Git 克隆仓库后，从本地源安装
pip install .

适用于 Linux / MacOS / Windows 的 CPU 后端预编译轮子已在 release 中发布。对于 CUDA / Metal 后端，请从源代码或源码分发包进行编译。

使用预先转换的 GGML 模型

以下是一个简单的示例，使用 chatglm_cpp.Pipeline 加载 GGML 模型并与之对话。首先进入 examples 文件夹（cd examples），然后启动 Python 交互式 shell：

>>> import chatglm_cpp
>>> 
>>> pipeline = chatglm_cpp.Pipeline("../models/chatglm-ggml.bin")
>>> pipeline.chat([chatglm_cpp.ChatMessage(role="user", content="你好")])
ChatMessage(role="assistant", content="你好👋！我是人工智能助手 ChatGLM-6B，很高兴见到你，欢迎问我任何问题。", tool_calls=[])

若需以流式方式对话，请运行以下 Python 示例：

python3 cli_demo.py -m ../models/chatglm-ggml.bin -i

在浏览器中启动 Web 演示以进行对话：

python3 web_demo.py -m ../models/chatglm-ggml.bin

其他模型：

python3 cli_demo.py -m ../models/chatglm2-ggml.bin -p 你好 --temp 0.8 --top_p 0.8  # CLI 演示
python3 web_demo.py -m ../models/chatglm2-ggml.bin --temp 0.8 --top_p 0.8  # Web 演示

ChatGLM3-6B

CLI 演示

聊天模式：

python3 cli_demo.py -m ../models/chatglm3-ggml.bin -p 你好 --temp 0.8 --top_p 0.8

函数调用：

python3 cli_demo.py -m ../models/chatglm3-ggml.bin --temp 0.8 --top_p 0.8 --sp system/function_call.txt -i

代码解释器：

python3 cli_demo.py -m ../models/chatglm3-ggml.bin --temp 0.8 --top_p 0.8 --sp system/code_interpreter.txt -i

Web 演示

安装 Python 依赖项及用于代码解释器的 IPython 内核。

pip install streamlit jupyter_client ipython ipykernel
ipython kernel install --name chatglm3-demo --user

启动 Web 演示：

streamlit run chatglm3_demo.py

函数调用	代码解释器

python3 cli_demo.py -m ../models/chatglm4-ggml.bin -p 你好 --temp 0.8 --top_p 0.8

python3 cli_demo.py -m ../models/chatglm4v-ggml.bin --image 03-Confusing-Pictures.jpg -p "这张图片有什么不寻常之处" --temp 0

# CLI 演示
python3 cli_demo.py -m ../models/codegeex2-ggml.bin --temp 0 --mode generate -p "\
# language: Python
# write a bubble sort function
"
# Web 演示
python3 web_demo.py -m ../models/codegeex2-ggml.bin --temp 0 --max_length 512 --mode generate --plain

在运行时转换 Hugging Face LLMs

有时提前转换并保存中间 GGML 模型可能不太方便。这里提供一种直接从原始 Hugging Face 模型加载、在一分钟内将其量化为 GGML 模型并开始服务的方法。您只需将 GGML 模型路径替换为 Hugging Face 模型名称或路径即可。

>>> import chatglm_cpp
>>> 
>>> pipeline = chatglm_cpp.Pipeline("THUDM/chatglm-6b", dtype="q4_0")
Loading checkpoint shards: 100%|██████████████████████████████████| 8/8 [00:10<00:00,  1.27s/it]
Processing model states: 100%|████████████████████████████████| 339/339 [00:23<00:00, 14.73it/s]
...
>>> pipeline.chat([chatglm_cpp.ChatMessage(role="user", content="你好")])
ChatMessage(role="assistant", content="你好👋！我是人工智能助手 ChatGLM-6B，很高兴见到你，欢迎问我任何问题。", tool_calls=[])

同样地，在任何示例脚本中将 GGML 模型路径替换为 Hugging Face 模型，即可正常工作。例如：

python3 cli_demo.py -m THUDM/chatglm-6b -p 你好 -i

API 服务器

我们支持多种类型的 API 服务器，以便与流行的前端集成。可通过以下命令安装额外依赖：

pip install 'chatglm-cpp[api]'

请记得添加相应的 CMAKE_ARGS 以启用加速。

LangChain API

启动 LangChain 的 API 服务器：

MODEL=./models/chatglm2-ggml.bin uvicorn chatglm_cpp.langchain_api:app --host 127.0.0.1 --port 8000

使用 curl 测试 API 端点：

curl http://127.0.0.1:8000 -H 'Content-Type: application/json' -d '{"prompt": "你好"}'

结合 LangChain 使用：

>>> from langchain.llms import ChatGLM
>>> 
>>> llm = ChatGLM(endpoint_url="http://127.0.0.1:8000")
>>> llm.predict("你好")
'你好👋！我是人工智能助手 ChatGLM2-6B，很高兴见到你，欢迎问我任何问题。'

更多选项请参阅 examples/langchain_client.py 和 LangChain ChatGLM 集成。

OpenAI API

启动兼容 OpenAI 聊天完成协议的 API 服务器：

MODEL=./models/chatglm3-ggml.bin uvicorn chatglm_cpp.openai_api:app --host 127.0.0.1 --port 8000

使用 curl 测试您的端点：

curl http://127.0.0.1:8000/v1/chat/completions -H 'Content-Type: application/json' \
    -d '{"messages": [{"role": "user", "content": "你好"}]}'

使用 OpenAI 客户端与您的模型对话：

>>> from openai import OpenAI
>>> 
>>> client = OpenAI(base_url="http://127.0.0.1:8000/v1")
>>> response = client.chat.completions.create(model="default-model", messages=[{"role": "user", "content": "你好"}])
>>> response.choices[0].message.content
'你好👋！我是人工智能助手 ChatGLM3-6B，很高兴见到你，欢迎问我任何问题。'

如需流式响应，请查看示例客户端脚本：

python3 examples/openai_client.py --base_url http://127.0.0.1:8000/v1 --stream --prompt 你好

工具调用也同样支持：

python3 examples/openai_client.py --base_url http://127.0.0.1:8000/v1 --tool_call --prompt 上海天气怎么样

请求 GLM4V 并附带图像输入：

# 使用本地图像文件请求
python3 examples/openai_client.py --base_url http://127.0.0.1:8000/v1 --prompt "描述这张图片" \
    --image https://oss.gittoolsai.com/images/li-plus_chatglm.cpp_readme_f52c51021b38.jpg --temp 0
# 使用图像 URL 请求
python3 examples/openai_client.py --base_url http://127.0.0.1:8000/v1 --prompt "描述这张图片" \
    --image https://www.barnorama.com/wp-content/uploads/2016/12/03-Confusing-Pictures.jpg --temp 0

借助此 API 服务器作为后端，ChatGLM.cpp 模型可以无缝集成到任何使用 OpenAI 风格 API 的前端中，包括 mckaywrigley/chatbot-ui、fuergaosi233/wechat-chatgpt、Yidadaa/ChatGPT-Next-Web 等。

使用 Docker

选项 1：本地构建

在本地构建 Docker 镜像，并启动容器以在 CPU 上运行推理：

docker build . --network=host -t chatglm.cpp

# C++ 示例
docker run -it --rm -v $PWD/models:/chatglm.cpp/models chatglm.cpp ./build/bin/main -m models/chatglm-ggml.bin -p "你好"
# Python 示例
docker run -it --rm -v $PWD/models:/chatglm.cpp/models chatglm.cpp python3 examples/cli_demo.py -m models/chatglm-ggml.bin -p "你好"
# LangChain API 服务器
docker run -it --rm -v $PWD/models:/chatglm.cpp/models -p 8000:8000 -e MODEL=models/chatglm-ggml.bin chatglm.cpp \
    uvicorn chatglm_cpp.langchain_api:app --host 0.0.0.0 --port 8000
# OpenAI API 服务器
docker run -it --rm -v $PWD/models:/chatglm.cpp/models -p 8000:8000 -e MODEL=models/chatglm-ggml.bin chatglm.cpp \
    uvicorn chatglm_cpp.openai_api:app --host 0.0.0.0 --port 8000

若需支持 CUDA，请确保已安装 nvidia-docker。然后运行以下命令：

docker build . --network=host -t chatglm.cpp-cuda \
    --build-arg BASE_IMAGE=nvidia/cuda:12.2.0-devel-ubuntu20.04 \
    --build-arg CMAKE_ARGS="-DGGML_CUDA=ON -DCMAKE_CUDA_ARCHITECTURES=80"
docker run -it --rm --gpus all -v $PWD/models:/chatglm.cpp/models chatglm.cpp-cuda \
    ./build/bin/main -m models/chatglm-ggml.bin -p "你好"

选项 2：使用预构建镜像

用于 CPU 推理的预构建镜像已发布在 Docker Hub 和 GitHub Container Registry (GHCR) 上。

从 Docker Hub 拉取并运行示例：

docker run -it --rm -v $PWD/models:/chatglm.cpp/models liplusx/chatglm.cpp:main \
    ./build/bin/main -m models/chatglm-ggml.bin -p "你好"

从 GHCR 拉取并运行示例：

docker run -it --rm -v $PWD/models:/chatglm.cpp/models ghcr.io/li-plus/chatglm.cpp:main \
    ./build/bin/main -m models/chatglm-ggml.bin -p "你好"

预构建镜像也支持 Python 示例和 API 服务器，使用方法与 选项 1 相同。

性能

环境：

• CPU 后端性能是在一台配备 Intel(R) Xeon(R) Platinum 8260 CPU @ 2.40GHz 的 Linux 服务器上，使用 16 个线程进行测量。
• CUDA 后端性能是在一块 V100-SXM2-32GB GPU 上，使用 1 个线程进行测量。
• MPS 后端性能是在 Apple M2 Ultra 设备上，使用 1 个线程进行测量。

ChatGLM-6B：

ChatGLM2-6B / ChatGLM3-6B / CodeGeeX2：

ChatGLM4-9B：

模型质量

我们通过在 WikiText-2 测试数据集上评估困惑度来衡量模型质量，采用 https://huggingface.co/docs/transformers/perplexity 中的滑动窗口策略。较低的困惑度通常表示模型表现更好。

从 链接 下载并解压数据集。使用步长为 512、最大输入长度为 2048 的方式计算困惑度：

./build/bin/perplexity -m models/chatglm3-base-ggml.bin -f wikitext-2-raw/wiki.test.raw -s 512 -l 2048

开发

单元测试与基准测试

要执行单元测试，需添加 CMake 标志 -DCHATGLM_ENABLE_TESTING=ON 以启用测试功能。重新编译并运行单元测试（包括基准测试）：

mkdir -p build && cd build
cmake .. -DCHATGLM_ENABLE_TESTING=ON && make -j
./bin/chatglm_test

仅进行基准测试：

./bin/chatglm_test --gtest_filter='Benchmark.*'

代码格式化

要在 build 文件夹内格式化代码，运行 make lint。请确保已预先安装 clang-format、black 和 isort。

性能分析

要检测性能瓶颈，可添加 CMake 标志 -DGGML_PERF=ON：

cmake .. -DGGML_PERF=ON && make -j

这将在运行模型时打印每次图操作的耗时信息。

致谢

• 本项目深受 @ggerganov 的 llama.cpp 启发，并基于其 NN 库 ggml 构建。
• 感谢 @THUDM 提供的优秀 ChatGLM-6B、ChatGLM2-6B、ChatGLM3 和 GLM-4，以及他们发布的模型源代码和检查点。

ChatGLM.cpp 快速上手指南

ChatGLM.cpp 是基于 C++ 和 ggml 实现的 ChatGLM 系列模型推理框架，支持在 MacBook、Linux 和 Windows 上进行高效的本地实时对话。它支持 int4/int8 量化、流式输出以及 Python 绑定。

环境准备

系统要求

• 操作系统: Linux, macOS, Windows
• 硬件: x86/ARM CPU, NVIDIA GPU (需 CUDA), Apple Silicon GPU (需 Metal)
• 软件依赖:
  • Git
  • CMake (3.14+)
  • C++ 编译器 (GCC, Clang, 或 MSVC)
  • Python 3.8+ (用于模型转换和 Python 绑定)

前置依赖安装 在克隆仓库前，请确保已安装基础构建工具。若使用 GPU 加速，请提前安装对应的 CUDA Toolkit 或 Xcode (macOS)。

安装步骤

1. 克隆项目

递归克隆仓库以获取子模块：

git clone --recursive https://github.com/li-plus/chatglm.cpp.git && cd chatglm.cpp

注：如果忘记加 --recursive 参数，请在目录内运行 git submodule update --init --recursive。

2. 模型量化转换

ChatGLM.cpp 需要将 Hugging Face 格式的模型转换为 GGML 格式。首先安装必要的 Python 包（推荐使用国内镜像源加速）：

python3 -m pip install -U pip
python3 -m pip install torch tabulate tqdm transformers accelerate sentencepiece -i https://pypi.tuna.tsinghua.edu.cn/simple

执行转换脚本（以 ChatGLM3-6B 为例，转换为 int4 量化版本）：

python3 chatglm_cpp/convert.py -i THUDM/chatglm3-6b -t q4_0 -o models/chatglm3-ggml.bin

• -i: 模型名称（如 THUDM/chatglm3-6b）或本地路径。
• -t: 量化类型，推荐 q4_0 (int4) 以平衡速度与显存。
• -o: 输出文件路径。

支持的模型: ChatGLM-6B, ChatGLM2-6B, ChatGLM3, GLM-4(V), CodeGeeX2 等。

3. 编译项目

使用 CMake 构建项目。根据硬件选择是否开启加速：

• CPU 默认编译:

  cmake -B build
  cmake --build build -j --config Release
  

• NVIDIA GPU 加速 (CUDA):

  cmake -B build -DGGML_CUDA=ON
  cmake --build build -j --config Release
  

• Apple Silicon GPU 加速 (Metal):

  cmake -B build -DGGML_METAL=ON
  cmake --build build -j --config Release
  

基本使用

命令行交互

编译完成后，可直接运行生成的可执行文件进行对话。

单次问答示例：

./build/bin/main -m models/chatglm3-ggml.bin -p "你好"

交互式对话（多轮上下文）： 添加 -i 参数进入交互模式，历史对话将作为上下文。

./build/bin/main -m models/chatglm3-ggml.bin -i

提示：输入 exit 或按下 Ctrl+C 可退出交互模式。运行 ./build/bin/main -h 查看更多参数选项。

Python 快速调用

如果你更习惯使用 Python，可以直接安装预编译包或从源码安装。

安装：

pip install -U chatglm-cpp -i https://pypi.tuna.tsinghua.edu.cn/simple

如需开启 GPU 加速，请在安装前设置环境变量，例如：CMAKE_ARGS="-DGGML_CUDA=ON" pip install -U chatglm-cpp

代码示例：

import chatglm_cpp

# 加载量化后的模型
pipeline = chatglm_cpp.Pipeline("models/chatglm3-ggml.bin")

# 进行对话
response = pipeline.chat([chatglm_cpp.ChatMessage(role="user", content="你好")])
print(response.content)