Mise en service des LLM : Ollama vs vLLM vs TGI

Comparez vLLM, SGLang, Ollama, TGI et LocalAI pour la mise en service des LLM

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

Toutes les options disponibles sur la place de marché CLORE.AI.

Mise à jour 2025 : SGLang s’est imposé comme un framework de premier plan, souvent surpassant vLLM en débit et en TTFT dans les benchmarks. vLLM v0.7 et SGLang v0.4 sont tous deux recommandés pour les charges de production.

Guide de décision rapide

Les configurations multi-GPU de classe 80 Go ne sont pas répertoriées sur la place de marché Clore.ai. Les plus grosses machines répertoriées aujourd’hui sont 4× RTX PRO 6000 Blackwell (96 Go chacune, 380 Go au total) et 8–11× RTX 5090 (32 Go chacune). La capacité A100 / H200 / B200 est proposée en bare metal sur demande. Consultez bare metal sur demande. Consultez Tarifs et disponibilité des GPU avant de dimensionner un déploiement.

Cas d’utilisation	Meilleur choix	Pourquoi
Tests rapides et chat	Ollama	Configuration la plus simple, démarrage le plus rapide
API de production (débit maximal)	SGLang ou vLLM	Le débit le plus élevé en 2025
Modèles de raisonnement (DeepSeek-R1)	SGLang	Meilleur support pour les chaînes de raisonnement
Intégration HuggingFace	TGI	Prise en charge native de HF
Développement local	Ollama	Fonctionne partout
Forte concurrence	SGLang ou vLLM	Lotissement continu
Multi-modal (TTS, STT, embeddings)	LocalAI	Solution tout-en-un
Applications en streaming	vLLM ou SGLang	Les deux sont excellents

Comparaison des temps de démarrage

Solution	Démarrage typique	Remarques
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

Fonctionnalité	Ollama	vLLM	SGLang	TGI	LocalAI
Facilité de configuration	⭐⭐⭐⭐⭐	⭐⭐⭐	⭐⭐⭐	⭐⭐⭐	⭐⭐⭐⭐
Performances	⭐⭐⭐	⭐⭐⭐⭐⭐	⭐⭐⭐⭐⭐	⭐⭐⭐⭐	⭐⭐⭐
Prise en charge des modèles	⭐⭐⭐⭐	⭐⭐⭐⭐⭐	⭐⭐⭐⭐⭐	⭐⭐⭐⭐	⭐⭐⭐⭐
Compatibilité API	Personnalisé + OpenAI	OpenAI	OpenAI	Personnalisé + OpenAI	OpenAI
Multi-GPU	Limité	Excellente	Excellente	Bon	Limité
Efficacité mémoire	Bon	Excellente	Excellente	Très bonne	Bon
Multi-modal	Vision uniquement	Vision uniquement	Vision uniquement	Non	TTS, STT, intégration
Temps de démarrage	30 s	5 à 15 min	3 à 8 min	3 à 10 min	5 à 10 min
Modèles de raisonnement	Limité	Bon	Excellente	Bon	Limité
Idéal pour	Développement	Production	Production + Raisonnement	Écosystème HF	Multi-modal

---

Benchmarks 2025 : DeepSeek-R1-32B

TTFT, TPOT et débit (A100 80 Go, batch=32, entrée=512, sortie=512)

Framework	TTFT (ms)	TPOT (ms/tok)	Débit (tok/s)	Remarques
SGLang v0.4	180	14	2,850	Meilleur global en 2025
vLLM v0.7	240	17	2,400	Excellent, proche de SGLang
llama.cpp	420	28	1,100	CPU+GPU, quantifié
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 du débit (RTX 4090, Llama 3.1 8B, 10 utilisateurs concurrents)

Framework	Jetons/s	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
Ollama	160*	—	Séquentiel par défaut

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

---

SGLang

Aperçu

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

Avantages

• ✅ Souvent le meilleur en TTFT et en débit dans les benchmarks 2025

• ✅ Attention Radix pour une réutilisation efficace du KV-cache

