# Service LLM : Ollama vs vLLM vs TGI

Choisissez la solution de service LLM adaptée à vos besoins sur CLORE.AI.

{% hint style="success" %}
Toutes les options disponibles sur [CLORE.AI Marketplace](https://clore.ai/marketplace).
{% endhint %}

{% hint style="info" %}
**Mise à jour 2025 :** SGLang est apparu comme un cadre de premier plan, souvent **surclassant vLLM** en termes de débit et de benchmarks TTFT. Les versions vLLM v0.7 et SGLang v0.4 sont recommandées pour les charges de production.
{% endhint %}

## Guide de décision rapide

| Cas d'utilisation                     | Meilleur choix         | Pourquoi                                               |
| ------------------------------------- | ---------------------- | ------------------------------------------------------ |
| Tests rapides et chat                 | **composant Ollama**   | Configuration la plus simple, démarrage le plus rapide |
| API de production (débit maximal)     | **SGLang** ou **vLLM** | Plus haut débit en 2025                                |
| Modèles de raisonnement (DeepSeek-R1) | **SGLang**             | Meilleur support pour les chaînes de raisonnement      |
| Intégration HuggingFace               | **TGI**                | Support natif HF                                       |
| Développement local                   | **composant Ollama**   | Fonctionne partout                                     |
| Haute simultanéité                    | **SGLang** ou **vLLM** | Regroupement continu                                   |
| Multimodal (TTS, STT, Embeddings)     | **LocalAI**            | Solution tout-en-un                                    |
| Applications en streaming             | **vLLM** ou **SGLang** | Les deux excellent                                     |

## Comparaison du temps de démarrage

| Solution         | Démarrage typique | Remarques                      |
| ---------------- | ----------------- | ------------------------------ |
| composant Ollama | 30-60 secondes    | Le plus rapide, léger          |
| SGLang           | 3-8 minutes       | Télécharge le modèle depuis HF |
| vLLM             | 5-15 minutes      | Télécharge le modèle depuis HF |
| TGI              | 3-10 minutes      | Télécharge le modèle depuis HF |
| LocalAI          | 5-10 minutes      | Précharge plusieurs modèles    |

{% hint style="info" %}
Les erreurs HTTP 502 pendant le démarrage sont normales - le service est encore en cours d'initialisation.
{% endhint %}

***

## Comparaison générale

| Fonction                    | composant Ollama      | vLLM             | SGLang                    | TGI                   | LocalAI         |
| --------------------------- | --------------------- | ---------------- | ------------------------- | --------------------- | --------------- |
| **Facilité d'installation** | ⭐⭐⭐⭐⭐                 | ⭐⭐⭐              | ⭐⭐⭐                       | ⭐⭐⭐                   | ⭐⭐⭐⭐            |
| **Performances**            | ⭐⭐⭐                   | ⭐⭐⭐⭐⭐            | ⭐⭐⭐⭐⭐                     | ⭐⭐⭐⭐                  | ⭐⭐⭐             |
| **Support de modèles**      | ⭐⭐⭐⭐                  | ⭐⭐⭐⭐⭐            | ⭐⭐⭐⭐⭐                     | ⭐⭐⭐⭐                  | ⭐⭐⭐⭐            |
| **Compatibilité API**       | Personnalisé + OpenAI | OpenAI           | OpenAI                    | Personnalisé + OpenAI | OpenAI          |
| **Multi-GPU**               | Limité                | Excellent        | Excellent                 | Bon                   | Limité          |
| **Efficacité mémoire**      | Bon                   | Excellent        | Excellent                 | Très bon              | Bon             |
| **Multi-modal**             | Vision seulement      | Vision seulement | Vision seulement          | Non                   | TTS, STT, Embed |
| **Temps de démarrage**      | 30 s                  | 5-15 min         | 3-8 min                   | 3-10 min              | 5-10 min        |
| **Modèles de raisonnement** | Limité                | Bon              | Excellent                 | Bon                   | Limité          |
| **Idéal pour**              | Développement         | Production       | Production + Raisonnement | Écosystème HF         | Multimodal      |

***

## Benchmarks 2025 : DeepSeek-R1-32B

### TTFT, TPOT et débit (A100 80GB, batch=32, input=512, output=512)

| Cadre            | TTFT (ms) | TPOT (ms/tok) | Débit (tok/s) | Remarques                            |
| ---------------- | --------- | ------------- | ------------- | ------------------------------------ |
| **SGLang v0.4**  | **180**   | **14**        | **2,850**     | Meilleur global 2025                 |
| **vLLM v0.7**    | 240       | 17            | 2,400         | Excellent, proche de SGLang          |
| llama.cpp        | 420       | 28            | 1,100         | CPU+GPU, quantifié                   |
| composant Ollama | 510       | 35            | 820           | Priorité à la facilité d'utilisation |

> **TTFT** = Temps jusqu'au premier token (latence). **TPOT** = Temps par token de sortie. Plus bas est meilleur pour les deux.

### Comparaison de débit (RTX 4090, Llama 3.1 8B, 10 utilisateurs concurrents)

| Cadre            | Tokens/sec | Utilisateurs concurrents | Remarques                       |
| ---------------- | ---------- | ------------------------ | ------------------------------- |
| SGLang v0.4      | 920        | 20-30                    | Mise en cache d'attention Radix |
| vLLM v0.7        | 870        | 20-30                    | PagedAttention                  |
| TGI              | 550        | 10-20                    |                                 |
| composant Ollama | 160\*      | —                        | Séquentiel par défaut           |

\*Ollama sert les requêtes séquentiellement par défaut

***

## SGLang

### Aperçu

SGLang (Structured Generation Language) est un cadre de service LLM à haut débit développé par des chercheurs de l'UC Berkeley et de LMSYS. Dans les benchmarks 2025, il égalise ou dépasse souvent vLLM — surtout pour les modèles de raisonnement comme DeepSeek-R1.

### Avantages

* ✅ Souvent le TTFT et le débit les plus rapides dans les benchmarks 2025
* ✅ Attention Radix pour une réutilisation efficace du cache KV
* ✅ Excellent support pour les modèles de raisonnement (DeepSeek-R1, QwQ)
* ✅ API compatible OpenAI
* ✅ Regroupement continu et mise en cache des préfixes
* ✅ Support du décodage spéculatif
* ✅ Parallélisme tensoriel multi-GPU

### Inconvénients

* ❌ Écosystème plus récent, moins de ressources communautaires que vLLM
* ❌ Configuration plus complexe qu'Ollama
* ❌ Linux uniquement

### Démarrage rapide

```bash
pip install sglang[all]

# Servir un modèle
python -m sglang.launch_server \
    --model-path meta-llama/Llama-3.1-8B-Instruct \
    --host 0.0.0.0 \
    --port 8000
```

### DeepSeek-R1 avec SGLang

```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
```

### Utilisation de l'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': 'Explain quantum entanglement'}
    ],
    temperature=0.7,
    max_tokens=512
)
print(response.choices[0].message.content)
```

### Multi-GPU

```bash
# 2 GPUs (parallélisme tensoriel)
python -m sglang.launch_server \
    --model-path meta-llama/Llama-3.1-70B-Instruct \
    --host 0.0.0.0 \
    --port 8000 \
    --tp 2
