Strata 0.2.12 : le moteur d'inférence dédié à Qwen3.8-Flash-Next accélère sur GPU 12 Go, Strix Halo et DGX Spark

Strata : trois versions en six jours pour un moteur d'inférence né fin septembre

Strata est un moteur d'inférence open source (licence MIT, écrit en C++) publié sur GitHub par Niko1221 le 24 septembre 2026 et construit autour d'un seul modèle de langage : Qwen3.8-Flash-Next, le modèle MoE (mixture of experts, mélange d'experts) de l'équipe Qwen d'Alibaba. La description du dépôt tient en une phrase : faire tourner Qwen3.8-Flash-Next sur du matériel grand public, avec un installeur en un clic pour Windows et Linux, et servir des API compatibles OpenAI et Anthropic sur localhost. Le moteur accepte aussi DeepSeek V4.1-Flash et Qwen3.6-35B-A3B, mais tout le travail d'optimisation (drafter, noyaux GPU, formats de quantisation) vise Qwen3.8-Flash-Next. Six semaines après sa création, le projet dépasse 41 000 étoiles et publie à un rythme inhabituel : 0.2.10 le 2 novembre, 0.2.11 le 5 novembre et 0.2.12 le 7 novembre, d'après la page des versions du dépôt GitHub, source de cet article.

Ce qui intéresse un administrateur de serveur GPU, c'est l'approche : au lieu d'exiger que le modèle entier tienne en VRAM, Strata garde les poids denses et une partie des experts sur la carte graphique, le reste des experts en RAM, et une table de consultation de 29 Go sur le SSD. C'est ce qui lui permet d'annoncer un modèle de 125 milliards de paramètres sur une carte de 12 Go, avec les compromis que nous détaillons plus bas. Nous avions déjà comparé vLLM et Ollama sur serveur dédié : cet article résume ce que les trois versions de la semaine changent, ce que Strata apporte face à ces deux moteurs, et surtout les prérequis réels en VRAM, RAM et disque, car les chiffres divergent d'une page à l'autre de la documentation.

Strata 0.2.12 : drafter DFlash2 réglé, cartes 12 Go, Strix Halo, DGX Spark et Mac

La note de version de la 0.2.12 (application et Terminal en 0.2.12, moteur en 0.1.58) met en avant un drafter DFlash2 réglé par l'équipe Strata, un traitement des prompts plus rapide sur les cartes NVIDIA de 12 Go, sur les puces AMD Strix Halo et sur Mac, un décodage un peu plus rapide sur le NVIDIA DGX Spark, et une série de corrections d'appels d'outils. Le drafter est un petit modèle auxiliaire (0,34 Go, 0,52 Go sur Intel Arc) qui propose les tokens suivants, que le modèle principal se contente de vérifier : c'est le principe du décodage spéculatif. La version réglée, dérivée du Qwen3.8-Flash-Next-DFlash2 d'Inco AI (Apache 2.0), s'active seule en mode Auto sur Mac, sur les cartes NVIDIA qui gardent tous les experts en VRAM, sur le DGX Spark, sur Strix Halo, sur Intel Arc série A et sur les cartes NVIDIA de 12 Go avec le fichier UD-IQ4_XS-v31. Pour revenir au drafter MTP : strata launch --drafting mtp.

Les mesures publiées comparent la 0.2.11 et la 0.2.12 sur la même machine, moteur relancé à chaque essai, ordre alterné, réponses de 300 tokens en décodage glouton. Les vitesses de lecture du prompt sont en tokens par seconde, la génération en variation relative :

Le bond de la RTX 3060 vient d'une correction de démarrage sur Linux : le second contrôle de mémoire libre comptait la mémoire du moteur lui-même comme disponible, et Strata basculait sur le cache de fichiers (lecture des experts depuis le disque) à trois démarrages sur trois en 0.2.11, zéro sur trois en 0.2.12. Un avertissement s'affiche désormais quand la bascule se produit malgré tout, et STRATA_FILE_TIER_HONEST=0 désactive le contrôle. Sur Strix Halo (Windows), les gains viennent de noyaux de prompt fusionnés pour UD-Q4_K_XL et pour les couches Q5_0 de UD-IQ4_XS-v31, réversibles avec STRATA_GFX1151_DEFAULTS=0. Sur les Radeon gfx1201 (R9700, RX 9070), le mode Auto repasse au drafter MTP, parce que 11 moteurs DFlash2 sur 50 restaient bloqués sur le prompt en 0.2.11 : les reculs de génération du tableau sur R9700 viennent de ce changement de drafter, pas d'une régression du moteur. Sur le DGX Spark, un problème connu subsiste : le premier long prompt après démarrage se lit à 590 à 670 tok/s, contre 1 154 à 1 235 tok/s une fois les pages mémoire en cache.

Côté appels d'outils, la 0.2.12 accepte le nom de modèle envoyé par Claude Desktop sur /v1/messages en le redirigeant vers le modèle chargé, reconnaît les ouvertures <function=tools NOM>, <toolcall> et <tool-call> quand un outil déclaré suit, apparie les résultats d'outils Anthropic par tool_use_id, et fait aboutir un tool_choice forcé avec plusieurs outils dans 24 essais sur 24, contre 0 sur 24 avant. Un nouveau réglage undeclared_tool_calls (valeur text par défaut, call en option) décide si un appel vers un outil non déclaré est renvoyé comme du texte ou comme un appel. Les compilations CUDA 12 et 13 pour les cartes sm_60 à sm_75 fonctionnent de nouveau, la construction de l'image Docker est réparée, et une installation neuve sur Mac ne reste plus bloquée à l'étape de préparation du modèle.

0.2.10 et 0.2.11 : DFlash2 par défaut, moteur multi-GPU, contexte 128K et fichiers Unsloth 1 à 4 bits

La 0.2.10 du 2 novembre (moteur 0.1.56) a fait de DFlash2 le drafter par défaut en mode Auto partout où le moteur le supporte : cartes CUDA de compute capability 8.6, 8.9, 12.0 et 12.1 (RTX 30, 40 et 50, RTX A6000, DGX Spark), Radeon gfx1100, gfx1151 et gfx1201, Apple Metal et Intel Arc. DFlash2 pèse environ 0,7 Go, et la couche MTP de 5,2 Go n'est plus téléchargée ni chargée. Les gains de génération mesurés face à MTP sur une carte : +12,0 % en réponses courtes et +8,8 % en réponses longues sur Strix Halo avec UD-Q4_K_XL, +7,88 % en décodage glouton sur RTX PRO 5000 avec IQ3_S, +6,6 % sur Radeon AI PRO R9700, +5,8 % sur DGX Spark, +7,4 % sur M5 Max, et 2,6 % de moins sur Intel Arc A750 où il reste pourtant le choix Auto. La limite à connaître pour un serveur : DFlash2 sert une requête à la fois. Dès que deux requêtes tournent en parallèle, pour DeepSeek, ou sur le moteur multi-GPU, le mode Auto repasse à MTP.

La même version a introduit un moteur multi-GPU sur Linux, dérivé de sFNX (John Fink, MIT), où chaque carte porte une part de chaque couche et toutes lisent les poids en même temps. Le mode Auto l'active si toutes les conditions sont réunies : Linux, exactement deux cartes NVIDIA de compute capability 8.6 ou 12.0 ou quatre Radeon AI PRO R9700, un fichier Qwen3.8 dont tous les experts routés tiennent en VRAM, environ 43 Gio de RAM libre (dont 27,5 Gio pour la table d'embedding) et un contexte de 131 072 tokens au plus. Sur deux RTX A6000 avec UD-Q4_K_XL en 128K, l'édition de code passe de 195 à 377 à 394 tok/s, la prose de 93 à 139 à 146 tok/s, et six requêtes simultanées cumulent 224 tok/s au lieu de 168. Sur deux RTX PRO 6000 Blackwell, les éditions montent de 420 à 432 tok/s à 666 à 741 tok/s. Sur quatre R9700, un utilisateur passe de 98 à 158 tok/s et huit requêtes de 243 à 350 tok/s. Désactivation : strata launch --split-engine off. La 0.2.12 signale encore qu'en mode peer (--peer-device, deux cartes), environ 4 % des démarrages plantent à la première requête, cause inconnue, alors que le moteur multi-GPU complet n'est pas touché.

