llama-cpp-python完全指南：从安装到生产级API服务搭建

llama-cpp-python完全指南：从安装到生产级API服务搭建

【免费下载链接】llama-cpp-python Python bindings for llama.cpp 项目地址: https://gitcode.com/gh_mirrors/ll/llama-cpp-python

简介

llama-cpp-python是一个为llama.cpp提供Python绑定的开源项目，它允许开发者在Python环境中轻松使用llama.cpp的功能。该项目提供了低级C API访问、高级Python API以及OpenAI兼容的Web服务器，支持文本补全、聊天补全、函数调用、多模态模型等多种功能。本文将从安装开始，详细介绍如何使用llama-cpp-python构建生产级的API服务。

核心功能

llama-cpp-python提供了以下核心功能：

• 低级C API访问，通过ctypes接口
• 高级Python API，支持文本补全
  • OpenAI风格的API
  • LangChain兼容性
  • LlamaIndex兼容性
• OpenAI兼容的Web服务器
  • 本地Copilot替代
  • 函数调用支持
  • 视觉API支持
  • 多模型支持

完整文档可在官方文档查看。

安装指南

系统要求

• Python 3.8+
• C编译器
  • Linux: gcc或clang
  • Windows: Visual Studio或MinGW
  • MacOS: Xcode

基础安装

要安装llama-cpp-python包，只需运行以下命令：

pip install llama-cpp-python

这将从源代码构建llama.cpp并将其与Python包一起安装。如果安装失败，可以添加--verbose选项以查看完整的cmake构建日志。

预构建Wheel（新功能）

还可以安装具有基本CPU支持的预构建wheel：

pip install llama-cpp-python \
  --extra-index-url https://abetlen.github.io/llama-cpp-python/whl/cpu

安装配置

llama.cpp支持多种硬件加速后端以加快推理速度，以及特定于后端的选项。有关完整列表，请参见llama.cpp README。

所有llama.cpp cmake构建选项都可以通过CMAKE_ARGS环境变量或安装过程中的--config-settings / -C cli标志进行设置。

环境变量

# Linux和Mac
CMAKE_ARGS="-DGGML_BLAS=ON -DGGML_BLAS_VENDOR=OpenBLAS" \
  pip install llama-cpp-python

# Windows
$env:CMAKE_ARGS = "-DGGML_BLAS=ON -DGGML_BLAS_VENDOR=OpenBLAS"
pip install llama-cpp-python

CLI / requirements.txt

也可以通过pip install -C / --config-settings命令设置这些选项，并保存到requirements.txt文件中：

pip install --upgrade pip # 确保pip是最新的
pip install llama-cpp-python \
  -C cmake.args="-DGGML_BLAS=ON;-DGGML_BLAS_VENDOR=OpenBLAS"

# requirements.txt
llama-cpp-python -C cmake.args="-DGGML_BLAS=ON;-DGGML_BLAS_VENDOR=OpenBLAS"

支持的后端

以下是一些常见的后端、它们的构建命令以及所需的其他环境变量。

OpenBLAS（CPU）

要使用OpenBLAS安装，在安装前设置GGML_BLAS和GGML_BLAS_VENDOR环境变量：

CMAKE_ARGS="-DGGML_BLAS=ON -DGGML_BLAS_VENDOR=OpenBLAS" pip install llama-cpp-python

CUDA

要安装CUDA支持，在安装前设置GGML_CUDA=on环境变量：

CMAKE_ARGS="-DGGML_CUDA=on" pip install llama-cpp-python

预构建Wheel（新功能）

也可以安装具有CUDA支持的预构建wheel，只要系统满足以下要求：

• CUDA版本为12.1、12.2、12.3、12.4或12.5
• Python版本为3.10、3.11或3.12

pip install llama-cpp-python \
  --extra-index-url https://abetlen.github.io/llama-cpp-python/whl/<cuda-version>

其中<cuda-version>是以下之一：

