INSTALLER llama.cpp SUR LINUX POUR DE L'IA EN LOCAL (INFÉRENCE)

SYNTHÈSE STRUCTURÉE

Qu’est-ce que llama.cpp ?

llama.cpp est un moteur d’inférence haute performance dédié aux modèles de langage (LLM). Il offre une compatibilité d’API avec OpenAI, ce qui permet de réutiliser des développements existants tout en exécutant l’inférence en local. L’intervenant précise : « si vous avez déjà fait des petits développements et que vous utilisez l’API de chat GPT, et bien llama.cpp est totalement compatible avec cet API, sauf que le traitement IA se fait en local sur votre propre machine. » Le projet évolue très rapidement, avec des mises à jour fréquentes.

Prérequis matériels et logiciels

llama.cpp fonctionne en CPU (lentement) mais tire parti des GPU Nvidia et AMD. Sur une carte AMD, l’accélération passe par Vulkan. L’intervenant utilise une AMD Radeon RX 7600 avec 6 Go de VRAM. Il faut installer les paquets suivants avant la compilation :

git, gcc, gcc-c++ (compilation)
openssl-devel (sécurité TLS)
spirv-headers-devel (Vulkan)
glslc et vulkan-devel (spécifiques AMD)

Création de l’utilisateur dédié et des répertoires

Pour une installation propre en mode serveur, on crée un utilisateur système :

useradd -m llama-cpp
usermod -aG render llama-cpp

On prépare les répertoires dans /opt :

mkdir -p /opt/llama-cpp/{bin,models}
chown -R llama-cpp:llama-cpp /opt/llama-cpp

L’intervenant explique : « on va pas laisser dans le /home/llama-cpp les sources et surtout les programmes compilés. On va installer ça dans un endroit qui est tout à fait approprié. »

Compilation depuis les sources avec support Vulkan

On clone le dépôt et on compile avec CMake en activant Vulkan :

git clone https://github.com/ggerganov/llama.cpp
cd llama.cpp
cmake -B build -DGGML_VULKAN=ON
cmake --build build --config Release -j$(nproc)

L’astuce $(nproc) parallélise la compilation sur tous les cœurs disponibles. Pour Nvidia, il faudrait utiliser -DGGML_CUDA=ON avec l’option -DCUDA_TOOLKIT_ROOT_DIR pointant vers le binaire nvcc.

Déploiement des binaires et configuration de l’environnement

On copie les binaires compilés dans /opt/llama-cpp/bin :

cp -r build/bin/* /opt/llama-cpp/bin/

On édite le fichier .bashrc de l’utilisateur llama-cpp pour ajouter :

export PATH="$PATH:/opt/llama-cpp/bin"
export LD_LIBRARY_PATH="$LD_LIBRARY_PATH:/opt/llama-cpp/bin"
export LLAMA_CACHE="/opt/llama-cpp/models"
export HF_HUB_CACHE="/opt/llama-cpp/models"

Ces variables permettent d’exécuter llama-server directement et de centraliser les modèles téléchargés.

Gestion de SELinux (distributions Red Hat)

Sur Fedora/RHEL, SELinux bloque l’exécution des binaires depuis /opt. Il faut appliquer le contexte bin_t :

semanage fcontext -a -t bin_t "/opt/llama-cpp/bin(/.*)?"
restorecon -Rv /opt/llama-cpp/bin

L’intervenant précise : « on va ajouter le contexte bin_t pour lui dire il y a des fichiers binaires là-dedans et donc tu peux les exécuter automatiquement avec des services systemd. »

Téléchargement et lancement d’un modèle

Les modèles doivent être au format GGUF. L’intervenant recommande ceux de « unslot » pour leur qualité et leur optimisation. On peut télécharger un modèle directement via llama-server avec l’option --hf :

llama-server --hf unsloth/gemma-4-4b-it-GGUF --hf-file gemma-4-4b-it-Q4_K_M.gguf --temp 0.2 --host 0.0.0.0 --port 8080

Le modèle est chargé en VRAM (environ 5 Go pour un Q4_K_M). L’interface web est accessible à http://127.0.0.1:8080.

Création du service systemd

Pour un démarrage automatique, on crée /etc/systemd/system/llama-cpp.service :

[Unit]
Description=llama.cpp server
After=network-online.target

[Service]
User=llama-cpp
WorkingDirectory=/opt/llama-cpp/bin
Environment="LD_LIBRARY_PATH=/opt/llama-cpp/bin"
Environment="LLAMA_CACHE=/opt/llama-cpp/models"
Environment="HF_HUB_CACHE=/opt/llama-cpp/models"
ExecStart=/opt/llama-cpp/bin/llama-server --hf unsloth/gemma-4-4b-it-GGUF --hf-file gemma-4-4b-it-Q4_K_M.gguf --temp 0.2 --host 0.0.0.0 --port 8080
Restart=always
RestartSec=10

[Install]
WantedBy=multi-user.target

On active et démarre le service :

systemctl daemon-reload
systemctl enable llama-cpp.service
systemctl start llama-cpp.service

Les logs sont consultables avec journalctl -fu llama-cpp.

Ouverture du pare-feu

Si un pare-feu est actif, il faut ouvrir le port utilisé (8080 dans l’exemple) :

firewall-cmd --add-port=8080/tcp --permanent
firewall-cmd --reload

CONCEPTS CLÉS

GGUF : Format de fichier optimisé pour les modèles de langage, utilisé par llama.cpp. Il permet une quantification (réduction de la précision numérique) pour diminuer la taille et la consommation mémoire.
Quantification : Technique qui réduit la précision des poids du modèle (ex: Q4_K_M signifie quantification 4 bits avec une méthode K-means améliorée). Cela permet de faire tenir des modèles plus gros dans la VRAM disponible.
Vulkan : API de calcul graphique multiplateforme utilisée par llama.cpp pour l’accélération GPU sur les cartes AMD (alternative à CUDA pour Nvidia).
VRAM : Mémoire vidéo du GPU, ressource critique pour l’inférence de LLM. Le modèle doit tenir entièrement dans cette mémoire pour fonctionner efficacement.

CONCLUSION

La mise en place de llama.cpp en tant que service système D permet de déployer un serveur d’inférence LLM local, performant et compatible avec l’API OpenAI, sur du matériel grand public (une simple carte AMD Radeon RX 7600 suffit pour des modèles de taille moyenne). L’intervenant insiste sur l’importance d’une installation propre et automatisée : « on va pas utiliser cette commande là pour installer llama.cpp. On va le faire correctement avec un service systemd façon à ce que si vous souhaitez l’installer sur un serveur qui tourne tout le temps, on fasse ça proprement. » Cette approche garantit une disponibilité continue et une maintenance simplifiée, essentielle pour une utilisation en production ou en développement.