Troisième apport de la 0.2.10 : le contexte de 128K sur les cartes de 8 Go. Le contexte par défaut reste 131 072 tokens et, quand la VRAM manque, Strata dégrade par paliers plutôt que de refuser : la fenêtre du cache KV descend à 20 480, puis 8 192, puis 4 096 cellules ; la couche MTP est abandonnée ; les tampons de prompt passent de 128 à 16 emplacements de cache d'experts ; enfin la tête de sortie (0,41 Gio) part en RAM hôte épinglée, ce qui rend le décodage environ trois fois plus lent. Sur une Intel Arc A750 de 8 Go, quatre démarrages en 128K ont donné 12,7 à 14,8 tok/s. Une RTX 5070 de 12 Go bridée à 8 Go tournait 17 à 27 % moins vite. La note précise que les cartes de 12 Go ne changent pas, et que ces paliers ne s'appliquent qu'aux cartes dédiées, pas aux puces Apple ni aux GPU intégrés.

La 0.2.11 du 5 novembre (moteur 0.1.57) a ajouté les fichiers Unsloth « Dynamic v3.1 » de Qwen3.8-Flash-Next, retéléversés le 4 novembre et vérifiés par taille et SHA-256, de 1 à 4 bits :

Le dernier fichier de chaque jeu est une table de 28,8 Go lue à chaque token, partagée entre deux jeux voisins. UD-IQ1_S ne charge pas, une couche mélangeant deux formats d'experts. En décodage, UD-IQ1_M a été mesuré à 43 à 45 tok/s sur DGX Spark et 101 à 114 tok/s sur RTX A6000. La même version active des noyaux de prompt K-quant sur NVIDIA (compute capability 8.0 et plus) pour UD-Q4, Q5 et Q6_K_XL : sur RTX PRO 6000, un prompt de 4K passe de 2 338 à 3 097 tok/s (+37,7 %) et un prompt de 32K de 3 709 à 4 886 tok/s (+32,6 %). Les paires de petites cartes (2 x 8 Go, 2 x 12 Go, 2 x 16 Go) démarrent désormais en découpage par couches, avec des prompts à 1 000 à 2 200 tok/s contre 6 000 à 7 000 sur de grandes cartes, et le plantage par manque de mémoire de la 0.2.10 sur 2 x 16 Go est corrigé. Les conversations sont enregistrées en fichiers JSON plutôt qu'en stockage navigateur, et un bogue de réplicas (#2892, un même modèle chargé deux fois) qui laissait une requête lire la sortie de la précédente, avec réponses vides ou texte fuité, est corrigé sur le serveur Python : 30 transferts forcés sur 30 et 60 requêtes sur 60 sont propres.

Ce que Strata apporte face à Ollama et vLLM sur un serveur GPU

Ollama et vLLM répondent à deux besoins distincts, que notre comparatif détaille : la simplicité et l'inférence CPU pour le premier, le débit sous charge concurrente pour le second. Strata occupe un troisième créneau : un seul grand modèle MoE sur une machine à GPU grand public et beaucoup de RAM, pour un à huit utilisateurs, avec un drafter spéculatif activé par défaut.

Le dernier point n'est pas une réserve de principe. Chaque note de version de Strata liste ses propres reculs : extraction JSON 18,9 % plus lente sur RTX 3060 en 0.2.12, appels d'outils 9,5 % plus lents sur Strix Halo, mode peer qui plante à 4 % des démarrages, et une liste de dix tickets d'appels d'outils encore ouverts. C'est honnête, et c'est aussi le signe qu'un serveur Strata se met à jour version par version, avec un retour arrière prêt (strata components rollback). Pour une API multi-locataire à fort débit avec un modèle qui tient en VRAM, vLLM reste la réponse. Pour tester quinze modèles différents ou tourner sans GPU, Ollama reste la réponse (installer Ollama sur un VPS Linux). Strata vaut le détour quand l'objectif est précisément Qwen3.8-Flash-Next, ou DeepSeek V4.1-Flash, sur une machine qui n'a pas 100 Go de VRAM.

Prérequis réels : VRAM, RAM et disque pour un MoE déchargé en partie sur CPU

D'abord le modèle lui-même, d'après sa fiche Hugging Face : Qwen3.8-Flash-Next compte 125 milliards de paramètres de modèle de langage, plus 51 milliards pour une table d'embedding n-gram et 4 milliards pour la couche MTP, soit 180 milliards au total dans les fichiers safetensors (les métadonnées GGUF d'Unsloth indiquent 177 milliards). Seuls 6 milliards sont actifs par token : chaque token active 10 experts routés et 1 expert partagé parmi 512. Les 48 couches alternent trois couches Gated DeltaNet et une couche d'attention éparse, ce qui garde le cache KV léger, et le contexte natif est de 262 144 tokens. En BF16, le GGUF pèse 354 Go. C'est cette architecture qui rend le déchargement viable : à chaque token, le GPU ne lit qu'une petite fraction des experts, le reste peut dormir en RAM.