• cu121: CUDA 12.1
• cu122: CUDA 12.2
• cu123: CUDA 12.3
• cu124: CUDA 12.4
• cu125: CUDA 12.5

例如，安装CUDA 12.1 wheel：

pip install llama-cpp-python \
  --extra-index-url https://abetlen.github.io/llama-cpp-python/whl/cu121

Metal（MacOS）

要安装Metal（MPS）支持，在安装前设置GGML_METAL=on环境变量：

CMAKE_ARGS="-DGGML_METAL=on" pip install llama-cpp-python

预构建Wheel（新功能）

也可以安装具有Metal支持的预构建wheel，只要系统满足以下要求：

• MacOS版本为11.0或更高
• Python版本为3.10、3.11或3.12

pip install llama-cpp-python \
  --extra-index-url https://abetlen.github.io/llama-cpp-python/whl/metal

详细的MacOS Metal GPU安装文档可在docs/install/macos.md找到。

其他后端

llama-cpp-python还支持其他后端，如hipBLAS（ROCm）、Vulkan、SYCL和RPC。具体安装方法请参考官方文档。

系统特定注意事项

Windows注意事项

如果遇到找不到'nmake'或CMAKE_C_COMPILER的错误，可以按照llama.cpp仓库中的说明提取w64devkit，并在运行pip install之前手动将其添加到CMAKE_ARGS：

$env:CMAKE_GENERATOR = "MinGW Makefiles"
$env:CMAKE_ARGS = "-DGGML_OPENBLAS=on -DCMAKE_C_COMPILER=C:/w64devkit/bin/gcc.exe -DCMAKE_CXX_COMPILER=C:/w64devkit/bin/g++.exe"

MacOS注意事项

M1 Mac性能问题

注意：如果使用Apple Silicon（M1）Mac，请确保安装了支持arm64架构的Python版本。例如：

wget https://github.com/conda-forge/miniforge/releases/latest/download/Miniforge3-MacOSX-arm64.sh
bash Miniforge3-MacOSX-arm64.sh

否则，安装时将构建llama.cpp的x86版本，在Apple Silicon（M1）Mac上速度会慢10倍。

M系列Mac错误：(mach-o file, but is an incompatible architecture (have 'x86_64', need 'arm64'))

尝试使用以下命令安装：

CMAKE_ARGS="-DCMAKE_OSX_ARCHITECTURES=arm64 -DCMAKE_APPLE_SILICON_PROCESSOR=arm64 -DGGML_METAL=on" pip install --upgrade --verbose --force-reinstall --no-cache-dir llama-cpp-python

升级和重新安装

要升级并重建llama-cpp-python，请在pip install命令中添加--upgrade --force-reinstall --no-cache-dir标志，以确保从源代码重建包。

高级Python API使用

基础用法

高级API通过Llama类提供了一个简单的托管接口。

以下是一个使用高级API进行基本文本补全的简短示例：

from llama_cpp import Llama

llm = Llama(
      model_path="./models/7B/llama-model.gguf",
      # n_gpu_layers=-1, # 取消注释以使用GPU加速
      # seed=1337, # 取消注释以设置特定种子
      # n_ctx=2048, # 取消注释以增加上下文窗口
)
output = llm(
      "Q: Name the planets in the solar system? A: ", # 提示
      max_tokens=32, # 生成最多32个token，设为None则生成到上下文窗口结束
      stop=["Q:", "\n"], # 在模型生成新问题之前停止
      echo=True # 在输出中回显提示
) # 生成补全，也可以调用create_completion
print(output)

默认情况下，llama-cpp-python生成OpenAI兼容格式的补全：

