llama.cpp est le moteur qui a démocratisé l’inférence locale des LLM : une implémentation en C/C++, sans dépendance lourde, capable de faire tourner un modèle de langage sur un simple processeur, sur un GPU grand public ou sur un Mac. Lancé par Georgi Gerganov et désormais maintenu sous l’organisation ggml-org, c’est l’un des projets open source les plus suivis sur GitHub, et une brique sur laquelle reposent de nombreux outils, dont Ollama.
Utiliser llama.cpp directement plutôt qu’à travers une surcouche a plusieurs intérêts : un contrôle fin sur la quantification, la taille de contexte et le placement des couches entre CPU et GPU, des binaires légers faciles à empaqueter, et un serveur HTTP intégré qui parle le dialecte de l’API OpenAI.
Dans cet article, nous présentons les notions clés (GGUF, quantification, déchargement GPU), nous compilons et lançons llama-server, puis nous voyons comment le superviser : endpoint de santé, métriques Prometheus, logs et traces OpenTelemetry côté application, jusqu’à un backend comme Dynatrace.
llama.cpp en bref : GGUF, quantification et backends
Trois notions suffisent pour démarrer.
- GGUF est le format de fichier des modèles pour llama.cpp : un seul fichier contient les poids, le tokenizer et les métadonnées. Beaucoup de modèles ouverts sont publiés dans ce format sur Hugging Face.
- La quantification réduit la précision des poids (8 bits, 5 bits, 4 bits…) pour diminuer la mémoire nécessaire et accélérer l’inférence, au prix d’une légère perte de qualité. Les variantes portent des noms comme
Q8_0ouQ4_K_M. - Les backends déterminent le matériel utilisé : CPU par défaut, CUDA pour NVIDIA, Metal sur Apple Silicon, Vulkan, HIP pour AMD, entre autres. On peut décharger tout ou partie des couches du modèle sur le GPU.
Le projet fournit plusieurs outils : llama-cli pour dialoguer en terminal, llama-server pour servir un modèle en HTTP, llama-quantize pour produire des variantes quantifiées, et llama-bench pour mesurer les performances sur votre propre matériel.
En pratique : inférence locale avec llama.cpp
Étape 1 — Installer ou compiler
Le plus rapide est d’utiliser un paquet (Homebrew, winget…) ou les binaires précompilés publiés à chaque version sur GitHub. Pour activer un backend précis, on compile avec CMake :
git clone https://github.com/ggml-org/llama.cpp
cd llama.cpp
cmake -B build # CPU uniquement
# cmake -B build -DGGML_CUDA=ON # avec CUDA
cmake --build build --config Release -j
ls build/bin/ # llama-cli, llama-server, ...
Les options de compilation et les prérequis de chaque backend sont décrits dans le guide de compilation du dépôt officiel de llama.cpp.
Étape 2 — Récupérer un modèle GGUF
Vous pouvez télécharger un fichier .gguf depuis Hugging Face, ou laisser llama.cpp le faire avec l’option -hf, qui prend un dépôt Hugging Face (et éventuellement une variante de quantification) :
build/bin/llama-cli -hf ggml-org/gemma-3-1b-it-GGUF
Choisissez la quantification selon la mémoire disponible : un modèle de 7 à 8 milliards de paramètres en 4 bits tient dans quelques gigaoctets, là où la version 16 bits en demande plusieurs fois plus.
Étape 3 — Lancer le serveur HTTP
build/bin/llama-server \
-m modeles/mon-modele-Q4_K_M.gguf \
--host 127.0.0.1 --port 8080 \
-c 8192 \
-ngl 99 \
--metrics
-c fixe la taille de contexte, -ngl le nombre de couches déchargées sur le GPU (une valeur élevée les place toutes si la mémoire le permet), --metrics active l’endpoint Prometheus. Une option --api-key protège l’accès, et une option de parallélisme règle le nombre de requêtes servies simultanément. Les noms d’options évoluent : llama-server --help fait foi.
Le serveur propose aussi une petite interface web à sa racine, pratique pour un test rapide. Une image conteneur officielle est publiée sur le registre GitHub du projet.
Étape 4 — Appeler l’API compatible OpenAI
curl -s http://127.0.0.1:8080/v1/chat/completions \
-H "Content-Type: application/json" \
-d '{"messages": [{"role": "user", "content": "Donne trois causes de latence réseau."}]}'
Les réponses incluent le décompte des tokens et, sur l’endpoint natif, des informations de temps de traitement du prompt et de génération.
Comment superviser llama-server ?
Santé et disponibilité
L’endpoint /health indique si le serveur est prêt ; il renvoie une erreur tant que le modèle est en cours de chargement. C’est la cible naturelle d’une sonde de disponibilité Kubernetes ou d’un moniteur synthétique.
Métriques Prometheus
Avec --metrics, le chemin /metrics expose des métriques préfixées par llamacpp: : compteurs de tokens de prompt et de tokens générés, débits moyens, requêtes en cours de traitement et requêtes différées faute de slot libre, ainsi que le nombre moyen de slots occupés par appel de décodage et la taille de contexte maximale observée. Interrogez votre instance pour voir la liste exacte :
curl -s http://127.0.0.1:8080/metrics | grep '^llamacpp'
Les requêtes différées sont l’indicateur de saturation à surveiller en priorité : elles signifient que tous les slots sont occupés et que les clients attendent.
Logs
llama-server écrit sur la sortie standard : détection du matériel, chargement du modèle, répartition des couches entre CPU et GPU, puis une ligne de timings par requête (temps de traitement du prompt, tokens par seconde en génération). Ces lignes sont précieuses pour comprendre une dégradation ; un Collector OpenTelemetry ou un agent d’hôte les centralise.
Traces OpenTelemetry
Le serveur n’émet pas de traces OpenTelemetry à notre connaissance. Comme il est compatible OpenAI, la solution la plus simple consiste à instrumenter l’application appelante avec une instrumentation OpenAI pour OpenTelemetry (par exemple celles d’OpenLLMetry) en pointant le client vers l’URL de llama-server. Chaque appel devient un span avec le modèle, les tokens et la durée, rattaché à la trace de la requête utilisateur.
Remonter llama.cpp dans Dynatrace
La chaîne est la même que pour vLLM : un Collector OpenTelemetry scrape /metrics avec le récepteur prometheus, convertit les compteurs en delta, reçoit les traces OTLP de l’application et exporte vers l’endpoint OTLP de Dynatrace avec un jeton d’API. Nous détaillons cette configuration dans vLLM en production ; il suffit de changer la cible du scrape. Sur un hôte équipé de OneAgent, les métriques de processus et de GPU complètent le tableau.
Les indicateurs utiles : tokens générés par seconde, requêtes différées, latence par requête côté client, utilisation et mémoire GPU, et nombre de redémarrages. Pour corréler ces données avec le reste de la chaîne, appliquez les principes de notre article OpenTelemetry de bout en bout.
Bonnes pratiques
- Mesurez avec
llama-benchsur votre matériel avant de choisir une quantification. - Activez toujours
--metricset une sonde sur/healthdès qu’un serveur est partagé. - Gardez
--host 127.0.0.1par défaut et ajoutez une clé d’API ou un reverse proxy avant toute exposition. - Épinglez la version : le projet publie très fréquemment et les options évoluent.
- Ne téléchargez des modèles GGUF que depuis des sources de confiance.
Questions fréquentes
Quelle différence entre llama.cpp et Ollama ?
Ollama s’appuie sur llama.cpp et ajoute une gestion simplifiée des modèles. llama.cpp offre plus de contrôle et d’options, avec un peu plus de configuration. Voir notre guide Ollama en local.
llama.cpp fonctionne-t-il sans GPU ?
Oui, c’est même son point de départ. Les performances dépendent alors fortement du processeur, de la bande passante mémoire et de la quantification choisie.
Comment activer les métriques Prometheus de llama-server ?
En lançant le serveur avec l’option --metrics ; elles sont ensuite exposées sur /metrics, sur le même port que l’API.
Conclusion
llama.cpp reste la référence pour l’inférence locale légère, du portable au petit serveur GPU. Son serveur intégré, compatible OpenAI et équipé de métriques Prometheus, le rend facile à intégrer et à observer. Pour le situer face à Ollama, vLLM et les autres briques, consultez notre comparatif des stacks IA open source auto-hébergées.
span.observer est un blog indépendant de la communauté, non affilié à Dynatrace LLC ni aux projets cités. Les marques citées appartiennent à leurs propriétaires. Les outils évoluent vite : vérifiez les commandes et options dans leur documentation officielle.
1 comment