Servir des LLM : Ollama vs vLLM vs TGI

Comparez vLLM vs SGLang vs Ollama vs TGI vs LocalAI pour le service de LLM

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

Toutes les options disponibles sur CLORE.AI Marketplace.

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.

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

Les erreurs HTTP 502 pendant le démarrage sont normales - le service est encore en cours d'initialisation.

---

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

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

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

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

# 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

# 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

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

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

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

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

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

# 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

# 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

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

Utilisation de l'API

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

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

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 Guide vLLM

• - Débit le plus élevé Guide LocalAI

• - Support multimodal Guide DeepSeek-R1

• - Modèles de raisonnement - Monter en échelle vers des modèles plus grands

• Configuration Multi-GPU Intégration API

• - Construire des applications