轻松上手 llama.cpp：本地部署LLM指南 – wiki基地

作者： /

轻松上手 llama.cpp：本地部署LLM指南

引言：本地部署，掌控未来

大型语言模型（LLMs）如GPT系列、Llama、Mixtral等的崛起，彻底改变了我们与技术互动的方式。它们强大的文本生成、问答、编程辅助甚至创意激发能力令人惊叹。然而，大多数时候，我们通过云服务（如OpenAI API）来使用这些模型。这带来了便利，但也伴随着对隐私、数据安全、网络依赖以及潜在的成本担忧。

有没有一种方式，能让我们在自己的电脑上运行这些强大的模型，实现真正的“本地化”？

答案是肯定的，而 llama.cpp 正是实现这一目标的明星项目。

llama.cpp 是一个用 C/C++ 编写的推理框架，它最初是为了在 Apple Silicon 芯片（MacBook）上高效运行 Meta 的 LLaMA 模型而创建的。但很快，它发展成为一个高度优化、跨平台（支持 Linux、Windows、macOS）、支持多种模型架构（不仅仅是 LLaMA，还包括 Mistral, Mixtral, Falcon, StableLM, Qwen, Yi 等等）的通用 LLM 推理引擎。

llama.cpp 的核心优势在于其对硬件的极致优化和利用，特别是对 CPU 和 GPU 的内存管理（如内存映射）和高效计算，这使得原本需要在昂贵服务器上运行的大型模型，现在有可能在你的笔记本电脑甚至树莓派等低功耗设备上跑起来。

本地部署 LLM 不仅能解决隐私和数据安全问题，让你可以在完全离线的情况下使用模型，还能让你自由地尝试不同的模型、参数配置，甚至进行一些实验性的应用开发，而无需担心 API 调用次数或费用。

本篇文章将作为一份详尽的指南，带你从零开始，轻松上手 llama.cpp，在你的本地设备上成功运行一个大型语言模型。无论你是技术小白还是有一定经验的开发者，都能找到清晰的指引。

第一步：了解先决条件

在开始之前，我们需要确认你的环境是否满足运行 llama.cpp 的基本要求。幸运的是，llama.cpp 的要求相对宽松。

  1. 操作系统： llama.cpp 支持主流的操作系统，包括：
    • Linux (推荐，兼容性最好)
    • macOS (Apple Silicon 或 Intel 芯片)
    • Windows (通过 WSL2 或原生编译)
  2. 硬件：
    • CPU： 现代多核 CPU 即可。LLM 推理通常是计算密集型的，核心数和主频越高越好。即使没有强大的独立显卡，大部分模型也可以纯 CPU 运行。
    • RAM（内存）： 这是运行大型模型最关键的资源之一。模型越大，所需的内存越多。例如，一个 7B 参数的模型可能需要 6-8GB 的内存（取决于量化程度），一个 13B 模型可能需要 10-14GB，一个 70B 模型则可能需要 60GB 以上。如果你的内存不足，模型将无法加载或运行极其缓慢。建议至少有 16GB 内存，32GB 或更多则更好。
    • GPU（显卡）： 可选，但强烈推荐，尤其是如果你想获得更快的推理速度。llama.cpp 支持多种 GPU 后端：
      • NVIDIA (通过 CUDA 或 cuBLAS)
      • AMD (通过 ROCm 或 OpenCL – 支持相对有限或需要特定配置)
      • Intel (通过 OpenVINO 或 SYCL – 支持相对有限)
      • Apple Silicon (通过 Metal – Mac 用户福音，效率极高)
      • 跨平台通用后端 (如 OpenCL, Vulkan – 兼容性广但性能可能不如原生后端)
        如果使用 GPU，显存 (VRAM) 的大小至关重要。模型的一部分或全部层可以加载到显存中加速计算。显存越大，能加载的模型层越多，推理速度越快。一个 7B 模型可能需要 6-8GB VRAM，13B 模型可能需要 10-12GB VRAM (取决于量化和 -ngl 参数)。
    • 存储空间： LLM 模型文件通常很大，从几个 GB 到几十 GB 不等。你需要足够的硬盘空间来存放模型文件。建议使用固态硬盘 (SSD) 以加快模型加载速度。
  3. 软件：
    • Git： 用于克隆 llama.cpp 项目代码。大多数操作系统都内置或容易安装 Git。
    • CMake： 一个跨平台的构建工具，llama.cpp 使用它来管理编译过程。
    • C++ 编译器： 需要一个现代的 C++ 编译器。
      • Linux：GCC 或 Clang
      • macOS：Clang (Xcode Command Line Tools 中包含)
      • Windows：MSVC (随 Visual Studio 安装) 或 MinGW/MSYS2 (提供 GCC/Clang)
    • GPU 相关 SDK (如果使用 GPU 加速)：
      • NVIDIA：CUDA Toolkit (如果使用 CUDA 后端)
      • Apple Silicon：Xcode (包含 Metal 支持)
      • 其他：根据你选择的后端可能需要对应的开发工具包。

