llama.cpp 1.0.0 : migration, cache KV FP8 et sécurité serveur

Passez à llama.cpp et ggml 1.0.0 sans interrompre vos agents de programmation locaux. Supprimez les anciennes fonctions C et options de défragmentation, comparez la mémoire et la qualité du cache KV FP8, configurez le cache d'experts MoE et vérifiez les restrictions de llama-server sur les outils et les URL privées. Découvrez aussi ce que garantit le versionnement sémantique et quand agir si vous utilisez Ollama ou LM Studio.

Sommaire
llama.cpp 1.0.0 : migration, cache KV FP8 et sécurité serveur

Avant de passer à llama.cpp 1.0.0, vérifiez vos bindings C, vos options de lancement et les paramètres de sécurité de llama-server. La version publiée le 13 novembre 2026 supprime des API obsolètes, ajoute le cache KV FP8 et de nouveaux réglages pour le cache d’experts MoE. Elle introduit aussi des autorisations explicites pour les outils serveur et les URL de médias privés. Si vous utilisez un modèle local avec un agent de programmation, commencez par une instance de test et vérifiez la génération de texte ainsi que les appels d’outils.

Cette version apporte également un engagement de versionnement pour libllama et libggml. Désormais, une modification incompatible de l’API C publique doit entraîner un changement de version majeure.

Cette règle facilite l’évaluation des futures mises à jour. Elle ne garantit pas que les réponses des modèles, les performances, les backends GPU ou tous les endpoints HTTP conserveront exactement le même comportement.

Quelles sont les nouveautés de llama.cpp 1.0.0 ?

Cette version concerne les développeurs qui intègrent llama.cpp dans une application, les administrateurs de llama-server et les utilisateurs qui optimisent la mémoire de l’inférence locale.

DomaineChangement dans 1.0.0Action à prévoir
VersionnementLes incompatibilités de l’API C publique et de l’ABI entraînent une nouvelle version majeureVerrouiller une version ou un commit en production
API CSuppression de 35 fonctions obsolètes et de llama_set_warmupAdapter les bindings et recompiler
Configuration du contexteSuppression de defrag_thold et --defrag-tholdRetirer les anciens réglages
Décodage spéculatifDéplacement de NextN API vers llama.h et renommage d’une fonctionCorriger les inclusions et les appels
Cache KVPrise en charge de f8_e4m3 pour K et VMesurer la mémoire, la qualité et la compatibilité
Inférence MoECache d’experts GPU avec traitement de certains défauts de cache par le CPUVérifier le GPU et ajuster la taille du cache et la part du CPU
Sécurité serveurRestrictions d’authentification des outils et des URL privéesExaminer l’exposition réseau et l’authentification
ModèlesKimi-K3.1-Pro, Ripple, xing4_0 et nouveautés multimodalesVérifier la conversion et le chargement
API vocaleEndpoint /v1/audio/speech compatible OpenAITester avec un modèle vocal compatible

Ces changements figurent dans les notes de version v1.0.0 et dans l’annonce officielle du versionnement.

Le projet annonce la prise en charge de plus de 150 variantes d’architectures de modèles. Cela ne signifie pas que chaque checkpoint ou fonctionnalité fonctionne sur tous les backends.

Que garantit le versionnement sémantique après 1.0.0 ?

Le nouvel engagement de compatibilité concerne les interfaces C publiques situées dans ./include, notamment celles de llama.cpp et de ggml.

Les mainteneurs définissent trois types d’évolution :

ComposantSignificationExemple
MAJORModification incompatible de l’API C publique1.x.x vers 2.0.0
MINORFonction compatible, nouveau backend, nouveau modèle ou ajout d’API1.0.0 vers 1.1.0
PATCHCorrection de bogue sans modification de l’API1.0.0 vers 1.0.1

Ces exemples illustrent la règle. Ils ne correspondent pas à des versions futures déjà annoncées.

Pour une application compilée avec libllama, cette politique réduit le risque de voir les signatures des fonctions publiques changer de façon inattendue au sein d’une même version majeure.

La garantie ne s’étend pas automatiquement aux en-têtes internes, aux symboles non documentés, aux paramètres CLI, aux détails des réponses HTTP ou au comportement des modèles.

Comment verrouiller une version de llama.cpp ?

Utilisez un tag de version précis ou un commit immuable lorsque vous compilez llama.cpp comme dépendance de votre application.

Le guide officiel de compilation explique comment récupérer le code et utiliser CMake. Ajoutez la sélection du tag v1.0.0 à cette procédure.