Les tailles de fichiers et la mémoire nécessaire, d'après la page des modèles de Strata :

La règle de dimensionnement de Strata : RAM nécessaire = experts + environ 10 Go. Avec 64 Go, toutes les tailles ISTA-DASLab tiennent ; avec 48 Go, seulement Q2_0 et IQ2_XS. Un mode « RAM réduite » lit les experts directement depuis les fichiers et laisse le GPU garder ce qu'il peut : un PC de 32 Go avec un GPU de 24 Go fait tourner Q2_0, IQ2_XS et le Coder, un GPU de 12 à 16 Go avec 32 Go de RAM fait tourner le Coder, mais la documentation prévient que c'est beaucoup plus lent. À cela s'ajoutent une table de 29 Go laissée sur le SSD, environ 6 Go pour la couche MTP ou 0,7 Go pour DFlash2, et un SSD NVMe est attendu : avec un disque lent, chaque token attend le disque. Le nombre de requêtes parallèles par défaut découle de la VRAM : 1 sur 12 Go, 2 sur 20 Go, 3 sur 24 Go, 4 à partir de 32 Go. Le lecteur d'images tourne sur le CPU sous 24 Go de VRAM, sur le GPU au-delà (1 à 1,4 Go de VRAM).

Les chiffres qui divergent selon les pages, et comment les lire :