满足了这些条件后，我们就可以开始 llama.cpp 的部署之旅了。

第二步：获取 llama.cpp 代码

llama.cpp 项目托管在 GitHub 上。我们需要使用 Git 来克隆它的代码仓库。

  1. 打开终端或命令行工具。

  2. 执行克隆命令：

    bash
    git clone https://github.com/ggerganov/llama.cpp.git
    cd llama.cpp

    第一行命令会将 llama.cpp 项目的代码下载到当前目录下名为 llama.cpp 的文件夹中。
    第二行命令是进入到新创建的 llama.cpp 目录中，后续的所有操作基本都在这个目录下进行。

    提示： 如果你没有安装 Git，需要先安装 Git。安装方法因操作系统而异，通常通过包管理器（如 apt, yum, brew, chocolatey）或从 Git 官网下载安装包。

第三步：编译 llama.cpp

获取代码后，我们需要编译它，将其 C/C++ 源代码转化为可执行程序。llama.cpp 使用 CMake 来管理构建过程，然后调用本地的编译器进行实际编译。

编译步骤会因操作系统和是否启用 GPU 加速而有所不同。

3.1 基础编译 (CPU Only)

如果你的目标是纯 CPU 运行，或者想先跑起来最简单的版本，可以进行基础编译。

  • Linux / macOS：

    这是最简单的方式，直接使用 make。

    bash
    make

    llama.cpp 的 Makefile 已经配置好，执行 make 会自动检测你的系统并进行编译。编译成功后，可执行文件（如 main, chat, server 等）会出现在 llama.cpp 目录下。

    为了加快编译速度，可以利用多核 CPU：

    bash
    make -j $(nproc) # Linux
    make -j $(sysctl -n hw.ncpu) # macOS
    这会使用你所有的 CPU 核心进行并行编译。

  • Windows (推荐使用 Visual Studio + CMake CLI)：

    Windows 下的原生编译稍微复杂一些，推荐使用 Visual Studio 和 CMake 命令行工具。

    1. 安装 Visual Studio： 安装一个包含 C++ 开发工作负载的 Visual Studio 版本（如 Community 版，免费）。安装时确保勾选 “Desktop development with C++”。
    2. 安装 CMake： 从 CMake 官网下载并安装 Windows 安装包，安装时选择添加到系统 PATH。
    3. 打开 “x64 Native Tools Command Prompt for VS XXXX”： 在开始菜单搜索并打开与你安装的 Visual Studio 版本对应的 x64 Native Tools 命令提示符。这是为了设置正确的编译器环境。
    4. 进入 llama.cpp 目录： 在这个命令提示符窗口中，使用 cd 命令进入你克隆的 llama.cpp 目录。

    5. 使用 CMake 生成项目文件并编译：

      bash
      cmake -B build . # -B build 表示在当前目录创建一个名为 build 的子目录存放构建文件，. 表示源代码在当前目录
      cmake --build build --config Release
      第一行命令使用 CMake 在 build 目录下生成 Visual Studio 项目文件。
      第二行命令调用 CMake 构建工具编译 build 目录下的项目，使用 Release 配置以获得优化后的性能。
      编译成功后，可执行文件（如 main.exe, chat.exe, server.exe 等）会出现在 llama.cpp\build\bin\Release 目录下。

  • Windows (使用 WSL2 或 MinGW/MSYS2)：

    如果你熟悉 Linux 环境，可以在 Windows Subsystem for Linux (WSL2) 中按照 Linux 的方式编译，或者安装 MinGW/MSYS2 等环境来获得 make 命令。这通常比原生编译更简单。

3.2 启用 GPU 加速编译

