Intensif Gratuit 21–22/11Intensif gratuit de 2 jours en Vibecoding (21–22 nov, 16h00 MSK) · Cohorte 3 le 23/11S'inscrire gratuitement →Cohorte 3 (23/11)
SortieAnalyse · Sur le radarQdrant Blog→ original

Qdrant fait tourner des embeddings sur un microcontrôleur ESP32 : une phrase en vecteur en 1,2 ms

Pour qu'un appareil recherche par sens sans passer par le cloud, il faut convertir le texte en vecteur de nombres (un embedding). Or les modèles classiques pour cela pèsent entre 310 Mo et 4,28 Go. La carte ESP32 ne dispose que de 16 Mo de mémoire flash et n'a pas d'OS : Qdrant a donc retenu un modèle statique de 7,5 Mo, c'est-à-dire une table de vecteurs précalculés pour chaque mot. Une phrase de 10 à 12 tokens (mots et fragments de mots) devient un vecteur en 1,2 ms. Pour les microcontrôleurs, privilégiez les modèles statiques plutôt que les transformeurs compressés.

Traité par IA depuis Qdrant Blog ; édité par Hamidun News
Qdrant fait tourner des embeddings sur un microcontrôleur ESP32 : une phrase en vecteur en 1,2 ms
Source : Qdrant Blog. Collage: Hamidun News.
Écouter l'article
Fiche synthèse et chiffres clés
ParamètreDonnées
Source primaireQdrant Blog ↗
Rédacteur en chef
Chiffre clé #1Environ 830 embeddings par seconde contre 11 à 15 mille sur un MacBook Pro
Chiffre clé #2Il faut environ 3000 fois moins de mémoire que sur un ordinateur portable
Chiffre clé #3Le tokenizer WordPiece en Rust tient en 200 lignes sans bibliothèques

Imaginez une enceinte connectée ou un capteur d'usine capables de chercher par sens directement sur l'appareil, sans cloud. Pour cela, tout texte est d'abord converti en embedding : un ensemble de nombres permettant de comparer des phrases selon leur sens. Les modèles classiques pour cette tâche sont énormes.

L'équipe de Qdrant a montré comment contourner cette limite sur une carte ESP32. Il s'agit d'un microcontrôleur doté de 16 Mo de mémoire flash et de 8 Mo de PSRAM (mémoire vive rapide), sans disque ni système d'exploitation (OS). Une phrase de 10 à 12 tokens, c'est-à-dire des mots et leurs fragments, devient un vecteur en 1,2 ms.

Cela représente environ 830 phrases par seconde. Le secret tient à un modèle statique : il s'agit simplement d'une table de vecteurs précalculés.

Pourquoi les modèles classiques ne fonctionnent pas ici

Le problème est double. Premièrement, la taille. Un modèle d'embeddings récent de taille modeste occupe 310 Mo en 8 bits, et un modèle plus grand réclame 4,28 Go. Face aux 16 Mo de mémoire flash de la carte, il ne s'agit pas d'un problème d'optimisation mais d'une incompatibilité totale. Deuxièmement, le calcul : les transformeurs reposent sur de lourdes multiplications de matrices et entraînent souvent des dépendances encombrantes comme PyTorch.

Sur des appareils dotés d'un OS, de plusieurs cœurs et de gigaoctets de mémoire, tout cela reste supportable. Sur une carte disposant de quelques mégaoctets de flash, sans disque ni système d'exploitation, c'est impossible. Les auteurs résument franchement : il est impossible de faire tourner un modèle d'embeddings classique sur du matériel nu.

Le modèle statique, une table de mots

La solution vient des modèles d'embeddings statiques, d'une simplicité extrême : chaque token du vocabulaire possède un vecteur préenregistré. Pour obtenir l'embedding d'une phrase, il suffit de découper le texte en tokens, de récupérer la ligne correspondante dans la table pour chacun, de calculer la moyenne et, si besoin, de normaliser le résultat. Aucune couche de réseau de neurones ni multiplication de matrices n'intervient.

Le candidat idéal existait déjà : potion-base-2M ne pèse que 7,5 Mo, ce qui tient confortablement dans les 16 Mo de flash de la carte. Restait à savoir comment acheminer le modèle et son vocabulaire jusqu'à la puce, alors qu'aucun fichier ne peut être lu depuis un support externe.

Comment tout cela tient dans le firmware

Le code est écrit en Rust en mode sans bibliothèque standard (no_std) : il dialogue directement avec le matériel et ne compte pas sur les services d'un OS. Trois problèmes ont dû être résolus.

Premier problème : les poids. Un script de compilation exécuté sur l'ordinateur portable lit le fichier du modèle au format safetensors, repère la table d'embeddings et génère des constantes : taille du vocabulaire, positions de début et de fin des octets des poids. Le modèle est ensuite intégré entièrement dans le binaire du firmware. Si le fichier est malformé, l'erreur apparaît à la compilation et non sur l'appareil. Sur la puce, les poids se lisent simplement en mémoire.

