> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-zh/dui-bi/llm-serving-comparison.md).

# LLM 服务：Ollama vs vLLM vs TGI

比较 vLLM、SGLang、Ollama、TGI 和 LocalAI 的 LLM 服务能力

根据你的需求，在 CLORE.AI 上选择合适的 LLM 服务方案。

{% hint style="success" %}
CLORE.AI 上提供的所有选项 [CLORE.AI 市场](https://clore.ai/marketplace).
{% endhint %}

{% hint style="info" %}
**2025 更新：** SGLang 已成为一流框架，通常 **优于 vLLM** 在吞吐量和 TTFT 基准测试中表现更好。vLLM v0.7 和 SGLang v0.4 都推荐用于生产工作负载。
{% endhint %}

## 快速决策指南

{% hint style="warning" %}
**Clore.ai 市场上未列出多 GPU 的 80GB 级机型。** 目前列出的最大配置是 4× RTX PRO 6000 Blackwell（每张 96GB，共 380GB）以及 8–11× RTX 5090（每张 32GB）。A100 / H200 / B200 容量可按 [裸机](https://clore.ai/bare-metal) 需求提供。部署前请查看 [GPU 价格与可用性](/guides/guides_v2-zh/ru-men-zhi-nan/pricing.md) 。
{% endhint %}

| 使用场景              | 最佳选择                  | 原因           |
| ----------------- | --------------------- | ------------ |
| 快速测试与聊天           | **Ollama**            | 最简单的设置，最快的启动 |
| 生产 API（最大吞吐量）     | **SGLang** 或 **vLLM** | 2025 年最高吞吐量  |
| 推理模型（DeepSeek-R1） | **SGLang**            | 最适合推理链支持     |
| HuggingFace 集成    | **TGI**               | 原生 HF 支持     |
| 本地开发              | **Ollama**            | 处处可用         |
| 高并发               | **SGLang** 或 **vLLM** | 连续批处理        |
| 多模态（TTS、STT、嵌入）   | **LocalAI**           | 一体化解决方案      |
| 流式应用              | **vLLM** 或 **SGLang** | 两者都很优秀       |

## 启动时间对比

| 解决方案    | 典型启动时间  | 备注        |
| ------- | ------- | --------- |
| Ollama  | 30-60 秒 | 最快、最轻量    |
| SGLang  | 3-8 分钟  | 从 HF 下载模型 |
| vLLM    | 5-15 分钟 | 从 HF 下载模型 |
| TGI     | 3-10 分钟 | 从 HF 下载模型 |
| LocalAI | 5-10 分钟 | 预加载多个模型   |

{% hint style="info" %}
启动期间出现 HTTP 502 错误是正常的——服务仍在初始化。
{% endhint %}

***

## 概览对比

| 功能          | Ollama       | vLLM    | SGLang  | TGI          | LocalAI    |
| ----------- | ------------ | ------- | ------- | ------------ | ---------- |
| **设置难易度**   | ⭐⭐⭐⭐⭐        | ⭐⭐⭐     | ⭐⭐⭐     | ⭐⭐⭐          | ⭐⭐⭐⭐       |
| **性能**      | ⭐⭐⭐          | ⭐⭐⭐⭐⭐   | ⭐⭐⭐⭐⭐   | ⭐⭐⭐⭐         | ⭐⭐⭐        |
| **模型支持**    | ⭐⭐⭐⭐         | ⭐⭐⭐⭐⭐   | ⭐⭐⭐⭐⭐   | ⭐⭐⭐⭐         | ⭐⭐⭐⭐       |
| **API 兼容性** | 自定义 + OpenAI | OpenAI  | OpenAI  | 自定义 + OpenAI | OpenAI     |
| **多 GPU**   | 有限           | 优秀      | 优秀      | 好            | 有限         |
| **内存效率**    | 好            | 优秀      | 优秀      | 非常好          | 好          |
| **多模态**     | 仅视觉          | 仅视觉     | 仅视觉     | 否            | TTS、STT、嵌入 |
| **启动时间**    | 30 秒         | 5-15 分钟 | 3-8 分钟  | 3-10 分钟      | 5-10 分钟    |
| **推理模型**    | 有限           | 好       | 优秀      | 好            | 有限         |
| **最适合**     | 开发           | 生产环境    | 生产 + 推理 | HF 生态        | 多模态        |

***

## 2025 基准测试：DeepSeek-R1-32B

### TTFT、TPOT 和吞吐量（A100 80GB，batch=32，input=512，output=512）

| 框架              | TTFT（ms） | TPOT（ms/tok） | 吞吐量（tok/s） | 备注           |
| --------------- | -------- | ------------ | ---------- | ------------ |
| **SGLang v0.4** | **180**  | **14**       | **2,850**  | 2025 年整体最佳   |
| **vLLM v0.7**   | 240      | 17           | 2,400      | 优秀，接近 SGLang |
| llama.cpp       | 420      | 28           | 1,100      | CPU+GPU，量化版  |
| Ollama          | 510      | 35           | 820        | 优先考虑易用性      |

> **TTFT** = 首个 token 时间（延迟）。 **TPOT** = 每个输出 token 的时间。两者都是越低越好。

### 吞吐量对比（RTX 4090，Llama 3.1 8B，10 个并发用户）

| 框架          | 每秒 Token 数 | 并发用户数 | 备注                 |
| ----------- | ---------- | ----- | ------------------ |
| SGLang v0.4 | 920        | 20-30 | Radix attention 缓存 |
| vLLM v0.7   | 870        | 20-30 | PagedAttention     |
| TGI         | 550        | 10-20 |                    |
| Ollama      | 160\*      | —     | 默认按顺序              |

\*Ollama 默认按顺序处理请求

***

## SGLang

### 概览

SGLang（Structured Generation Language）是一个高吞吐量的 LLM 服务框架，由来自 UC Berkeley 和 LMSYS 的研究人员开发。在 2025 年基准测试中，它经常与 vLLM 持平或更胜一筹——尤其是在像 DeepSeek-R1 这样的推理模型上。

### 优点

* ✅ 往往在 2025 年基准测试中拥有最快的 TTFT 和吞吐量
* ✅ Radix attention 实现高效的 KV 缓存复用
* ✅ 对推理模型（DeepSeek-R1、QwQ）支持出色
* ✅ 兼容 OpenAI 的 API
* ✅ 连续批处理和前缀缓存
* ✅ 支持推测解码
* ✅ 多 GPU 张量并行

### 缺点

* ❌ 生态较新，社区资源少于 vLLM
* ❌ 比 Ollama 更复杂的设置
* ❌ 仅支持 Linux

### 快速开始

```bash
pip install sglang[all]

# 部署一个模型
python -m sglang.launch_server \\
    --model-path meta-llama/Llama-3.1-8B-Instruct \\
    --host 0.0.0.0 \\
    --port 8000
```

### 使用 SGLang 部署 DeepSeek-R1

```bash
python -m sglang.launch_server \\
    --model-path deepseek-ai/DeepSeek-R1-Distill-Qwen-32B \\
    --host 0.0.0.0 \\
    --port 8000 \\
    --tp 2 \\
    --reasoning-parser deepseek-r1
```

### API 使用

```python
from openai import OpenAI

client = OpenAI(base_url='http://localhost:8000/v1', api_key='dummy')

response = client.chat.completions.create(
    model='meta-llama/Llama-3.1-8B-Instruct',
    messages=[
        {'role': 'user', 'content': '解释量子纠缠'}
    ],
    temperature=0.7,
    max_tokens=512
)
print(response.choices[0].message.content)
```

### 多 GPU

```bash
# 2 块 GPU（张量并行）
python -m sglang.launch_server \\
    --model-path meta-llama/Llama-3.1-70B-Instruct \\
    --host 0.0.0.0 \\
    --port 8000 \\
    --tp 2
```

### 最适合

* 🎯 追求最大吞吐量的生产 API
* 🎯 推理模型（DeepSeek-R1、QwQ、o1 风格）
* 🎯 低延迟（TTFT）应用
* 🎯 重前缀工作负载（高 KV 缓存复用）

***

## Ollama

### 概览

Ollama 是本地运行 LLM 最简单的方式。非常适合开发、测试和个人使用。

### 优点

* ✅ 一条命令即可安装并运行
* ✅ 内置模型库
* ✅ 出色的 CLI 体验
* ✅ 适用于 Mac、Linux、Windows
* ✅ 自动量化
* ✅ 低资源开销

### 缺点

* ❌ 吞吐量低于其他方案
* ❌ 多 GPU 支持有限
* ❌ 生产就绪程度较低
* ❌ 优化选项更少

### 快速开始

```bash
# 安装
curl -fsSL https://ollama.com/install.sh | sh

# 运行任意模型
ollama run llama3.2
ollama run mistral
ollama run codellama

# 提供 API
ollama serve
```

### API 使用

```python
import requests

# 生成
response = requests.post('http://localhost:11434/api/generate', json={
    'model': 'llama3.2',
    'prompt': '解释量子计算',
    'stream': False
})
print(response.json()['response'])

# 聊天
response = requests.post('http://localhost:11434/api/chat', json={
    'model': 'llama3.2',
    'messages': [
        {'role': 'user', 'content': '你好！'}
    ]
})
```

### OpenAI 兼容性

```python
from openai import OpenAI

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

response = client.chat.completions.create(
    model='llama3.2',
    messages=[{'role': 'user', 'content': '你好！'}]
)
```

### 性能

| 模型            | GPU       | 每秒 Token 数 |
| ------------- | --------- | ---------- |
| Llama 3.2 3B  | RTX 3060  | 45-55      |
| Llama 3.1 8B  | RTX 3090  | 35-45      |
| Llama 3.1 70B | A100 40GB | 15-20      |

### 最适合

* 🎯 快速原型开发
* 🎯 个人 AI 助手
* 🎯 学习与实验
* 🎯 简单部署

***

## vLLM

### 概览

vLLM 是一个经过实战检验的高吞吐量 LLM 推理引擎，适用于生产环境。v0.7（2025）带来了更好的性能、更强的量化支持，以及新的推测解码选项。

### 优点

* ✅ 最高吞吐量（连续批处理 + PagedAttention）
* ✅ 采用 PagedAttention 高效利用内存
* ✅ 出色的多 GPU 支持
* ✅ 兼容 OpenAI 的 API
* ✅ 生产就绪，社区庞大
* ✅ 支持多种量化格式（AWQ、GPTQ、FP8）
* ✅ v0.7 支持推测解码

### 缺点

* ❌ 设置更复杂
* ❌ 启动时内存开销更高
* ❌ 仅支持 Linux（无原生 Windows/Mac）
* ❌ 需要更多配置

### 快速开始

```bash
pip install vllm

# 部署模型（vLLM v0.7）
python -m vllm.entrypoints.openai.api_server \
    --model meta-llama/Llama-3.1-8B-Instruct \\
    --host 0.0.0.0 \\
    --port 8000
```

### Docker 部署

```bash
docker run --gpus all -p 8000:8000 \\
    vllm/vllm-openai:v0.7.0 \\
    --model meta-llama/Llama-3.1-8B-Instruct
```

### API 使用

```python
from openai import OpenAI

client = OpenAI(base_url='http://localhost:8000/v1', api_key='dummy')

# 聊天完成
response = client.chat.completions.create(
    model='meta-llama/Llama-3.1-8B-Instruct',
    messages=[
        {'role': 'system', 'content': '你很有帮助。'},
        {'role': 'user', 'content': '写一首关于编程的俳句'}
    ],
    temperature=0.7,
    max_tokens=100
)

# 流式输出
stream = client.chat.completions.create(
    model='meta-llama/Llama-3.1-8B-Instruct',
    messages=[{'role': 'user', 'content': '给我讲个故事'}],
    stream=True
)
for chunk in stream:
    print(chunk.choices[0].delta.content, end='')
```

### 多 GPU

```bash
# 2 GPUs
python -m vllm.entrypoints.openai.api_server \
    --model meta-llama/Llama-3.1-70B-Instruct \
    --tensor-parallel-size 2

# 4 GPUs
python -m vllm.entrypoints.openai.api_server \
    --model meta-llama/Llama-3.1-70B-Instruct \
    --tensor-parallel-size 4
```

### 性能

| 模型            | GPU       | 每秒 Token 数 | 并发用户数 |
| ------------- | --------- | ---------- | ----- |
| Llama 3.1 8B  | RTX 3090  | 80-100     | 10-20 |
| Llama 3.1 8B  | RTX 4090  | 120-150    | 20-30 |
| Llama 3.1 70B | A100 40GB | 25-35      | 5-10  |
| Llama 3.1 70B | 2x A100   | 50-70      | 15-25 |

### 最适合

* 🎯 适合拥有大型社区的生产 API
* 🎯 高流量应用
* 🎯 多用户聊天服务
* 🎯 追求最大吞吐量

***

## Text Generation Inference（TGI）

### 概览

HuggingFace 的生产服务器，与 HF 生态紧密集成。

### 优点

* ✅ 原生 HuggingFace 集成
* ✅ 非常适合 HF 模型
* ✅ 良好的多 GPU 支持
* ✅ 内置安全功能
* ✅ Prometheus 指标
* ✅ 文档完善

### 缺点

* ❌ 吞吐量略低于 vLLM/SGLang
* ❌ 资源消耗更高
* ❌ 配置复杂
* ❌ 启动时间更长

### 快速开始

```bash
# Docker（推荐）
docker run --gpus all -p 8080:80 \\
    ghcr.io/huggingface/text-generation-inference:latest \\
    --model-id meta-llama/Llama-3.1-8B-Instruct

# 对于受限模型，使用 HF token
docker run --gpus all -p 8080:80 \\
    -e HUGGING_FACE_HUB_TOKEN=$HF_TOKEN \\
    ghcr.io/huggingface/text-generation-inference:latest \\
    --model-id meta-llama/Llama-3.1-8B-Instruct
```

### 性能

| 模型            | GPU       | 每秒 Token 数 | 并发用户数 |
| ------------- | --------- | ---------- | ----- |
| Llama 3.1 8B  | RTX 3090  | 60-80      | 8-15  |
| Llama 3.1 8B  | RTX 4090  | 90-120     | 15-25 |
| Llama 3.1 70B | A100 40GB | 20-30      | 3-8   |

### 最适合

* 🎯 HuggingFace 模型用户
* 🎯 研究环境
* 🎯 需要内置安全功能
* 🎯 需要 Prometheus 监控

***

## LocalAI

### 概览

LocalAI 是一个兼容 OpenAI 的 API，支持多种模态：LLM、TTS、STT、嵌入和图像生成。

### 优点

* ✅ 多模态支持（LLM、TTS、STT、嵌入）
* ✅ 可直接替换 OpenAI
* ✅ 提供预构建模型
* ✅ 支持 GGUF 模型
* ✅ 支持重排序
* ✅ Swagger UI 文档

### 缺点

* ❌ 启动时间更长（5-10 分钟）
* ❌ LLM 吞吐量低于 vLLM/SGLang
* ❌ 图像生成可能存在 CUDA 问题
* ❌ 仅用于纯 LLM 时更复杂

### 快速开始

```bash
docker run --gpus all -p 8080:8080 localai/localai:master-aio-gpu-nvidia-cuda-12
```

### API 使用

```python
from openai import OpenAI

client = OpenAI(base_url='http://localhost:8080/v1', api_key='dummy')

# 聊天
response = client.chat.completions.create(
    model='gpt-4',
    messages=[{'role': 'user', 'content': '你好！'}]
)

# TTS
audio = client.audio.speech.create(model='tts-1', input='你好，世界', voice='alloy')

# STT
transcript = client.audio.transcriptions.create(model='whisper-1', file=open('audio.mp3', 'rb'))

# 嵌入
embeddings = client.embeddings.create(model='text-embedding-ada-002', input='你好，世界')
```

### 最适合

* 🎯 需要多种模态（TTS、STT、LLM）
* 🎯 想要 OpenAI API 兼容性
* 🎯 运行 GGUF 模型
* 🎯 文档重排序工作流

***

## 性能对比（2025）

### 吞吐量（tokens/秒）— 单用户

| 模型                       | Ollama | vLLM v0.7 | SGLang v0.4 | TGI |
| ------------------------ | ------ | --------- | ----------- | --- |
| Llama 3.1 8B（RTX 3090）   | 40     | 90        | 100         | 70  |
| Llama 3.1 8B（RTX 4090）   | 65     | 140       | 160         | 110 |
| Llama 3.1 70B（A100 40GB） | 18     | 30        | 35          | 25  |

### 吞吐量 — 多用户（10 并发）

| 模型                       | Ollama | vLLM v0.7 | SGLang v0.4 | TGI |
| ------------------------ | ------ | --------- | ----------- | --- |
| Llama 3.1 8B（RTX 4090）   | 150\*  | 800       | 920         | 500 |
| Llama 3.1 70B（A100 40GB） | 50\*   | 200       | 240         | 150 |

\*Ollama 默认按顺序处理

### 内存使用量

| 模型                | Ollama | vLLM v0.7 | SGLang v0.4 | TGI  |
| ----------------- | ------ | --------- | ----------- | ---- |
| Llama 3.1 8B      | 5GB    | 6GB       | 6GB         | 7GB  |
| Llama 3.1 70B（Q4） | 38GB   | 40GB      | 39GB        | 42GB |

### 首个 token 时间（TTFT）— DeepSeek-R1-32B

| 框架          | TTFT（A100 80GB） | TPOT（ms/tok） |
| ----------- | --------------- | ------------ |
| SGLang v0.4 | **180ms**       | **14ms**     |
| vLLM v0.7   | 240ms           | 17ms         |
| llama.cpp   | 420ms           | 28ms         |
| Ollama      | 510ms           | 35ms         |

***

## 功能对比

| 功能         | Ollama | vLLM v0.7    | SGLang v0.4  | TGI              | LocalAI    |
| ---------- | ------ | ------------ | ------------ | ---------------- | ---------- |
| OpenAI API | ✅      | ✅            | ✅            | ✅                | ✅          |
| 流式输出       | ✅      | ✅            | ✅            | ✅                | ✅          |
| 批处理        | 基础     | 连续           | 连续           | 动态               | 基础         |
| 多 GPU      | 有限     | 优秀           | 优秀           | 好                | 有限         |
| 量化         | GGUF   | AWQ、GPTQ、FP8 | AWQ、GPTQ、FP8 | bitsandbytes、AWQ | GGUF       |
| LoRA       | ✅      | ✅            | ✅            | ✅                | ✅          |
| 推测解码       | ❌      | ✅            | ✅            | ✅                | ❌          |
| 前缀缓存       | ❌      | ✅            | ✅（Radix）     | ✅                | ❌          |
| 推理模型       | 有限     | 好            | 优秀           | 好                | 有限         |
| 指标         | 基础     | Prometheus   | Prometheus   | Prometheus       | Prometheus |
| 函数调用       | ✅      | ✅            | ✅            | ✅                | ✅          |
| 视觉模型       | ✅      | ✅            | ✅            | ✅                | 有限         |
| TTS        | ❌      | ❌            | ❌            | ❌                | ✅          |
| STT        | ❌      | ❌            | ❌            | ❌                | ✅          |
| 嵌入         | ✅      | 有限           | 有限           | 有限               | ✅          |

***

## 何时使用哪种

### 在以下情况使用 Ollama：

* 你想在 5 分钟内开始使用
* 你正在做原型开发或学习
* 你需要一个个人 AI 助手
* 你使用的是 Mac 或 Windows
* 简单性比速度更重要

### 在以下情况使用 SGLang：

* 你需要 **绝对最低的延迟** （TTFT）
* 你在服务 **推理模型** （DeepSeek-R1、QwQ、o1 风格）
* 你的工作负载具有大量 **前缀共享** （RAG、系统提示）
* 你需要在 2025 基准测试中达到顶级吞吐量
* 你想要前沿优化（Radix attention）

### 在以下情况使用 vLLM：

* 你需要在 **成熟、受良好支持的** 框架中获得最大吞吐量
* 你在大规模服务许多用户
* 你需要具备大型社区支持的生产级可靠性
* 你想要 OpenAI 的即插即用替代方案
* 你有多 GPU 部署
* 你需要广泛的模型格式支持（AWQ、GPTQ、FP8）

### 在以下情况使用 TGI：

* 你处于 HuggingFace 生态中
* 你需要内置安全功能
* 你想要详细的 Prometheus 指标
* 你需要直接服务 HF 模型
* 你处于研究环境中

### 在以下情况使用 LocalAI：

* 你需要在 LLM 之外同时使用 TTS 和 STT
* 你想为 RAG 使用嵌入
* 你需要文档重排序
* 你想要一个一体化方案
* 你正在构建支持语音的应用

***

## 迁移指南

### 从 Ollama 迁移到 SGLang

```python
# Ollama
client = OpenAI(base_url='http://localhost:11434/v1', api_key='ollama')
response = client.chat.completions.create(model='llama3.2', ...)

# SGLang - 只需更改 URL 和模型名称
client = OpenAI(base_url='http://localhost:8000/v1', api_key='dummy')
response = client.chat.completions.create(model='meta-llama/Llama-3.2-3B-Instruct', ...)
```

### 从 vLLM 迁移到 SGLang

两者都支持 OpenAI API——只需更改端点 URL。API 完全兼容。

```bash
# vLLM
python -m vllm.entrypoints.openai.api_server --model ... --port 8000

# SGLang（等效）
python -m sglang.launch_server --model-path ... --port 8000
```

***

## 按 GPU 的推荐

| GPU           | 单用户         | 多用户         | 推理模型   |
| ------------- | ----------- | ----------- | ------ |
| RTX 3060 12GB | Ollama      | Ollama      | Ollama |
| RTX 3090 24GB | Ollama      | vLLM        | SGLang |
| RTX 4090 24GB | SGLang/vLLM | SGLang/vLLM | SGLang |
| A100 40GB+    | SGLang      | SGLang      | SGLang |

***

## 下一步

* [Ollama 指南](/guides/guides_v2-zh/yu-yan-mo-xing/ollama.md) - 最容易设置
* [vLLM 指南](/guides/guides_v2-zh/yu-yan-mo-xing/vllm.md) - 最高吞吐量
* [LocalAI 指南](/guides/guides_v2-zh/yu-yan-mo-xing/localai-openai-compatible.md) - 多模态支持
* [DeepSeek-R1 指南](/guides/guides_v2-zh/yu-yan-mo-xing/deepseek-r1.md) - 推理模型
* [多 GPU 设置](/guides/guides_v2-zh/gao-ji/multi-gpu-setup.md) - 扩展到更大的模型
* [API 集成](/guides/guides_v2-zh/gao-ji/api-integration.md) - 构建应用程序


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-zh/dui-bi/llm-serving-comparison.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.