• 8 ou 12 Go de VRAM ? Les deux sont vrais, mais ne disent pas la même chose. 8 Go est le plancher à partir duquel la 0.2.10 démarre un contexte de 128K, au prix des paliers de dégradation ci-dessus et d'un décodage à 12 à 15 tok/s sur Arc A750. 12 Go (RTX 3060, RTX 5070) est la classe de cartes sur laquelle Strata mesure et optimise, avec une seule requête parallèle par défaut. Pour DeepSeek V4.1-Flash, la page des modèles fixe le minimum à 12 Go. Et dans le découpage multi-cartes, une carte de moins de 8 Go n'est pas acceptée aux côtés d'une autre ;
• Taille totale du modèle : 125 milliards si l'on compte le modèle de langage, 177 ou 180 milliards avec la table d'embedding n-gram et la couche MTP. Les 28,8 ou 29 Go du dernier fichier de chaque jeu, c'est cette table, laissée sur le SSD ;
• Tailles de fichiers : la page des modèles de Strata donne 188 Go pour le Q8_0 et 94 Go pour UD-IQ4_XS, la fiche Hugging Face d'Unsloth 192 Go et 93,7 Go. Les notes de version arrondissent parfois en Go, parfois en Gio. Sur cette même page, le Coder ISTA-DASLab est annoncé à 29,6 Go dans le texte et 23 Go dans le tableau ;
• Strix Halo : en 0.2.11, un partage de 64 Go pour la partie graphique donne 63,6 Gio reportés, alors que le cache d'experts par défaut réclame 66,86 Gio : il faut fixer le budget à la main.