Exemple avec Bash :

git clone https://github.com/ggml-org/llama.cpp
cd llama.cpp
git fetch --tags
git checkout v1.0.0

cmake -B build
cmake --build build --config Release

Ces commandes correspondent à la procédure de compilation CPU documentée. Certains systèmes peuvent activer d’autres backends par défaut. Examinez votre configuration avant de supposer quel périphérique exécutera le modèle.

Pour une compilation standard, la documentation situe le programme serveur dans ./build/bin/llama-server. Le chemin peut varier selon la plateforme et le générateur CMake.

Ajoutez les options CMake documentées pour le backend GPU dont vous avez besoin.

En production, conservez le tag, le hash du commit Git, les options de compilation et le backend utilisé. Testez chaque mise à jour avant de remplacer le binaire fonctionnel.

Si votre application embarque sa propre version de llama.cpp, verrouillez aussi la version de l’application ou du wrapper. Elle peut différer de celle du moteur intégré.

Quelles API et options de ligne de commande ont été supprimées ?

La première étape de migration consiste à retirer les interfaces C obsolètes et l’ancien seuil de défragmentation.

Le nettoyage de l’API réalisé dans la PR #30565 supprime 35 fonctions obsolètes, llama_set_warmup et le réglage du seuil de défragmentation.

Vérifiez les points suivants :

  • Supprimez les appels à llama_set_warmup.
  • Retirez defrag_thold des paramètres de contexte.
  • Enlevez --defrag-thold des scripts de démarrage.
  • Remplacez llama_set_embd_state_src par llama_set_ctx_state_src lorsque cela s’applique.
  • Mettez à jour les inclusions et les déclarations de NextN API, désormais exposées dans llama.h.

Les 35 fonctions supprimées n’ont pas nécessairement chacune un remplacement direct. Comparez les en-têtes du tag v1.0.0 avec les symboles utilisés par vos bindings.

Corriger les scripts contenant —defrag-thold

Une ancienne commande pouvait démarrer le serveur ainsi :

./build/bin/llama-server \
  -m /path/to/model.gguf \
  -c 32768 \
  --defrag-thold 0.1

Avec 1.0.0, supprimez simplement l’option :

./build/bin/llama-server \
  -m /path/to/model.gguf \
  -c 32768

Il ne faut pas choisir une autre valeur de seuil. Le paramètre lui-même a disparu. N’inventez pas de remplacement non documenté.

Recherchez les anciens noms dans les scripts shell, les configurations Docker, les services et le code source :

grep -RInE \
  'defrag[_-]thold|llama_set_warmup|llama_set_embd_state_src' \
  ./scripts ./config ./src

Adaptez les dossiers à votre projet. Retirez de la commande les chemins qui n’existent pas.

Vérifiez aussi les variables d’environnement et les réglages des wrappers qui pourraient encore générer l’ancien argument.

Mettre à jour les bindings C et Python

Si votre application utilise directement llama.h, comparez son code avec les en-têtes de v1.0.0 avant de recompiler.

Pour les applications CMake, recompilez avec la nouvelle bibliothèque. Examinez les messages du compilateur et de l’éditeur de liens.

Avec Python, vérifiez d’abord que la version du wrapper annonce explicitement la prise en charge de llama.cpp 1.0.0.

Remplacer l’exécutable llama.cpp ne met pas automatiquement à jour les définitions déjà compilées dans une extension Python.

Certains wrappers embarquent leur propre copie du code source de llama.cpp. Dans ce cas, suivez leur procédure de mise à jour. Évitez de remplacer manuellement leur bibliothèque partagée sans vérifier la compatibilité.

Un import réussi ne constitue qu’un premier contrôle. Chargez un modèle, générez des tokens et testez les opérations de contexte ou de décodage spéculatif utilisées par votre application.

Comment activer le cache KV FP8 dans llama.cpp 1.0.0 ?

Utilisez -ctk f8_e4m3 -ctv f8_e4m3 pour demander le stockage FP8 des clés et des valeurs du mécanisme d’attention.

Le cache KV conserve les informations des tokens déjà traités. Le modèle peut ainsi continuer la génération sans recalculer tout le contexte.

Plus le contexte est long, plus ce cache demande généralement de mémoire.

FP8 stocke chaque valeur sur 8 bits, contre 16 bits pour FP16. À dimensions de tenseurs équivalentes, le stockage brut de K/V peut donc être réduit approximativement de moitié.