{
  "id": "cmpl-xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
  "object": "text_completion",
  "created": 1679561337,
  "model": "./models/7B/llama-model.gguf",
  "choices": [
    {
      "text": "Q: Name the planets in the solar system? A: Mercury, Venus, Earth, Mars, Jupiter, Saturn, Uranus, Neptune and Pluto.",
      "index": 0,
      "logprobs": None,
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 14,
    "completion_tokens": 28,
    "total_tokens": 42
  }
}

文本补全可通过Llama类的__call__和create_completion方法获得。

从Hugging Face Hub拉取模型

可以使用from_pretrained方法直接从Hugging Face下载gguf格式的Llama模型。需要安装huggingface-hub包才能使用此功能（pip install huggingface-hub）。

llm = Llama.from_pretrained(
    repo_id="Qwen/Qwen2-0.5B-Instruct-GGUF",
    filename="*q8_0.gguf",
    verbose=False
)

默认情况下，from_pretrained会将模型下载到huggingface缓存目录，然后可以使用huggingface-cli工具管理已安装的模型文件。

聊天补全

高级API还提供了一个简单的聊天补全接口。

聊天补全要求模型知道如何将消息格式化为单个提示。Llama类通过预注册的聊天格式（即chatml、llama-2、gemma等）或提供自定义聊天处理程序对象来实现这一点。

模型将按照以下优先级顺序将消息格式化为单个提示：

• 如果提供，则使用chat_handler
• 如果提供，则使用chat_format
• 使用gguf模型元数据中的tokenizer.chat_template（大多数新模型应该支持，旧模型可能不支持）
• 否则，回退到llama-2聊天格式

设置verbose=True可以查看所选的聊天格式。

from llama_cpp import Llama
llm = Llama(
      model_path="path/to/llama-2/llama-model.gguf",
      chat_format="llama-2"
)
llm.create_chat_completion(
      messages = [
          {"role": "system", "content": "You are an assistant who perfectly describes images."},
          {
              "role": "user",
              "content": "Describe this image in detail please."
          }
      ]
)

聊天补全可通过Llama类的create_chat_completion方法获得。

为了与OpenAI API v1兼容，可以使用create_chat_completion_openai_v1方法，该方法将返回pydantic模型而不是字典。

JSON和JSON Schema模式

要将聊天响应限制为仅有效的JSON或特定的JSON Schema，可以在create_chat_completion中使用response_format参数。

JSON模式

以下示例将响应限制为仅有效的JSON字符串。

from llama_cpp import Llama
llm = Llama(model_path="path/to/model.gguf", chat_format="chatml")
llm.create_chat_completion(
    messages=[
        {
            "role": "system",
            "content": "You are a helpful assistant that outputs in JSON.",
        },
        {"role": "user", "content": "Who won the world series in 2020"},
    ],
    response_format={
        "type": "json_object",
    },
    temperature=0.7,
)

JSON Schema模式

要进一步将响应限制为特定的JSON Schema，可以将模式添加到response_format参数的schema属性中。

from llama_cpp import Llama
llm = Llama(model_path="path/to/model.gguf", chat_format="chatml")
llm.create_chat_completion(
    messages=[
        {
            "role": "system",
            "content": "You are a helpful assistant that outputs in JSON.",
        },
        {"role": "user", "content": "Who won the world series in 2020"},
    ],
    response_format={
        "type": "json_object",
        "schema": {
            "type": "object",
            "properties": {"team_name": {"type": "string"}},
            "required": ["team_name"],
        },
    },
    temperature=0.7,
)

函数调用

高级API支持OpenAI兼容的函数和工具调用。这可以通过预训练的functionary模型聊天格式或通用的chatml-function-calling聊天格式实现。

from llama_cpp import Llama
llm = Llama(model_path="path/to/chatml/llama-model.gguf", chat_format="chatml-function-calling")
llm.create_chat_completion(
      messages = [
        {
          "role": "system",
          "content": "A chat between a curious user and an artificial intelligence assistant. The assistant gives helpful, detailed, and polite answers to the user's questions. The assistant calls functions with appropriate input when necessary"

        },
        {
          "role": "user",
          "content": "Extract Jason is 25 years old"
        }
      ],
      tools=[{
        "type": "function",
        "function": {
          "name": "UserDetail",
          "parameters": {
            "type": "object",
            "title": "UserDetail",
            "properties": {
              "name": {
                "title": "Name",
                "type": "string"
              },
              "age": {
                "title": "Age",
                "type": "integer"
              }
            },
            "required": [ "name", "age" ]
          }
        }
      }],
      tool_choice={
        "type": "function",
        "function": {
          "name": "UserDetail"
        }
      }
)

Functionary v2

可以在这里找到该系列模型的各种gguf转换文件。Functionary能够智能地调用函数，并分析任何提供的函数输出以生成连贯的响应。所有v2版本的functionary模型都支持并行函数调用。初始化Llama类时，可以提供functionary-v1或functionary-v2作为chat_format。

由于llama.cpp和HuggingFace的tokenizers之间存在差异，需要为functionary提供HF Tokenizer。LlamaHFTokenizer类可以初始化并传递给Llama类。这将覆盖Llama类中使用的默认llama.cpp tokenizer。tokenizer文件已包含在托管gguf文件的各个HF仓库中。

from llama_cpp import Llama
from llama_cpp.llama_tokenizer import LlamaHFTokenizer
llm = Llama.from_pretrained(
  repo_id="meetkai/functionary-small-v2.2-GGUF",
  filename="functionary-small-v2.2.q4_0.gguf",
  chat_format="functionary-v2",
  tokenizer=LlamaHFTokenizer.from_pretrained("meetkai/functionary-small-v2.2-GGUF")
)

注意：不需要提供Functionary中使用的默认系统消息，因为它们会自动添加到Functionary聊天处理程序中。因此，消息应仅包含聊天消息和/或为模型提供额外上下文的系统消息（例如：datetime等）。

多模态模型

llama-cpp-python支持诸如llava1.5之类的多模态模型，这些模型允许语言模型从文本和图像中读取信息。

以下是支持的多模态模型及其各自的聊天处理程序（Python API）和聊天格式（服务器API）。

模型	LlamaChatHandler	chat_format
llava-v1.5-7b	Llava15ChatHandler	llava-1-5
llava-v1.5-13b	Llava15ChatHandler	llava-1-5
llava-v1.6-34b	Llava16ChatHandler	llava-1-6
moondream2	MoondreamChatHandler	moondream2
nanollava	NanollavaChatHandler	nanollava
llama-3-vision-alpha	Llama3VisionAlphaChatHandler	llama-3-vision-alpha
minicpm-v-2.6	MiniCPMv26ChatHandler	minicpm-v-2.6
qwen2.5-vl	Qwen25VLChatHandler	qwen2.5-vl

需要使用自定义聊天处理程序来加载clip模型并处理聊天消息和图像。

from llama_cpp import Llama
from llama_cpp.llama_chat_format import Llava15ChatHandler
chat_handler = Llava15ChatHandler(clip_model_path="path/to/llava/mmproj.bin")
llm = Llama(
  model_path="./path/to/llava/llama-model.gguf",
  chat_handler=chat_handler,
  n_ctx=2048, # n_ctx应增加以适应图像嵌入
)
llm.create_chat_completion(
    messages = [
        {"role": "system", "content": "You are an assistant who perfectly describes images."},
        {
            "role": "user",
            "content": [
                {"type" : "text", "text": "What's in this image?"},
                {"type": "image_url", "image_url": {"url": "https://upload.wikimedia.org/wikipedia/commons/thumb/d/dd/Gfp-wisconsin-madison-the-nature-boardwalk.jpg/2560px-Gfp-wisconsin-madison-the-nature-boardwalk.jpg" } }
            ]
        }
    ]
)

也可以使用from_pretrained方法从Hugging Face Hub拉取模型。

from llama_cpp import Llama
from llama_cpp.llama_chat_format import MoondreamChatHandler

chat_handler = MoondreamChatHandler.from_pretrained(
  repo_id="vikhyatk/moondream2",
  filename="*mmproj*",
)

llm = Llama.from_pretrained(
  repo_id="vikhyatk/moondream2",
  filename="*text-model*",
  chat_handler=chat_handler,
  n_ctx=2048, # n_ctx应增加以适应图像嵌入
)

response = llm.create_chat_completion(
    messages = [
        {
            "role": "user",
            "content": [
                {"type": "image_url", "image_url": {"url": "https://upload.wikimedia.org/wikipedia/commons/thumb/d/dd/Gfp-wisconsin-madison-the-nature-boardwalk.jpg/2560px-Gfp-wisconsin-madison-the-nature-boardwalk.jpg" } },
                {"type" : "text", "text": "What's in this image?"}

            ]
        }
    ]
)
print(response["choices"][0]["text"])

注意：多模态模型还支持工具调用和JSON模式。

加载本地图像

图像可以作为base64编码的数据URI传递。以下示例演示了如何执行此操作。

import base64

def image_to_base64_data_uri(file_path):
    with open(file_path, "rb") as img_file:
        base64_data = base64.b64encode(img_file.read()).decode('utf-8')
        return f"data:image/png;base64,{base64_data}"

# 将'file_path.png'替换为PNG文件的实际路径
file_path = 'file_path.png'
data_uri = image_to_base64_data_uri(file_path)

messages = [
    {"role": "system", "content": "You are an assistant who perfectly describes images."},
    {
        "role": "user",
        "content": [
            {"type": "image_url", "image_url": {"url": data_uri }},
            {"type" : "text", "text": "Describe this image in detail please."}
        ]
    }
]

投机解码

llama-cpp-python支持投机解码，允许模型基于草稿模型生成补全。

使用投机解码的最快方法是通过LlamaPromptLookupDecoding类。

只需在初始化期间将其作为草稿模型传递给Llama类。

from llama_cpp import Llama
from llama_cpp.llama_speculative import LlamaPromptLookupDecoding

llama = Llama(
    model_path="path/to/model.gguf",
    draft_model=LlamaPromptLookupDecoding(num_pred_tokens=10) # num_pred_tokens是要预测的token数量，10是默认值，通常对GPU很好，2对仅CPU机器性能更好。
)

嵌入生成

要生成文本嵌入，请使用create_embedding或embed。注意，为了使这些功能正常工作，必须在创建模型时向构造函数传递embedding=True。

import llama_cpp

llm = llama_cpp.Llama(model_path="path/to/model.gguf", embedding=True)

embeddings = llm.create_embedding("Hello, world!")

# 或者一次创建多个嵌入

embeddings = llm.create_embedding(["Hello, world!", "Goodbye, world!"])

在Transformer风格的模型中，嵌入主要有两种概念：token级别和序列级别。序列级嵌入是通过将token级嵌入"池化"在一起产生的，通常是通过平均它们或使用第一个token。

专门用于嵌入的模型通常默认返回序列级嵌入，每个输入字符串一个。非嵌入模型（如那些设计用于文本生成的模型）通常只返回token级嵌入，每个序列中的每个token一个。因此，token级嵌入的返回类型的维度将高出一个。

在某些情况下，可以使用模型创建时的pooling_type标志控制池化行为。使用LLAMA_POOLING_TYPE_NONE可以确保从任何模型获得token级嵌入。相反，让面向生成的模型产生序列级嵌入目前是不可能的，但可以始终手动进行池化。

调整上下文窗口

Llama模型的上下文窗口决定了一次可以处理的最大token数量。默认情况下，这设置为512个token，但可以根据需求进行调整。

例如，如果需要处理更大的上下文，可以在初始化Llama对象时设置n_ctx参数来扩展上下文窗口：

llm = Llama(model_path="./models/7B/llama-model.gguf", n_ctx=2048)

OpenAI兼容Web服务器

llama-cpp-python提供了一个旨在作为OpenAI API替代品的Web服务器。这允许将llama.cpp兼容模型与任何OpenAI兼容客户端（语言库、服务等）一起使用。

安装和启动

要安装服务器包并开始使用：

pip install 'llama-cpp-python[server]'
python3 -m llama_cpp.server --model models/7B/llama-model.gguf

类似于上面的硬件加速部分，也可以像这样安装GPU（cuBLAS）支持：

CMAKE_ARGS="-DGGML_CUDA=on" FORCE_CMAKE=1 pip install 'llama-cpp-python[server]'
python3 -m llama_cpp.server --model models/7B/llama-model.gguf --n_gpu_layers 35

导航到http://localhost:8000/docs查看OpenAPI文档。

要绑定到0.0.0.0以启用远程连接，请使用python3 -m llama_cpp.server --host 0.0.0.0。同样，要更改端口（默认为8000），使用--port。

可能还需要设置提示格式。对于chatml，使用：

python3 -m llama_cpp.server --model models/7B/llama-model.gguf --chat_format chatml

服务器选项

要查看完整的选项列表，请运行：

python3 -m llama_cpp.server --help

注意：所有服务器选项也可用作环境变量。例如，可以通过设置MODEL环境变量来设置--model。

有关可用选项的更多信息，请查看下面的服务器配置参考。所有ServerSettings和ModelSettings中定义的字段都可以通过CLI参数和环境变量进行设置。

此外，服务器支持配置，请查看配置部分以获取更多信息和示例。

代码补全

llama-cpp-python通过GitHub Copilot支持代码补全。

注意：没有GPU加速的话，这可能不够快，无法使用。

首先需要下载GGUF格式的可用代码补全模型之一：

• replit-code-v1_5-GGUF

然后需要运行OpenAI兼容的Web服务器，并大幅增加GitHub Copilot请求的上下文大小：

python3 -m llama_cpp.server --model <model_path> --n_ctx 16192

然后只需更新.vscode/settings.json中的设置，指向代码补全服务器：

{
    // ...
    "github.copilot.advanced": {
        "debug.testOverrideProxyUrl": "http://<host>:<port>",
        "debug.overrideProxyUrl": "http://<host>:<port>"
    }
    // ...
}

函数调用

llama-cpp-python支持基于JSON模式的结构化函数调用。函数调用与OpenAI函数调用API完全兼容，可以通过官方OpenAI Python客户端连接使用。

首先需要下载GGUF格式的可用函数调用模型之一：

• functionary

然后运行服务器时，还需要指定用于函数调用的chat_format，如functionary-v1或functionary-v2。

注意，由于llama.cpp和HuggingFace的tokenizers之间存在差异，如这里所述，需要为functionary提供HF Tokenizer。tokenizer文件已包含在托管gguf文件的各个HF仓库中。

python3 -m llama_cpp.server --model <model_path_to_functionary_v2_model> --chat_format functionary-v2 --hf_pretrained_model_name_or_path <model_path_to_functionary_v2_tokenizer>

查看此示例笔记本，了解函数调用的一些有趣用例。

多模态模型

llama-cpp-python支持llava1.5系列多模态模型，允许语言模型从文本和图像中读取信息。

首先需要下载GGUF格式的可用多模态模型之一：

• llava-v1.5-7b
• llava-v1.5-13b
• bakllava-1-7b
• llava-v1.6-34b
• moondream2

然后运行服务器时，还需要指定用于图像嵌入的clip模型的路径和llava-1-5 chat_format：

python3 -m llama_cpp.server --model <model_path> --clip_model_path <clip_model_path> --chat_format llava-1-5

然后可以像平常一样使用OpenAI API：

from openai import OpenAI

client = OpenAI(base_url="http://<host>:<port>/v1", api_key="sk-xxx")
response = client.chat.completions.create(
    model="gpt-4-vision-preview",
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "image_url",
                    "image_url": {
                        "url": "<image_url>"
                    },
                },
                {"type": "text", "text": "What does the image say"},
            ],
        }
    ],
)
print(response)