Deuxième problème : le tokenizer. La bibliothèque de tokenisation de Hugging Face ne peut pas être utilisée, car elle nécessite la bibliothèque standard. Les auteurs ont donc implémenté eux-mêmes l'algorithme WordPiece. Il recherche glouton le plus long fragment du mot présent dans le vocabulaire, le détache, puis répète l'opération sur le reste. En ajoutant la normalisation du texte (suppression des caractères de contrôle et des accents, traitement des idéogrammes chinois, passage en minuscules) et le découpage aux espaces et aux signes de ponctuation, on obtient un peu plus de 200 lignes de code.

Troisième problème : le vocabulaire. Il s'agit habituellement d'une table de hachage, mais la carte n'en dispose pas. Le vocabulaire est donc empaqueté à la compilation dans un bloc de données compact : d'abord le nombre d'entrées, puis un index de emplacements de taille fixe contenant les décalages, puis les entrées elles-mêmes, triées. Chaque entrée comprend un identifiant de 4 octets, un octet de longueur et les octets du token. La recherche d'un identifiant à partir d'une chaîne se fait par une simple recherche dichotomique. Certaines opérations nécessitent un tas, fourni par un allocateur dédié.

Résultats et limites

Une phrase de 10 à 12 tokens se transforme en embedding en 1,2 ms environ, soit près de 830 embeddings par seconde. Sur un MacBook Pro, la même approche atteint 11 000 à 15 000 embeddings par seconde, mais sur des textes nettement plus longs. En revanche, la puce nécessite environ 3000 fois moins de mémoire.

Les limites sont évidentes. Un modèle statique ne saisit pas le contexte comme un transformeur : le vecteur résulte d'une moyenne des contributions des tokens pris isolément. Pour des requêtes courtes, des commandes ou une recherche sémantique simple dans une petite base, cela peut suffire ; pour des tâches fines, comme distinguer des formulations proches de sens, c'est peu probable. La vitesse n'est pas non plus record, même si cela importe peu pour des appareils aux requêtes peu fréquentes.

Pour les développeurs de systèmes embarqués, la conclusion pratique est la suivante : si vous avez besoin d'embeddings sur microcontrôleur, n'essayez pas de compresser un transformeur, commencez par un modèle statique. Une table de poids, un vocabulaire et une boucle de moyennage suffisent. Qdrant parle de cette étape comme de la première moitié du travail et promet pour la suite une recherche vectorielle directement sur la puce. Le code complet est publié sur le blog de l'entreprise.

Dossier

Questions clés sur cet article

Pourquoi les modèles classiques ne fonctionnent pas ici?

Le problème est double. Premièrement, la taille. Un modèle d'embeddings récent de taille modeste occupe 310 Mo en 8 bits, et un modèle plus grand réclame 4,28 Go. Face aux 16 Mo de mémoire flash de la carte, il ne s'agit pas d'un problème d'optimisation mais d'une incompatibilité totale. Deuxièmement, le calcul : les transformeurs reposent sur de lourdes multiplications de matrices et entraînent souvent des dépendances encombrantes comme PyTorch.

Que sait-on sur Le modèle statique, une table de mots ?

La solution vient des modèles d'embeddings statiques, d'une simplicité extrême : chaque token du vocabulaire possède un vecteur préenregistré. Pour obtenir l'embedding d'une phrase, il suffit de découper le texte en tokens, de récupérer la ligne correspondante dans la table pour chacun, de calculer la moyenne et, si besoin, de normaliser le résultat. Aucune couche de réseau de neurones ni multiplication de matrices n'intervient.

Comment tout cela tient dans le firmware?

Le code est écrit en Rust en mode sans bibliothèque standard (no_std) : il dialogue directement avec le matériel et ne compte pas sur les services d'un OS. Trois problèmes ont dû être résolus. Premier problème : les poids. Un script de compilation exécuté sur l'ordinateur portable lit le fichier du modèle au format safetensors, repère la table d'embeddings et génère des constantes : taille du vocabulaire, positions de début et de fin des octets des poids.

ZK
Zhemal Khamidun — CPO d'Alpina Digital, product manager d'AlpinaGPT. Conçoit des produits IA depuis 2019. Hamidun News est un projet personnel devenu un agrégateur en production avec plus de 6 000 lecteurs.
✦ Unified AI Workspace · Nomad

Test Frontier LLMs & Autonomous Agents in One Workspace

Run Claude Opus 5.5, GPT-6, Gemini 3.1, and DeepSeek side-by-side in Nomad AI (nomadnet.ai) — unified model routing, deep research, and multimodal workflows under one subscription.

Try Nomad AI →Launch Nomad Agent
Qu'en pensez-vous ?
Chargement des commentaires…