Le seul chiffre qui fait foi est celui de votre machine. Strata fournit pour cela une commande qui calcule ce qui manque sans rien télécharger, puis un moniteur qui montre la répartition réelle des experts entre VRAM et RAM :

strata launch --family qwen --model iq3_s --plan
strata monitor --once

Installer Strata sur un serveur Linux : Terminal ou Docker

Sur un serveur sans écran, la version Terminal s'installe avec le script officiel, puis se pilote en ligne de commande. Le script place le binaire dans ~/.local/bin/strata :

curl -fsSL https://github.com/Niko1221/Strata/releases/latest/download/install.sh -o install.sh && sh install.sh
strata launch --family qwen --model iq3_s --plan
strata launch --family qwen --model iq3_s --context 32k --parallel 1 --yes --no-tui
strata launch --status
strata launch --show-key

Le serveur écoute sur http://127.0.0.1:8080 : base /v1 pour les clients OpenAI, racine pour les clients Anthropic (dont Claude Code via strata connect), avec un en-tête Authorization: Bearer portant la clé générée. L'option --access accepte local, lan, cloudflare ou tailscale. Mise à jour : strata update --check puis strata update (qui demande avant d'arrêter un modèle chargé, ou --stop-model en script) ; retour en arrière du moteur : strata components rollback.

Les images Docker sont publiées sur le GitHub Container Registry sous ghcr.io/niko1221/strata:<version>-<variante>, avec latest-<variante> pour la dernière version. Variantes : cuda13 (RTX 20 à 50, pilote NVIDIA 580 ou plus), cuda12 (GTX 10, P100, V100 ou pilote 575 à 579), rocm-gfx120x (RX 9000, R9700), rocm-gfx110x (RX 7000), rocm-gfx1151 (Strix Halo) et sycl (Intel Arc, avec des fichiers de modèle déjà préparés). L'hôte doit être un Linux x86-64 avec le NVIDIA Container Toolkit (installer Docker sur un serveur Linux). Commande de référence pour NVIDIA, avec un volume pour les modèles et une écoute limitée à localhost :

docker run -d --name strata --gpus all -p 127.0.0.1:8080:8080 \
  --ulimit memlock=-1:-1 --shm-size 2g --stop-timeout 120 \
  -v strata-data:/data -e FAMILY=qwen -e MODEL=IQ3_S -e API_KEY=$(openssl rand -hex 24) \
  ghcr.io/niko1221/strata:latest-cuda13

docker logs -f strata
docker exec -it strata strata monitor

Trois consignes de la documentation Docker à respecter : ne fixez aucune limite mémoire au conteneur, Strata planifie à partir de la RAM totale du système ; gardez --stop-timeout 120, le déchargement du modèle prend du temps et un arrêt brutal finit en code 137 ; et figez le tag de version plutôt que latest si vous voulez choisir le moment des mises à jour (un docker pull du nouveau tag, docker stop, docker rm, puis la même commande de lancement). Les variables CONTEXT (32k à 256k), PARALLEL (1 à 8), KV (int8 par défaut) et GPU (indices des cartes) reprennent les options du Terminal. Pour exposer l'API en HTTPS, il faut un nom de domaine dont l'enregistrement DNS pointe vers l'adresse IP fixe du serveur, un serveur web en frontal, NGINX en reverse proxy devant le port 8080 avec des délais longs, et un pare-feu qui ne laisse passer que 22, 80 et 443 (sécuriser un serveur Ubuntu avec SSH, UFW et Fail2ban). La documentation Docker rappelle que seul GET /health répond sans clé, et conseille API_KEY_FILE avec un secret Docker plutôt qu'une clé tapée dans l'historique du shell. Branchez ensuite Open WebUI sur l'endpoint OpenAI si vos utilisateurs veulent une interface de chat.

Système d'exploitation, répertoires, sauvegarde : ce que la documentation précise et ce qu'elle tait