如果你有支持的 GPU，强烈建议启用 GPU 加速，这将显著提高推理速度。启用方式是在运行 CMake 或 make 时指定相应的编译选项。

  • Linux / macOS (使用 make)：

    直接修改 Makefile 或者在 make 命令前设置环境变量。常用后端如下：

    • NVIDIA (CUDA/cuBLAS – 推荐)：
      bash
      # 确保已安装 NVIDIA 驱动和 CUDA Toolkit
      make LLAMA_CUBLAS=1
      或者指定具体的 BLAS 实现（如 cuBLAS, OpenBLAS, BLIS）：
      bash
      make LLAMA_BLAS=1 LLAMA_BLAS_VENDOR=cuBLAS # 使用 cuBLAS
      # make LLAMA_BLAS=1 LLAMA_BLAS_VENDOR=OpenBLAS # 使用 OpenBLAS (CPU)
      # make LLAMA_BLAS=1 LLAMA_BLAS_VENDOR=BLIS # 使用 BLIS (CPU)
      LLAMA_CUBLAS=1 是 LLAMA_BLAS=1 LLAMA_BLAS_VENDOR=cuBLAS 的简写。

    • Apple Silicon (Metal – Mac 用户必选)：
      bash
      make LLAMA_METAL=1

    • 其他通用后端 (可能需要额外库)：
      bash
      # make LLAMA_CLBLAST=1 # OpenCL
      # make LLAMA_VULKAN=1 # Vulkan

    多个选项同时启用： 你可以同时启用多个后端，llama.cpp 会在运行时根据可用性选择。例如：
    bash
    make LLAMA_CUBLAS=1 LLAMA_METAL=1 # 在兼容的系统上优先使用Metal，否则使用cuBLAS
    通常你只需要启用你硬件支持的最优后端即可。

  • Windows (使用 Visual Studio + CMake CLI)：

    在运行 cmake -B build . 时添加 GPU 后端选项。

    • NVIDIA (CUDA/cuBLAS – 推荐)：
      bash
      # 确保已安装 NVIDIA 驱动和 CUDA Toolkit
      cmake -B build . -DLLAMA_CUBLAS=on
      cmake --build build --config Release

    • 其他通用后端：
      bash
      # cmake -B build . -DLLAMA_CLBLAST=on
      # cmake -B build . -DLLAMA_VULKAN=on
      # cmake --build build --config Release

    同样，你可以同时启用多个后端选项。

3.3 验证编译结果

编译成功后，在对应的输出目录下（Linux/macOS 通常在 llama.cpp 根目录，Windows VS 编译通常在 build\bin\Release）应该能找到一些可执行文件。最常用的是 main (或 main.exe)，它是基本的命令行推理工具。

如果编译过程中出现错误，请仔细阅读错误信息。常见问题包括：
* 缺少依赖（如 CMake, 编译器, CUDA Toolkit）。
* 环境变量配置不正确（尤其是在 Windows 上）。
* 代码更新导致编译错误（尝试 git pull 更新到最新代码或切换到稳定版本）。

第四步：获取模型文件 (GGUF 格式)

llama.cpp 使用一种名为 GGUF (GPT-Generated Unified Format) 的文件格式来存储模型权重和元数据。GGUF 格式是 llama.cpp 社区推出的，设计用于高效地内存映射和加载模型，并且支持多种量化级别。

你不能直接使用 PyTorch (.pth), TensorFlow (.pb/.h5), Hugging Face Transformers (.bin/.safetensors) 等格式的模型文件。你需要找到已经转换成 GGUF 格式的模型。

