# Mise à disposition de 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](https://docs.clore.ai/guides/guides_v2-fr/modeles-de-langage/ollama) Guide vLLM * [- Débit le plus élevé](https://docs.clore.ai/guides/guides_v2-fr/modeles-de-langage/vllm) Guide LocalAI * [- Support multimodal](https://docs.clore.ai/guides/guides_v2-fr/modeles-de-langage/localai-openai-compatible) Guide DeepSeek-R1 * [- Modèles de raisonnement](https://docs.clore.ai/guides/guides_v2-fr/modeles-de-langage/deepseek-r1) - Monter en échelle vers des modèles plus grands * [Configuration Multi-GPU](https://docs.clore.ai/guides/guides_v2-fr/avance/multi-gpu-setup) Intégration API * [ ](https://docs.clore.ai/guides/guides_v2-fr/avance/api-integration) - Construire des applications