Cette estimation ne tient pas compte des métadonnées, des facteurs d’échelle, de l’alignement mémoire, des poids du modèle ni des buffers de calcul. Elle ne signifie pas que toute la VRAM utilisée diminue de moitié.

Commencer par mesurer une configuration FP16

Utilisez le même modèle et la même taille de contexte pour les deux essais.

Démarrez d’abord le serveur avec FP16 :

./build/bin/llama-server \
  -m /path/to/model.gguf \
  -c 32768 \
  --host 127.0.0.1 \
  --port 8080 \
  -ctk f16 \
  -ctv f16

Relevez dans les journaux la mémoire allouée au cache KV. Notez également la mémoire disponible, la vitesse de traitement du prompt et la vitesse de génération.

Arrêtez ensuite le serveur et démarrez-le avec FP8 :

./build/bin/llama-server \
  -m /path/to/model.gguf \
  -c 32768 \
  --host 127.0.0.1 \
  --port 8080 \
  -ctk f8_e4m3 \
  -ctv f8_e4m3

La version ajoute également des facteurs d’échelle statiques facultatifs par tenseur pour le cache FP8.

Consultez les journaux de démarrage pour vérifier les types de cache sélectionnés et les tailles allouées. L’acceptation de l’argument ne prouve pas que votre backend GPU prend en charge tous les chemins de calcul optimisés.

FP8 permet-il de doubler la longueur du contexte ?

Pas nécessairement.

FP8 réduit le stockage des tenseurs KV, mais la fenêtre de contexte reste limitée par le modèle et la mémoire disponible.

Prenons une configuration hypothétique dont le cache KV FP16 occupe 8 GiB. Le stockage brut des mêmes tenseurs en FP8 pourrait descendre à environ 4 GiB.

Il s’agit d’un calcul théorique, pas d’une mesure réalisée sur llama.cpp.

La mémoire libérée pourrait permettre un contexte plus long ou davantage de requêtes simultanées. Elle ne permet pas de dépasser les capacités effectives de contexte prises en charge par le modèle.

FP8 utilise aussi une précision inférieure. La documentation du lancement ne fournit pas de résultat universel concernant la qualité du code ou la fiabilité des appels d’outils avec ce cache.

Pour un agent de programmation, comparez FP16 et FP8 sur les mêmes tâches :

  1. Retrouvez un symbole précis dans un long fichier source.
  2. Préparez une modification portant sur plusieurs fichiers.
  3. Générez un appel d’outil structuré.
  4. Reprenez une tâche après plusieurs longs tours de conversation.

Évaluez la justesse du code et le format des arguments d’outils. Ne comparez pas uniquement les tokens par seconde.

Comment fonctionne le nouveau cache d’experts MoE ?

Le cache MoE est utile lorsque les poids des experts d’un modèle Mixture-of-Experts se trouvent dans la RAM du système plutôt que dans la mémoire GPU.

Un modèle MoE sélectionne certains experts pour chaque token. Transférer régulièrement leurs poids de la RAM vers le GPU peut ralentir le décodage.

Le cache conserve dans la mémoire GPU les experts résidant en RAM les plus souvent utilisés. Un autre réglage permet au CPU de traiter une partie des défauts de cache.

Ce mécanisme est différent du cache KV FP8. Le cache MoE gère les poids des experts, tandis que le cache KV conserve l’état de l’attention.

Le guide officiel du cache MoE décrit les paramètres suivants :

OptionEffetValeur par défaut
-cmoeConserver tous les poids des experts MoE en mémoire CPUDésactivé sans sélection explicite
--moe-cache-mib NRéserver N MiB de cache GPU pour les experts résidant en RAM0, désactivé
--moe-cache-cpu-share FTraiter sur le CPU la proportion F des défauts une fois le cache plein0

La plage documentée pour CPU share va de 0 à 1.

Le cache suit ces règles :

  • Les accès trouvés dans le cache sont traités par le GPU.
  • Avant que le cache soit plein, chaque défaut entraîne un transfert vers le GPU.
  • Une fois le cache plein, le CPU traite la proportion de défauts configurée.
  • Les autres défauts entraînent le transfert des poids pour un calcul sur le GPU.
  • Les grands lots peuvent encore nécessiter des transferts d’experts.

Le traitement sur CPU peut être utile lorsque la lecture des poids en RAM est plus rapide que leur transfert vers le GPU.

La mémoire hôte verrouillée, appelée pinned memory, peut modifier cet équilibre. Lorsque les transferts utilisent déjà efficacement la bande passante disponible, augmenter CPU share peut apporter peu de bénéfices.

