LLM auto hébergées · 21 October 2026

llm-d 1.0 et DeepInfer : la bataille de l’inférence distribuée arrive (enfin) chez vous

En ce 20 octobre 2026, deux annonces tombées à quelques heures d’intervalle ont fait trembler le petit monde de l’inférence open source : llm-d 1.0, le projet soutenu par IBM et Google Cloud et désormais porté par la CNCF, et l’ouverture de DeepInfer, le moteur qui fait tourner DeepSeek-V4.1-Flash. D’un côté un orchestrateur de flottes GPU/TPU avec routage cache-aware, de l’autre un moteur d’inférence taillé pour le MoE et la quantization. La question qui fâche : qu’est-ce qui, dans ces deux briques de datacenter, descend réellement jusqu’à votre homelab — et qu’est-ce qui restera à jamais un artefact de salle serveur ?

Octobre 2026 : le mois où l’inférence open source a changé d’échelle

Il faut mesurer l’ironie du calendrier. Le 20 octobre 2026, Google Cloud a annoncé la sortie de llm-d 1.0, stack d’inférence distribuée open source avec routage cache-aware pour flottes TPU et GPU. Le même jour, DeepSeek a ouvert le code de DeepInfer, le framework d’inférence qui propulse DeepSeek-V4.1-Flash. Deux annonces, deux philosophies, un même point de bascule : l’inférence LLM open source cesse d’être un concours de « qui lance le plus gros modèle sur une carte » pour devenir une discipline d’ingénierie système.

Le contexte n’est pas anodin. Depuis deux ans, la communauté locale vit une drôle de tension. D’un côté, des runtimes comme llama.cpp ont démocratisé l’inférence GGUF sur à peu près n’importe quoi — au point que Windows ML a ajouté en octobre 2026 un support expérimental de llama.cpp pour les modèles GGUF avec API locale compatible OpenAI. De l’autre, les modèles ouverts sont devenus des monstres MoE de plusieurs centaines de milliards de paramètres, et les machines capables de les faire tourner en local — mini-PC à mémoire unifiée de 128 Go comme l’AMD Ryzen AI Halo à 3 999 $, ou GPU à 192 Go de mémoire unifiée comme le Gorgon Halo — existent, mais restent des cas particuliers.

Entre les deux, un vide : personne ne savait vraiment orchestrer plusieurs machines, plusieurs GPU, plusieurs modèles, sans finir avec un cluster Kubernetes qui consomme plus de watts que le GPU qu’il est censé servir. C’est exactement ce vide que llm-d 1.0 et DeepInfer viennent occuper — chacun à sa manière.

La question centrale de cet essai est simple, mais elle mérite d’être posée sans détour : qu’est-ce qui, dans ces deux briques, descend réellement jusqu’à un homelab, et qu’est-ce qui reste un artefact de datacenter ? Nous allons procéder en trois temps : décryptage architectural des deux projets, confrontation de leurs approches et de leurs revendications, puis grille de lecture matérielle et décisionnelle pour savoir quand adopter — et surtout quand s’abstenir.

Ce que llm-d 1.0 apporte vraiment : un cerveau de routage posé sur Kubernetes

Commençons par le plus ambitieux des deux. llm-d n’est pas un moteur d’inférence : c’est un orchestrateur. Comprendre cette distinction, c’est comprendre 80 % des malentendus qui entourent le projet.

Concrètement, llm-d 1.0 s’articule autour de quatre briques. D’abord, un scheduler Kubernetes classique, qui place les pods de serving sur les nœuds disponibles. Ensuite, la Gateway API Inference Extension, un point d’entrée standardisé qui expose un endpoint unique à l’application cliente et se charge de router les requêtes. Troisièmement, le cœur du réacteur : le routage cache-aware par préfixe. L’idée est d’une élégance redoutable — plutôt que de répartir les requêtes en round-robin comme le ferait un load-balancer naïf, llm-d inspecte le préfixe de chaque prompt entrant et l’envoie au pod qui a déjà ce préfixe en cache KV. Pourquoi ? Parce que dans un LLM, le coût du prefill (le calcul des états internes pour chaque token d’entrée) est proportionnel à la longueur du prompt, et que recalculer un préfixe déjà vu est du gaspillage pur. Sur des charges de type RAG ou agents avec des system prompts longs et répétés, le gain peut être considérable — nous y reviendrons.