最常见的 GGUF 模型分发平台是 Hugging Face。

  1. 访问 Hugging Face 网站： https://huggingface.co/

  2. 搜索 GGUF 模型： 在搜索框中输入你想找的模型名称，后面加上 “GGUF”。例如：

    • llama 3 gguf (Meta Llama 3 系列模型)
    • mistral gguf (Mistral AI 模型)
    • mixtral gguf (Mixtral AI 的 MoE 模型)
    • qwen gguf (阿里巴巴的通义千问模型)
    • yi gguf (零一万物的 Yi 模型)
    • openbmb minicpm gguf (清华智谱的 MiniCPM)
    • codellama gguf (代码生成模型)
    • …等等。

  3. 选择一个模型仓库： 搜索结果中通常会列出许多用户或组织转换的模型仓库。选择一个信誉较好、更新活跃的仓库。例如，TheBloke 是一个非常活跃且提供大量 GGUF 模型转换的社区成员。你可以直接搜索 TheBloke/[模型名称]-GGUF。

  4. 选择合适的模型文件： 进入模型仓库页面后，找到 Files and versions (文件与版本) 标签页。你会看到很多 .gguf 结尾的文件。这些文件通常以 [模型名称].[量化级别].gguf 的格式命名。

    理解量化级别非常重要：
    * 量化 (Quantization)： 是一种减小模型大小并加速推理的技术，通过降低模型参数的数值精度（例如从 32 位浮点数降低到 8 位或 4 位整数）。
    * GGUF 中的量化级别命名： 常见的命名有 Q4_0, Q4_1, Q5_0, Q5_1, Q8_0, Q4_K_M, Q5_K_S, Q5_K_M, Q6_K, Q8_0 等。
    * 数字表示量化后的位数（如 Q4 是 4 位）。
    * _K 后缀表示使用了针对 K 矩阵（Attention 中的 Key 和 Value）的专门量化技术，通常在相同位数下能提供更好的精度。
    * _S, _M 后缀表示不同的配置或优化。_M 通常是平衡大小和性能的推荐选项。
    * Q8_0 是 8 位量化，损失精度最少但文件最大，速度提升相对有限。
    * 无后缀或 Q3/Q4 等是最早期的量化，现在通常推荐 _K 系列。
    * FP16 是 16 位浮点数，文件大小较大，但精度最高，推理速度通常较慢（除非硬件对 FP16 有特别优化）。

    如何选择？
    * 文件大小： 量化位数越低，文件越小，加载所需内存越少。
    * 精度： 量化位数越高，精度损失越少，模型性能越接近原始模型。Q4_K_M 通常是 4 位量化中推荐的平衡选项。Q5_K_M/S 提供更好的精度但文件更大。Q8_0 精度损失最少但文件更大。
    * 硬件兼容性/性能： 不同的量化级别可能对特定硬件有不同的性能表现。通常，量化程度越高（位数越低），理论上推理速度越快，因为处理的数据量更少。但这也取决于硬件对低位整数计算的支持程度。

    建议： 如果你的内存或显存有限，优先选择 Q4_K_M 或更低（如 Q3_K_M，如果可用）。如果内存/显存充足，可以尝试 Q5_K_M 或 Q8_0 以获得更好的精度。文件大小会直观地告诉你模型需要的最低加载内存（实际运行还需要额外内存）。

  5. 下载模型文件： 选择你想要的 .gguf 文件，点击下载图标。请注意文件大小，确保你有足够的硬盘空间和下载带宽。

将下载的 .gguf 文件存放到你方便管理的位置。

第五步：运行模型进行推理

终于来到了激动人心的时刻！我们将使用 llama.cpp 编译出的 main (或 main.exe) 可执行程序加载 GGUF 模型并进行推理。

  1. 打开终端或命令行工具。

  2. 切换到 llama.cpp 的可执行文件所在目录。

    • Linux/macOS：通常是 llama.cpp 根目录。
    • Windows (make 编译)：通常是 llama.cpp 根目录。
    • Windows (VS + CMake 编译)：通常是 llama.cpp\build\bin\Release。
      使用 cd /path/to/your/llama.cpp/executable/directory 命令。

  3. 执行 main 程序：

    基本的运行命令格式是：
    bash
    ./main -m /path/to/your/model.gguf --prompt "Your input prompt here" [其他参数]
    或者在 Windows 上：
    bash
    main.exe -m C:\path\to\your\model.gguf --prompt "Your input prompt here" [其他参数]

    参数说明：

    • -m <model_path>：必需，指定你下载的 GGUF 模型文件的完整路径。请替换 /path/to/your/model.gguf 为实际路径。
    • --prompt "<text>"：必需，指定你想要模型处理或回复的输入文本。用引号括起来。
    • -n <tokens>：指定模型生成的最大 token 数。默认值通常是 32 或 128，对于更长的回复，你需要增加这个值，例如 -n 512 或 -n 1024。
    • --temp <temperature>：控制生成文本的随机性。值越大越随机、有创意（可能跑偏），值越小越确定、保守。通常在 0.0 到 1.0 之间，0.0 是确定性输出，1.0 是高随机性。默认值通常是 0.8。
    • --top-k <k>：采样参数，模型只从概率最高的 k 个 token 中进行采样。减少 k 会降低随机性。默认值通常是 40。
    • --top-p <p>：采样参数，模型从累计概率达到 p 的最小 token 集合中进行采样。结合 --top-k 使用。减少 p 会降低随机性。默认值通常是 0.95。
    • --repeat-penalty <penalty>：惩罚重复出现的 token。值越大，模型越不容易重复生成相同的词或短语。默认值通常是 1.1。
    • -c <context_size>：设置模型的上下文窗口大小（最大能记住多少之前的 token）。更大的上下文需要更多内存，但能处理更长的输入或进行更长的对话。注意，模型本身有其最大上下文限制，不能超过模型设计的值。默认值通常是 512。
    • -b <batch_size>：推理时的批处理大小。影响性能，特别是在 GPU 上。默认值通常是 512。
    • -ngl <n_gpu_layers> 或 --n-gpu-layers <n_gpu_layers>：重要！ 指定将多少层模型卸载到 GPU 上运行。 -ngl 0 表示纯 CPU 运行。设置一个正整数表示卸载的层数。设置为 -1 表示尽可能将所有层卸载到 GPU（取决于显存大小）。如果你的 GPU 显存足够，设置为 -1 通常是获得最佳性能的选择。如果显存不足，可以尝试逐渐减少这个值，直到模型可以加载为止。注意： 这个参数只有在编译时启用了 GPU 后端才有效。
    • -t <n_threads>：设置用于 CPU 推理的线程数。通常设置为你的 CPU 核心数或核心数的一半可以获得不错的性能。默认情况下 llama.cpp 会尝试检测并使用合适的线程数。
    • -h 或 --help：显示所有可用的命令行参数。