Avant de configurer un serveur pour Strata, il faut savoir sur quel système d'exploitation le moteur tourne réellement. Le guide d'installation du dépôt distingue l'application de bureau, avec interface graphique, et le Terminal, qui se pilote depuis le shell et reste le seul mode possible sur une machine sans écran :

Les scripts install.sh et install.ps1 sont publiés avec chaque version, à côté d'un fichier SHA256SUMS.txt : vérifiez l'empreinte avant d'exécuter un script téléchargé sur une machine de production. Sous Linux et macOS, le script écrit tout dans le répertoire personnel de l'utilisateur, sans que la documentation mentionne sudo : le binaire dans ~/.local/bin/strata, les composants du moteur dans ~/.local/share/strata/components (variable d'environnement XDG_DATA_HOME), les conversations et l'état de l'hôte dans ~/.strata (variable STRATA_HOME). Sous Windows, les composants vont dans %LOCALAPPDATA%\Strata\components. Les modèles sont proposés dans Documents/Strata/Models à la première installation ; strata launch --data-dir envoie les nouveaux téléchargements vers un autre disque, et --move-data déplace l'existant. Les droits root ne servent qu'à installer le pilote et le NVIDIA Container Toolkit (nvidia-ctk runtime configure --runtime=docker, puis redémarrage de Docker). Le conteneur, lui, tourne en root pour accéder aux périphériques GPU et à la mémoire épinglée : la documentation demande de ne lui monter que des répertoires que vous acceptez de lui laisser lire, en lecture seule (:ro) pour les modèles.

Dans le conteneur, tout ce qui persiste tient dans le volume /data : Strata-data/ (fichiers de modèle et pack préparé), state/ (préréglages, résultats de réglage, clé API), install/ (réglages d'exécution et journaux) et home/. Pour loger 100 à 200 Go de modèles, montez une partition ou un volume dédié à la place du volume nommé (-v /mnt/modeles/strata:/data), sur SSD NVMe : la page de dépannage explique qu'un voyant disque qui clignote sans arrêt signifie que les experts absents de la RAM sont lus directement depuis le disque, et un disque dur mécanique transforme chaque token en attente. La documentation ne décrit aucune procédure de backup. Les fichiers de modèle se retéléchargent et sont vérifiés par SHA-256, donc la sauvegarde prioritaire porte sur state/, qui contient la clé API et les réglages : un rsync vers un hôte distant suffit, chiffré puisque la clé y figure (chiffrer ses sauvegardes hors site).

Au premier démarrage, le moteur lit 34 à 55 Go dans la RAM et en verrouille une partie pour la carte graphique : cela prend plusieurs minutes, et le second démarrage va plus vite tant que les fichiers restent dans le cache du système. La page de dépannage ne propose de redémarrer la machine que dans deux cas : après une mise à jour du pilote graphique, et si l'interface reste figée plus de dix minutes au premier chargement. Pour un diagnostic sans rien charger, strata doctor --live affiche la carte et le pilote retenus ; si le port 8080 est déjà pris, strata launch --status dit si c'est Strata lui-même, --restart remplace l'instance en cours et --port 8081 en démarre une seconde si la mémoire le permet. La documentation ne fournit pas d'unité systemd pour relancer le Terminal au redémarrage du serveur : strata launch --yes --no-tui s'y prête (les codes de sortie 7 et 8 de strata update sont documentés pour les scripts), sur le modèle de notre tutoriel créer un service systemd sous Linux.

Le cas Strix Halo mérite un mot sur le BIOS, car c'est là que se joue la mémoire. La machine de test du projet (Ryzen AI Max+ 395, 128 Go) réserve 64 Go à la partie graphique dans le BIOS, et Windows voit les 64 autres ; le moteur traite l'ensemble comme un seul bassin de 128 Go. Sous Windows, la version minimale du pilote est AMD Adrenalin 26.10.1 : le pilote de mars 2025 échoue en contexte 32K. Sous Linux, les mesures des mainteneurs viennent d'un Ubuntu 26.04 avec un noyau 7.0 et ROCm 7.14.1 ; leurs paramètres de boot du noyau (ttm.pages_limit et ttm.page_pool_size, soit un GTT de 112 Gio au lieu de la moitié de la RAM, et amd_iommu=off) ne sont pas exigés par le moteur, ils lui laissent seulement plus de place. Une machine de 64 ou 32 Go obtient un cache d'experts plus petit et tourne plus lentement ; l'installation le dit, mais ne refuse jamais. La variable d'environnement STRATA_UMA_RESERVE_GIB fixe la réserve laissée au système, par défaut le plus grand de 8 Gio ou 8 % de la RAM.

Quel serveur pour Strata : housing GPU, serveur dédié ou VPS

Le profil matériel que dessine Strata est précis : un GPU de 12 à 32 Go, 64 Go de RAM ou plus, un SSD NVMe de plusieurs centaines de Go. Nos serveurs dédiés sont des machines bi-processeur Intel Xeon E5-2620 v4 sans carte graphique : ils conviennent à l'inférence CPU, comme le montre notre retour d'expérience LLM sur CPU avec llama.cpp sur un Xeon Gold, mais pas à Strata, dont la documentation ne décrit aucun mode sans GPU. Pour faire tourner Qwen3.8-Flash-Next avec Strata chez nous, la voie est le housing GPU : vous montez votre machine (une RTX 4090 ou 5090, une RTX 6000 Ada, une L40S), nous l'hébergeons au datacenter Equinix PA6 à Paris avec une enveloppe de 800 W à 3 kVA sur alimentation redondée, un port uplink 10 Gbps et des IP fixes, à partir de 399 € HT par mois. Une seule RTX 4090 (450 W constructeur) avec un processeur de 170 W tient dans l'offre GPU Starter ; deux cartes de ce type demandent l'offre GPU Pro. Le principe du housing est expliqué dans housing en datacenter : comment ça marche.

Un serveur d'inférence exposé sur Internet est une cible, et un GPU qui mine à 100 % pour quelqu'un d'autre est un scénario documenté (31 dépôts Hugging Face piégés avec un cryptomineur GPU). Strata génère une clé API dès que le serveur est joignable au-delà de la machine, télécharge ses modèles depuis des dépôts vérifiés par SHA-256 et conserve un fichier téléchargé corrompu en .bad plutôt que de le supprimer. Le reste vous appartient : SSH par clé, pare-feu, mises à jour de l'hôte, et surveillance de la RAM, car un modèle qui déborde finit tué par le noyau (comprendre l'OOM Killer). Un VPS est un serveur virtuel sans carte graphique, et la virtualisation ne change rien à la règle : Strata y constate l'absence de GPU et n'installe rien. Si votre besoin se limite à un modèle dense de 27 milliards de paramètres pour un utilisateur, un VPS Linux de 32 ou 48 Go suffit avec Ollama : Qwen 3.8 27B avec Ollama sur un VPS Linux.

Conclusion

En une semaine, Strata a fait de DFlash2 son drafter par défaut, lancé un moteur multi-GPU sur Linux, ouvert le contexte de 128K aux cartes de 8 Go, intégré les fichiers Unsloth de 1 à 4 bits, puis réglé son drafter et ses noyaux de prompt pour les cartes de 12 Go, Strix Halo, Mac et DGX Spark, avec des gains mesurés de x3 sur la lecture du prompt d'une RTX 3060. Le moteur ne remplace ni vLLM pour le débit multi-utilisateur ni Ollama pour la polyvalence, mais il rend un MoE de 125 milliards de paramètres exploitable sur une machine à GPU grand public, à condition de lire les prérequis avec soin : 12 Go de VRAM pour un usage sérieux, 64 Go de RAM pour les quantisations ISTA-DASLab, 72 à 88 Go pour les 4 bits d'Unsloth, un SSD NVMe, et une mise à jour suivie version par version, retour arrière prêt. Avant tout achat de carte, lancez strata launch --plan sur la configuration visée, et comparez avec serveur dédié bare metal ou VPS ce que vous attendez vraiment de la machine.