Quatrième brique, la plus impressionnante sur le papier : la disaggregation prefill/decode, via NIXL ou LMCache. Le principe : séparer physiquement les machines qui font le prefill (calcul-bound, elles ont besoin de FLOPS) de celles qui font le decode (mémoire-bound, elles ont besoin de bande passante mémoire). Les états KV calculés par les premières sont transférés aux secondes via un protocole rapide. C’est l’héritage direct de travaux de recherche comme DistServe et Splitwise, qui avaient montré dès 2024 que cette séparation pouvait améliorer l’utilisation GPU.

Ce que llm-d assemble, plutôt qu’il n’invente, c’est donc un empilement de briques connues : vLLM et SGLang pour le serving, DistServe et Splitwise pour la théorie de la disaggregation, Kubernetes pour l’orchestration, la Gateway API pour l’exposition. La valeur ajoutée est dans le câblage — et dans le fait que tout cela soit désormais un projet CNCF, donc avec une gouvernance ouverte et une promesse de stabilité d’API.

Ce qui est réellement exposé à l’utilisateur : les CRDs Kubernetes (donc les politiques de routage, les définitions de pools de serving), les métriques Prometheus, et les endpoints Gateway. Ce qui reste interne : l’algorithme exact de scoring du cache (comment llm-d décide quel pod a « le meilleur » préfixe quand plusieurs en ont un partiel), et les protocoles de transfert KV entre nœuds — qui, on s’en doute, ne sont pas documentés en détail dans le communiqué de presse.

DeepInfer : la mécanique interne du moteur qui fait tourner DeepSeek-V4.1-Flash

Passons à l’autre camp. DeepInfer n’est pas un orchestrateur : c’est un moteur. Là où llm-d dit « voici comment répartir les requêtes sur ta flotte », DeepInfer dit « voici comment faire tourner efficacement ce modèle sur ce matériel ». La nuance est capitale.

Anatomiquement, DeepInfer embarque les quatre mécanismes qu’on attend d’un moteur moderne taillé pour les gros modèles ouverts. Gestion du cache KV : le cache des états intermédiaires, qui est le principal consommateur de mémoire pendant l’inférence, avec des stratégies d’éviction et probablement d’offload vers la RAM ou le disque. Parallélisme expert : indispensable pour un modèle MoE comme DeepSeek-V4.1-Flash, où chaque token n’active qu’un sous-ensemble des experts — le moteur doit répartir ces experts sur plusieurs GPU et router les tokens vers le bon expert, ce qui est un casse-tête de communication. Quantization FP8/INT4 : les formats de poids compressés qui permettent de faire tenir un modèle énorme dans une mémoire limitée, au prix d’une légère perte de qualité. Speculative decoding : la technique qui consiste à faire deviner plusieurs tokens par un petit modèle « draft » puis à les valider en batch par le gros modèle, pour gagner en débit sur les générations longues.

Ce que l’ouverture du code change pour un utilisateur hors datacenter est réel, mais partiel. Réel, parce qu’on peut enfin lire les flags, comprendre les formats de poids attendus, ajuster les seuils de quantization, et surtout apprendre — un moteur d’inférence de production ouvert, c’est une mine pédagogique. Partiel, parce que les chemins critiques (kernels CUDA optimisés, protocoles de communication inter-GPU) restent souvent dépendants d’un matériel spécifique, et que DeepInfer a manifestement été conçu pour les configurations que DeepSeek utilise en interne — pas pour votre Mac Studio.

La mise en regard avec llm-d est éclairante : DeepInfer est un moteur, llm-d est un orchestrateur. Ils sont complémentaires — on peut parfaitement imaginer llm-d router des requêtes vers des pods DeepInfer — mais aussi concurrents sur le terrain de la « brique d’inférence complète ». La vraie question pour l’utilisateur, c’est : lequel des deux résout mon problème ? Si votre problème est « mon modèle est trop gros pour ma carte », c’est DeepInfer (ou vLLM, ou llama.cpp). Si votre problème est « j’ai cinq GPU et je ne sais pas comment répartir mes requêtes intelligemment », c’est llm-d.

Prefill/decode disaggregation, cache KV, topologie réseau : la couche que personne ne voit mais qui décide de tout

Il faut s’arrêter un instant sur ces abstractions communes aux deux projets, parce que c’est là que se joue la vraie bataille — et là que se cachent les déceptions.