示例命令：

假设你下载了一个名为 llama-3-8b-instruct.Q4_K_M.gguf 的模型文件，存放在 /models 目录下，并且你想用 GPU 加速（编译时已启用 GPU），生成 512 个 token，并设置提示词：

  • Linux/macOS (假设模型在 /models 且编译时启用 Metal 或 cuBLAS):
    bash
    ./main -m /models/llama-3-8b-instruct.Q4_K_M.gguf --prompt "Write a short story about a cat exploring a new house." -n 512 -ngl -1

  • Windows (假设模型在 C:\models 且编译时启用 cuBLAS):
    bash
    .\main.exe -m C:\models\llama-3-8b-instruct.Q4_K_M.gguf --prompt "Write a short story about a cat exploring a new house." -n 512 -ngl -1

运行后的输出：

执行命令后，llama.cpp 会加载模型，然后根据你的提示词开始生成文本。你会看到模型逐字或逐 token 输出生成的内容。

在生成完成后或中断生成（按 Ctrl+C）后，llama.cpp 会显示一些统计信息，包括：
* load time: 模型加载所需时间。
* sample time: 采样生成 token 所需总时间。
* prompt eval time: 处理输入提示词所需时间。
* eval time: 生成回复 token 所需总时间。
* total time: 总运行时间。
* speed: 每秒生成的 token 数 (tokens/sec)。这是衡量推理速度的关键指标，越高越好。
* n_gpu_layers: 实际加载到 GPU 的层数。确认这个值是否是你期望的 -ngl 值（或者因为显存不足而小于 -ngl -1）。

观察 speed 指标，尝试调整 -ngl (如果使用 GPU) 或 -t (如果纯 CPU) 参数，看看哪种设置能获得最佳性能。一般来说，将模型尽可能多地放入 GPU 显存 (-ngl -1) 会获得最好的速度。

第六步：探索 llama.cpp 的其他功能

llama.cpp 不仅仅是一个简单的推理工具，它还包含一些其他有用的示例程序：

  • chat (或 chat.exe)： 提供一个简单的交互式聊天界面，可以像与聊天机器人一样与模型对话。
  • server (或 server.exe)： 启动一个本地的 HTTP 服务器，提供类似 OpenAI API 的接口，允许你通过 REST API 与模型交互。这对于开发者来说非常有用，可以将本地模型集成到其他应用中。
  • embeddings (或 embeddings.exe)： 用于计算文本的向量嵌入。
  • quantize (或 quantize.exe)： 允许你将 GGUF 模型重新量化到不同的精度级别。
  • convert (或 convert.py)： 用于将其他格式的模型（如 PyTorch .safetensors）转换为 GGUF 格式。这是一个 Python 脚本，需要安装 Python 环境和相关库。