Exemple : mettre en cache des experts MoE résidant en RAM

Vous devez disposer d’un backend GPU pris en charge et d’une mémoire GPU suffisante pour le cache des experts.

Une compilation limitée au CPU ne peut pas fournir ce cache GPU.

Sur un système NVIDIA équipé de l’environnement de développement CUDA nécessaire, les instructions officielles pour CUDA indiquent :

cmake -B build -DGGML_CUDA=ON
cmake --build build --config Release

Pour les autres plateformes GPU compatibles, utilisez les options de compilation prévues pour leur backend.

Avec un modèle MoE compatible et une compilation prenant en charge le GPU :

./build/bin/llama-server \
  -m /path/to/moe-model.gguf \
  -cmoe \
  -c 32768 \
  --host 127.0.0.1 \
  --port 8080 \
  --moe-cache-mib 2048 \
  --moe-cache-cpu-share 0.5

L’option -cmoe conserve les poids des experts dans la RAM. --moe-cache-mib 2048 demande 2,048 MiB de mémoire GPU pour les experts sélectionnés.

La valeur 0.5 attribue au CPU 50% des défauts de cache après remplissage.

Avant que le cache soit plein, les défauts déclenchent toujours des transferts vers le GPU. Les accès présents dans le cache sont également exécutés sur le GPU.

Ces valeurs constituent un exemple de configuration. Elles ne représentent pas un réglage optimal pour toutes les machines.

Le GPU doit conserver suffisamment de mémoire pour les couches du modèle, le cache KV et les buffers de calcul. La mémoire réservée aux experts réduit celle disponible pour ces autres éléments.

Si la demande de mémoire dépasse la capacité disponible, réduisez le cache ou modifiez la répartition des poids. Ce mécanisme ne permet pas automatiquement d’exécuter un modèle trop volumineux.

Laisser le script de réglage choisir une configuration

Le projet fournit un utilitaire pour rechercher des paramètres adaptés à votre matériel.

Depuis le dépôt llama.cpp, exécutez :

python3 scripts/moe-cache-tune.py -- \
  ./build/bin/llama-server \
  -m /path/to/moe-model.gguf \
  -cmoe \
  -t 8 \
  -c 32768

Le script de réglage lance le serveur avec plusieurs tailles de cache et proportions de calcul CPU.

Le guide officiel décrit six mesures : deux tailles de cache combinées aux valeurs 0, 0.5 et 0.95 pour CPU share.

Le script utilise ces mesures pour estimer d’autres configurations. Il affiche les vitesses mesurées, le débit prévu et les arguments recommandés.

Conservez les réglages réels de votre modèle, du nombre de threads CPU, du contexte et de la répartition des experts. Ils influencent la mémoire disponible et la vitesse d’inférence.

Le cache vise principalement le décodage de petits lots. Les grands lots peuvent encore nécessiter des transferts de poids d’experts.

Si votre modèle est dense ou si tous ses experts tiennent déjà dans la mémoire GPU, ce cache a peu de chances de vous aider. Commencez avec sa valeur par défaut désactivée.

Quels changements de sécurité concernent llama-server ?

La version 1.0.0 ajoute des autorisations explicites pour l’exposition d’outils sans authentification et pour les URL de médias privées.

Ces paramètres sont particulièrement importants lorsque des clients peuvent accéder au serveur depuis une autre machine.

—allow-unauthenticated-tools

L’option --allow-unauthenticated-tools autorise l’utilisation d’outils serveur, de serveurs MCP ou d’un proxy MCP depuis une adresse non loopback, sans API key.

La référence officielle des paramètres serveur indique que cette autorisation est désactivée par défaut. Elle précise qu’elle ne doit servir que sur des réseaux de confiance.

Une écoute sur 127.0.0.1 limite les connexions à la machine locale. En revanche, une écoute sur 0.0.0.0 peut rendre le serveur accessible depuis d’autres interfaces réseau.

Il faut donc examiner toute configuration combinant accès non local, outils serveur ou MCP activés, et absence d’API key.

L’option est la suivante :

--allow-unauthenticated-tools

Ne l’ajoutez pas automatiquement pour corriger une migration. Elle autorise explicitement un accès non authentifié à des fonctions sensibles.

Ce paramètre concerne les outils exécutés par le serveur et leur exposition via MCP. Il est distinct de la génération d’une réponse structurée tool_calls par le modèle.

Pour développer sur la même machine, privilégiez un serveur local :

