> ## Content Index
> Fetch the complete content index at: https://www.hubwiz.com/blog/llms.txt
> Use this file to discover other available public pages before exploring further.

# 本地运行大模型的5个工具
- URL: https://www.hubwiz.com/blog/5-tools-to-serve-llms-locally/
- Published: 2024-12-14T13:46:39.000Z
- Updated: 2024-12-14T13:46:39.000Z
- Description: 在本指南中，我们将重点介绍5个在大模型本地服务领域取得进展的著名项目：VLLM、LLAMA CPP Server 、SGLang、Ollama和TGI。
- Author: admin
- Tags: TOOL, VLLM, LLAMA.CPP, SGLANG, OLLAMA, TGI, #Import 2026-10-14 14:41

在快速发展的人工智能领域，有效地服务大型语言模型 (LLM) 和视觉语言模型 (VLM) 对于充分发挥其潜力至关重要。随着这些模型变得越来越复杂，找到强大且可扩展的服务解决方案变得越来越重要。

在本指南中，我们将重点介绍5个在这一领域取得进展的著名项目：VLLM、LLAMA CPP Server 、SGLang、Ollama和TGI。

## 1、VLLM

![](https://www.hubwiz.com/blog/content/images/2024/12/image-582.png)

[VLLM](https://docs.vllm.ai/en/latest/index.html?ref=hubwiz.com) 是一个高性能库，专为高效的 LLM 推理和服务而设计。它在吞吐量和灵活性方面表现出色，具有最先进的服务功能、通过 PagedAttention 实现的高效内存管理以及持续请求批处理等功能。 CUDA/HIP 图形执行和优化的 CUDA 内核提高了其性能。VLLM 支持各种量化方法，并与流行的 HuggingFace 模型无缝集成。它还提供高吞吐量服务，具有多种解码算法、张量和管道并行性、流式输出，并与 NVIDIA 和 AMD GPU 兼容。实验性功能包括前缀缓存和多 lora 支持。

![](https://www.hubwiz.com/blog/content/images/2024/12/image-583.png)

### 1.1 使用说明

要安装 VLLM，请运行以下命令：

```
pip install vllm

```

安装后，你可以使用以下命令提供 LLM：

```
vllm serve Qwen/Qwen2-1.5B-Instruct --dtype auto --api-key token-abc123
```

基本 vllm 参数：

- `--host` HOSTNAME：服务器主机名（默认值：localhost）
- `--port` PORT：服务器端口号（默认值：8000）
- `--api-key` KEY：用于服务器访问的 API 密钥（如果提供，服务器需要此密钥在标头中）
- `--model` MODEL：要使用的 HuggingFace 模型的名称或路径（例如，Qwen/Qwen2-1.5B-Instruct）
- `--tokenizer` TOKENIZER：要使用的标记器的名称或路径（例如，Qwen/Qwen2-1.5B-Instruct）
- `--quantization` METHOD：量化方法模型权重（例如，aqlm、awq、fp8、bitsandbytes、None）
- `--dtype` TYPE：模型权重和激活的数据类型（例如，auto、half、float16、bfloat16、float32）
- `--device` DEVICE：执行设备类型（例如，auto、cuda、cpu、tpu）
- `--lora-modules` MODULES：LoRA 模块配置（名称=路径对列表）

### 1.2 使用 Docker 部署

要使用 Docker 部署 VLLM，请运行以下命令：

```
docker pull vllm/vllm-openai:v0.5.4

docker run --runtime nvidia --gpus all \
    -v ~/.cache/huggingface:/root/.cache/huggingface \
    --env "HUGGING_FACE_HUB_TOKEN=<secret>" \
    -p 8000:8000 \
    --ipc=host \
    vllm/vllm-openai:latest \
    --model Qwen/Qwen2-1.5B-Instruct
```

要将端点与 openai 库一起使用：

```
from openai import OpenAI
client = OpenAI(
    base_url="http://localhost:8000/v1",
    api_key="token-abc123",
)

completion = client.chat.completions.create(
  model="Qwen/Qwen2-1.5B-Instruct",
  messages=[
    {"role": "user", "content": "Hello!"}
  ]
)

print(completion.choices[0].message)
```

## 2、LLaMA.cpp HTTP 服务器

![](https://www.hubwiz.com/blog/content/images/2024/12/image-584.png)

[LLaMA.cpp ](https://github.com/ggerganov/llama.cpp/blob/master/examples/server/README.md?ref=hubwiz.com)HTTP 服务器是一个轻量级且快速的基于 C/C++ 的 HTTP 服务器，利用 httplib、nlohmann::json 和 llama.cpp。它提供了一组 LLM REST API 和一个简单的 Web 界面，用于与 llama.cpp 交互。主要功能包括支持 GPU 和 CPU 上的 F16 和量化模型、OpenAI API 兼容性、并行解码、连续批处理和监控端点。它还支持架构约束的 JSON 响应，并且正在开发多模式功能。

### 2.1 使用说明

要安装 LLaMA.cpp，请运行以下命令：

```
git clone https://github.com/ggerganov/llama.cpp
cd llama.cpp && make
```

安装后，我们应该从 Hugging Face hub 下载 gguf 模型 (Mistral-7B-Instruct-v0.2-GGUF) 作为示例：

```
cd models && wget https://huggingface.co/TheBloke/Mistral-7B-Instruct-v0.2-GGUF/resolve/main/mistral-7b-instruct-v0.2.Q2_K.gguf
```

要启动服务器，请运行以下命令：

```
cd .. 
./llama-server -m models/mistral-7b-instruct-v0.2.Q2_K.gguf -c 2048
```

### 2.2 基本 vllm 参数

常规：

- `-h、--help、--usage`：打印使用情况并退出
- `--version`：显示版本和构建信息
- `-v，--verbose`：打印详细信息
- `--verbosity N`：设置特定详细程度（默认值：0）
- `--color`：为输出着色（默认值：false）
- `-s，--seed SEED`：RNG 种子（默认值：-1，小于 0 时使用随机种子）
- `-t，--threads N`：线程数（默认值：8）
- `--ctx-size N`：提示上下文的大小（默认值：0，0 = 从模型加载）
- `-n，--predict N`：要预测的标记数（默认值：-1，-1 = 无穷大，-2 = 直到上下文填满）
- `--prompt PROMPT`：开始生成的提示（默认值：''）
- `--interactive`：以交互模式运行（默认值：false）

采样：

- `--temp N`：温度（默认值：0.8）
- `--top-k N`：Top-k 采样（默认值：40，0 = 禁用）
- `--top-p N`：Top-p 采样（默认值：0.9，1.0 = 禁用）
- `--mirostat N`：使用 Mirostat 采样（默认值：0，0 = 禁用，1 = Mirostat，2 = Mirostat 2.0）

模型：

- `-m，--model FNAME`：模型路径（默认值：models/$filename）
- `--lora FNAME`：应用 LoRA 适配器（隐含 --no-mmap）
- `--control-vector FNAME`：添加控制向量
- `--check-tensors`：检查模型张量数据中是否存在无效值（默认值：false）

服务器：

- `--host HOST`：要监听的 IP 地址（默认值：127.0.0.1）
- `--port PORT`：要监听的端口（默认值：8080）
- `--timeout N`：服务器读写超时（秒）（默认值： 600)

日志记录：

- `-ld，--logdir LOGDIR`：保存 YAML 日志的路径（如果未设置则不记录）
- `--log-enable`：启用跟踪日志

上下文：

- `--rope-scaling {none,linear,yarn}`：RoPE 频率缩放方法（默认值：线性）

并行：

- `-np，--parallel N`：要解码的并行序列数（默认值：1）  
嵌入：
- `--embd-normalize`：嵌入的规范化（默认值：2）

### 2.3 使用 Docker 部署

要使用 Docker 部署 LLaMA.cpp，请运行以下命令：

```
docker run -p 8080:8080 -v /path/to/models:/models ghcr.io/ggerganov/llama.cpp:server 
            -m models/mistral-7b-instruct-v0.2.Q2_K.gguf 
            -c 512 
            --host 0.0.0.0 
            --port 8080

# or, with CUDA:
docker run -p 8080:8080 
            -v /path/to/models:/models 
            --gpus all ghcr.io/ggerganov/llama.cpp:server-cuda 
            -m models/mistral-7b-instruct-v0.2.Q2_K.gguf
            -c 512 
            --host 0.0.0.0 
            --port 8080 
            --n-gpu-layers 99
```

要将端点与 openai 库一起使用：

```
from openai import OpenAI
client = OpenAI(
    base_url="http://localhost:8081/v1",
    api_key="token-abc123",
)

completion = client.chat.completions.create(
  model="Mistral-7B-Instruct-v0.2-GGUF",
  messages=[
    {"role": "user", "content": "Hello!"}
  ]
)

print(completion.choices[0].message)
```

## 3、SGLang

![](https://www.hubwiz.com/blog/content/images/2024/12/image-585.png)

[SGLang ](https://github.com/sgl-project/sglang?ref=hubwiz.com)是一个专为 LLM 和 VLM 设计的快速服务框架，专注于提高交互速度和控制。它具有高效的后端运行时，使用 RadixAttention 进行前缀缓存、前跳约束解码和各种量化技术。SGLang 还支持张量并行和高级内核以提高性能。灵活的前端语言允许轻松编程复杂的 LLM 应用程序，包括链式生成调用、高级提示和并行性，以及与多种模态和外部交互的集成。

![](https://www.hubwiz.com/blog/content/images/2024/12/image-586.png)

![](https://www.hubwiz.com/blog/content/images/2024/12/image-587.png)

### 3.1 使用说明

要安装 SGLang，请运行以下命令：

```
pip install --upgrade pip
pip install "sglang[all]"

# Install FlashInfer CUDA kernels
pip install flashinfer -i https://flashinfer.ai/whl/cu121/torch2.3/
```

要启动服务器，请运行以下命令：

```
! python -m sglang.launch_server --model-path Qwen/Qwen2-1.5B-Instruct --port 30000
```

### 3.2 基本 vllm 参数

必需选项

- `--model-path MODEL_PATH`：模型权重路径（必需）。

可选关键选项

- `--tokenizer-path TOKENIZER_PATH`：tokenizer 路径。
- `--host HOST`：服务器主机（默认为 localhost）。
- `--port PORT`：服务器端口（默认为 8000 或其他常用端口）。
- `--tokenizer-mode {auto,slow}`：默认可能为自动。
- `--load-format {auto,pt,safetensors,npcache,dummy}`：默认可能为自动。
- `--dtype {auto,half,float16,bfloat16,float,float32}`：默认可能为自动。
- `--context-length CONTEXT_LENGTH`：默认为 None，使用模型的配置值。

性能和资源选项

- `--mem-fraction-static MEM_FRACTION_STATIC`：静态分配的内存分数。
- `--max-prefill-tokens MAX_PREFILL_TOKENS`：预填充批次中的最大令牌数。
- `--max-running-requests MAX_RUNNING_REQUESTS`：最大运行请求数。
- `--max-num-reqs MAX_NUM_REQS`：内存池中的最大请求数。
- `--max-total-tokens MAX_TOTAL_TOKENS`：内存池中的最大 token 数。

调度和并行性

- `--schedule-policy {lpm,random,fcfs,dfs-weight}`：调度策略，默认为 fcfs（先到先得）。
- `--tp-size TP_SIZE`：张量并行性大小。
- `--dp-size DP_SIZE`：数据并行性大小。

日志记录和调试

- `--log-level LOG_LEVEL`：日志记录级别。
- `--log-requests`：日志请求。
- `--show-time-cost`：显示自定义标记的时间成本。

高级选项

- `--quantization {awq,fp8,gptq,marlin,gptq_marlin,awq_marlin,squeezellm,bitsandbytes}`：量化方法。
- `--load-balance-method {round_robin,shortest_queue}`：负载平衡策略。  
实验性或可选功能
- `--enable-torch-compile`：实验性优化功能。
- `--disable-disk-cache`：禁用磁盘缓存。

### 3.3 使用 Docker 部署

要使用 Docker 部署 SGLang，请运行以下命令：

```
docker pull lmsysorg/sglang:v0.2.10-cu124

docker run --gpus all \
    -p 30000:30000 \
    -v ~/.cache/huggingface:/root/.cache/huggingface \
    --env "HF_TOKEN=<secret>" \
    --ipc=host \
    lmsysorg/sglang:latest \
    python3 -m sglang.launch_server --model-path Qwen/Qwen2-1.5B-Instruct --host 0.0.0.0 --port 30000
```

使用openai库访问端点：

```
import openai
client = openai.Client(
    base_url="http://127.0.0.1:30000/v1", api_key="EMPTY")

# Text completion
response = client.completions.create(
    model="default",
    prompt="The capital of France is",
    temperature=0,
    max_tokens=32,
)
print(response)
```

## 4、Ollama：简化本地 LLM 部署

![](https://www.hubwiz.com/blog/content/images/2024/12/image-589.png)

[Ollama](https://ollama.com/?ref=hubwiz.com) 是一个开源平台，旨在简化在本地机器上部署大型语言模型的过程。它充当了 LLM 通常所需的复杂基础设施与寻求更易于访问和可定制的 AI 体验的用户之间的桥梁。凭借其与 OpenAI 兼容的 API，Ollama 可与现有工具和工作流程无缝集成。

![](https://www.hubwiz.com/blog/content/images/2024/12/image-590.png)

该平台强调对量化模型的支持，这对于减少内存使用和提高性能至关重要。Ollama 提供了一个不断增长的预训练模型库，从多功能通用选项到用于小众任务的专用模型。可用的著名模型包括 Llama 3.1、Qwen、Mistral 和 deepseek-coder-v2 等专用变体。

Ollama 的用户友好型设置过程和直观的模型管理由其统一的 Modelfile 格式提供。它的跨平台支持（包括 Windows、macOS 和 Linux）进一步增强了可访问性。通过提供具有与 OpenAI 兼容的接口的本地模型服务，Ollama 是寻求本地部署灵活性以及标准 API 集成便利性的开发人员的强大选择。

### 4.1 安装依赖项和 Ollama

首先，我们需要安装 openai Python 包。该库提供了一个简单的接口来与任何 OpenAI 兼容的 API 进行交互，这在我们稍后连接到 Ollama 服务器时将至关重要。

```
pip install openai
```

接下来，我们使用单个命令安装 Ollama（适用于 Linux）。Ollama 旨在简化运行本地 LLM 的过程，因此设置起来既快速又简单。

```
curl -fsSL https://ollama.com/install.sh | sh
```

### 4.2 使用 Ollama 拉取和提供模型

安装 Ollama 后，我们拉取 qwen2:1.5b 模型。该模型是 Ollama 支持的众多模型之一，它展示了该工具在本地管理和运行各种大型语言模型的能力。

```
ollama pull qwen2:1.5b
```

拉取模型后，我们启动 Ollama 服务器。这使我们能够在本地提供模型并通过 API 访问它。

### 4.3 使用 OpenAI 客户端向 Ollama 发出简单请求

在这里，我们设置 OpenAI 客户端与 Ollama 服务器进行通信。base\_url 指向本地服务器，而 api\_key 是必需的，但 Ollama 未使用。

```
ollama serve
```

然后，我们向 qwen2:1.5b 模型（即我们上面拉取的模型）发送聊天完成请求。

```
from openai import OpenAI

client = OpenAI(
    base_url = 'http://127.0.0.1:11434/v1',
    api_key='ollama', 
)

response = client.chat.completions.create(
  model="qwen2:1.5b",
  messages=[
        {"role": "system", "content": "You are a helpful assistant." },
        {"role": "user", "content": "What is deep learning?"}
    ]
)
print(response.choices[0].message.content)
```

### 4.4 使用 OpenAI API 流式传输响应

客户端的配置方式相同，但这次我们在生成响应时对其进行流式传输。这对于需要在令牌进入时对其进行处理的实时应用程序特别有用。

```
from openai import OpenAI

# init the client but point it to TGI
client = OpenAI(
    base_url="http://127.0.0.1:11434/v1",
    api_key="ollama"
)

chat_completion = client.chat.completions.create(
    model="qwen2:1.5b",
    messages=[
        {"role": "system", "content": "You are a helpful assistant." },
        {"role": "user", "content": "What is deep learning?"}
    ],
    stream=True
)

# iterate and print stream
for message in chat_completion:
    print(message.choices[0].delta.content)
```

## 5、TGI：高性能 LLM 服务

![](https://www.hubwiz.com/blog/content/images/2024/12/image-591.png)

[TGI (文本生成推理) ](https://huggingface.co/docs/text-generation-inference/index?ref=hubwiz.com)是一种可用于生产的用于部署和提供 LLM 的工具包，重点是高性能文本生成。与本系列中讨论的其他工具一样，TGI 提供了与 OpenAI 兼容的 API，可轻松将高级 LLM 集成到现有应用程序中。

TGI 支持流行的开源模型，如 gemma2、mistral-nemo、mistral-large、qwen 等，使其成为需要可扩展、高吞吐量 AI 解决方案的组织的诱人选择。主要功能包括张量并行性或跨多个 GPU 进行更快的推理、使用服务器发送事件 (SSE) 进行令牌流式传输以及连续批处理以最大化吞吐量。

![](https://www.hubwiz.com/blog/content/images/2024/12/image-592.png)

除了这些功能之外，TGI 还实现了 Flash Attention 和 Paged Attention 等高级优化，这对于提高 Transformer 架构上的推理速度至关重要。它还通过 bitsandbytes 和 GPT-Q 等技术支持模型量化，从而实现高效部署，同时保持模型性能。对于定制任务，TGI 提供微调支持和指导功能，进一步增强输出的相关性和准确性。

凭借其强大的功能集，包括分布式跟踪和用于监控的 Prometheus 指标，TGI 是要求苛刻的生产环境中提供 LLM 的理想解决方案。

### 5.1 本地安装 TGI

首先，我们通过安装必要的依赖项（包括 libssl-dev 和 gcc）来设置环境。我们还下载并安装协议缓冲区 (protoc) 包，这对于编译 TGI 框架使用的 protobuf 文件至关重要。

```
sudo apt-get install libssl-dev gcc -y
PROTOC_ZIP=protoc-21.12-linux-x86_64.zip
curl -OL https://github.com/protocolbuffers/protobuf/releases/download/v21.12/$PROTOC_ZIP
sudo unzip -o $PROTOC_ZIP -d /usr/local bin/protoc
sudo unzip -o $PROTOC_ZIP -d /usr/local 'include/*'
rm -f $PROTOC_ZIP
```

### 5.2 在本地构建和运行 TGI

要安装和运行 TGI，需要构建启用扩展（CUDA 内核）的存储库，以便在 GPU 上获得最佳性能。之后，你可以使用 Hugging Face 生态系统支持的任何模型（如 Mistral）启动文本生成服务。

```
BUILD_EXTENSIONS=True make install 
text-generation-launcher --model-id mistralai/Mistral-Large-Instruct-2407
```

要运行不同的模型，只需更改 `--model-id` 参数：

```
text-generation-launcher --model-id Qwen/Qwen2-1.5B-Instruct

```

### 5.3 使用量化运行

可以通过运行预量化权重或使用 AWQ、GPTQ 或 bitsandbytes 等动态量化选项来减少 VRAM 使用量。这在有限硬件上处理大型模型时特别有用。

```
text-generation-launcher --model-id Qwen/Qwen2-72B-Instruct-GPTQ-Int8 --sharded true --num-shard 2 --quantize gptq

```

### 5.4 使用 Docker 进行 TGI 部署

如果你更喜欢使用 Docker，可以通过安装模型数据卷并公开服务器的端口来轻松部署 TGI：

```
model=Qwen/Qwen2-1.5B-Instruct
volume=$PWD/data
```

然后，运行具有 GPU 访问权限的 Docker 容器：

```
docker run --gpus all --shm-size 1g -p 8080:80 -v $volume:/data \
    ghcr.io/huggingface/text-generation-inference:2.2.0 --model-id $model
```

你可以通过发送生成文本的请求来测试部署：

```
curl 127.0.0.1:8080/generate_stream \
    -X POST \
    -d '{"inputs":"What is Deep Learning?","parameters":{"max_new_tokens":20}}' \
    -H 'Content-Type: application/json'
```

### 5.5 OpenAI 兼容 API 支持

TGI 的一项重要功能（从 1.4.0 版开始）是它与 OpenAI Chat Completion API 兼容。这允许你使用 OpenAI 的客户端库或其他期望相同架构的库与 TGI 的消息 API 进行交互。

> 发出同步请求

在这里，我们设置 OpenAI 客户端，但将其指向 TGI 端点。然后，我们创建一个类似于你使用 OpenAI API 执行的聊天完成请求。

```
from openai import OpenAI

# init the client but point it to TGI
client = OpenAI(
    base_url="http://localhost:3000/v1",
    api_key="-"
)

chat_completion = client.chat.completions.create(
    model="tgi",
    messages=[
        {"role": "system", "content": "You are a helpful assistant." },
        {"role": "user", "content": "What is deep learning?"}
    ],
    stream=False
)

print(chat_completion.choices[0].message.content)
```

> 发出流式请求

对于实时应用程序，你可以在生成响应时对其进行流式传输。OpenAI 客户端通过迭代流的每个部分来处理此问题，使你能够动态处理和显示结果。

```
from openai import OpenAI

# init the client but point it to TGI
client = OpenAI(
    base_url="http://localhost:3000/v1",
    api_key="-"
)

chat_completion = client.chat.completions.create(
    model="tgi",
    messages=[
        {"role": "system", "content": "You are a helpful assistant." },
        {"role": "user", "content": "What is deep learning?"}
    ],
    stream=True
)

# iterate and print stream
for message in chat_completion:
    print(message)
```

---

原文链接：[Serving Large models (part one): VLLM, LLAMA CPP Server, and SGLang](https://blog.gopenai.com/serving-large-models-part-one-vllm-llama-cpp-server-and-sglang-3a079af6966e?ref=hubwiz.com)

汇智网翻译整理，转载请标明出处