配置和多模型支持

服务器支持通过JSON配置文件进行配置，可以使用--config_file参数或CONFIG_FILE环境变量传递该文件。

python3 -m llama_cpp.server --config_file <config_file>

配置文件支持CLI和环境变量支持的所有服务器和模型选项，但不是仅支持单个模型，配置文件可以指定多个模型。

服务器支持基于请求中的model参数将请求路由到多个模型，该参数与配置文件中的model_alias匹配。

目前，内存中只加载一个模型，服务器将根据需要自动加载和卸载模型。

{
    "host": "0.0.0.0",
    "port": 8080,
    "models": [
        {
            "model": "models/OpenHermes-2.5-Mistral-7B-GGUF/openhermes-2.5-mistral-7b.Q4_K_M.gguf",
            "model_alias": "gpt-3.5-turbo",
            "chat_format": "chatml",
            "n_gpu_layers": -1,
            "offload_kqv": true,
            "n_threads": 12,
            "n_batch": 512,
            "n_ctx": 2048
        },
        {
            "model": "models/OpenHermes-2.5-Mistral-7B-GGUF/openhermes-2.5-mistral-7b.Q4_K_M.gguf",
            "model_alias": "gpt-4",
            "chat_format": "chatml",
            "n_gpu_layers": -1,
            "offload_kqv": true,
            "n_threads": 12,
            "n_batch": 512,
            "n_ctx": 2048
        },
        {
            "model": "models/ggml_llava-v1.5-7b/ggml-model-q4_k.gguf",
            "model_alias": "gpt-4-vision-preview",
            "chat_format": "llava-1-5",
            "clip_model_path": "models/ggml_llava-v1.5-7b/mmproj-model-f16.gguf",
            "n_gpu_layers": -1,
            "offload_kqv": true,
            "n_threads": 12,
            "n_batch": 512,
            "n_ctx": 2048
        },
        {
            "model": "models/mistral-7b-v0.1-GGUF/ggml-model-Q4_K.gguf",
            "model_alias": "text-davinci-003",
            "n_gpu_layers": -1,
            "offload_kqv": true,
            "n_threads": 12,
            "n_batch": 512,
            "n_ctx": 2048
        },
        {
            "model": "models/replit-code-v1_5-3b-GGUF/replit-code-v1_5-3b.Q4_0.gguf",
            "model_alias": "copilot-codex",
            "n_gpu_layers": -1,
            "offload_kqv": true,
            "n_threads": 12,
            "n_batch": 1024,
            "n_ctx": 9216
        }
    ]
}

配置文件格式由ConfigFileSettings类定义。

自定义FastAPI服务器

llama-cpp-python还提供了创建自定义FastAPI服务器的示例。要运行此示例：

pip install fastapi uvicorn sse-starlette
export MODEL=../models/7B/...

然后运行：

uvicorn --factory llama_cpp.server.app:create_app --reload

或

python3 -m llama_cpp.server

然后访问http://localhost:8000/docs查看交互式API文档。

要查看服务器的实际实现，请参见llama_cpp/server/app.py。

总结

llama-cpp-python是一个功能强大的工具，它为llama.cpp提供了Python绑定，使得在Python环境中使用llama.cpp的功能变得简单。从简单的文本补全到复杂的多模态模型和函数调用，llama-cpp-python都提供了直观的API。通过OpenAI兼容的Web服务器，还可以轻松构建生产级的API服务。

无论您是想在本地开发环境中使用llama.cpp，还是构建一个完整的AI服务，llama-cpp-python都能满足您的需求。通过本文档，您应该已经掌握了从安装到高级功能使用的所有知识。现在，您可以开始构建自己的AI应用了！

【免费下载链接】llama-cpp-python Python bindings for llama.cpp 项目地址: https://gitcode.com/gh_mirrors/ll/llama-cpp-python