Le couple prefill/decode est la clé de voûte de toute l’inférence moderne. Le prefill, c’est le calcul de tous les états internes pour le prompt d’entrée : massivement parallélisable, donc calcul-bound — il aime les GPU avec beaucoup de FLOPS. Le decode, c’est la génération token par token : séquentiel, donc mémoire-bound — il aime les GPU avec beaucoup de bande passante mémoire. Sur une seule carte, ces deux phases se disputent les mêmes ressources et se pénalisent mutuellement. D’où l’idée de les séparer physiquement.

Mais voilà le hic : séparer prefill et decode implique de transférer le cache KV entre les deux machines. Et ce cache KV, pour un prompt de plusieurs milliers de tokens sur un modèle de plusieurs dizaines de milliards de paramètres, peut peser des gigaoctets. Le transférer via un réseau Ethernet classique, c’est noyer le gain de la séparation dans le coût du transfert. D’où l’insistance des deux projets sur la topologie réseau : RDMA, NCCL, interconnexions rapides type NVLink ou InfiniBand. Ce sont des technologies de datacenter, pas de homelab.

C’est ici que se situe le seuil de rentabilité de la disaggregation. En dessous d’un certain volume de trafic et d’une certaine vitesse d’interconnexion, séparer prefill et decode est contre-productif : on paie le transfert KV sans amortir la séparation. Sur une machine unique, c’est absurde. Sur deux machines reliées par du 10 GbE, c’est douteux. Sur un petit cluster avec NVLink ou RDMA, ça commence à avoir du sens — mais on n’est plus dans le homelab, on est dans le labo d’entreprise.

Le cache KV offload, lui, est plus accessible : plutôt que de jeter les états d’un préfixe quand la mémoire GPU est pleine, on les pousse vers la RAM ou le SSD. C’est ce que fait llama.cpp avec son cache de prompt, et c’est ce que font vLLM et DeepInfer avec des stratégies plus sophistiquées. Sur un homelab, c’est probablement le mécanisme le plus immédiatement utile — mais il existe déjà dans les runtimes simples.

Les chiffres que revendiquent les deux camps — et ce qu’ils valent vraiment

Abordons le sujet qui fâche : les chiffres. Les deux annonces du 20 octobre revendiquent des gains. SiliconANGLE rapporte que llm-d ajoute des contrôles pour faire tourner des modèles d’IA en interne, et TechTarget titre que llm-d 1.0 s’attaque aux coûts élevés de l’inférence IA. On parle donc de réduction de coût par million de tokens, d’amélioration du TTFT (time to first token) et du TPOT (time per output token), et de meilleur taux d’utilisation GPU.

Mais il faut être clair : aucun chiffre précis, sourcé et reproductible, n’est disponible dans la matière que nous avons pu consulter. Les communiqués évoquent des gains, sans que nous puissions les citer sans risquer l’erreur. C’est d’ailleurs un problème récurrent dans ce domaine : les annonces de frameworks d’inférence promettent des améliorations spectaculaires, mesurées sur des configurations taillées sur mesure (H100, H200, TPU v5e), sur des modèles choisis pour l’occasion (Llama, Qwen3, Mixtral, DeepSeek-V4.1-Flash), et rarement reproduites par des tiers indépendants.

Face à cela, la posture raisonnable est celle de l’exigence méthodologique. Pour croire un chiffre de gain en inférence, il faut demander : sur quel modèle exact ? sur quel matériel exact ? avec quelle baseline (vLLM ? SGLang ? llama.cpp ?) ? avec quel protocole de mesure (débit en batch, latence en mono-requête, longueur de contexte fixée) ? et le code de benchmark est-il publié ? Tant que ces cinq questions n’ont pas de réponse, un « +X % de débit » est un argument marketing, pas une donnée.

Les benchmarks tiers existent — MLPerf Inference, Artificial Analysis, les rapports de la communauté r/LocalLLaMA — mais ils portent rarement sur les tout derniers frameworks, et jamais sur des configurations homelab exotiques. C’est une limite structurelle de l’écosystème, pas une spécificité de llm-d ou DeepInfer.

llama.cpp et Ollama face à ces usines à gaz : le vrai match coût/bénéfice

Venons-en au cœur du sujet pour notre lectorat : est-ce que tout cela vaut le coup face à un bon vieux llama.cpp ou Ollama ?