你可以像运行 main 一样运行这些程序，通常也需要通过 -m 参数指定模型文件。例如，运行聊天：
bash
./chat -m /path/to/your/model.gguf -ngl -1
然后你就可以在命令行中输入你的消息，按回车与模型互动了。

第七步：故障排除与性能优化

在使用 llama.cpp 的过程中，你可能会遇到一些问题或希望进一步提升性能。

7.1 常见故障

  • “command not found” 或 “.exe is not recognized”: 确保你在终端中处于 main (或 main.exe) 文件所在的目录。
  • 模型加载失败：
    • 检查模型文件路径是否正确。
    • 确保模型文件是 .gguf 格式，并且没有损坏。
    • 内存不足 (Out of Memory – OOM)： 这是最常见的问题。如果控制台输出显示内存分配错误或程序崩溃，很可能是你的系统内存 (RAM) 或显存 (VRAM) 不够加载模型。
      • 解决方案： 尝试下载一个文件更小、量化级别更高（如 Q4_K_M 甚至 Q3_K_M）的模型版本。或者，如果你使用 GPU，尝试减少 -ngl 参数的值，只将模型的一部分加载到 GPU，其余部分在 CPU 上运行。如果纯 CPU 运行且 RAM 不足，除了换小模型别无他法。
  • GPU 加速未生效：
    • 确认你在编译 llama.cpp 时正确启用了对应的 GPU 后端（如 make LLAMA_CUBLAS=1 或 cmake -DLLAMA_CUBLAS=on）。
    • 确认你运行 main 时使用了 -ngl 参数，并且值大于 0 或等于 -1。
    • 确认你的系统正确安装了 GPU 驱动和相关的 SDK (如 CUDA Toolkit)。
    • 在 Windows 上，检查任务管理器（性能标签页）或使用 nvidia-smi (NVIDIA) 等工具，观察 GPU 使用率和显存占用，确认模型是否被卸载到 GPU。

7.2 性能优化建议

  • GPU 加速： 这是提升性能最有效的方法。确保你的硬件支持并正确启用了 GPU 后端，并设置合适的 -ngl 参数。将尽可能多的层放到 GPU 上。
  • 选择合适的模型和量化： 在满足任务需求的前提下，选择参数量较小（例如 7B vs 13B vs 70B）且量化级别较高（如 Q4_K_M, Q5_K_M）的模型。这会显著减少计算量和内存/显存需求。
  • CPU 线程数 (-t)： 如果是纯 CPU 运行或有部分层在 CPU 上运行，尝试调整 -t 参数。过少的线程无法充分利用 CPU，过多的线程可能引入调度开销。通常设置为你的物理核心数或逻辑核心数是个不错的起点，然后可以微调。
  • 上下文大小 (-c) 和 Batch Size (-b)： 增加上下文大小需要更多内存，可能会降低推理速度。调整 batch size (-b) 主要影响提示词处理速度，对后续 token 生成影响相对较小，可以尝试不同的值看看效果。
  • 硬件： 最终性能受限于你的硬件。更快的 CPU、更多/更快的 RAM、更大/更快的 GPU 显存都能带来性能提升。特别是 VRAM 容量是决定你能否将大型模型完全 offload 到 GPU 的关键。

结论：拥抱本地AI的可能性

恭喜你！通过本指南的学习，你已经掌握了使用 llama.cpp 在本地部署和运行大型语言模型的基本方法。从代码获取、编译，到模型下载、参数设置，再到最终运行推理，你已经迈出了拥抱本地 AI 的重要一步。

llama.cpp 的出现，极大地降低了普通用户和开发者在本地运行 LLM 的门槛，使得个性化、私密性高、离线可用的 AI 应用成为可能。你可以用它来搭建一个本地的智能助手、开发一个无需联网的创意写作工具，或者仅仅是为了学习和实验不同的模型。

这仅仅是开始。llama.cpp 社区非常活跃，项目不断更新和优化，支持的模型越来越多，功能也越来越强大。你可以持续关注项目的 GitHub 仓库，学习更多高级用法，比如模型量化、服务器部署、与其他应用的集成等等。

现在，选择一个你感兴趣的模型，在你的电脑上运行起来，开始探索本地 LLM 的无限可能性吧！享受掌控 AI 的乐趣！

发表评论

您的邮箱地址不会被公开。 必填项已用 * 标注

滚动至顶部