Intermédiaire 22 minMini-PC

LLM 70B en local sur GB10 : le tutoriel complet

LLM 70B en local sur GB10 : le tutoriel complet
Réponse directe

Sur une GIGABYTE AI TOP ATOM (puce NVIDIA GB10, 128 Go), Llama 3.3 70B tient avec de la marge : 43,6 Go avec un contexte de 8 192 tokens, 82 Go avec 131 072. Il écrit entre 4,6 et 5,3 tokens par seconde avec trois voies : Ollama, llama.cpp ou vLLM. Un brouillon Llama 3.2 1B porte llama.cpp à 12 tokens par seconde en prose et 19 en code. À huit utilisateurs, vLLM tient 38,6 tokens par seconde au total en moyenne pendant deux heures.

Un modèle de 70 milliards de paramètres comme Llama 3.3 70B est « dense » : il utilise tous ses paramètres pour écrire chaque mot, et il lui faut beaucoup de mémoire. Les 128 Go d'une machine GB10 l'accueillent largement. Ce tutoriel donne les commandes de trois façons de l'installer, testées sur une AI TOP ATOM fournie gracieusement par GIGABYTE, puis les mesures qui aident à choisir : vitesse, petit modèle brouillon, mémoire du contexte, tenue sur deux heures et service à plusieurs.

Par Mohamed Meguedmi·Màj 2026-10-29·Mesuré sur GIGABYTE AI TOP ATOM
i
Transparence
Matériel fourni gracieusement par GIGABYTE pour cette série de guides. Les mesures et les avis sont les nôtres ; GIGABYTE n'a ni relu ni validé ce contenu avant sa publication. Cette page ne contient aucun lien d'affiliation. Nos données, infographies et photos sont réutilisables librement sous licence CC BY 4.0, en citant quelllm.fr.
Les chiffres clés
43,6Go
pour Llama 3.3 70B avec 8 192 tokens de contexte
× 4
en code avec un petit modèle brouillon : 18,7 tok/s
38,6tok/s
en moyenne au total pour 8 utilisateurs, stables pendant 2 heures
3voies
Ollama, llama.cpp et vLLM, commandes à copier
L'AI TOP ATOM vue de haut et de face : capot uni gris anthracite, façade à lamelles et logo GIGABYTE.
L'AI TOP ATOM vue de haut : un capot uni, à poser sur un bureau ou une étagère. Photo de notre unité, fond neutralisé. Agrandir ↗

#La machine, la méthode et les unités

Quelques mots de vocabulaire d'abord. Un token est un morceau de mot : en français, un token vaut environ deux tiers de mot. Le contexte est le texte que le modèle garde en mémoire pendant un échange : vos questions, vos documents et ses réponses. La vitesse d'écriture est le rythme d'affichage de la réponse, en tokens par seconde (tok/s). La vitesse de lecture est le rythme auquel la machine absorbe votre texte avant de répondre.

La machine est une GIGABYTE AI TOP ATOM, référence ATAGB10-9000. Sa puce NVIDIA GB10 réunit 20 cœurs Arm et un GPU Blackwell, qui se partagent 128 Go de mémoire à 273 Go/s. Le SSD fait 4 To en PCIe 5.0. Elle tourne sous DGX OS 7.5.0, le système de NVIDIA basé sur Ubuntu (pilote 580.159.03, CUDA 13.0). Le système voit 121,7 Go de mémoire.

Ce qui vient de la plateforme NVIDIA GB10
La puce, ses 128 Go à 273 Go/s et DGX OS fixent les vitesses de ce guide. En rejouant deux références publiées pour le DGX Spark de NVIDIA, avec llama.cpp et avec Ollama, nos vitesses sont à 4,3 % près au plus. À notre connaissance, elles devraient donc valoir pour les autres machines GB10 de 128 Go. Les relevés de ce guide portent sur l'AI TOP ATOM.
Ce qui vient de GIGABYTE
Le châssis d'environ un litre et son refroidissement, la finition, les références (la 9000 porte un SSD de 4 To en PCIe 5.0) et la garantie du revendeur. Pendant nos deux heures de service continu, le GPU n'a pas dépassé 72 °C et aucun bridage n'est apparu.

