Yzma : des embeddings jusqu'à 2,6 fois plus rapides qu'Ollama, le comparatif

Yzma est un moteur d'inférence écrit en Go qui fait une chose simple à dire et rare à faire : il appelle llama.cpp dans son propre processus. Pas de serveur séparé, pas de REST, pas d'attente. Le résultat, selon les chiffres publiés par l'équipe, est un moteur qui produit les embeddings jusqu'à 2,6 fois plus vite qu'Ollama. Dans cet article, nous prenons les benchmarks de référence, nous refaisons les calculs et nous voyons ce qui change quand l'embedding devient le goulot d'étranglement de votre RAG.

Qu'est-ce que Yzma et pourquoi ça vous concerne

Yzma est un moteur d'inférence open source écrit en Go pur. Il ne réimplémente pas le moteur : il incorpore llama.cpp dans le processus via purego/ffi, sans CGo. Il lit les modèles GGUF et tourne sur CUDA, Metal, Vulkan et OpenVINO, jusqu'au navigateur avec WebGPU. Il couvre environ 96 % des fonctionnalités de llama.cpp, avec des pointes à 840 tok/s sur une workstation desktop et 30 tok/s sur une carte Arduino.

Pour ceux qui n'ont jamais entendu parler d'engine d'inférence : c'est le logiciel qui fait tourner le modèle. Ollama est l'un de ces engine — un serveur qui expose une API locale. Yzma se positionne différemment : c'est une bibliothèque à intégrer dans votre application Go, avec l'option d'un serveur compatible OpenAI si vous en avez besoin.

La différence d'architecture est tout le sujet : quand votre code appelle un embedding, chez Ollama la requête part vers un serveur, traverse le réseau, le serveur décode la requête, llama.cpp calcule, le vecteur revient et le serveur l'encapsule de nouveau. Chez Yzma, le vecteur naît dans votre processus et arrive directement dans votre variable.

Les chiffres : des embeddings 2,6x plus rapides

Les benchmarks de référence sont publiés sur le site du projet, relevés le 16 octobre 2026 sur un portable Intel Core i9-13900HX avec RTX 4070. Versions utilisées : yzma 1.30.0, Ollama 0.40.5, Docker Model Runner v1.2.8. Modèle d'embedding : bge-small, 29 tokens de prompt, vecteur de 384 dimensions.

Moteur	Latence par embedding	Débit prompt	Index de 10 000 documents
Yzma	1,7 ms	17 123 tok/s	17 s
Ollama	4,5 ms	6 393 tok/s	45 s
Docker Model Runner	4,6 ms	6 360 tok/s	46 s

Nous refaisons les comptes nous-mêmes, sans nous fier au tableau :

• Rapport de latence : 4,5 ms ÷ 1,7 ms = 2,65. Le « 2,6x » déclaré est exact.
• Rapport de débit : 17 123 ÷ 6 393 = 2,68. Même résultat côté opposé.
• Pour un index de 10 000 documents : 10 000 × 1,7 ms = 17 s avec Yzma ; 10 000 × 4,5 ms = 45 s avec Ollama. Un index qui met 17 secondes prend un quart du temps avec le moteur le plus répandu.

La même page mesure aussi la génération de texte, où l'avantage se resserre : 9,2 à 12,1 % de plus en vitesse et un time-to-first-token entre 48 % et 60 % de celui du serveur. Avec Gemma 4 : 118,6 tok/s contre 105,8 (ttft 12,3 ms contre 24,6). Avec Qwen3-VL : 166,9 tok/s contre 152,8 (ttft 9,0 contre 15,1).

Pourquoi l'in-process gagne sur les embeddings

La raison est entièrement mécanique. Dans un serveur, le round trip REST existe quel que soit ce que le modèle renvoie. Pour la génération de texte, le round trip est quasi gratuit : le token arrive en streaming et le transfert réseau est une fraction minuscule du temps total. Pour l'embedding, non : la réponse est un seul vecteur, 384 nombres peut-être. Le modèle travaille en moins de 2 millisecondes, et la partie fixe — HTTP, sérialisation, décodage de la requête — pèse le même montant.

En chiffres : si le round trip REST coûte ~2,8 ms et le calcul ~1,7 ms, le serveur totalise 4,5 ms et l'in-process 1,7 ms. Les 62 % du temps d'Ollama dans cette mesure ne sont pas le modèle : c'est la tuyauterie.

La conséquence pratique concerne ceux qui construisent du RAG : l'indexation est le point où les embeddings s'appellent à des milliers, l'une après l'autre. Un quart du temps d'indexation, c'est du temps de setup remboursé, et une latence de 1,7 ms rend pertinent de faire plus d'embeddings à l'étape de requête. La comparaison plus large entre les deux engine — architecture, formats, quand choisir — on l'a déjà faite dans Ollama vs llama.cpp : sous le capot ; et si vous voulez comprendre où finissent vos embeddings une fois calculées, partez de RAG : posez des questions à vos documents.

Comment l'utiliser

Yzma est d'abord une bibliothèque pour services Go. Trois commandes :

go install github.com/hybridgroup/yzma@latest
yzma install --lib
export YZMA_LIB=$HOME/yzma

Ensuite, dans votre code Go, la bibliothèque charge le modèle GGUF et restitue le vecteur de votre appel, sans démarrer aucun autre processus. Si vous préférez un serveur : yzma en démarre un avec une API compatible OpenAI, ainsi un client existant — Python, Node, curl — pointe vers localhost à la place d'Ollama.

Si ça ne marche pas : si la ligne go install ne trouve pas les toolchain, mettez à jour Go ; si le serveur ne répond pas sur le port local, vérifiez que la variable YZMA_LIB pointe vraiment sur la bibliothèque installée — c'est la cause d'échec la plus fréquente au setup.

Et les limites ?

• Les chiffres sont publiés par l'équipe de yzma, sur une seule machine de référence. Aucun laboratoire indépendant n'a reproduit la mesure : traitez-les comme déclarés, pas comme vérifiés.
• Yzma n'est pas un remplaçant drop-in d'Ollama : vous n'héritez pas de la bibliothèque de modèles, de l'écosystème et des mises à jour hebdomadaires. C'est une alternative pour ceux qui construisent des services en Go et veulent le chemin le plus court vers l'embedding.
• L'avantage sur le texte généré est marginal (9–12 %). Si votre cas est le chatbot, l'argument Yzma repose seulement sur le time-to-first-token, pas sur le débit.

Sources

• Benchmarks officiels du projet
• Dépôt GitHub de Yzma
• Fil Hacker News du 19 octobre 2026

En résumé

Yzma incorpore llama.cpp dans le processus, sans REST au milieu : sur le benchmark publié par l'équipe (16 octobre 2026, i9-13900HX + RTX 4070), les embeddings passent de 4,5 ms à 1,7 ms, soit 2,6x — et le calcul est là : 4,5 ÷ 1,7 = 2,65. L'index de 10 000 documents passe de 45 à 17 secondes. Sur la génération de texte, l'avantage est de 9–12 % avec un time-to-first-token divisé par deux. C'est open source, en Go, et couvre environ 96 % de llama.cpp : les chiffres ont été publiés par le vendor sur une seule machine, alors avant de trancher, mesurez sur votre matériel.

Article généré par IA