Posons les termes. Un llama.cpp sur une RTX 4090, c’est : un binaire, un fichier GGUF, une ligne de commande, et ça tourne. Zéro dépendance à Kubernetes, zéro configuration réseau, zéro courbe d’apprentissage. Un Ollama, c’est encore plus simple : un ollama run et c’est parti. Pour un usage mono-utilisateur, avec un modèle de 7B à 70B, sur une carte unique, c’est écrasamment la bonne réponse. Les runtimes simples ont d’ailleurs progressé : llama.cpp a sorti sa v0.5.0 en 2026 avec un backend, des modèles et un serveur améliorés, et Windows ML a intégré un support expérimental de llama.cpp pour GGUF avec API locale compatible OpenAI. Le plancher technique n’a jamais été aussi bas.

llm-d, en face, c’est : un cluster Kubernetes, la Gateway API Inference Extension, des CRDs à configurer, des politiques de routage à écrire, des métriques à surveiller, et un réseau à dimensionner. Le coût d’exploitation est réel — en temps, en compétences, en électricité (un cluster de trois nœuds avec deux GPU chacun, ça consomme). Et ce coût ne s’amortit que si vous avez plusieurs GPU, plusieurs modèles, plusieurs utilisateurs simultanés, et des prompts à préfixes répétés. C’est-à-dire : un petit opérateur qui sert une API à des clients, une équipe qui fait tourner un RAG interne avec un system prompt de 2 000 tokens, un labo qui héberge plusieurs modèles pour plusieurs projets.

DeepInfer, lui, se situe entre les deux. C’est un moteur, donc plus simple qu’un orchestrateur, mais taillé pour des modèles MoE énormes et du matériel spécifique. Si vous faites tourner DeepSeek-V4.1-Flash sur du matériel adapté (plusieurs GPU, mémoire confortable), c’est pertinent. Si vous faites tourner un Llama 8B sur une 4090, c’est absurde — llama.cpp fera aussi bien, plus simplement.

Le point de bascule, en pratique, se situe autour de plusieurs requêtes simultanées sur un contexte long, avec plusieurs GPU. En dessous, l’orchestration coûte plus qu’elle ne rapporte. C’est une loi assez universelle de l’ingénierie système : l’abstraction a un coût fixe, et ce coût fixe n’est amorti que par le volume.

Conditions matérielles minimales : ce qu’il faut pour tirer parti de l’un ou de l’autre

Distinguons soigneusement « ça démarre » de « ça apporte un gain ». C’est la distinction la plus utile de tout cet article.

Pour llm-d 1.0, « ça démarre » signifie : un cluster Kubernetes (même minikube sur une machine), la Gateway API Inference Extension installée, un pod vLLM ou SGLang qui sert un modèle. Ça, n’importe qui peut le faire en une après-midi. « Ça apporte un gain » signifie : au moins deux nœuds GPU, un réseau correct (idéalement RDMA ou NVLink, à défaut du 25-100 GbE), plusieurs modèles ou plusieurs instances du même modèle, et une charge de requêtes avec des préfixes répétés. En dessous, vous payez l’overhead du scheduler et le coût du transfert KV sans rien gagner.

Pour DeepInfer, « ça démarre » signifie : un matériel compatible avec les formats de quantization visés (FP8/INT4), et assez de mémoire pour le modèle. « Ça apporte un gain » signifie : un modèle MoE assez gros pour que le parallélisme expert ait un sens, sur plusieurs GPU avec une interconnexion rapide. Un modèle MoE mal dimensionné pour une seule carte — où les experts se disputent la mémoire — sera plus lent que le même modèle en dense sur le même matériel.

Les pièges à signaler : l’overhead du scheduler Kubernetes (réel, mais souvent surestimé), le coût du transfert KV (sous-estimé, lui, surtout sur réseau Ethernet), et le dimensionnement des MoE (un MoE de plusieurs centaines de milliards de paramètres ne tient pas sur une carte de 24 Go, même quantizé, sans offload massif qui tue le débit).

Quand adopter, quand s’abstenir : la carte des cas d’usage

Dressons la typologie décisionnelle, sans détour.

Adoptez llm-d si : vous servez plusieurs modèles ou plusieurs instances à plusieurs utilisateurs, vous avez au moins deux GPU sur des machines distinctes, vos prompts partagent des préfixes longs (RAG, agents, system prompts massifs), et vous avez déjà de l’expérience Kubernetes. C’est un outil pour opérateur, pas pour bricoleur.