• ✅ Excellent support des modèles de raisonnement (DeepSeek-R1, QwQ)

• ✅ API compatible OpenAI

• ✅ Lotissement continu et cache de préfixe

• ✅ Prise en charge 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': 'Explique l’intrication quantique'}
    ],
    temperature=0.7,
    max_tokens=512
)
print(response.choices[0].message.content)

Multi-GPU

# 2 GPU (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

• 🎯 API de production avec un large support communautaire

• 🎯 Modèles de raisonnement (DeepSeek-R1, QwQ, style o1)

• 🎯 Applications à faible latence (TTFT)

• 🎯 Charges de travail riches en préfixes (forte réutilisation du KV-cache)

---

Ollama

Aperçu

Ollama est la façon la plus simple d’exécuter des LLM localement. Parfait pour le développement, les tests et l’usage personnel.

Avantages

• ✅ Installation et exécution en une seule 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

• ❌ Prise en charge limitée du multi-GPU

• ❌ Moins prêt pour la production

• ❌ Moins d’options d’optimisation

Démarrage rapide

# Installation
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': 'Explique l’informatique quantique',
    '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': 'Bonjour !'}]
)

Performances

Modèle	GPU	Jetons/s
Llama 3.2 3B	RTX 3060	45-55
Llama 3.1 8B	RTX 3090	35-45
Llama 3.1 70B	A100 40 Go	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, une meilleure prise en charge de la quantification et de nouvelles options de décodage spéculatif.

Avantages

• ✅ Débit le plus élevé (lotissement continu + PagedAttention)

• ✅ PagedAttention pour une gestion efficace de la mémoire

• ✅ Excellente prise en charge 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 dans la 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 davantage 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': 'Vous êtes utile.'},
        {'role': 'user', 'content': 'Écris un haïku sur le codage'}
    ],
    temperature=0.7,
    max_tokens=100
)

# Diffusion en continu
stream = client.chat.completions.create(
    model='meta-llama/Llama-3.1-8B-Instruct',
    messages=[{'role': 'user', 'content': 'Raconte-moi une histoire'}],
    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	Jetons/s	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 40 Go	25-35	5-10
Llama 3.1 70B	2x A100	50-70	15-25

Idéal pour

• 🎯 API de production avec une grande communauté

• 🎯 Applications à fort trafic

• 🎯 Services de chat multi-utilisateurs

• 🎯 Besoin de débit maximal

---

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

• ✅ Bonne prise en charge 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 un jeton HF pour les modèles soumis à accès restreint
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	Jetons/s	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 40 Go	20-30	3-8

Idéal pour

• 🎯 Utilisateurs de modèles HuggingFace

• 🎯 Environnements de recherche

• 🎯 Besoin de fonctions de sécurité intégrées

• 🎯 Besoins de supervision Prometheus

---

LocalAI

Aperçu

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

Avantages

• ✅ Prise en charge multi-modale (LLM, TTS, STT, embeddings)

• ✅ Remplacement OpenAI prêt à l’emploi

• ✅ Modèles préconstruits disponibles

• ✅ Prend en charge les modèles GGUF

• ✅ Prise en charge du 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 rencontrer des problèmes CUDA

• ❌ Plus complexe pour un usage LLM pur

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': 'Bonjour !'}]
)

# TTS
audio = client.audio.speech.create(model='tts-1', input='Bonjour le monde', 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='Bonjour le monde')

Idéal pour

• 🎯 Besoin de plusieurs modalités (TTS, STT, LLM)

• 🎯 Voulez-vous la compatibilité avec l’API OpenAI

• 🎯 Exécution de modèles GGUF

• 🎯 Flux de travail de reranking de documents

---

Comparaison des performances (2025)

Débit (tokens/seconde) — utilisateur unique

Modèle	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 40 Go)	18	30	35	25

Débit — plusieurs utilisateurs (10 en parallèle)

Modèle	Ollama	vLLM v0.7	SGLang v0.4	TGI
Llama 3.1 8B (RTX 4090)	150*	800	920	500
Llama 3.1 70B (A100 40 Go)	50*	200	240	150