./build/bin/llama-server \
  -m /path/to/model.gguf \
  --host 127.0.0.1 \
  --port 8080 \
  --jinja

Pour les clients distants, utilisez le mécanisme d’authentification --api-key documenté et des restrictions réseau adaptées.

Avec Bash, saisissez la clé sans l’afficher :

read -rs LLAMA_SERVER_API_KEY && export LLAMA_SERVER_API_KEY

Démarrez ensuite le serveur en référençant la variable d’environnement :

./build/bin/llama-server \
  -m /path/to/model.gguf \
  --host 0.0.0.0 \
  --port 8080 \
  --jinja \
  --api-key "$LLAMA_SERVER_API_KEY"

Protégez également le serveur par des contrôles d’accès réseau. Une API key ne suffit pas à sécuriser n’importe quel déploiement public.

—media-allow-private-urls

La deuxième modification concerne les URL HTTP(S) de médias envoyées au serveur, par exemple les références d’images.

Par défaut, le serveur refuse l’accès aux médias situés sur des adresses locales ou privées.

L’option d’autorisation est :

--media-allow-private-urls

Lorsqu’elle est activée, le serveur peut récupérer des médias HTTP(S) depuis des adresses locales ou privées.

Cela peut servir à une application de confiance qui héberge ses images sur un service interne. Mais le risque de SSRF augmente si des utilisateurs non fiables contrôlent les URL fournies au serveur.

Préférez l’envoi direct des données d’image dans un format pris en charge ou un hébergement de médias contrôlé.

Si l’accès aux URL privées est indispensable, limitez les utilisateurs autorisés à envoyer des requêtes et les destinations accessibles depuis le serveur. N’activez pas cette option uniquement pour accepter une URL inconnue.

Autres correctifs de sécurité

La version apporte aussi des corrections concernant :

  • La validation de --cors-origins et la comparaison des origines.
  • La protection contre le DNS rebinding.
  • Les risques de SSRF via le proxy CORS.
  • L’accès direct du navigateur aux instances serveur enfants.
  • Les destinations susceptibles de recevoir HF_TOKEN.
  • L’annulation des appels d’outils MCP après déconnexion du client ou expiration du délai.

La transmission de HF_TOKEN est désormais limitée aux hôtes huggingface.co.

Pour les agents de programmation, l’annulation des appels MCP permet d’éviter que des outils devenus inutiles continuent de fonctionner après la déconnexion du client.

Une notification d’annulation ne garantit toutefois pas qu’un outil externe puisse annuler les opérations qu’il a déjà effectuées.

Consultez les changements dans la PR #32113, la PR #32115 et les notes de version v1.0.0.

Comment vérifier un backend local pour agent de programmation ?

Testez la génération du modèle avant de reconnecter Claude Code, OpenCode ou un autre client de programmation.

Démarrez un serveur accessible uniquement en loopback, avec un modèle adapté aux instructions :

./build/bin/llama-server \
  -m /path/to/coding-model.gguf \
  --alias local-coder \
  -c 32768 \
  --host 127.0.0.1 \
  --port 8080 \
  --jinja

Le modèle doit prendre en charge le comportement d’appel d’outils attendu par le client. L’option --jinja active le traitement des modèles de conversation. Elle n’ajoute pas cette capacité à un modèle qui ne la possède pas.

Consultez la liste des modèles avec curl :

curl --fail-with-body \
  http://127.0.0.1:8080/v1/models

La réponse doit identifier l’alias de modèle configuré.

Envoyez ensuite une requête de génération simple :

curl --fail-with-body \
  http://127.0.0.1:8080/v1/chat/completions \
  -H 'Content-Type: application/json' \
  -d '{
    "model": "local-coder",
    "messages": [
      {
        "role": "user",
        "content": "Explain what a Git diff shows in one sentence."
      }
    ],
    "max_tokens": 100
  }'

Vérifiez la présence de la réponse dans choices.

Lorsque ce test fonctionne, configurez le client avec son mécanisme documenté de fournisseur personnalisé. L’URL de base de l’API locale compatible OpenAI est :

http://127.0.0.1:8080/v1

La compatibilité avec OpenAI Chat Completions ne signifie pas que le serveur implémente intégralement Anthropic Messages API ou OpenAI Responses API.

Claude Code peut avoir besoin d’un adaptateur de protocole ou d’une autre méthode de connexion prise en charge. OpenCode peut utiliser un fournisseur personnalisé compatible, si le modèle et l’API correspondent à sa configuration.