```

### Idéal pour

* 🎯 APIs de production à débit maximal
* 🎯 Modèles de raisonnement (DeepSeek-R1, QwQ, style o1)
* 🎯 Applications à faible latence (TTFT)
* 🎯 Charges de travail avec préfixes lourds (forte réutilisation du cache KV)

***

## composant Ollama

### Aperçu

Ollama est le moyen le plus simple d'exécuter des LLM localement. Parfait pour le développement, les tests et un usage personnel.

### Avantages

* ✅ Installation et exécution en une commande
* ✅ Bibliothèque de modèles intégrée
* ✅ Excellente expérience CLI
* ✅ Fonctionne sur Mac, Linux, Windows
* ✅ Quantification automatique
* ✅ Faible consommation de ressources

### Inconvénients

* ❌ Débit inférieur aux alternatives
* ❌ Support multi-GPU limité
* ❌ Moins adapté à la production
* ❌ Moins d'options d'optimisation

### Démarrage rapide

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

# Exécuter n'importe quel modèle
ollama run llama3.2
ollama run mistral
ollama run codellama

# Servir l'API
ollama serve
```

### Utilisation de l'API

```python
import requests

# Générer
response = requests.post('http://localhost:11434/api/generate', json={
    'model': 'llama3.2',
    'prompt': 'Explain quantum computing',
    'stream': False
})
print(response.json()['response'])

# Chat
response = requests.post('http://localhost:11434/api/chat', json={
    'model': 'llama3.2',
    'messages': [
        {'role': 'user', 'content': 'Bonjour !'}
    ]
})
```

