Lexique · Frameworks / outils IA

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.

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.

  1. 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.

  2. 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.

  3. 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.

  4. 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.

  5. É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.

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.

bash
# 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 :

python
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èrellama.cppvLLM
CiblePoste de travail, petit serveur, embarquéServing GPU en production
MatérielCPU, Apple Silicon, GPU variésGPU, NVIDIA en priorité
Format de modèlesGGUF quantifiéPoids du Hub, versions quantifiées (AWQ, GPTQ, FP8)
Charge multi-utilisateursLimitéeTrès bonne (continuous batching)
LangageC/C++Python, noyaux GPU optimisés
InstallationBinaire ou compilationpip ou image Docker
Idéal pourUsage personnel, prototypage, hors ligneAPI 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 -c libère de la mémoire.
  • Choisir la quantization : partir de Q4_K_M, puis tester Q8_0 si la qualité déçoit.
  • Décharger sur le GPU : augmenter -ngl jusqu'à 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.

Pertinent si

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.
Moins adapté si

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.

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.

Ressources pour approfondir llama.cpp

Trois articles pour passer du moteur à son usage concret, en local et en production.

Questions fréquentes

Questions fréquentes

Oui. llama.cpp est un logiciel open source distribué sous licence MIT, utilisable y compris à des fins commerciales. Le coût dépend uniquement du matériel qui l'exécute et de la licence du modèle chargé, qui peut imposer ses propres conditions d'usage.

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