*Ollama traite les requêtes de manière séquentielle par défaut

Utilisation mémoire

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

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

Framework	TTFT (A100 80 Go)	TPOT (ms/tok)
SGLang v0.4	180 ms	14 ms
vLLM v0.7	240 ms	17 ms
llama.cpp	420 ms	28 ms
Ollama	510 ms	35 ms

---

Comparaison des fonctionnalités

Fonctionnalité	Ollama	vLLM v0.7	SGLang v0.4	TGI	LocalAI
API OpenAI	✅	✅	✅	✅	✅
Flux continu	✅	✅	✅	✅	✅
Lotissement	Basique	Continu	Continu	Dynamique	Basique
Multi-GPU	Limité	Excellente	Excellente	Bon	Limité
Quantification	GGUF	AWQ, GPTQ, FP8	AWQ, GPTQ, FP8	bitsandbytes, AWQ	GGUF
LoRA	✅	✅	✅	✅	✅
Décodage spéculatif	❌	✅	✅	✅	❌
Cache de préfixe	❌	✅	✅ (Radix)	✅	❌
Modèles de raisonnement	Limité	Bon	Excellente	Bon	Limité
Métriques	Basique	Prometheus	Prometheus	Prometheus	Prometheus
Appel de fonction	✅	✅	✅	✅	✅
Modèles de vision	✅	✅	✅	✅	Limité
TTS	❌	❌	❌	❌	✅
STT	❌	❌	❌	❌	✅
Embeddings	✅	Limité	Limité	Limité	✅

---

Quand utiliser quoi

Utiliser Ollama quand :

• Vous voulez commencer en 5 minutes

• Vous faites du prototypage ou de l’apprentissage

• Vous avez besoin d’un assistant IA personnel

• Vous êtes sur Mac ou Windows

• La simplicité compte plus que la vitesse

Utiliser SGLang quand :

• Vous avez besoin de la latence absolue la plus faible (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 plan dans les benchmarks 2025

• Vous voulez des optimisations de pointe (attention Radix)

Utiliser vLLM quand :

• Vous avez besoin du débit maximal avec un framework mature, bien pris en charge framework

• Vous servez de nombreux utilisateurs à grande échelle

• Vous avez besoin d’une fiabilité de production avec une grande communauté

• Vous voulez un remplacement direct d’OpenAI

• Vous avez des configurations multi-GPU

• Vous avez besoin d’une large prise en charge des formats de modèles (AWQ, GPTQ, FP8)

Utiliser TGI quand :

• 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 directement des modèles HF

• Vous êtes dans un environnement de recherche

Utiliser LocalAI quand :

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

• Vous voulez des embeddings pour le RAG

• Vous avez besoin du reranking de documents

• Vous voulez une solution unique tout-en-un

• Vous créez des applications avec la voix

---

Guide de migration

D’Ollama vers SGLang

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

# SGLang - changez simplement l’URL et le nom du modèle
client = OpenAI(base_url='http://localhost:8000/v1', api_key='dummy')
response = client.chat.completions.create(model='meta-llama/Llama-3.2-3B-Instruct', ...)

De vLLM vers SGLang

Les deux prennent en charge l’API OpenAI - changez simplement l’URL du point de terminaison. Les API 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

GPU	Utilisateur unique	Multi-utilisateur	Modèles de raisonnement
RTX 3060 12 Go	Ollama	Ollama	Ollama
RTX 3090 24 Go	Ollama	vLLM	SGLang
RTX 4090 24 Go	SGLang/vLLM	SGLang/vLLM	SGLang
A100 40Go+	SGLang	SGLang	SGLang

---

Étapes suivantes

• Guide Ollama - Configuration la plus simple

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

• Guide LocalAI - Prise en charge multimodale

• Guide DeepSeek-R1 - Modèles de raisonnement

• Configuration multi-GPU - Passer à des modèles plus grands

• Intégration API - Créer des applications