### Compatibilité 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': 'Hello!'}]
)
```

### Performances

| Modèle        | GPU       | Tokens/sec |
| ------------- | --------- | ---------- |
| Llama 3.2 3B  | RTX 3060  | 45-55      |
| Llama 3.1 8B  | RTX 3090  | 35-45      |
| Llama 3.1 70B | A100 40GB | 15-20      |

### Idéal pour

* 🎯 Prototypage rapide
* 🎯 Assistant IA personnel
* 🎯 Apprentissage et expérimentation
* 🎯 Déploiements simples

***

## vLLM

### Aperçu

vLLM est un moteur d'inférence LLM à haut débit éprouvé en production. La v0.7 (2025) apporte de meilleures performances, un meilleur support de quantification et de nouvelles options de décodage spéculatif.

### Avantages

* ✅ Débit le plus élevé (regroupement continu + PagedAttention)
* ✅ PagedAttention pour une mémoire efficace
* ✅ Excellent support multi-GPU
* ✅ API compatible OpenAI
* ✅ Prêt pour la production, grande communauté
* ✅ Prend en charge de nombreux formats de quantification (AWQ, GPTQ, FP8)
* ✅ Décodage spéculatif en v0.7

### Inconvénients

* ❌ Configuration plus complexe
* ❌ Plus grande consommation mémoire au démarrage
* ❌ Linux uniquement (pas de support natif Windows/Mac)
* ❌ Nécessite plus de configuration

### Démarrage rapide

```bash
pip install vllm

# Servir le modèle (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
```

### Déploiement Docker

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

### Utilisation de l'API

```python
from openai import OpenAI

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

# Complétion de chat
response = client.chat.completions.create(
    model='meta-llama/Llama-3.1-8B-Instruct',
    messages=[
        {'role': 'system', 'content': 'You are helpful.'},
        {'role': 'user', 'content': 'Write a haiku about coding'}
    ],
    temperature=0.7,
    max_tokens=100
)

# Streaming
stream = client.chat.completions.create(
    model='meta-llama/Llama-3.1-8B-Instruct',
    messages=[{'role': 'user', 'content': 'Tell me a story'}],
    stream=True
)
for chunk in stream:
    print(chunk.choices[0].delta.content, end='')
```

### Multi-GPU

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

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

### Performances

| Modèle        | GPU       | Tokens/sec | Utilisateurs concurrents |
| ------------- | --------- | ---------- | ------------------------ |
| 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                    |

### Idéal pour

* 🎯 APIs de production avec grande communauté
* 🎯 Applications à fort trafic
* 🎯 Services de chat multi-utilisateurs
* 🎯 Besoins de débit maximum

***

## Text Generation Inference (TGI)

### Aperçu

Le serveur de production de HuggingFace, étroitement intégré à l'écosystème HF.

### Avantages

* ✅ Intégration native HuggingFace
* ✅ Idéal pour les modèles HF
* ✅ Bon support multi-GPU
* ✅ Fonctions de sécurité intégrées
* ✅ Métriques Prometheus
* ✅ Bien documenté

### Inconvénients

* ❌ Débit légèrement inférieur à vLLM/SGLang
* ❌ Plus gourmand en ressources
* ❌ Configuration complexe
* ❌ Temps de démarrage plus longs

### Démarrage rapide

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

# Avec token HF pour les modèles restreints
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
```

### Performances

| Modèle        | GPU       | Tokens/sec | Utilisateurs concurrents |
| ------------- | --------- | ---------- | ------------------------ |
| 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                      |

### Idéal pour

* 🎯 Utilisateurs de modèles HuggingFace
* 🎯 Environnements de recherche
* 🎯 Besoin de fonctionnalités de sécurité intégrées
* 🎯 Besoin de monitoring Prometheus

***

