Qu'est-ce qu'un serveur d'inférence LLM en entreprise ?
Un serveur d'inférence LLM en entreprise est la couche logicielle qui accepte des requêtes concurrentes de nombreux utilisateurs ou applications et les répartit efficacement sur un pool de GPU partagé. Cela diffère d'un runtime mono-utilisateur, qui charge un modèle pour un seul processus sur une seule machine.
Trois éléments distinguent un logiciel de serving de niveau entreprise d'un outil pour ordinateur portable : le continuous batching (regrouper plusieurs requêtes en cours sur le même passage GPU), le parallélisme multi-GPU (répartir un modèle sur plusieurs GPU ou nœuds), et une surface d'API de production (health checks, métriques, hooks d'autoscaling) qu'une équipe plateforme peut exploiter dans Kubernetes.
vLLM, Hugging Face TGI et NVIDIA NIM ont tous été conçus autour de ces trois exigences dès le départ. Ollama, construit sur llama.cpp, a été pensé pour la portabilité et la simplicité sur une seule machine -- un objectif différent, valide, mais pas le même. Voir notre comparatif des moteurs mono-utilisateur si la question « quel outil s'installe le plus facilement sur mon PC » est celle que vous vous posez réellement -- ce guide couvre l'autre bout de cette décision.
Comparatif : vLLM vs TGI vs NVIDIA NIM vs Ollama
Capacité | vLLM | TGI | NVIDIA NIM | Ollama |
|---|---|---|---|---|
| Licence | Apache 2.0 / Gratuit | Apache 2.0 / Gratuit | NVIDIA AI Enterprise / Payant | MIT / Gratuit |
| Objectif de conception | Serving GPU haut débit | Serving HF hérité (maintenance) | Stack entreprise NVIDIA clé en main | Mono-utilisateur, pas multi-tenant |
| Multi-GPU | Parallélisme tensoriel + pipeline | Parallélisme tensoriel | Parallélisme tensoriel (par profil) | Mono-nœud (selon la doc) |
| Continuous batching | Oui (PagedAttention) | Oui (routeur Rust) | Oui (au niveau du moteur) | Requêtes parallèles (1 par défaut) |
| Quantification | GPTQ / AWQ / FP8 / INT4 | bitsandbytes / GPTQ / AWQ / EETQ / Marlin / FP8 | Selon le profil de modèle | GGUF Q4-Q8 |
| Déploiement Kubernetes | Helm / production-stack / KServe | Image conteneur / manifestes propres | NIM Operator (officiel) | Charts communautaires cités |
| Modèle de support | Communauté / GitHub | Mode maintenance / archivé | Support entreprise NVIDIA | Communauté (selon la doc) |
| Observabilité | Métriques Prometheus intégrées | Prometheus + traces OTel | Métriques DCGM / propres à NIM | Aucun point de métriques documenté |
Comprendre vLLM : un moteur open source à haut débit
vLLM est un serveur d'inférence open source (Apache 2.0) conçu spécifiquement pour le serving multi-GPU à haut débit. Issu du Sky Computing Lab de UC Berkeley, c'est un moteur open source largement utilisé pour les API LLM en production.
- PagedAttention : gère le cache KV par blocs de taille fixe plutôt que par allocation contiguë par requête, ce qui augmente l'utilisation mémoire GPU atteignable et permet à plus de requêtes concurrentes de partager un GPU.
- Continuous batching : les nouvelles requêtes rejoignent un batch en cours plutôt que d'attendre la fin du batch actuel, maintenant l'utilisation GPU élevée sous un trafic variable.
- Multi-GPU et multi-nœud : le parallélisme tensoriel répartit les couches d'un modèle sur les GPU d'un nœud ; le parallélisme pipeline répartit sur plusieurs nœuds pour les modèles trop grands pour la VRAM combinée d'un nœud.
- Quantification : les formats GPTQ, AWQ, FP8 et INT4 réduisent l'empreinte VRAM par réplique, augmentant le nombre de répliques simultanées qu'un parc GPU fixe peut héberger.
- API compatible OpenAI :
vllm serve <model>expose un remplacement direct de l'API OpenAI Chat Completions, minimisant le travail d'intégration côté application. - vLLM fournit un Helm chart officiel et s'intègre à KServe pour le serving de modèles natif Kubernetes, avec un autoscaling piloté par la profondeur de file ou l'utilisation GPU.
# Déployer un modèle avec parallélisme tensoriel sur 4 GPU
pip install vllm
# --api-key ne protège que les chemins /v1, /v2, /inference et /cohere ; les autres endpoints restent ouverts. Placez un pare-feu ou un reverse proxy devant avant toute exposition du port
vllm serve meta-llama/Llama-3.3-70B-Instruct \
--tensor-parallel-size 4 \
--gpu-memory-utilization 0.9 \
--api-key "$VLLM_API_KEY" \
--host 0.0.0.0 --port 8000Comprendre Hugging Face TGI : désormais en mode maintenance
Hugging Face Text Generation Inference (TGI) est un serveur d'inférence open source (Apache 2.0) pour les modèles du Hugging Face Hub, mais il est désormais en mode maintenance : son dépôt GitHub a été archivé (lecture seule) en mars 2026, et Hugging Face recommande vLLM et SGLang pour les nouveaux déploiements. Selon son README, il alimente encore Hugging Chat, l'Inference API et les Inference Endpoints ; les déploiements existants continuent donc de fonctionner, mais n'attendez pas de nouvelles fonctions.
- Routeur de requêtes en Rust : gère la file d'attente et le continuous batching selon la documentation de TGI.
- Flash Attention et Paged Attention : la documentation de TGI mentionne les deux, des techniques d'efficacité mémoire popularisées par vLLM.
- Parallélisme tensoriel : répartit un modèle sur plusieurs GPU d'un nœud ; le serving multi-nœud est pris en charge mais avec moins d'outillage first-party que chez vLLM.
- Quantification : formats bitsandbytes, GPTQ, AWQ, EETQ, Marlin et FP8.
- Intégration native au Hugging Face Hub : récupérer un modèle, son tokenizer et ses poids safetensors ne demande aucune étape de conversion manuelle si le modèle est déjà hébergé sur le Hub.
- Remarque sur la licence : TGI a brièvement été distribué sous une licence plus restrictive rédigée par Hugging Face (HFOIL 1.0 ; voir la FAQ sur la licence de TGI) en 2023-2024 avant de revenir à Apache 2.0 -- vérifiez la version de licence figée dans votre manifeste de déploiement, car une image mise en cache plus ancienne peut encore porter l'étiquette restrictive.
- Migration : démarrez les nouveaux projets sur vLLM ou SGLang ; pour un parc TGI existant, prévoyez un passage à un moteur activement maintenu plutôt que de rester sur une base de code archivée. La dernière version de TGI est la v3.3.7, de décembre 2025.
Comprendre NVIDIA NIM : l'option soutenue par l'éditeur
NVIDIA NIM (NVIDIA Inference Microservices) est un conteneur payant et pré-packagé qui encapsule un moteur d'inférence open source optimisé par NVIDIA derrière une API standardisée, vendu dans le cadre de l'abonnement NVIDIA AI Enterprise. Il échange la configuration manuelle de vLLM et TGI contre un déploiement soutenu et pré-optimisé.
- Conteneurs de moteur avec optimisations NVIDIA : la documentation actuelle de NIM for LLMs indique que chaque image de conteneur regroupe un moteur open source, vLLM ou SGLang, avec des optimisations NVIDIA ; selon la même page de présentation, l'ancienne architecture 1.x regroupait plusieurs backends dans un seul conteneur. Vérifiez quel moteur utilise votre version de NIM avant de comparer le débit avec un vLLM auto-hébergé.
- Support entreprise assuré par NVIDIA : la différence avec les options open source -- une voie de support éditeur sous licence NVIDIA AI Enterprise ; vérifiez les conditions exactes de SLA et de disponibilité dans votre contrat.
- NIM Operator pour Kubernetes : l'operator de NVIDIA crée le déploiement Kubernetes de chaque service NIM, peut pré-mettre des modèles en cache sur les nœuds et prend en charge l'autoscaling sur des métriques DCGM ou propres à NIM.
- Catalogue de modèles : NVIDIA maintient un ensemble sélectionné de modèles à poids ouverts pré-packagés en conteneurs NIM prêts à l'emploi, plus un chemin pour packager des modèles fine-tunés maison.
- Le compromis est la dépendance vis-à-vis de l'éditeur et le coût de licence : NIM est conçu pour les GPU NVIDIA, et la production exige une licence NVIDIA AI Enterprise, qui commence selon la FAQ NIM de NVIDIA à 4 500 $ US par GPU et par an. Les membres du NVIDIA Developer Program peuvent auto-héberger NIM pour la recherche, le développement et l'expérimentation sur 16 GPU maximum. Confirmez les conditions actuelles auprès de NVIDIA AI Enterprise avant de budgétiser, car les tarifs d'abonnement logiciel évoluent sans beaucoup de communication publique.
Pourquoi Ollama n'est pas un moteur de serving entreprise
Ollama n'est pas conçu pour le serving multi-tenant en entreprise, et c'est un choix de conception, pas un défaut. Ollama encapsule llama.cpp avec une API REST simple et un téléchargement de modèle en une commande, optimisé pour un développeur exécutant un modèle sur une machine.
- Concurrence : selon sa FAQ, Ollama gère les requêtes parallèles via OLLAMA_NUM_PARALLEL (1 par défaut) et une file d'attente (OLLAMA_MAX_QUEUE, 512 par défaut), mais ne documente ni batching continu ni gestion mémoire de type PagedAttention : il n'est pas conçu pour de nombreux utilisateurs simultanés comme vLLM ou NIM.
- Multi-GPU : Ollama peut répartir un grand modèle sur les GPU d'une machine, mais sa documentation ne décrit aucun serving parallèle tensoriel ou multi-nœud comparable à celui de vLLM.
- Kubernetes : un Helm chart communautaire est listé dans le README GitHub ; aucun operator Kubernetes first-party ni aucune intégration d'autoscaler n'est listé dans sa documentation.
- Observabilité : la documentation d'Ollama ne décrit aucun point de métriques, contrairement à vLLM et TGI.
- Là où Ollama reste le bon outil dans une entreprise : les ordinateurs portables des développeurs, un prototype départemental à faible trafic interne, ou un appareil edge isolé servant un utilisateur à la fois. Dès que le trafic exige de la concurrence multi-tenant, passez à vLLM, TGI ou NIM -- voir les configurations multi-GPU pour LLM locaux pour le volet matériel de cette transition.
Décisions d'architecture : mono-nœud vs multi-nœud
La première décision d'architecture est mono-nœud contre multi-nœud, et elle dépend de si le modèle tient dans la mémoire GPU combinée d'un nœud -- pas seulement du volume de trafic.
Les équipes qui ont besoin de nœuds multi-GPU sans acheter un parc entier peuvent comparer les hébergeurs de serveurs GPU.
- Mono-nœud, multi-GPU : utilisez le parallélisme tensoriel (
--tensor-parallel-sizechez vLLM,--num-shardchez TGI) pour répartir les couches d'un modèle sur les GPU d'un serveur. C'est le défaut pour les modèles qui tiennent dans la VRAM combinée d'un nœud. - Multi-nœud : ajoutez le parallélisme pipeline dès qu'un modèle dépasse la mémoire GPU d'un nœud, ou que le volume de requêtes dépasse ce que le parallélisme tensoriel sur un nœud peut servir. vLLM le prend en charge via Ray ; NIM via ses propres modèles de déploiement multi-nœud.
- Répartition de charge : un équilibreur round-robin simple fonctionne pour des répliques de taille identique, mais un routage conscient du cache KV -- renvoyer une requête de suivi de la même conversation vers la réplique qui détient déjà son contexte en cache -- réduit sensiblement la latence pour les workloads de type chat.
- Routage de modèles : les entreprises exécutant plus d'un modèle (par exemple un modèle de code et un modèle de chat général) font généralement tourner des pools de répliques séparés par modèle derrière une couche de routage, plutôt qu'un pool partagé -- la mémoire GPU ne se partage pas assez proprement entre des modèles très différents pour justifier la complexité.
- Autoscaling : mettez à l'échelle sur la profondeur de file ou l'utilisation GPU, pas sur le CPU (le défaut classique du HPA Kubernetes) -- l'utilisation CPU d'un pod d'inférence GPU bouge souvent à peine lorsque la charge change. KEDA avec une métrique Prometheus personnalisée est le pattern courant pour vLLM/TGI ; l'Operator de NIM le câble en tant que partie du produit. Voir la mise à l'échelle des LLM locaux pour l'entreprise pour la planification de capacité plus large derrière ce choix.
Comment déployer un stack d'inférence multi-GPU
Déployer un stack d'inférence entreprise suit une séquence fixe : définir le SLA, dimensionner le parc, choisir le moteur, puis câbler déploiement, routage et observabilité autour.
- 1Définir le SLA de latence et de concurrence avant de choisir le matériel.
- 2Dimensionner le parc GPU selon l'empreinte VRAM du modèle et la cible de concurrence, pas seulement selon le nombre de paramètres du modèle.
- 3Choisissez le moteur de serving -- vLLM (ou SGLang) pour la flexibilité open source, NIM pour un déploiement clé en main avec support éditeur ; ne démarrez pas de nouveau projet sur TGI.
- 4Conteneuriser le moteur et le déployer via Helm (ou le NIM Operator) dans votre cluster Kubernetes.
- 5Configurer le parallélisme tensoriel au sein d'un nœud et le parallélisme pipeline entre nœuds si le modèle le requiert.
- 6Mettre en place un équilibrage de charge conscient du cache KV ou round-robin devant le pool de répliques.
- 7Câbler l'autoscaling sur la profondeur de file ou l'utilisation GPU, pas sur le CPU.
- 8Ajouter l'observabilité Prometheus/OpenTelemetry et effectuer un test de charge à la concurrence cible avant la mise en production.
Licences et modèle de support comparés
La licence est la ligne qui modifie le plus le coût total de possession entre ces options. vLLM est sous licence Apache 2.0 et gratuit à toute échelle, tout comme TGI (Apache 2.0, désormais archivé) -- vous ne payez que l'infrastructure GPU en dessous. NVIDIA NIM exige une licence NVIDIA AI Enterprise en production, qui commence selon la FAQ de NVIDIA à 4 500 $ US par GPU et par an en plus du coût du GPU ; la recherche, le développement et l'expérimentation sur 16 GPU maximum sont gratuits pour les membres du NVIDIA Developer Program. Confirmez les conditions actuelles directement auprès de NVIDIA avant de budgétiser. Ollama est sous licence MIT et gratuit, avec un support limité au GitHub et au Discord de la communauté -- sa documentation ne mentionne aucune offre de support entreprise payante.
Le modèle de support compte autant que le coût de licence pour un système de production : le support de vLLM passe par les issues GitHub et les canaux communautaires (rapide pour les problèmes courants, sans SLA), TGI ne reçoit plus que des correctifs de maintenance mineurs, NIM s'accompagne d'un contrat de support NVIDIA, et la documentation d'Ollama ne mentionne aucune voie de support hors canaux communautaires.
Points d'observabilité pour le serving en production
vLLM et TGI exposent tous deux un endpoint /metrics compatible Prometheus prêt à l'emploi, couvrant la latence des requêtes, la profondeur de file, l'utilisation du cache KV GPU et le débit en tokens. Reliez cela à une stack Prometheus/Grafana existante pour des tableaux de bord de niveau production sans instrumentation sur mesure.
NVIDIA NIM prend en charge les métriques GPU basées sur DCGM et des métriques propres à NIM, que son Operator peut utiliser pour l'autoscaling -- un meilleur choix si le reste de l'infrastructure est déjà centré sur NVIDIA.
Ollama a des métriques intégrées minimales : sa documentation ne décrit aucun point de métriques, ce qui correspond à sa conception mono-utilisateur mais constitue une vraie lacune si vous l'exploitez comme infrastructure partagée et avez besoin de la latence par requête pour de nombreux utilisateurs simultanés.
Quel serveur d'inférence choisir ?
Choix open source par défaut : vLLM -- large communauté, vaste prise en charge matérielle, outillage multi-GPU et versions fréquentes.
Déjà chez Hugging Face : planifiez quand même vLLM ou SGLang -- TGI est en mode maintenance, ne le gardez que pour les déploiements existants.
Adapté si vous avez besoin d'un support éditeur : NVIDIA NIM -- support éditeur, clé en main, moyennant un coût de licence.
Pas pour du trafic de production multi-tenant : Ollama -- à réserver aux machines de développeurs et aux déploiements edge mono-utilisateur.
- 🧭 Équipe plateforme qui exploite une API LLM interne partagée pour de nombreuses équipes → vLLM, auto-hébergé sur Kubernetes.
- 🧭 Entreprise réglementée souhaitant un contrat de support éditeur → NVIDIA NIM ; ajoutez votre propre journalisation d'audit en amont (voir le guide de conformité entreprise associé).
- 🧭 Équipe déjà standardisée sur le Hugging Face Hub pour l'hébergement des modèles → vLLM, qui charge directement les modèles du Hub ; gardez TGI uniquement pour les déploiements existants.
- 🧭 Développeurs qui construisent une preuve de concept avant que l'infrastructure ne soit prête → Ollama, puis migration vers vLLM dès que le trafic simultané devient réel.
- ❌ Si vous attendez plus d'une poignée d'utilisateurs simultanés, Ollama n'est pas conçu pour un point d'accès de production partagé -- utilisez plutôt vLLM.
- ❌ Si vous avez besoin d'un autoscaling natif Kubernetes sur la charge de requêtes, la documentation d'Ollama ne mentionne aucun équivalent au scaling par profondeur de file piloté par KEDA -- utilisez vLLM ou NIM.
Erreurs courantes dans le dimensionnement de l'infrastructure d'inférence entreprise
- Dimensionner les GPU selon le nombre de paramètres plutôt que le nombre de requêtes concurrentes. Un parc GPU dimensionné juste pour qu'une copie du modèle tienne en VRAM n'a aucune marge pour des utilisateurs concurrents -- dimensionnez pour la concurrence de pointe, puis vérifiez que le modèle tient toujours.
- Déployer Ollama derrière un équilibreur de charge de production partagé. Cela fonctionne dans une démo avec deux utilisateurs ; il n'est pas conçu pour un déploiement destiné à des centaines d'utilisateurs.
- Mettre à l'échelle sur l'utilisation CPU. Les pods d'inférence GPU bougent souvent à peine côté CPU lorsque la charge change -- mettez plutôt à l'échelle sur la profondeur de file ou l'utilisation GPU.
- Ignorer la vérification de licence sur d'anciennes images TGI en cache. Confirmez que le tag d'image récupéré correspond bien à la version Apache 2.0, pas à un build de l'ère HFOIL 1.0 mis en cache.
- Budgéter NIM sans confirmer les tarifs actuels par GPU directement auprès de NVIDIA. Les tarifs d'abonnement logiciel entreprise évoluent ; un devis périmé n'est pas une base de budget.
Sources
- Documentation vLLM -- Docs officielles vLLM : PagedAttention, continuous batching et guides de déploiement multi-GPU/multi-nœud.
- Hugging Face Text Generation Inference (GitHub) -- Dépôt officiel de TGI : avis de mode maintenance, statut d'archivage, formats de quantification pris en charge et historique des licences.
- Documentation NVIDIA NIM -- Docs officielles NIM : modèles pris en charge, images de moteur vLLM et SGLang et le NIM Operator pour Kubernetes.
- Ollama GitHub -- Dépôt officiel Ollama et suivi des issues, référencé pour le comportement de concurrence et de déploiement.
- NVIDIA AI Enterprise -- Page produit de NVIDIA pour l'abonnement AI Enterprise sous lequel NIM est distribué.
- FAQ NVIDIA NIM -- Déclarations de NVIDIA sur la licence de NIM : usage Developer Program jusqu'à 16 GPU, licence NVIDIA AI Enterprise en production et prix de départ.
Questions fréquentes
Quelle est la différence entre vLLM et NVIDIA NIM ?
vLLM est un serveur d'inférence gratuit et open source (Apache 2.0) que vous hébergez et exploitez vous-même. NVIDIA NIM est un conteneur prêt à l'emploi de NVIDIA qui, selon la documentation actuelle de NVIDIA, regroupe le moteur vLLM ou SGLang avec des optimisations NVIDIA ; la production exige une licence NVIDIA AI Enterprise et inclut le support éditeur. vLLM donne du contrôle sans frais de licence, au prix du réglage et du support à votre charge ; NIM échange cela contre une licence. PromptQuorum n'a pas comparé les deux par des benchmarks.
Ollama peut-il être utilisé pour le serving d'inférence multi-utilisateurs en entreprise ?
Déconseillé pour le trafic de production multi-tenant. Ollama traite les requêtes parallèles via OLLAMA_NUM_PARALLEL (1 par défaut) et une file d'attente, mais ne documente ni batching continu ni gestion mémoire de type PagedAttention, et sa documentation ne mentionne aucun autoscaling natif Kubernetes. Il convient aux postes de développeurs, aux appareils edge mono-utilisateur ou aux prototypes internes à faible trafic.
NVIDIA NIM vaut-il le coût de licence face à vLLM ou TGI open source ?
Cela dépend de ce que valent pour vous le contrat de support éditeur et le packaging de NVIDIA par rapport au coût de licence, face à une infrastructure gratuite que vous exploitez vous-même. Les entreprises réglementées qui souhaitent un contrat de support éditeur justifient souvent le coût (la journalisation d'audit reste à ajouter séparément) ; les équipes disposant d'une expertise interne en infrastructure ML exploitent souvent vLLM sans coût de licence.
Comment mettre à l'échelle l'inférence LLM sur plusieurs GPU et nœuds ?
Utilisez le parallélisme tensoriel pour répartir les couches d'un modèle sur les GPU d'un même nœud, et le parallélisme pipeline pour répartir sur plusieurs nœuds quand le modèle dépasse la mémoire GPU cumulée d'un nœud. vLLM prend en charge les deux (multi-nœud via Ray ou multiprocessing) ; TGI gère le parallélisme tensoriel avec moins d'outillage multi-nœud officiel et est en mode maintenance ; NIM déploie les modèles multi-GPU via ses profils de modèle et s'exécute sur Kubernetes grâce au NIM Operator.
Quels formats de quantification chaque serveur d'inférence prend-il en charge ?
vLLM prend en charge GPTQ, AWQ, FP8 et INT4. TGI indique bitsandbytes, GPTQ, AWQ, EETQ, Marlin et FP8. NVIDIA NIM choisit la précision selon le profil de modèle et le GPU. Ollama utilise le format GGUF en précision Q4 à Q8, visant l'économie de mémoire sur une machine plutôt que le débit multi-tenant.
Comment déployer vLLM ou TGI sur Kubernetes ?
vLLM documente plusieurs voies Kubernetes, dont un chart Helm, KServe et le production-stack du vllm-project. TGI fournit une image de conteneur que vous intégrez dans vos propres manifestes. Configurez des requêtes de ressources adaptées à votre allocation GPU, réglez l'autoscaling sur la profondeur de file ou l'utilisation GPU plutôt que sur le CPU, et ajoutez un ServiceMonitor Prometheus pour collecter le point de métriques.
Qu'est-ce que le continuous batching et pourquoi compte-t-il pour le serving entreprise ?
Le batching continu permet à de nouvelles requêtes de rejoindre un lot GPU déjà en cours, au lieu d'attendre la fin du lot courant. Il maintient une utilisation GPU élevée sous un trafic réel irrégulier, ce qui explique qu'il soit la norme dans vLLM, TGI et les moteurs de NIM, et l'une des plus grandes différences avec un outil mono-utilisateur comme Ollama.
Quel serveur d'inférence a la meilleure observabilité ?
vLLM expose des métriques sur son point /metrics et TGI propose des métriques Prometheus et le traçage OpenTelemetry -- idéal pour une pile Prometheus/Grafana existante. NVIDIA NIM prend en charge les métriques DCGM et propres à NIM via son Operator, plus adapté à une infrastructure centrée sur NVIDIA. La documentation d'Ollama ne décrit aucun point de métriques.
Plusieurs modèles nécessitent-ils des parcs GPU séparés, ou peuvent-ils partager un pool ?
En pratique, les entreprises exécutant plus d'un modèle font généralement tourner des pools de répliques séparés par modèle plutôt que de partager un pool, car la mémoire GPU ne se partage pas proprement entre des modèles de tailles très différentes. Routez les requêtes vers le bon pool au niveau de l'application ou de la passerelle plutôt que de tenter de colocaliser plusieurs modèles sur les mêmes répliques GPU.
Comment la licence diffère-t-elle entre vLLM, TGI et NVIDIA NIM ?
vLLM et Hugging Face TGI sont tous deux sous licence Apache 2.0 et gratuits à toute échelle -- vous ne payez que l'infrastructure GPU. NVIDIA NIM exige une licence NVIDIA AI Enterprise en production, qui commence selon la FAQ de NVIDIA à 4 500 $ US par GPU et par an en plus du matériel GPU ; les membres du Developer Program peuvent auto-héberger NIM pour la recherche et le développement sur 16 GPU maximum. Confirmez les prix actuels directement auprès de NVIDIA. Ollama est sous licence MIT, gratuit, avec un support uniquement communautaire.
Hugging Face TGI est-il encore maintenu ?
TGI est en mode maintenance. Son README indique que Hugging Face n'accepte que des corrections de bogues mineures, des améliorations de documentation et de la maintenance légère, et le dépôt GitHub a été archivé (lecture seule) en mars 2026. La dernière version est la v3.3.7 de décembre 2025, et Hugging Face recommande vLLM et SGLang pour les nouveaux déploiements. Les déploiements TGI existants continuent de fonctionner, mais prévoyez une migration.
Comment vLLM et TensorRT-LLM se comparent-ils ?
vLLM est un moteur de serving généraliste qui charge directement les modèles au format Hugging Face et fonctionne sur les GPU NVIDIA et AMD ainsi que sur d'autres matériels. TensorRT-LLM est la bibliothèque d'inférence de NVIDIA pour les GPU NVIDIA. Les versions antérieures compilaient un modèle à l'avance en un moteur TensorRT propre à un GPU ; la documentation actuelle de NVIDIA décrit un workflow basé sur PyTorch dans lequel le backend de moteur TensorRT a été supprimé, vérifiez donc la version que vous déployez. vLLM implique en général un déploiement plus simple et une couverture matérielle et de modèles plus large ; TensorRT-LLM convient aux équipes engagées sur les GPU NVIDIA. Voir TensorRT-LLM expliqué.