Adoptez DeepInfer si : vous faites tourner DeepSeek-V4.1-Flash ou un autre gros MoE, vous avez le matériel adapté (plusieurs GPU, formats de quantization supportés), et vous voulez exploiter au maximum le parallélisme expert et le speculative decoding. C’est un outil pour utilisateur avancé de modèles énormes.

Abstenez-vous dans tous les autres cas. Mono-utilisateur ? llama.cpp ou Ollama. Petit modèle (7B-13B) ? llama.cpp ou Ollama. GPU unique ? llama.cpp ou Ollama. Latence non critique (batch offline, génération de contenu) ? llama.cpp ou Ollama. Budget serré ? llama.cpp ou Ollama. C’est brutal, mais c’est la réalité : 90 % des usages homelab n’ont aucun besoin de llm-d ni de DeepInfer, et adopter l’un ou l’autre relève du surdimensionnement pur.

Le surdimensionnement a un coût caché : la complexité d’exploitation. Un cluster Kubernetes mal configuré tombe la nuit ; un llama.cpp mal configuré rame mais tourne. Pour un particulier, la fiabilité d’un binaire simple bat la sophistication d’un orchestrateur.

Ce que cette bataille annonce : l’inférence distribuée devient un standard, pas un luxe

Prenons de la hauteur. Ce qui s’est joué le 20 octobre 2026 n’est pas seulement la sortie de deux outils : c’est la reconnaissance institutionnelle de l’inférence distribuée comme discipline à part entière. llm-d entre à la CNCF, avec IBM et Google Cloud derrière — c’est-à-dire que les géants du cloud considèrent qu’un standard ouvert d’orchestration d’inférence est nécessaire à l’écosystème. DeepSeek ouvre DeepInfer — c’est-à-dire qu’un des laboratoires les plus avancés au monde considère que le code de son moteur d’inférence doit être public pour que son modèle soit adopté.

La convergence probable, dans les 12 à 24 mois, est claire : les orchestrateurs (llm-d, CNCF) et les moteurs (DeepInfer, vLLM, SGLang) vont apprendre à se parler via des interfaces standardisées — routage cache-aware d’un côté, protocoles de transfert KV de l’autre. On peut parier sur une standardisation des API de disaggregation, sur des runtimes qui intègrent nativement ces mécanismes, et sur la fin progressive du choix binaire entre « simple mais lent » et « puissant mais ingérable ».

Pour le homelab, l’attente raisonnable n’est pas de voir llm-d tourner sur un Raspberry Pi, mais de voir ses briques simplifiées descendre dans les runtimes grand public : un routage cache-aware intégré à Ollama, un offload KV intelligent par défaut dans llama.cpp, une disaggregation prefill/decode optionnelle sur les machines à mémoire unifiée. C’est déjà ce qui se passe, à petits pas : les runtimes simples intègrent année après année des mécanismes qui étaient hier réservés aux datacenters.

La vraie leçon de ce mois d’octobre 2026, c’est que l’inférence open source a cessé d’être un problème de « quel modèle je peux faire tenir » pour devenir un problème de « comment j’orchestre mes ressources ». C’est une bonne nouvelle : les problèmes d’ingénierie système ont des solutions qui finissent par se standardiser et se simplifier. Mais c’est aussi un avertissement : entre la démonstration de datacenter et le homelab, il y a un gouffre que personne ne comble encore — et qu’il faut regarder en face avant de déployer Kubernetes pour faire tourner un 8B.

Sources

• Google Cloud Ships llm-d 1.0 With Cache-Aware Routing for TPU and GPU Fleets — MarkTechPost, 20 octobre 2026
• DeepSeek Open-Sources DeepInfer, the Inference Framework Behind DeepSeek-V4.1-Flash — MarkTechPost, 20 octobre 2026
• IBM-backed llm-d framework adds controls for running AI models in-house — SiliconANGLE, 20 octobre 2026
• CNCF’s llm-d 1.0 tackles high AI inference costs — TechTarget, 20 octobre 2026
• Windows ML: 2026 Updates for GGUF Models and Local AI — Techgenyz, 9 octobre 2026
• AI Development on Windows: from PyTorch and llama.cpp to Windows ML — Microsoft Foundry on Windows Blog, 7 octobre 2026
• llama.cpp v0.5.0 in 2026: What Changed, How to Install, Run GGUF & Use the Local API — 27 septembre 2026

Article recherché et rédigé automatiquement · Magazine Electrosens