Llama.cpp

Prérequis

• Un GPU est recommandé, idéalement NVIDIA avec le plus de VRAM possible. Contrairement à Ollama ou vLLM, llama.cpp permet cependant de répartir le modèle entre GPU et CPU si la VRAM est insuffisante, au prix d’une baisse de performances. Voir ce lien pour partager un GPU dans un LXC
• Les modèles peuvent fonctionner sur CPU uniquement, mais avec des performances très faibles (souvent inutilisables en pratique pour un usage interactif).
• VRAM recommandée : dépend du niveau d’offload GPU. Pour un usage optimal, prévoir environ la taille du modèle (en Q4) + 1 à 3 Go pour le KV cache. Il est toutefois possible de réduire la VRAM nécessaire en déportant une partie du modèle en RAM.
• RAM recommandée : au minimum équivalente à la taille du modèle, idéalement 1,5 à 2 fois, notamment si une partie du modèle est exécutée sur CPU.
• Espace disque à prévoir en fonction du ou des modèle que vous allez utiliser ou tester, Exemples :
  • qwen2.5:7b (Q4) ≈ 4–5 Go
  • qwen2.5:14b (Q4) ≈ 8–10 Go
  • llama3:70b (Q4) ≈ 35–40 Go
• Utiliser un SSD/NVMe améliore fortement les temps de chargement.
• CPU / vCPU recommandés :
  • Avec GPU : 4 à 8 vCPU recommandés (gestion du KV cache et offload partiel CPU)
  • Sans GPU : prévoir au minimum 8 à 16 vCPU, les performances restant très limitées.
• Note : Q4 correspond au niveau de "quantization", c’est-à-dire une réduction de la précision numérique du modèle afin de diminuer son utilisation en mémoire (VRAM). Les niveaux vont généralement de Q1 à Q8 : Q8 est le plus précis (proche du modèle original), mais aussi le plus gourmand en ressources. À l’inverse, Q1 est très léger mais fortement dégradé. En pratique, Q4 (voire Q5) est généralement considéré comme le meilleur compromis entre performances, consommation de VRAM et qualité de réponse.

Installation

Prérequis système

Installer les dépendances nécessaires :

# apt update && apt upgrade
# apt install -y git build-essential cmake curl libcurl4-openssl-dev

Support GPU NVIDIA (CUDA)

(Optionnel) Vérifier derniere version :

# curl https://developer.download.nvidia.com/compute/cuda/repos/debian13/x86_64/ | grep keyring

Installer le dépôt CUDA NVIDIA :

# apt install -y wget
# cd /opt
# wget https://developer.download.nvidia.com/compute/cuda/repos/debian13/x86_64/cuda-keyring_1.1-1_all.deb
# dpkg -i cuda-keyring_1.1-1_all.deb
# apt update

Vérifier les versions disponibles du compilateur CUDA :

# apt-cache search cuda-compiler

Installer explicitement une version du compilateur CUDA :

# apt install -y cuda-compiler-13-2

Récupération du projet

# cd /opt
# git clone https://github.com/ggerganov/llama.cpp.git
# cd llama.cpp

Compilation (avec support CUDA)

Connaitre les versions de nvcc installées :

# find /usr /opt -name nvcc 2>/dev/null

Compilation :

# export CUDACXX=/usr/local/cuda-13.2/bin/nvcc
# cmake -B build -DGGML_CUDA=ON -DCMAKE_CUDA_COMPILER=/usr/local/cuda-13.2/bin/nvcc
# #cmake -B build -DGGML_CUDA=ON
# cmake --build build -j$(nproc)

Les binaires seront disponibles dans :

/opt/llama.cpp/build/bin/

Téléchargement d’un modèle (format GGUF)

Créer un dossier pour les modèles :

# mkdir -p /opt/llama.cpp/models
# cd /opt/llama.cpp/models

Exemple avec Qwen 3 8B Q4 :

# curl -L -o qwen3-8b-q4.gguf <URL_DU_MODELE>

Test rapide