Les mesures datent des 6 et 7 octobre 2026 (l'assistant privé avec Open WebUI, des 7 et 8 octobre). Le protocole a été figé le 6 octobre à 13 h 30, avant la première mesure. Des avenants datés, écrits avant les essais qu'ils décrivent, ont ajouté le décodage spéculatif et le budget mémoire. La méthode et les données de nos tableaux sont publiées sur notre page de méthode.

Les vitesses d'écriture de llama.cpp et de TensorRT-LLM viennent de six textes de 400 tokens : trois en prose française et trois demandes de code. Celles d'Ollama (un texte de 300 mots) et de vLLM (requêtes aléatoires de 1 024 tokens en entrée et 256 en sortie) suivent les protocoles décrits dans leurs sections. La température est fixée à 0 : le modèle choisit toujours le mot le plus probable, ce qui rend les essais comparables. Nous publions la médiane des trois textes de chaque type.

Les tailles de mémoire sont en Go (1 Go = 1 024 Mo, comme l'affiche Linux) ; les débits en Go/s sont ceux annoncés par les fabricants, en unités décimales. Les versions utilisées sont llama.cpp b11430 (build du 5 octobre 2026), Ollama 0.34.1, vLLM 26.09 et TensorRT-LLM 1.3.0rc12, ces deux derniers dans les conteneurs de NVIDIA. Notre premier guide de la série donne les mesures de 13 modèles, dont Llama 3.3 70B ; celui-ci montre comment l'installer et l'accélérer.

#Voie 1 : Ollama, la plus simple

Ollama est la façon la plus simple de démarrer : une archive à décompresser, une commande pour télécharger le modèle, une autre pour lui parler. Nous avons installé la version 0.34.1 à partir de l'archive officielle pour Linux Arm, dans un dossier et sans service système. Si vous préférez l'installateur habituel, notre guide d'installation sur Linux le décrit.

Installer et lancer Ollama 0.34.1 (testé les 6 et 7 octobre 2026)
V=0.34.1
D=~/opt/ollama-$V
mkdir -p $D ~/models/ollama
curl -L -o ollama-$V.tar.zst https://github.com/ollama/ollama/releases/download/v$V/ollama-linux-arm64.tar.zst
tar --zstd -xf ollama-$V.tar.zst -C $D
export OLLAMA_MODELS=$HOME/models/ollama OLLAMA_HOST=127.0.0.1:11434 LD_LIBRARY_PATH=$D/lib/ollama:$LD_LIBRARY_PATH
$D/bin/ollama serve
Dans un second terminal : télécharger, interroger et inspecter le 70B (testé le 7 octobre 2026)
export OLLAMA_HOST=127.0.0.1:11434
~/opt/ollama-0.34.1/bin/ollama pull llama3.3:70b
~/opt/ollama-0.34.1/bin/ollama run llama3.3:70b --verbose "Explique en 300 mots la différence entre la mémoire unifiée d'un Mac et la VRAM d'un GPU dédié, pour un lecteur non technique."
~/opt/ollama-0.34.1/bin/ollama ps

L'option --verbose fait afficher les statistiques à la fin de la réponse. Chez nous, Llama 3.3 70B (en Q4_K_M, une compression des poids) écrit à 4,97 tok/s au premier passage et à 4,95 tok/s au second. La commande ollama ps indique 85 Go chargés, en unités décimales : Ollama a ouvert de lui-même un contexte de 131 072 tokens. Sur un texte de 18 823 tokens, la lecture prend 55,6 s, soit 338,7 tok/s, et l'écriture qui suit reste à 4,38 tok/s.

Pour situer ces chiffres : Ollama publie 4,423 tok/s pour Llama 3.1 70B Q4_K_M sur un DGX Spark de NVIDIA (version 0.12.6, 23 octobre 2025). Avec la même version, le même script et le même modèle (Llama 3.1 70B), notre ATOM donne 4,34 tok/s, à 2 % près. Pour réduire le contexte et la mémoire occupée, définissez la variable OLLAMA_CONTEXT_LENGTH avant de lancer le serveur ; nous n'avons pas mesuré cette variante.

#Voie 2 : llama.cpp, celle qui offre le plus de réglages

llama.cpp est un moteur open source très répandu. Il lit les modèles au format GGUF, un fichier unique qui contient les poids. Il faut le compiler une fois pour la puce GB10, mais il donne accès à tous les réglages : taille du contexte, format du cache du contexte, modèle brouillon. La compilation reprend le guide de NVIDIA, avec l'architecture CUDA 121a-real, celle de la GB10, mais sans libcurl (-DLLAMA_CURL=OFF) ni RPC.

Compiler llama.cpp b11430 pour la GB10
git clone --filter=blob:none https://github.com/ggml-org/llama.cpp.git ~/llama.cpp
cd ~/llama.cpp
git checkout b11430
cmake -B build -DGGML_NATIVE=ON -DGGML_CUDA=ON -DLLAMA_CURL=OFF -DCMAKE_BUILD_TYPE=Release \
  -DCMAKE_CUDA_ARCHITECTURES=121a-real -DCMAKE_CUDA_COMPILER=/usr/local/cuda/bin/nvcc
cmake --build build -j 16 --target llama-bench llama-server llama-cli

Le fichier choisi est Llama 3.3 70B en Q4_K_M, publié par bartowski : 39,6 Go. Avec le cache du disque vidé, llama.cpp le charge en 8 s depuis le SSD. La commande hf vient de la bibliothèque huggingface_hub (installation : pip install -U huggingface_hub). Si Hugging Face demande d'accepter la licence Llama, acceptez-la sur le site, puis connectez-vous avec hf auth login.

Télécharger le modèle et lancer le serveur (serveur testé le 6 octobre 2026)
hf download bartowski/Llama-3.3-70B-Instruct-GGUF Llama-3.3-70B-Instruct-Q4_K_M.gguf \
  --local-dir ~/models/gguf/bartowski/Llama-3.3-70B-Instruct-GGUF

~/llama.cpp/build/bin/llama-server \
  -m ~/models/gguf/bartowski/Llama-3.3-70B-Instruct-GGUF/Llama-3.3-70B-Instruct-Q4_K_M.gguf \
  -ngl 99 -fa on -lm dio -c 16384 -np 1 --port 8093 --host 127.0.0.1
-ngl 99
Place toutes les couches du modèle sur le GPU.
-fa on
Active Flash Attention, qui rend la lecture du contexte plus économe.
-lm dio
Lit le fichier par accès direct au disque, sans passer par le cache du système (mmap). C'est le mode du tableau de référence publié par le projet llama.cpp pour le DGX Spark.
-c 16384 -np 1
Un contexte de 16 384 tokens pour un seul utilisateur. Le contexte demandé est partagé entre les utilisateurs simultanés.
--host 127.0.0.1
Le serveur n'est joignable que depuis la machine elle-même.
Mesurer la vitesse d'écriture (même appel que dans nos mesures)
curl -s http://127.0.0.1:8093/completion -H "Content-Type: application/json" \
  -d '{"prompt":"Rédige un article de 600 mots expliquant à un dirigeant de PME pourquoi faire tourner une IA en local plutôt que dans le cloud.","n_predict":400,"temperature":0,"cache_prompt":false}' \
  | python3 -c 'import json,sys; t=json.load(sys.stdin)["timings"]; print(t["predicted_per_second"])'

Sur nos six textes, llama-server écrit à 4,70 tok/s en prose et 4,62 en code. L'outil de mesure llama-bench donne 4,8 tok/s en écriture (32 tokens) et 405 tok/s en lecture (2 048 tokens). Le modèle occupe 43,6 Go avec un contexte de 8 192 tokens.

À titre de repère, la mémoire lit au plus 273 milliards d'octets par seconde, et chaque token demande de relire les poids du modèle, soit 42,5 milliards d'octets : le maximum théorique est de 6,4 tok/s, et la mesure en atteint environ les trois quarts.

#Voie 3 : vLLM en NVFP4, pour plusieurs utilisateurs

vLLM est un serveur conçu pour répondre à plusieurs personnes en même temps. NVIDIA le fournit dans un conteneur, c'est-à-dire un programme isolé que lance Docker. Le modèle est Llama 3.3 70B en NVFP4, un format 4 bits de NVIDIA que les puces Blackwell calculent directement : il occupe 39,9 Go en mémoire. La matrice des modèles pris en charge dans le guide vLLM de NVIDIA pour DGX Spark liste ce modèle.

Télécharger le modèle NVFP4
hf download nvidia/Llama-3.3-70B-Instruct-NVFP4 \
  --local-dir ~/models/hf/nvidia/Llama-3.3-70B-Instruct-NVFP4
Lancer vLLM 26.09 dans son conteneur NVIDIA (testé le 6 octobre 2026)
docker run -d --init --name vllm70 --gpus all --ipc=host --ulimit memlock=-1 \
  -p 127.0.0.1:8002:8000 -v ~/models/hf/nvidia:/m:ro \
  nvcr.io/nvidia/vllm:26.09-py3 \
  vllm serve /m/Llama-3.3-70B-Instruct-NVFP4 --served-model-name Llama-3.3-70B-Instruct-NVFP4 \
  --gpu-memory-utilization 0.85 --max-model-len 8192 --max-num-seqs 16

until curl -s -m 3 http://127.0.0.1:8002/health >/dev/null; do sleep 10; done; echo prêt
Mesurer avec huit utilisateurs simultanés (outil intégré à vLLM)
docker exec vllm70 vllm bench serve --backend vllm --model Llama-3.3-70B-Instruct-NVFP4 \
  --tokenizer /m/Llama-3.3-70B-Instruct-NVFP4 --base-url http://127.0.0.1:8000 \
  --dataset-name random --ignore-eos --random-input-len 1024 --random-output-len 256 \
  --num-prompts 32 --max-concurrency 8 --seed 1

Les réglages --max-model-len 8192 et --max-num-seqs 16 limitent le contexte à 8 192 tokens et à 16 requêtes traitées en même temps. Le réglage --gpu-memory-utilization 0.85 fixe la part de mémoire que vLLM réserve : ici 103 Go, dont 59,6 Go de cache. Ce cache garde en même temps 390 352 tokens, soit l'équivalent de près de 48 requêtes de 8 192 tokens à la fois. Le premier démarrage prend environ 7 minutes : 4 min 20 s pour lire le modèle, puis environ 2 minutes de préparation.

Pour un utilisateur, vLLM écrit à 5,3 tok/s (5,26, 5,27 et 5,26 sur trois séries) et le premier mot arrive en 0,73 s en moyenne. Avec huit utilisateurs simultanés, la machine écrit 37,7 tok/s au total, attente du premier mot comprise ; une fois sa réponse commencée, chaque utilisateur reçoit 5,0 tok/s.

Le premier mot arrive en 2,8 s en moyenne et en moins de 4,8 s dans les cas les plus lents. Les requêtes de ce test ont 1 024 tokens en entrée et 256 en sortie ; chaque point est mesuré trois fois.

#Les trois voies côte à côte

Llama 3.3 70B sur l'AI TOP ATOM, 6 et 7 octobre 2026. Écriture en tokens par seconde, un seul utilisateur sauf mention contraire.
VoieÉcritureMémoireRéglagesÀ choisir pour
Ollama 0.34.1 (Q4_K_M)4,9585 Go affichés par Ollama (en unités décimales, soit environ 79 Go au sens de ce guide) avec le contexte de 131 072 tokens qu'il ouvre sans réglagepeudémarrer vite
llama.cpp b11430 (Q4_K_M)4,70 en prose, 4,62 en code43,6 Go à 8 192 tokens, 51,3 Go à 32 768tous : contexte, cache, brouillonun utilisateur, avec un brouillon
vLLM 26.09 (NVFP4)5,3 ; 37,7 au total pour 8 utilisateurs103 Go réservés avec le réglage 0,85ceux d'un serveurplusieurs utilisateurs

Les trois voies écrivent à la même vitesse, à moins de 15 % près. La raison est simple : pour chaque token, la puce relit les poids du modèle, et c'est la bande passante de 273 Go/s qui fixe le rythme d'un modèle dense. Un 70B écrit donc à environ 5 tok/s, soit environ 200 mots par minute, le rythme d'une lecture posée.

Ce rythme convient aux traitements patients : résumés, extractions, relectures, brouillons de réponses. Pour une conversation vive, deux leviers existent, présentés dans les sections suivantes : le modèle brouillon, et un modèle MoE (mixture of experts) qui n'utilise qu'une partie de ses paramètres à chaque token.

#Accélérer un 70B avec un petit modèle brouillon

Le décodage spéculatif utilise un petit modèle, le brouillon, qui propose plusieurs mots d'avance (plus exactement des tokens ; nous disons « mots » pour simplifier). Le gros modèle vérifie ces mots en une seule passe : cela coûte à peu près le temps d'en écrire un seul, car le temps est surtout celui de la lecture des poids.

Les mots justes sont gardés, les autres sont écartés. Le brouillon ne choisit pas le texte : c'est toujours le gros modèle qui valide. NVIDIA décrit le principe dans son guide pour DGX Spark, et le blog LMSYS note que cette technique réduit en partie la limite de bande passante de la machine.

#Avec llama.cpp : un brouillon Llama 3.2 1B

Le brouillon doit parler la même langue que le gros modèle, c'est-à-dire utiliser le même découpage en tokens. La famille Llama convient : Llama 3.2 1B, en Q8_0, accompagne Llama 3.3 70B. Quatre options suffisent : -md désigne le brouillon, --spec-type draft-simple choisit la méthode, --spec-draft-n-max fixe le nombre de tokens proposés d'avance (nous les appelons « mots » dans ce guide) et -ngld 99 place le brouillon sur le GPU.

Serveur llama.cpp avec brouillon (testé le 7 octobre 2026)
hf download bartowski/Llama-3.2-1B-Instruct-GGUF Llama-3.2-1B-Instruct-Q8_0.gguf \
  --local-dir ~/models/gguf/bartowski/Llama-3.2-1B-Instruct-GGUF

~/llama.cpp/build/bin/llama-server \
  -m ~/models/gguf/bartowski/Llama-3.3-70B-Instruct-GGUF/Llama-3.3-70B-Instruct-Q4_K_M.gguf \
  -md ~/models/gguf/bartowski/Llama-3.2-1B-Instruct-GGUF/Llama-3.2-1B-Instruct-Q8_0.gguf \
  --spec-type draft-simple -ngld 99 --spec-draft-n-max 8 \
  -ngl 99 -fa on -lm dio -c 16384 -np 1 --port 8093 --host 127.0.0.1
Llama 3.3 70B Q4_K_M, llama-server b11430, six textes de 400 tokens, température 0, 6 octobre 2026 pour le 70B seul et 7 octobre 2026 avec brouillon. Écriture en tok/s (médiane de trois textes). Acceptation : part des mots proposés que le gros modèle a gardés.
ConfigurationProse françaiseCodeAcceptation (prose / code)
70B seul4,704,62—
+ brouillon Llama 3.2 1B, 8 mots d'avance11,99 (×2,6)17,48 (×3,8)33 % / 50 %
+ brouillon Llama 3.2 1B, 16 mots d'avance10,84 (×2,3)18,65 (×4,0)19 % / 34 %

Le brouillon de 1 milliard de paramètres rend le 70B 2,6 à 4 fois plus rapide : 12 tok/s en prose et jusqu'à 19 tok/s en code. Le gain dépend du texte. Sur trois textes de code, la vitesse va de 13,2 à 18,0 tok/s avec 8 mots d'avance. Le brouillon est plus souvent suivi sur le code (50 % de mots gardés) que sur la prose (33 %).

Nos textes sont en français pour la prose et en anglais pour le code ; d'autres textes donneront d'autres gains. Pour la prose, 8 mots d'avance donnent mieux que 16 (11,99 contre 10,84). Pour le code, 16 donnent un peu plus (18,65 contre 17,48), avec un écart entre textes du même ordre. Commencez par 8.

Le même principe existe sans second fichier quand le modèle porte son propre module de prédiction de plusieurs tokens (MTP). Avec Qwen3.8 27B et l'option --spec-type draft-mtp, llama.cpp passe de 11,71 à 21,48 tok/s en prose (×1,8) et de 11,59 à 27,23 tok/s en code (×2,3).

#Avec TensorRT-LLM : la recette Draft-Target de NVIDIA

TensorRT-LLM est la bibliothèque de NVIDIA pour servir les modèles de façon optimisée. Son guide pour DGX Spark propose la méthode Draft-Target : Llama 3.3 70B en FP4 est accompagné de Llama 3.1 8B en FP4 comme brouillon. Les deux modèles sont fournis par NVIDIA. Dans la version 1.3.0rc12 du conteneur, la valeur du réglage s'écrit Draft_Target, avec un tiret bas.

Télécharger les deux modèles FP4 et écrire la configuration
hf download nvidia/Llama-3.3-70B-Instruct-FP4 --local-dir ~/models/hf/nvidia/Llama-3.3-70B-Instruct-FP4
hf download nvidia/Llama-3.1-8B-Instruct-FP4 --local-dir ~/models/hf/nvidia/Llama-3.1-8B-Instruct-FP4
mkdir -p ~/trt
cat > ~/trt/l70_draft4.yml <<'EOF'
print_iter_log: false
disable_overlap_scheduler: true
speculative_config:
  decoding_type: Draft_Target
  max_draft_len: 4
  speculative_model_dir: /m/nvidia/Llama-3.1-8B-Instruct-FP4/
kv_cache_config:
  enable_block_reuse: false
EOF
Lancer TensorRT-LLM 1.3.0rc12 et l'interroger (testé le 7 octobre 2026)
docker run -d --name trt --gpus all --ipc=host --ulimit memlock=-1 --ulimit stack=67108864 \
  -p 127.0.0.1:8003:8000 -v ~/models/hf:/m:ro -v ~/trt:/cfg \
  nvcr.io/nvidia/tensorrt-llm/release:1.3.0rc12 \
  trtllm-serve /m/nvidia/Llama-3.3-70B-Instruct-FP4 --backend pytorch --tp_size 1 --max_batch_size 1 \
  --host 0.0.0.0 --port 8000 --extra_llm_api_options /cfg/l70_draft4.yml --kv_cache_free_gpu_memory_fraction 0.9

curl -s http://127.0.0.1:8003/v1/chat/completions -H "Content-Type: application/json" \
  -d '{"model":"/m/nvidia/Llama-3.3-70B-Instruct-FP4","messages":[{"role":"user","content":"Rédige un article de 600 mots expliquant à un dirigeant de PME pourquoi faire tourner une IA en local plutôt que dans le cloud."}],"max_tokens":400,"temperature":0}'
Llama 3.3 70B FP4, TensorRT-LLM 1.3.0rc12, un utilisateur, six textes de 400 tokens, température 0, 7 octobre 2026. Vitesse calculée avec le nombre de tokens que renvoie le serveur. Écriture en tok/s (médiane de trois textes).
ConfigurationProse françaiseCode
+ brouillon Llama 3.1 8B FP4, 4 mots d'avance10,13 (×3,0 par rapport au même moteur sans brouillon)12,28 (×3,7)

Avec TensorRT-LLM, le brouillon multiplie la vitesse par 3,0 en prose et par 3,7 en code, par rapport au même moteur sans brouillon : le 70B écrit alors 10,1 tokens par seconde en prose et 12,3 en code.

Les deux voies, llama.cpp et TensorRT-LLM, apportent donc un gain du même ordre, de 2,6 à 4 fois. Pour un seul utilisateur, llama.cpp reste la plus simple : un fichier de brouillon et quatre options. TensorRT-LLM est la voie à suivre si vous voulez la recette officielle de NVIDIA, avec des modèles FP4 fournis par NVIDIA.

Graphique en barres horizontales de la vitesse d'écriture de Llama 3.3 70B en tokens par seconde. Sans brouillon : Ollama 4,95, llama.cpp 4,70 en prose et 4,62 en code, vLLM en NVFP4 5,3. Avec un brouillon : llama.cpp et Llama 3.2 1B 11,99 en prose et 17,48 en code, avec des gains de 2,6 et 3,8 ; TensorRT-LLM et Llama 3.1 8B 10,13 en prose et 12,28 en code, avec des gains de 3,0 et 3,7.
Vitesse d'écriture de Llama 3.3 70B pour un utilisateur, en tokens par seconde. Bleu : texte en prose ; violet : code ; orange : texte aléatoire du test vLLM. Les pastilles vertes donnent le gain face au même moteur sans brouillon. Pour llama.cpp, le trait blanc marque sa vitesse sans brouillon. Le cadre vert à l'éclair regroupe les mesures avec brouillon : 8 mots d'avance pour llama.cpp (avec 16 mots d'avance, le code atteint 18,65 tok/s, soit ×4,0) et 4 pour TensorRT-LLM. Pictogrammes en haut à droite : document, texte en prose ; </>, code ; dé, texte aléatoire du test vLLM ; trait blanc, vitesse sans brouillon. Agrandir ↗

#Le budget mémoire du contexte, de 8 192 à 131 072 tokens

Le contexte a un coût en mémoire : le cache KV. C'est la mémoire où le modèle garde ce qu'il a déjà lu, pour ne pas le recalculer. Il grossit avec la longueur du contexte. llama.cpp réserve tout ce cache dès le chargement, donc la mémoire occupée après le chargement est déjà la mémoire finale.

Nous la mesurons par la baisse de la mémoire disponible (MemAvailable de Linux), après avoir vidé le cache du disque. L'option -ctk q8_0 -ctv q8_0 range le cache sur 8 bits au lieu de 16 (f16), ce qui l'allège. Dans les tableaux et les graphiques, 8k désigne un contexte de 8 192 tokens, 32k de 32 768, 64k de 65 536 et 128k de 131 072.

Mesurer la mémoire occupée pour un contexte et un format de cache (testé le 7 octobre 2026)
ma() { awk '/MemAvailable/{print $2}' /proc/meminfo; }
sudo sh -c 'sync; echo 3 > /proc/sys/vm/drop_caches'; sleep 3; A0=$(ma)
~/llama.cpp/build/bin/llama-server \
  -m ~/models/gguf/bartowski/Llama-3.3-70B-Instruct-GGUF/Llama-3.3-70B-Instruct-Q4_K_M.gguf \
  -ngl 99 -fa on -lm dio -c 131072 -np 1 -ctk q8_0 -ctv q8_0 --port 8094 --host 127.0.0.1 &
until curl -s -m 2 http://127.0.0.1:8094/health | grep -q '"ok"'; do sleep 1; done
A1=$(ma); echo "occupé : $(echo "scale=1;($A0-$A1)/1048576" | bc) Go"
Mémoire occupée après le chargement, en Go, llama-server b11430, 7 octobre 2026. Cache f16 ou q8_0.
ModèleCache8 19232 76865 536131 072
Llama 3.3 70B Q4_K_Mf1643,651,361,481,9
Llama 3.3 70B Q4_K_Mq8_042,346,452,263,1
gpt-oss 120B MXFP4f1661,061,963,065,6
gpt-oss 120B MXFP4q8_060,761,362,163,2
Deux séries de barres de la mémoire occupée en Go selon le contexte (8k, 32k, 64k, 128k) et le format du cache (f16 et q8_0). Llama 3.3 70B : 43,6 et 42,3 à 8k, 51,3 et 46,4 à 32k, 61,4 et 52,2 à 64k, 81,9 et 63,1 à 128k. gpt-oss 120B : 61,0 et 60,7 à 8k, 61,9 et 61,3 à 32k, 63,0 et 62,1 à 64k, 65,6 et 63,2 à 128k. Une ligne verte marque les 121,7 Go visibles par le système.
Mémoire occupée après le chargement, en Go, selon le contexte réservé. Bleu : Llama 3.3 70B ; orange : gpt-oss 120B. Barre foncée : cache en f16 (16 bits) ; barre claire : cache en q8_0 (8 bits). La ligne verte en pointillés marque les 121,7 Go que voit le système. Le contexte coûte cher au 70B dense et presque rien à gpt-oss 120B. Agrandir ↗

Tout tient dans les 121,7 Go, même le 70B avec un contexte de 131 072 tokens en f16 : 81,9 Go. Le contexte ajoute 38 Go au 70B entre 8k et 128k en f16, et 21 Go en q8_0, soit près de moitié moins. gpt-oss 120B n'ajoute que 4,6 Go : il alterne des couches qui regardent tout le texte et des couches qui n'en regardent qu'une fenêtre courte. Le format q8_0 se paie par une vitesse un peu plus basse, de 9 à 11 % à 128k pour le 70B (tableau suivant).

→
Régler le contexte selon l'usage
Gardez le cache en f16 tant que la mémoire suffit. Passez en q8_0 pour ouvrir un contexte de 128k avec le 70B en laissant plus de 55 Go libres, par exemple pour un second modèle. Réservez seulement le contexte dont vous avez besoin : un contexte de 16 384 tokens (environ 11 000 mots, soit une trentaine de pages) suffit pour une conversation courante ou un document de taille moyenne.

Nous avons aussi rempli le contexte à 90 % avec des fiches pratiques de Service-Public, pour mesurer la lecture et l'écriture à contexte plein. À 128k, le texte fait 117 605 tokens pour le 70B et 117 889 pour gpt-oss 120B, soit environ 200 pages.

Contexte rempli à 90 %, llama-server b11430, 7 octobre 2026. Lecture et écriture en tok/s ; durée de lecture entre parenthèses.
ModèleCacheTexte lu (tokens)Mémoire (Go)LectureÉcriture
Llama 3.3 70Bf1629 214 (32k)51,4286,1 (102 s)4,22
Llama 3.3 70Bq8_029 214 (32k)46,5271,1 (108 s)4,02
Llama 3.3 70Bf16117 605 (128k)82,0181,9 (646 s)2,86
Llama 3.3 70Bq8_0117 605 (128k)63,2164,6 (715 s)2,54
gpt-oss 120Bf1629 227 (32k)61,71 443 (20 s)43,81
gpt-oss 120Bq8_029 227 (32k)61,21 401 (21 s)43,96
gpt-oss 120Bf16117 889 (128k)65,41 073 (110 s)26,93
gpt-oss 120Bq8_0117 889 (128k)63,4993 (119 s)24,97

Tout fonctionne à contexte plein. gpt-oss 120B lit un texte de 200 pages en 110 secondes et continue d'écrire à près de 27 tok/s. Le 70B lit les 117 605 tokens à 182 tok/s. Pour de très longs documents, un modèle MoE est plus rapide, en lecture comme en écriture.

#Deux heures de service à huit utilisateurs

Un serveur doit tenir dans la durée. Nous avons lancé vLLM 26.09 avec Llama 3.3 70B en NVFP4 et envoyé des requêtes pendant deux heures : huit utilisateurs en continu, des tranches de 32 requêtes de 1 024 tokens en entrée et 256 en sortie. Un relevé de la puce, à une mesure par seconde, a suivi la puissance, la fréquence et la température du GPU.

Boucle de deux heures et relevé du GPU (testé le 7 octobre 2026)
nvidia-smi --query-gpu=timestamp,power.draw,clocks.sm,temperature.gpu,utilization.gpu,clocks_throttle_reasons.active \
  --format=csv,noheader -lms 1000 > gpu.csv & P1=$!
FIN=$(( $(date +%s) + 7200 )); k=0
while [ $(date +%s) -lt $FIN ]; do
  k=$((k+1))
  docker exec vllm70 vllm bench serve --backend vllm --model Llama-3.3-70B-Instruct-NVFP4 \
    --tokenizer /m/Llama-3.3-70B-Instruct-NVFP4 --base-url http://127.0.0.1:8000 \
    --dataset-name random --ignore-eos --random-input-len 1024 --random-output-len 256 \
    --num-prompts 32 --max-concurrency 8 --seed $k
done
kill $P1   # arrête le relevé du GPU
Courbe plate du débit d'écriture de vLLM pendant 2 heures à 8 utilisateurs : de 38,70 à 38,46 tokens par seconde sur 33 tranches. Sous la courbe, la température maximale du GPU chaque minute, au plus 72 °C. À droite, cinq cartes : 8 utilisateurs pendant 2 h, écart de −0,6 %, 72 °C au plus, 5,1 tok/s par personne et puissance moyenne du GPU de 39,1 W.
Deux heures de service avec Llama 3.3 70B en NVFP4 sous vLLM, huit utilisateurs en continu. En haut, en vert : débit total d'écriture de chaque tranche de 32 requêtes. En bas, en orange : température maximale du GPU chaque minute. Les 39,1 W sont la puissance moyenne du GPU mesurée par la puce, pas celle de la machine entière. À droite : les huit personnes et l'horloge indiquent 8 utilisateurs pendant 2 h ; la flèche verte, l'écart entre la première et la dernière tranche ; le thermomètre, la température maximale ; la personne seule, la vitesse par personne ; l'éclair, la puissance du GPU. Agrandir ↗

Le résultat est simple : la vitesse n'a pas bougé. Le débit total va de 38,70 tok/s dans la première tranche à 38,46 dans la dernière, avec un minimum de 38,40 et un maximum de 38,70 : l'écart est de −0,6 %. Chaque utilisateur reçoit 5,1 tok/s. Le premier mot arrive en 2,8 s en médiane, entre 2,4 et 2,9 s selon la tranche.

Au total, la machine a servi 1 056 requêtes, lu 1 081 344 tokens et écrit 270 336 tokens, sans aucune erreur. Le GPU est resté à 72 °C au plus. Sa fréquence médiane était de 2 528 MHz et aucune raison de bridage n'a été relevée pendant les deux heures de relevé.

La puissance moyenne du GPU était de 39,1 W, avec une pointe à 95,0 W. Ces watts sont ceux du GPU, lus par la puce : ils ne comptent ni le processeur, ni la mémoire, ni le SSD, ni l'alimentation. Les deux heures représentent 78,8 Wh pour le GPU, soit 1,6 centime au tarif EDF Tarif Bleu Base (6 kVA), à 20,01 centimes le kWh.

#En faire un serveur : API OpenAI, clé et Open WebUI

Une API OpenAI est un format de requêtes que de nombreux outils savent parler : éditeurs de code, interfaces de discussion, scripts. llama-server et vLLM l'offrent tous les deux. Pour la protéger, llama-server accepte une clé avec l'option --api-key : sans clé, il répond par une erreur 401. Nous avons validé ces trois appels avec gpt-oss 20B ; pour le 70B, c'est la même commande avec un autre fichier.

Serveur avec clé et appels de test (validés avec gpt-oss 20B le 7 octobre 2026)
CLE=$(openssl rand -hex 32)   # gardez cette clé : vos clients l'enverront
~/llama.cpp/build/bin/llama-server \
  -m ~/models/gguf/bartowski/Llama-3.3-70B-Instruct-GGUF/Llama-3.3-70B-Instruct-Q4_K_M.gguf \
  -ngl 99 -fa on -c 16384 --jinja --api-key $CLE --port 8095 --host 127.0.0.1 &
until curl -s -m 2 http://127.0.0.1:8095/health | grep -q '"ok"'; do sleep 1; done   # attendre la fin du chargement

curl -s -o /dev/null -w "%{http_code}\n" http://127.0.0.1:8095/v1/models
curl -s -H "Authorization: Bearer $CLE" http://127.0.0.1:8095/v1/models
curl -s -H "Authorization: Bearer $CLE" -H "Content-Type: application/json" http://127.0.0.1:8095/v1/chat/completions \
  -d '{"model":"llama-3.3-70b","messages":[{"role":"user","content":"Donne trois conseils pour sécuriser un serveur IA local."}],"max_tokens":300}'

Le premier appel renvoie 401, le deuxième la liste des modèles servis, le troisième une réponse au format OpenAI. L'option --jinja applique le modèle de conversation fourni par le fichier du modèle.

!
Gardez le serveur sur votre réseau
Avec --host 127.0.0.1, seul le poste local peut se connecter. Pour ouvrir le serveur aux autres postes de votre réseau, remplacez --host 127.0.0.1 par l'adresse de la machine sur ce réseau et gardez la clé. Ne l'exposez pas directement sur Internet.

Pour une interface de discussion, Open WebUI se branche sur cette API. Voici la pile de notre test d'assistant privé (un autre guide de la série), avec gpt-oss 120B. Le serveur de modèle est dans un réseau Docker interne, sans accès à Internet. Open WebUI 0.11.4 est relié à ce réseau et à un réseau d'accès.

Ainsi, le modèle n'a aucune sortie vers l'extérieur. Le serveur n'a pas de clé, car seul le réseau interne peut le joindre ; la valeur local d'OPENAI_API_KEY sert seulement à satisfaire Open WebUI. Pour servir le 70B à la place, remplacez le chemin du fichier par celui de Llama-3.3-70B-Instruct-Q4_K_M.gguf et adaptez -c et -np au budget mémoire vu plus haut.

Open WebUI relié à llama-server dans un réseau interne (testé les 7 et 8 octobre 2026)
docker network create --internal reseau-interne
docker network create reseau-acces
docker run -d --init --name serveur-llm --network reseau-interne --network-alias gen --gpus all --ipc=host \
  -e LD_LIBRARY_PATH=/llama -v ~/llama.cpp/build/bin:/llama:ro -v ~/models/gguf:/models:ro \
  nvcr.io/nvidia/pytorch:26.03-py3 \
  /llama/llama-server -m /models/ggml-org/gpt-oss-120b-GGUF/gpt-oss-120b-MXFP4.gguf \
  -ngl 99 -fa on -c 131072 -np 10 --jinja --host 0.0.0.0 --port 8080 -a gpt-oss-120b
docker run -d --name open-webui --network reseau-acces -p 127.0.0.1:3100:8080 -v ~/open-webui-data:/app/backend/data \
  -e ENABLE_OLLAMA_API=false -e OPENAI_API_BASE_URL=http://gen:8080/v1 -e OPENAI_API_KEY=local \
  -e ENABLE_PERSISTENT_CONFIG=false -e OFFLINE_MODE=true -e HF_HUB_OFFLINE=1 \
  -e ANONYMIZED_TELEMETRY=false -e DO_NOT_TRACK=true -e SCARF_NO_ANALYTICS=true \
  -e WEBUI_SECRET_KEY=$(openssl rand -hex 32) ghcr.io/open-webui/open-webui:v0.11.4
docker network connect reseau-interne open-webui

Ouvrez ensuite http://127.0.0.1:3100 dans un navigateur de la machine : le modèle apparaît dans la liste. Dans notre test d'assistant privé, la pile complète, avec un serveur de plongements (bge-m3) en plus, était prête en 66 secondes. Selon le guide llama.cpp de NVIDIA, Open WebUI, Continue.dev et d'autres clients se branchent sur cette API, qui suit le format de l'API OpenAI (adresse du serveur suivie de /v1).

#L'alternative rapide : un modèle MoE de 120B

Un modèle MoE (mixture of experts) contient beaucoup de paramètres mais n'en utilise qu'une fraction à chaque token. gpt-oss 120B compte 117 milliards de paramètres dont 5,1 milliards actifs, et OpenAI le publie directement au format MXFP4.

Sur la GB10, il écrit à 58,0 tok/s avec l'outil de mesure llama-bench (écriture de 32 tokens), et à 54,4 tok/s en réponses longues sur llama-server, en prose comme en code. C'est plus de 11 fois la vitesse du 70B dense, avec une mémoire occupée de 61,0 Go à 8 192 tokens et de 65,6 Go à 131 072.

gpt-oss 120B avec llama.cpp (testé le 6 octobre 2026)
hf download ggml-org/gpt-oss-120b-GGUF gpt-oss-120b-MXFP4.gguf \
  --local-dir ~/models/gguf/ggml-org/gpt-oss-120b-GGUF

~/llama.cpp/build/bin/llama-server \
  -m ~/models/gguf/ggml-org/gpt-oss-120b-GGUF/gpt-oss-120b-MXFP4.gguf \
  -ngl 99 -fa on -lm dio -c 16384 -np 1 --port 8093 --host 127.0.0.1

La vitesse ne dit rien de la qualité : nous n'avons pas comparé les réponses des deux modèles. Voici comment choisir. Prenez gpt-oss 120B pour la conversation, les agents et les longs documents, où la vitesse compte. Prenez Llama 3.3 70B si vous avez besoin de ce modèle précis, par exemple un modèle réglé à partir de lui, ou pour des traitements en lot où 5 tok/s suffisent. Les mesures des 13 modèles, du 4B au 235B, sont dans notre premier guide de la série.

#Ce que ce guide ne mesure pas

La qualité des réponses
Nous mesurons la vitesse et la mémoire, pas ce que vaut chaque modèle.
Les gains du brouillon sur d'autres textes
Nos six textes sont en français pour la prose et en anglais pour le code. Les gains dépendent du texte et de la langue.
Les contextes au-delà de 131 072 tokens
Nous n'avons mesuré ni leur mémoire ni leur vitesse.
Les autres machines GB10 et la version 64 Go
Nos mesures sur l'ATOM 128 Go rejoignent les références publiées pour le DGX Spark.
La consommation de la machine entière
Les watts donnés sont ceux du GPU, lus par la puce.

Mises à jour et corrections : cette page sera révisée si une nouvelle version de DGX OS, de llama.cpp, d'Ollama, de vLLM ou de TensorRT-LLM change ces résultats ; chaque correction sera datée.

#Pour qui l'ATOM est le bon choix

Ce qui suit vient de nos mesures sur l'ATOM, une machine GB10 de 128 Go.

L'ATOM est le bon choix si vous voulez un modèle de 70 milliards de paramètres chez vous
Il tient avec de la marge : de 43,6 à 82 Go sur 121,7 Go, avec un contexte de 8 192 à 131 072 tokens, et trois voies d'installation fonctionnent.
… si plusieurs personnes ou agents partagent le modèle
Huit utilisateurs obtiennent 37,7 tok/s au total sur une série courte, et 38,6 tok/s en moyenne pendant deux heures, sans aucune erreur.
… si vous voulez aller plus vite sans changer de machine
Un petit brouillon multiplie la vitesse du 70B par 2,6 à 4, avec llama.cpp ou avec la recette de NVIDIA.
… si vous voulez une conversation rapide ou de longs documents
gpt-oss 120B écrit à 54,4 tok/s et lit 200 pages en 110 secondes.
… si votre travail passe par l'écosystème NVIDIA
CUDA 13, vLLM et TensorRT-LLM dans les conteneurs de NVIDIA et llama.cpp compilé pour la GB10 ont fonctionné chez nous sous DGX OS 7.5.0.

Côté GIGABYTE, le châssis d'environ un litre a gardé le GPU à 72 °C au plus pendant deux heures de charge continue, sans bridage. Les prix des machines GB10 bougent chaque semaine : vérifiez-les sur la fiche de la machine avant d'acheter.

#FAQ

FAQ
Peut-on faire tourner un modèle 70B sur une machine GB10 de 128 Go ?+
Oui, avec de la marge. Llama 3.3 70B en Q4_K_M occupe 43,6 Go avec un contexte de 8 192 tokens et 81,9 Go avec 131 072, sur 121,7 Go visibles. Trois voies ont fonctionné sur notre AI TOP ATOM : Ollama, llama.cpp et vLLM en NVFP4, avec les commandes de ce guide.
À quelle vitesse écrit un 70B sur l'AI TOP ATOM ?+
Pour un seul utilisateur, il écrit entre 4,6 et 5,3 tokens par seconde selon la voie. Avec un brouillon Llama 3.2 1B sous llama.cpp, il écrit à 12 tokens par seconde en prose et jusqu'à 19 en code. Avec huit utilisateurs sous vLLM, la machine écrit 37,7 tokens par seconde au total, et chaque utilisateur reçoit 5,0 tokens par seconde une fois sa réponse commencée.
Faut-il choisir Ollama, llama.cpp ou vLLM ?+
Ollama pour démarrer vite, sans réglage. llama.cpp pour régler le contexte, le format du cache et ajouter un brouillon, quand vous êtes seul. vLLM pour servir plusieurs personnes. Pour un seul utilisateur, les trois écrivent à moins de 15 % d'écart ; le choix dépend donc de l'usage plus que de la vitesse.
Comment rendre un 70B plus rapide sans changer de machine ?+
Avec le décodage spéculatif. Un petit brouillon propose des mots d'avance et le 70B les valide. Sur notre ATOM, Llama 3.2 1B avec llama.cpp multiplie la vitesse par 2,6 à 4, et la recette Draft-Target de NVIDIA avec TensorRT-LLM par 3,0 à 3,7. Le gain dépend du texte : il est plus fort sur le code.
Un 70B peut-il servir plusieurs personnes pendant des heures ?+
Oui. Pendant 2 heures, vLLM a servi huit utilisateurs en continu : 1 056 requêtes sans erreur, et un débit de 38,70 puis 38,46 tokens par seconde, soit −0,6 %. Le GPU est resté à 72 °C au plus, sans bridage.
Vaut-il mieux un modèle MoE de 120B qu'un 70B dense ?+
Pour la vitesse, oui : gpt-oss 120B écrit à 54,4 tokens par seconde, plus de 11 fois le 70B, avec 61 à 66 Go de mémoire. Nous n'avons pas comparé la qualité des réponses. Choisissez le 70B si vous avez besoin de ce modèle précis ou si 5 tokens par seconde suffisent à votre traitement.
Dans la même série
Ce guide vous a aidé ?

Un retour, une erreur, une précision ? Faites-nous signe, ça améliore le guide pour tout le monde.