Faire tourner un LLM local sur la NVIDIA Jetson Orin Nano Super

La Jetson Orin Nano Super est une carte edge AI compacte qui a du répondant : un GPU Ampere doté de 1024 cœurs CUDA, 8 Go de mémoire unifiée partagée entre le CPU et le GPU, et un support complet de JetPack 6. Dans ce tutoriel, je pars d’une Jetson vierge pour arriver à un LLM local pleinement fonctionnel en quelques commandes.

Matériel ciblé : NVIDIA Jetson Orin Nano Super (8 Go)
Version de JetPack : 6.4 (R36.4.7)
Modèle : Qwen3-4B-Instruct via Ollama

Prérequis

Vous devez déjà avoir :

• Une Jetson Orin Nano Super flashée sous JetPack 6.x
• Un accès SSH ou terminal
• Une connexion internet

Pas besoin de PyTorch, de TensorRT ni d’un framework ML lourd. Je garde la stack minimale.

Étape 1 : vérifier votre version de JetPack

cat /etc/nv_tegra_release

Vous devriez voir quelque chose comme :

# R36 (release), REVISION: 4.7, GCID: 42132812, BOARD: generic, EABI: aarch64

R36.x signifie JetPack 6, ce qu’il me faut pour un support CUDA moderne.

Étape 2 : corriger le PATH de CUDA

CUDA 12.6 est installé par JetPack mais n’est pas ajouté au PATH par défaut. On corrige ça :

echo 'export PATH=/usr/local/cuda/bin:$PATH' >> ~/.bashrc
echo 'export LD_LIBRARY_PATH=/usr/local/cuda/lib64:$LD_LIBRARY_PATH' >> ~/.bashrc
source ~/.bashrc

Vérifiez que ça fonctionne :

nvcc --version
# nvcc: NVIDIA (R) Cuda compiler driver
# Copyright (c) 2005-2024 NVIDIA Corporation
# Built on Wed_Aug_14_10:14:07_PDT_2024
# Cuda compilation tools, release 12.6, V12.6.68
# Build cuda_12.6.r12.6/compiler.34714021_0

Étape 3 : installer Ollama

Ollama est de loin la façon la plus simple de faire tourner des LLM sur Jetson. Le script d’installation détecte automatiquement JetPack et télécharge le build ARM64 + CUDA optimisé :

curl -fsSL https://ollama.com/install.sh | sh

Vous remarquerez qu’il télécharge deux paquets :

>>> Downloading ollama-linux-arm64.tar.zst
>>> Downloading ollama-linux-arm64-jetpack6.tar.zst
>>> NVIDIA JetPack ready.

Ce second paquet est le backend CUDA spécifique à la Jetson.

Étape 4 : lancer votre premier modèle

J’utilise Qwen3-4B-Instruct, un modèle 4B instruct capable qui tient confortablement dans les 8 Go de mémoire unifiée de la Jetson :

ollama run Jadio/Qwen3_4b_instruct_q4km

Ollama va récupérer le modèle et vous déposer dans un chat interactif. Essayez :

>>> Tell me a short story about a dog who loves tea

Pour mesurer la vitesse d’inférence, ajoutez --verbose :

ollama run Jadio/Qwen3_4b_instruct_q4km --verbose

À la fin de chaque réponse, vous verrez :

prompt eval rate:   31.31 tokens/s
eval rate:          17.54 tokens/s

Sur la Jetson Orin Nano Super, comptez environ 17 à 19 tokens/s en génération avec un modèle 3-4B quantifié en Q4_K_M, largement assez pour un usage interactif.

Étape 5 : utiliser votre propre modèle GGUF (optionnel)

Si le modèle que vous voulez n’est pas dans le registre Ollama, vous pouvez importer n’importe quel fichier GGUF directement. Téléchargez d’abord le GGUF (j’utilise uv et huggingface-cli) :

# Install uv (fast Python package manager)
curl -LsSf https://astral.sh/uv/install.sh | sh
source ~/.bashrc

# Install huggingface_hub CLI
uv tool install huggingface_hub

# Download a model (example: Nanbeige 4.1 3B)
hf download DevQuasar/Nanbeige.Nanbeige4.1-3B-GGUF \
  --include "*Q4_K_M*" \
  --local-dir ~/models/nanbeige4.1-3b

Créez ensuite un Modelfile Ollama :

cat > ~/Modelfile << EOF
FROM /home/your-user/models/nanbeige4.1-3b/Nanbeige.Nanbeige4.1-3B.Q4_K_M.gguf
EOF

ollama create nanbeige-q4 -f ~/Modelfile
ollama run nanbeige-q4

Contraintes mémoire

La Jetson Orin Nano Super dispose de 8 Go de mémoire unifiée partagée entre le CPU et le GPU. Les allocations CUDA et la RAM système se disputent donc le même pool. Quelques limites pratiques :

Tenez-vous-en aux modèles 3B-4B en quantization Q4_K_M pour une expérience fluide. Ollama gère l’allocation mémoire plus élégamment que llama.cpp lancé directement, ce qui est l’une des raisons pour lesquelles je le recommande ici.

Bonus : surveiller l’utilisation du GPU

Pendant que le modèle tourne, ouvrez un second terminal et consultez les stats GPU/mémoire en temps réel :

watch -n 1 tegrastats

Vous verrez l’utilisation mémoire, la charge GPU et la fréquence CPU dans une seule vue, pratique pour confirmer que le GPU est bel et bien utilisé pour l’inférence.

Et ensuite ?

Maintenant que vous avez un LLM local qui tourne sur votre Jetson, voici quelques suites naturelles :

• Exposer une API compatible OpenAI : l’API d’Ollama est déjà compatible, vous pouvez donc pointer n’importe quel client SDK OpenAI vers http://localhost:11434 et ça fonctionne sans rien faire de plus.
• Essayer un modèle de raisonnement : des modèles comme Nanbeige 4.1 incluent une phase de réflexion (<think>...</think>) avant de répondre. Intéressant à observer, mais gourmand sur du matériel contraint.
• Comparer des modèles : lancez ollama run llama3.2:3b, ollama run qwen2.5:3b et votre import perso côte à côte pour trouver votre préféré selon l’usage.

À venir : Rehoboam

Avoir un LLM local qui tourne sur votre Jetson ouvre la porte à quelque chose de plus intéressant qu’un chatbot. Dans un prochain article, je construirai Rehoboam, un système d’analyse de divergence inspiré de la sphère de Westworld.

L’idée : lui donner de vraies sources de données (flux RSS, métriques système, logs, API externes) et laisser le LLM évaluer la criticité de chaque événement, en renvoyant un score et une trajectoire structurés. FastAPI sert de colonne vertébrale, ollama serve assure l’inférence en local, et un dashboard affiche les divergences en temps réel.

Pas de cloud. Pas de télémétrie. Tout tourne sur la Jetson.

À la prochaine !
Yacine