## LocalAI

### Aperçu

LocalAI est une API compatible OpenAI qui prend en charge plusieurs modalités : LLMs, TTS, STT, embeddings et génération d'images.

### Avantages

* ✅ Support multimodal (LLM, TTS, STT, embeddings)
* ✅ Remplacement OpenAI clé en main
* ✅ Modèles préconstruits disponibles
* ✅ Prend en charge les modèles GGUF
* ✅ Support de reranking
* ✅ Documentation Swagger UI

### Inconvénients

* ❌ Temps de démarrage plus long (5-10 minutes)
* ❌ Débit LLM inférieur à vLLM/SGLang
* ❌ La génération d'images peut poser des problèmes CUDA
* ❌ Plus complexe pour un usage purement LLM

### Démarrage rapide

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

### Utilisation de l'API

```python
from openai import OpenAI

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

# Chat
response = client.chat.completions.create(
    model='gpt-4',
    messages=[{'role': 'user', 'content': 'Hello!'}]
)

# TTS
audio = client.audio.speech.create(model='tts-1', input='Hello world', voice='alloy')

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

# Embeddings
embeddings = client.embeddings.create(model='text-embedding-ada-002', input='Hello world')
```

### Idéal pour

* 🎯 Besoin de multiples modalités (TTS, STT, LLM)
* 🎯 Vouloir la compatibilité API OpenAI
* 🎯 Exécuter des modèles GGUF
* 🎯 Flux de travail de reranking de documents

***

## Comparaison de performance (2025)

### Débit (tokens/seconde) — Utilisateur unique

| Modèle                    | composant 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  |

### Débit — Utilisateurs multiples (10 concurrents)

| Modèle                    | composant 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 sert séquentiellement par défaut

### Utilisation mémoire

| Modèle             | composant Ollama | vLLM v0.7 | SGLang v0.4 | TGI  |
| ------------------ | ---------------- | --------- | ----------- | ---- |
| Llama 3.1 8B       | 5Go              | 6 Go      | 6 Go        | 7GB  |
| Llama 3.1 70B (Q4) | 38GB             | 40Go      | 39GB        | 42GB |

### Temps jusqu'au premier token (TTFT) — DeepSeek-R1-32B

| Cadre            | TTFT (A100 80GB) | TPOT (ms/tok) |
| ---------------- | ---------------- | ------------- |
| SGLang v0.4      | **180ms**        | **14ms**      |
| vLLM v0.7        | 240ms            | 17ms          |
| llama.cpp        | 420ms            | 28ms          |
| composant Ollama | 510ms            | 35ms          |

***

## Comparaison des fonctionnalités

| Fonction                   | composant Ollama | vLLM v0.7      | SGLang v0.4    | TGI               | LocalAI    |
| -------------------------- | ---------------- | -------------- | -------------- | ----------------- | ---------- |
| API OpenAI                 | ✅                | ✅              | ✅              | ✅                 | ✅          |
| Streaming                  | ✅                | ✅              | ✅              | ✅                 | ✅          |
| Regroupement (Batching)    | Basique          | Continu        | Continu        | Dynamique         | Basique    |
| Multi-GPU                  | Limité           | Excellent      | Excellent      | Bon               | Limité     |
| Quantification             | GGUF             | AWQ, GPTQ, FP8 | AWQ, GPTQ, FP8 | bitsandbytes, AWQ | GGUF       |
| LoRA                       | ✅                | ✅              | ✅              | ✅                 | ✅          |
| Décodage spéculatif        | ❌                | ✅              | ✅              | ✅                 | ❌          |
| Mise en cache des préfixes | ❌                | ✅              | ✅ (Radix)      | ✅                 | ❌          |
| Modèles de raisonnement    | Limité           | Bon            | Excellent      | Bon               | Limité     |
| Métriques                  | Basique          | Prometheus     | Prometheus     | Prometheus        | Prometheus |
| Appel de fonctions         | ✅                | ✅              | ✅              | ✅                 | ✅          |
| Modèles de vision          | ✅                | ✅              | ✅              | ✅                 | Limité     |
| TTS                        | ❌                | ❌              | ❌              | ❌                 | ✅          |
| STT                        | ❌                | ❌              | ❌              | ❌                 | ✅          |
| Embeddings                 | ✅                | Limité         | Limité         | Limité            | ✅          |