Avant de confier un vrai dépôt à l’agent, vérifiez la lecture d’un fichier, la proposition d’une modification et un appel d’outil.

Une génération de texte réussie ne prouve pas que les arguments structurés, les opérations sur les fichiers ou les longues sessions fonctionnent correctement.

Pour un autre parcours d’accès aux modèles, consultez le guide de configuration de Kimi K3.1 Pro avec Claude Code et Codex. Le guide des poids ouverts et de la licence de Kimi K3.1 Pro explique aussi les différences entre matériel local et API hébergée.

Faut-il mettre Ollama ou LM Studio à jour ?

Si vous utilisez Ollama ou LM Studio sans compiler ou configurer directement llama.cpp, ne remplacez pas vous-même leurs bibliothèques internes.

Ces applications gèrent leurs propres versions du moteur, leurs distributions et leurs tests d’intégration.

La sortie de llama.cpp 1.0.0 ne signifie pas que toutes les applications qui en dépendent l’ont déjà intégré.

Consultez les notes de version de chaque application et utilisez son mécanisme de mise à jour pour connaître la version du moteur réellement distribuée.

Surveillez notamment les changements suivants :

  • Une mise à jour mentionne explicitement llama.cpp 1.0.0 ou des modifications équivalentes.
  • L’application expose de nouveaux formats de cache KV ou des réglages MoE.
  • Les règles d’authentification des outils serveur ou de MCP changent.
  • Le chargement des modèles ou les appels d’outils fonctionnent différemment après une mise à jour.

Pour un simple usage de conversation sur ordinateur, vous pouvez conserver une version prise en charge qui fonctionne, tant qu’aucun correctif ou ajout précis n’est nécessaire.

Si l’application sert de backend à un agent de programmation, vérifiez tout le parcours client-serveur après chaque mise à jour.

Quand envisager une API hébergée ?

L’inférence locale reste intéressante lorsque votre matériel peut exécuter le modèle choisi avec la longueur de contexte et la vitesse requises.

Le cache KV FP8 peut réduire les besoins en mémoire. Le cache MoE peut aider certaines configurations dont les experts résident en RAM. Aucun des deux ne résout toutes les limites matérielles ni ne garantit une accélération des tâches de programmation.

Si les poids, le cache d’attention ou les requêtes concurrentes dépassent la capacité de votre machine, comparez un modèle local plus petit avec une solution hébergée.

Une API hébergée évite de gérer directement la mémoire GPU utilisée par le modèle. En contrepartie, elle introduit des coûts d’utilisation, des échanges réseau et une dépendance au fournisseur.

BetterToken est une option d’accès à plusieurs modèles par API avec facturation à l’usage. Ce service ne remplace pas l’exécution locale de llama.cpp et ne fournit pas les fonctions de sécurité de son serveur.

Avant de choisir une solution hébergée, comparez les modèles et le coût de votre charge sur la page des tarifs actuels.

Pour passer progressivement du local à l’hébergé, conservez deux configurations de fournisseur testées séparément. Ne supposez pas que l’identifiant du modèle, le format des outils ou les paramètres d’authentification sont identiques sur les deux endpoints.

Liste de contrôle pour une migration sûre

Avant de mettre à jour un backend local de programmation en production, vérifiez les points suivants :

  1. Verrouillez les sources de v1.0.0 ou un binaire de compilation précis.
  2. Supprimez --defrag-thold et les appels aux anciennes API C.
  3. Recompilez les bindings natifs avec les nouveaux en-têtes publics.
  4. Commencez les tests avec votre configuration précédente de cache KV FP16.
  5. Testez séparément FP8 KV et comparez la mémoire, la vitesse et la qualité du code.
  6. Ajustez le cache MoE seulement avec un backend GPU compatible et des experts résidant en RAM.
  7. Vérifiez l’authentification des outils et les restrictions sur les URL privées.
  8. Testez /v1/models, la génération de chat, les appels d’outils et le client de programmation.
  9. Conservez l’ancien binaire et sa configuration pour pouvoir revenir en arrière.

llama.cpp 1.0.0 définit une frontière de compatibilité plus claire pour ses bibliothèques C publiques. Une migration fiable reste toutefois conditionnée par vos bindings, votre matériel, l’exposition réseau du serveur et les tâches réelles de votre agent.

Prêt à optimiser votre workflow LLM ?

Connectez vos modèles via une API unique, gérez les clés et maîtrisez vos dépenses d’IA.

Commencer gratuitement