llama.cpp : définition, fonctionnement et exemple
Le moteur d'inférence en C/C++ qui exécute des LLM quantifiés sur CPU, GPU grand public et puces Apple : format GGUF, quantization, exemple llama-server et comparaison avec vLLM.
Par Équipe Blent· Mis à jour le · 14 min de lecture· Niveau avancé
llama.cpp en bref
- Type
- Moteur d'inférence de LLM
- Créateur
- Georgi Gerganov, 2023
- Licence
- MIT
- Langage
- C/C++
Définition : llama.cpp
llama.cpp est un moteur d'inférence open source écrit en C/C++, créé en 2023 par Georgi Gerganov, qui exécute des grands modèles de langage à poids ouverts sur du matériel ordinaire. Il s'appuie sur la bibliothèque de calcul tensoriel ggml et sur le format de fichier GGUF, qui regroupe des poids quantifiés en 4 ou 8 bits. Le même code tourne sur CPU, sur les puces Apple Silicon et sur de nombreux GPU, avec la possibilité de répartir un modèle entre mémoire vive et mémoire graphique. llama.cpp fournit une ligne de commande et un serveur HTTP compatible avec l'API d'OpenAI.
En une phrase : llama.cpp fait tourner un LLM quantifié sur presque n'importe quelle machine, et sert de moteur à des outils comme Ollama et LM Studio.
Dans cette définition
Qu'est-ce que llama.cpp ?
llama.cpp est un moteur d'inférence qui exécute des LLM à poids ouverts sur du matériel ordinaire. Écrit en C/C++ sans dépendance lourde, il charge un modèle quantifié depuis un fichier unique et génère du texte sur un processeur, une puce Apple ou une carte graphique grand public.
Le projet a été lancé en mars 2023 par Georgi Gerganov, quelques jours après la fuite des poids de LLaMA, le modèle de Meta. Il s'appuie sur ggml, la bibliothèque de calcul tensoriel du même auteur. Il a rendu possible une idée qui semblait réservée aux centres de données : faire tourner un modèle de plusieurs milliards de paramètres sur un ordinateur portable. En février 2026, l'équipe de ggml.ai a rejoint Hugging Face, avec l'engagement de garder le projet ouvert.
Aujourd'hui, llama.cpp est surtout connu comme le moteur sous-jacent d'outils plus accessibles. Ollama s'appuie sur son écosystème, et LM Studio permet de charger des modèles au même format. L'utiliser directement donne un contrôle plus fin sur la mémoire, le contexte et l'échantillonnage.
À retenir : llama.cpp n'est pas un modèle, c'est le moteur qui l'exécute. Sa spécialité est le local et le matériel modeste, pas le débit d'un serveur GPU.
GGUF et quantization : ce qui rend l'inférence locale possible
Deux choix techniques expliquent l'essentiel de l'intérêt de llama.cpp : un format de fichier autonome et une quantization poussée.
Le format GGUF
GGUF regroupe dans un seul fichier les poids du modèle, le vocabulaire du tokenizer et les métadonnées (architecture, taille du contexte, modèle de conversation). Un fichier suffit donc pour lancer l'inférence, ce qui simplifie la distribution : de nombreux modèles sont publiés tels quels sur le Hub de Hugging Face.
La quantization
Un modèle de 8 milliards de paramètres occupe environ 16 Go en 16 bits. La quantization stocke chaque poids sur moins de bits, souvent 4 ou 8, ce qui divise la taille par deux à quatre et permet de tenir dans la mémoire d'un portable. Les noms de variantes indiquent le niveau : Q4_K_M est un compromis courant, Q8_0 est plus fidèle et plus lourd. La qualité baisse légèrement avec le nombre de bits, d'où l'intérêt de tester le niveau choisi sur ses propres cas.
Exemple : lancer un modèle et un serveur
Le projet fournit des binaires précompilés et des paquets, par exemple via Homebrew sur macOS. Deux commandes principales couvrent l'essentiel : llama-cli pour discuter en terminal et llama-server pour exposer une API.
# Installation sur macOS ou Linux avec Homebrew
brew install llama.cpp
# Discussion en terminal avec un modèle GGUF téléchargé depuis Hugging Face
llama-cli -hf ggml-org/gemma-3-1b-it-GGUF
# Serveur HTTP avec API compatible OpenAI
llama-server -hf ggml-org/gemma-3-1b-it-GGUF \
--port 8080 \
-c 8192 \
-ngl 99
L'option -hf télécharge le modèle depuis le Hub au premier lancement. -c fixe la taille du contexte, qui conditionne la mémoire réservée au KV cache, et -ngl indique le nombre de couches à décharger sur le GPU. Une fois le serveur lancé, un client OpenAI l'interroge sans modification :
from openai import OpenAI
client = OpenAI(base_url="http://localhost:8080/v1", api_key="inutile")
response = client.chat.completions.create(
model="local",
messages=[{"role": "user", "content": "Explique la quantization en deux phrases."}],
temperature=0.2,
)
print(response.choices[0].message.content)
Le serveur n'exige pas de clé par défaut, la valeur transmise par le client est donc libre. Les noms de modèles et les options évoluent vite : vérifiez la documentation de votre version avant de les reprendre.
Les principaux cas d'usage de llama.cpp
llama.cpp convient dès qu'un modèle doit tourner sur du matériel contraint ou intégré dans une application, sans infrastructure GPU dédiée.
Assistant local
Discuter avec un modèle sur son ordinateur, hors ligne et sans envoyer de données à un tiers.
Serveur léger
Exposer une API compatible OpenAI pour une petite équipe, depuis une machine ordinaire.
Applications embarquées
Intégrer un modèle dans un logiciel de bureau ou un appareil via la bibliothèque C/C++.
Test de modèles quantifiés
Comparer plusieurs niveaux de quantization pour trouver le meilleur compromis qualité et mémoire.
Inférence sur Apple Silicon
Tirer parti de la mémoire unifiée des Mac pour exécuter des modèles de plusieurs milliards de paramètres.
Brique d'autres outils
Servir de moteur à des applications qui masquent la complexité derrière une interface plus simple.
Quels sont les avantages de llama.cpp ?
llama.cpp a démocratisé l'inférence locale parce qu'il demande peu de ressources et très peu de préparation.
- Fonctionnement sur CPU, sur Apple Silicon et sur de nombreux GPU, sans carte NVIDIA obligatoire.
- Format GGUF autonome : poids, vocabulaire et métadonnées tiennent dans un seul fichier.
- Quantization de 2 à 8 bits qui réduit fortement la mémoire nécessaire.
- Déchargement partiel sur GPU, qui permet d'exécuter un modèle plus gros que la mémoire graphique.
- Code compact en C/C++, sans environnement Python lourd, simple à compiler et à embarquer.
- Projet open source sous licence MIT, très actif, qui sert de socle à tout un écosystème d'outils.
Quelles sont les limites de llama.cpp ?
llama.cpp n'est pas conçu pour la charge d'un serveur de production : ses points forts en local deviennent des contraintes à grande échelle.
- Le débit multi-utilisateurs reste inférieur à celui d'un moteur comme vLLM sur des GPU de centre de données.
- La quantization dégrade légèrement la qualité des réponses, d'autant plus que le nombre de bits est faible.
- Les options en ligne de commande sont nombreuses et évoluent vite d'une version à l'autre.
- La prise en charge d'une nouvelle architecture de modèle dépend de son implémentation dans le projet.
- Le serveur intégré ne gère pas seul l'authentification avancée, les quotas ou le routage entre modèles.
- Un modèle doit être converti au format GGUF, ce qui ajoute une étape quand il n'est pas déjà publié ainsi.
llama.cpp vs vLLM : quelles différences ?
Les deux exécutent des modèles ouverts, mais pour des contextes opposés. llama.cpp vise le local et la légèreté, vLLM vise le serveur GPU à haut débit.
| Critère | llama.cpp | vLLM |
|---|---|---|
| Cible | Poste de travail, petit serveur, embarqué | Serving GPU en production |
| Matériel | CPU, Apple Silicon, GPU variés | GPU, NVIDIA en priorité |
| Format de modèles | GGUF quantifié | Poids du Hub, versions quantifiées (AWQ, GPTQ, FP8) |
| Charge multi-utilisateurs | Limitée | Très bonne (continuous batching) |
| Langage | C/C++ | Python, noyaux GPU optimisés |
| Installation | Binaire ou compilation | pip ou image Docker |
| Idéal pour | Usage personnel, prototypage, hors ligne | API interne à fort trafic |
Ce n'est pas un choix binaire. On prototype souvent en local avec llama.cpp ou Ollama, puis on déploie avec vLLM quand la charge et les GPU le justifient. Le comparatif entre Ollama et LM Studio aide à choisir l'interface adaptée.
Bonnes pratiques d'utilisation
Quelques réglages évitent la plupart des déconvenues :
- Dimensionner la mémoire : poids du modèle plus KV cache, qui augmente avec la taille du contexte. Réduire
-clibère de la mémoire. - Choisir la quantization : partir de
Q4_K_M, puis testerQ8_0si la qualité déçoit. - Décharger sur le GPU : augmenter
-ngljusqu'à saturer la mémoire graphique, le reste des couches tourne sur le CPU. - Rester à jour : le projet publie des versions très fréquentes, et les nouvelles architectures de modèles y sont ajoutées au fil du temps.
- Ajouter une passerelle : pour exposer le serveur à d'autres utilisateurs, placer devant lui un proxy qui gère l'authentification.
Pour ajuster un modèle avant de l'exporter, voir Unsloth.
Quand utiliser llama.cpp ?
Le critère décisif est le matériel : llama.cpp est le bon choix quand on n'a pas de GPU de serveur ou quand la simplicité prime.
llama.cpp est adapté
- Vous exécutez un modèle sur un ordinateur portable, un Mac ou un petit serveur.
- Vous voulez un binaire léger, sans pile Python à installer.
- Vous avez besoin de répartir un modèle entre CPU et GPU.
- Vous intégrez l'inférence dans une application native.
Un autre choix est préférable
- Vous servez des centaines d'utilisateurs simultanés sur des GPU dédiés.
- Vous préférez une interface prête à l'emploi : Ollama ou LM Studio suffisent.
- Vous voulez fine-tuner un modèle, ce qui relève d'autres outils.
- Un modèle propriétaire par API répond déjà au besoin.
Technologies et outils associés à llama.cpp
llama.cpp se situe au centre d'un écosystème : des outils le prennent comme moteur, d'autres le complètent ou le remplacent selon le contexte.
- Outil construit autour
Ollama
Simplifie le téléchargement et l'exécution de modèles locaux, en s'appuyant sur l'écosystème llama.cpp.
- Application de bureau
LM Studio
Interface graphique pour télécharger et lancer des modèles locaux, notamment au format GGUF.
- Alternative serveur
vLLM
Moteur de serving sur GPU à haut débit, pour la production multi-utilisateurs.
- Modèles
Hugging Face
Le Hub qui héberge de nombreux modèles au format GGUF, et qui accueille désormais l'équipe de ggml.
- Fine-tuning
Unsloth
Permet d'adapter un modèle, qui peut ensuite être exporté au format GGUF pour llama.cpp.
- Bibliothèque de calcul
ggml
La bibliothèque de tenseurs en C sur laquelle reposent les calculs de llama.cpp.
- Projet frère
whisper.cpp
Le portage du modèle de reconnaissance vocale Whisper, développé dans le même esprit.
- Infrastructure
Kubernetes
Orchestration possible de serveurs llama.cpp lorsqu'on les déploie en conteneurs.
Les concepts à connaître autour de llama.cpp
Quelques notions de l'inférence des LLM aident à lire la documentation et à choisir ses réglages.
- QuantizationLa réduction de la précision des poids, de 16 bits à 8, 4 bits ou moins, pour réduire la mémoire.
- GGUFLe format de fichier de ggml qui regroupe poids quantifiés, vocabulaire et métadonnées du modèle.
- TokenL'unité de texte traitée par le modèle, et la base des mesures de vitesse en tokens par seconde.
- KV cacheLe cache des calculs d'attention, qui grandit avec la longueur du contexte et consomme de la mémoire.
- SLMLe petit modèle de langage, dont la taille permet d'envisager une exécution locale.
- LLMLe grand modèle de langage, dont llama.cpp exécute des versions à poids ouverts.
Ressources pour approfondir llama.cpp
Trois articles pour passer du moteur à son usage concret, en local et en production.
- Tutoriel
Ollama : exécuter des LLM en local sur son propre PC
Installer et utiliser un outil construit autour de llama.cpp.
Lire l'article - Comparatif
LM Studio vs Ollama : exécuter des LLM en local
Choisir entre une application graphique et un outil en ligne de commande.
Lire l'article - Guide
Unsloth : fine-tuner des LLM
Adapter un modèle avant de l'exporter pour l'exécuter en local.
Lire l'article
Questions fréquentes
Questions fréquentes
Expertise
À propos de l'auteur
Équipe Blent
Les ingénieurs et mentors Blent conçoivent, évaluent et mettent en production des applications LLM, et forment chaque année des centaines de professionnels à l'IA générative.
Sources et méthodologie
- Dépôt GitHub ggml-org/llama.cpp et documentation du projet
- Documentation du format GGUF (ggml)
- Annonce de l'arrivée de ggml.ai chez Hugging Face, février 2026
- Retours d'expérience des projets et formations Blent
Comment fonctionne llama.cpp ?
De la récupération du modèle à la réponse, llama.cpp enchaîne cinq étapes, toutes exécutées dans un seul processus, sans dépendance à un environnement Python.
Obtenir un fichier GGUF
Le modèle est téléchargé déjà converti et quantifié, par exemple depuis le Hub de Hugging Face, ou converti à partir de poids d'origine avec les scripts fournis par le projet.
Charger les poids
Le fichier est projeté en mémoire. Les couches peuvent être réparties : certaines sur le GPU, les autres sur le CPU, selon la mémoire disponible.
Tokeniser le prompt
Le texte est converti en tokens grâce au vocabulaire et aux métadonnées embarqués dans le fichier GGUF, sans fichier de configuration annexe.
Calculer avec ggml
La bibliothèque ggml exécute le modèle sur le backend retenu (CPU, Metal, CUDA, Vulkan...) avec des noyaux dédiés aux poids quantifiés.
Échantillonner et diffuser
Le moteur choisit chaque token selon la température et les paramètres d'échantillonnage, puis renvoie la réponse au fil de l'eau en terminal ou via HTTP.