***

## Quand utiliser quoi

### Utilisez Ollama lorsque :

* Vous voulez démarrer en 5 minutes
* Vous prototypez ou apprenez
* Vous avez besoin d'un assistant IA personnel
* Vous êtes sur Mac ou Windows
* La simplicité compte plus que la vitesse

### Utilisez SGLang lorsque :

* Vous avez besoin de la **latence absolument la plus basse** (TTFT)
* Vous servez **des modèles de raisonnement** (DeepSeek-R1, QwQ, style o1)
* Vous avez des charges de travail avec un fort **partage de préfixe** (RAG, prompts système)
* Vous avez besoin d'un débit de premier ordre dans les benchmarks 2025
* Vous voulez des optimisations de pointe (attention Radix)

### Utilisez vLLM lorsque :

* Vous avez besoin du débit maximal avec un **cadre mature et bien supporté** Vous servez de nombreux utilisateurs à grande échelle
* Vous avez besoin de fiabilité en production avec une grande communauté
* Vous voulez un remplacement plug-and-play d'OpenAI
* Vous avez des configurations multi-GPU
* Vous avez besoin d'un large support de formats de modèles (AWQ, GPTQ, FP8)
* Utilisez TGI lorsque :

### Vous êtes dans l'écosystème HuggingFace

* Vous avez besoin de fonctions de sécurité intégrées
* Vous voulez des métriques Prometheus détaillées
* Vous devez servir des modèles HF directement
* Vous êtes en environnement de recherche
* Utilisez LocalAI lorsque :

### Vous avez besoin de TTS et STT en plus du LLM

* Vous voulez des embeddings pour le RAG
* Vous avez besoin de reranking de documents
* Vous voulez une solution tout-en-un
* Vous construisez des applications activées par la voix
* Guide de migration

***

## D'Ollama vers SGLang

### # Ollama

```python
response = client.chat.completions.create(model='llama3.2', ...)
client = OpenAI(base_url='http://localhost:11434/v1', api_key='ollama')
# SGLang - changez juste l'URL et le nom du modèle

response = client.chat.completions.create(model='meta-llama/Llama-3.2-3B-Instruct', ...)
client = OpenAI(base_url='http://localhost:8000/v1', api_key='dummy')
D vLLM vers SGLang
```

### Les deux prennent en charge l'API OpenAI - changez simplement l'URL du point de terminaison. Les APIs sont entièrement compatibles.

\# vLLM

```bash
python -m vllm.entrypoints.openai.api_server --model ... --port 8000
# SGLang (équivalent)

python -m sglang.launch_server --model-path ... --port 8000
Recommandations par GPU
```

***

## Utilisateur unique

| GPU                            | Multi-utilisateur | SGLang/vLLM      | Modèles de raisonnement |
| ------------------------------ | ----------------- | ---------------- | ----------------------- |
| RTX 3060 12GB                  | composant Ollama  | composant Ollama | composant Ollama        |
| RTX 3090 24GB                  | composant Ollama  | vLLM             | SGLang                  |
| RTX 4090 24GB                  | A100 40GB+        | A100 40GB+       | SGLang                  |
| - Configuration la plus simple | SGLang            | SGLang           | SGLang                  |

***

## Prochaines étapes

* [Guide Ollama](/guides/guides_v2-fr/modeles-de-langage/ollama.md) Guide vLLM
* [- Débit le plus élevé](/guides/guides_v2-fr/modeles-de-langage/vllm.md) Guide LocalAI
* [- Support multimodal](/guides/guides_v2-fr/modeles-de-langage/localai-openai-compatible.md) Guide DeepSeek-R1
* [- Modèles de raisonnement](/guides/guides_v2-fr/modeles-de-langage/deepseek-r1.md) - Monter en échelle vers des modèles plus grands
* [Configuration Multi-GPU](/guides/guides_v2-fr/avance/multi-gpu-setup.md) Intégration API
* [ ](/guides/guides_v2-fr/avance/api-integration.md) - Construire des applications


---

# Agent Instructions: 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:

```
GET https://docs.clore.ai/guides/guides_v2-fr/comparaisons/llm-serving-comparison.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
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.