# /opt/llama.cpp/build/bin/llama-cli \
  -m /opt/llama.cpp/models/qwen3-8b-q4.gguf \
  -ngl 35 \
  -c 2048 \
  -p "Explique moi ce qu'est llama.cpp"

Explication :

-ngl : nombre de couches envoyées au GPU
-c   : taille du contexte

Mode serveur (API compatible OpenAI)

# /opt/llama.cpp/build/bin/llama-server \
  -m /opt/llama.cpp/models/qwen3-8b-q4.gguf \
  -c 2048 \
  -ngl 35 \
  --host 0.0.0.0 \
  --port 8080

Le serveur est accessible via :

http://IP:8080

Test API

# curl http://localhost:8080/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "local",
    "messages": [
      {"role": "user", "content": "Bonjour"}
    ]
  }'

Optimisation (KV cache, performances, latence)

• Le paramètre de contexte (`-c`) influence directement la quantité de mémoire utilisée par le KV cache. Plus il est élevé, plus la consommation de VRAM augmente, ainsi que la latence de traitement du prompt.
• En pratique, une valeur de `2048` constitue souvent un bon compromis sur un GPU de 12 Go. Augmenter à `4096` peut améliorer la mémoire conversationnelle, mais au prix d’une consommation de VRAM plus importante.
• Le paramètre `-ngl` détermine le nombre de couches envoyées au GPU.
  • Plus la valeur est élevée, plus les performances augmentent.
  • Si la VRAM est insuffisante, réduire cette valeur permet de déporter une partie du modèle sur CPU.
  • Il est possible d’utiliser `-ngl 999` afin de laisser llama.cpp charger automatiquement le maximum de couches possible sur le GPU.
• Le paramètre `-fa` active Flash Attention.
  • Cette option améliore généralement les performances de traitement du prompt et réduit légèrement la latence.
  • Elle est recommandée sur GPU NVIDIA récents.
• Le paramètre `-b` (batch size) influence la vitesse de traitement du prompt.
  • Une valeur plus élevée peut améliorer les performances, mais augmente également la consommation de mémoire.
  • En cas de manque de VRAM, réduire cette valeur peut stabiliser le serveur.
• Le paramètre `-ub` (micro-batch size) permet d’ajuster plus finement l’utilisation mémoire.
  • Une valeur plus faible réduit les pics de consommation mémoire.
  • Une valeur plus élevée peut améliorer légèrement les performances si la VRAM le permet.

Exemple de configuration optimisée pour un GPU de 12 Go :

# /opt/llama.cpp/build/bin/llama-server \
  -m /opt/llama.cpp/models/qwen3-8b-q4.gguf \
  -c 2048 \
  -ngl 999 \
  -fa \
  -b 1024 \
  -ub 512 \
  --host 0.0.0.0 \
  --port 8080

Explication :

-c    : taille du contexte
-ngl  : nombre de couches envoyées au GPU
-fa   : active Flash Attention
-b    : taille du batch de traitement
-ub   : taille du micro-batch

• Si le serveur démarre correctement et qu’il reste de la marge en VRAM, il est possible d’augmenter progressivement `-b` ou le contexte.
• En cas d’erreur mémoire ou de performances instables :
  • réduire `-b`
  • réduire `-ngl`
  • réduire `-c`

Méthode d’ajustement recommandée

• Commencer avec :
  • `-c 2048`
  • `-ngl 999`
  • `-fa`
  • `-b 1024`
  • `-ub 512`
• Vérifier ensuite l’utilisation mémoire :

# nvidia-smi

• Si la VRAM est presque saturée :
  • réduire `-b`
  • puis réduire `-ngl` si nécessaire
• Si au contraire une marge importante reste disponible :
  • essayer `-b 2048`
  • ou augmenter légèrement le contexte

Remarques

• Contrairement à Ollama, llama.cpp ne décharge pas automatiquement le modèle après inactivité lorsque le serveur reste lancé.
• Le meilleur réglage dépend du modèle utilisé, du niveau de quantization, du contexte choisi et de la quantité de VRAM disponible.
• Sur un petit GPU, il est généralement préférable de privilégier un contexte plus faible et un offload GPU plus élevé, plutôt que l’inverse.