Intensivo Gratis 21–22.11Intensivo gratuito de 2 días en Vibecoding (21–22 nov, 16:00 MSK) · Cohorte 3 inicia 23.11Registrarse gratis →Cohorte 3 (23.11)
LanzamientoAnálisis · En radarQdrant Blog→ original

Qdrant ejecuta embeddings en un microcontrolador ESP32: una frase en un vector en 1,2 ms

Para que un dispositivo busque por significado sin nube, hay que convertir el texto en un vector de números (un embedding). Los modelos habituales para ello pesan entre 310 MB y 4,28 GB. La placa ESP32 tiene solo 16 MB de memoria flash y no dispone de sistema operativo, así que Qdrant optó por un modelo estático de 7,5 MB: una tabla de vectores precalculados para cada palabra. Una frase de 10 a 12 tokens (palabras y sus fragmentos) se convierte en un vector en 1,2 ms. Para microcontroladores, conviene elegir modelos estáticos en lugar de transformadores comprimidos.

Procesado por IA desde Qdrant Blog; editado por Hamidun News
Qdrant ejecuta embeddings en un microcontrolador ESP32: una frase en un vector en 1,2 ms
Fuente: Qdrant Blog. Collage: Hamidun News.
Escuchar artículo
Ficha técnica y cifras clave
ParámetroDatos
Fuente originalQdrant Blog ↗
Editor jefe
Dato clave #1Unos 830 embeddings por segundo frente a 11.000–15.000 en un MacBook Pro
Dato clave #2Se necesita unas 3000 veces menos memoria que en un portátil
Dato clave #3El tokenizador WordPiece en Rust cabe en 200 líneas sin bibliotecas

Imagine un altavoz inteligente o un sensor en una fábrica que buscan por significado directamente en el dispositivo, sin nube. Para ello, cualquier texto primero se convierte en un embedding: un conjunto de números que permite comparar frases según su significado. Los modelos habituales para esta tarea son enormes.

El equipo de Qdrant ha mostrado cómo sortear esta limitación en una placa ESP32. Es un microcontrolador con 16 MB de memoria flash y 8 MB de PSRAM (memoria RAM rápida), y no tiene disco ni sistema operativo (SO). Una frase de 10 a 12 tokens, es decir, palabras y sus fragmentos, se convierte en un vector en 1,2 ms.

Son unas 830 frases por segundo. El secreto está en el modelo estático: es, sencillamente, una tabla de vectores precalculados.

Por qué los modelos habituales no funcionan aquí

El problema es doble. Primero, el tamaño. Un modelo pequeño y moderno de embeddings, en formato de 8 bits, ocupa 310 MB de memoria, y uno más grande necesita 4,28 GB. Frente a los 16 MB de flash de la placa, esto no es un problema de optimización, sino una incompatibilidad total. Segundo, el cálculo: los transformadores se basan en multiplicaciones intensivas de matrices y suelen arrastrar dependencias pesadas, como PyTorch.

En dispositivos con sistema operativo, varios núcleos y gigabytes de memoria, todo esto es tolerable. En una placa con un par de megabytes de flash, sin disco y sin sistema operativo, no lo es. Los autores lo resumen sin rodeos: no se puede ejecutar un modelo de embeddings convencional en hardware desnudo.

El modelo estático como tabla de palabras

La solución llegó con los modelos estáticos de embeddings. Su diseño es de una simplicidad extrema: cada token del vocabulario tiene asignado de antemano su propio vector. Para obtener el embedding de una frase, hay que dividir el texto en tokens, extraer la fila de la tabla correspondiente a cada uno, promediarlas y, si se quiere, normalizar el resultado. No hay capas de red neuronal ni multiplicaciones de matrices.

Entre los modelos ya disponibles, un candidato adecuado fue potion-base-2M, que ocupa solo 7,5 MB y cabe sin problemas en los 16 MB de flash de la placa. Quedaba por resolver cómo cargar el modelo y el vocabulario en el chip, si no hay de dónde leer archivos.

Cómo se metió todo en el firmware

El código está escrito en Rust en modo sin biblioteca estándar (no_std): se comunica directamente con el hardware y no depende de servicios del sistema operativo. Por eso hubo que resolver tres problemas.

El primero: los pesos. Un script de compilación en el portátil lee el archivo del modelo en formato safetensors, localiza la tabla de embeddings y genera constantes: el tamaño del vocabulario y los bytes donde empiezan y terminan los pesos. Después, el modelo completo se incrusta en el binario del firmware. Si el archivo tiene un formato incorrecto, el error aparece durante la compilación y no en el dispositivo. En el chip, los pesos simplemente se leen desde la memoria.

El segundo: el tokenizador. No se puede usar la biblioteca de tokenizadores de Hugging Face, porque requiere la biblioteca estándar. Por eso, los autores implementaron el algoritmo WordPiece por su cuenta. Busca de forma voraz el fragmento más largo de la palabra que existe en el vocabulario, lo recorta y repite el proceso con el resto. Junto con la normalización del texto (eliminación de caracteres de control y acentos, tratamiento de los ideogramas chinos y paso a minúsculas) y la división por espacios y signos de puntuación, son algo más de 200 líneas de código.

El tercero: el vocabulario. Normalmente se usa una tabla hash, pero en la placa no hay lugar para ella. Así que, durante la compilación, el vocabulario se empaqueta en un bloque de datos compacto: primero el número de registros, después un índice de ranuras de tamaño fijo con desplazamientos y, por último, los registros en orden. Cada registro contiene un identificador de 4 bytes, 1 byte de longitud y los bytes del token. La búsqueda de un identificador a partir de una cadena se hace con una búsqueda binaria convencional. Algunas operaciones necesitan un heap, que proporciona un asignador de memoria independiente.

Qué se consiguió y cuáles son las limitaciones

Una frase de 10 a 12 tokens se convierte en un embedding en unos 1,2 ms, es decir, unos 830 embeddings por segundo. En un MacBook Pro, la misma idea da entre 11.000 y 15.000 embeddings por segundo, aunque sobre textos bastante más largos. En cambio, el chip necesita unas 3000 veces menos memoria.

Las limitaciones son evidentes. Un modelo estático no entiende el contexto como lo hace un transformador: el vector se construye promediando las contribuciones de cada token por separado. Para consultas cortas, comandos y búsqueda semántica sencilla sobre una base pequeña, puede bastar, pero para tareas finas, como distinguir formulaciones parecidas en significado, probablemente no. La velocidad tampoco es un récord, aunque para dispositivos con consultas esporádicas no resulta crítica.

La conclusión práctica para los desarrolladores de sistemas embebidos es clara: si necesitan embeddings en un microcontrolador, no intenten comprimir un transformador; empiecen por un modelo estático. Para él basta con la tabla de pesos, el vocabulario y un bucle de promediado. En Qdrant lo presentan como la primera mitad del trabajo, y prometen para la siguiente la búsqueda vectorial directamente en el chip. El código completo se ha publicado en el blog de la empresa.

Historia

Preguntas frecuentes sobre la noticia

¿Qué se sabe sobre Por qué los modelos habituales no funcionan aquí?

El problema es doble. Primero, el tamaño. Un modelo pequeño y moderno de embeddings, en formato de 8 bits, ocupa 310 MB de memoria, y uno más grande necesita 4,28 GB. Frente a los 16 MB de flash de la placa, esto no es un problema de optimización, sino una incompatibilidad total. Segundo, el cálculo: los transformadores se basan en multiplicaciones intensivas de matrices y suelen arrastrar dependencias pesadas, como PyTorch.

¿Qué se sabe sobre El modelo estático como tabla de palabras?

La solución llegó con los modelos estáticos de embeddings. Su diseño es de una simplicidad extrema: cada token del vocabulario tiene asignado de antemano su propio vector. Para obtener el embedding de una frase, hay que dividir el texto en tokens, extraer la fila de la tabla correspondiente a cada uno, promediarlas y, si se quiere, normalizar el resultado. No hay capas de red neuronal ni multiplicaciones de matrices.

Cómo se metió todo en el firmware?

El código está escrito en Rust en modo sin biblioteca estándar (no_std): se comunica directamente con el hardware y no depende de servicios del sistema operativo. Por eso hubo que resolver tres problemas. El primero: los pesos. Un script de compilación en el portátil lee el archivo del modelo en formato safetensors, localiza la tabla de embeddings y genera constantes: el tamaño del vocabulario y los bytes donde empiezan y terminan los pesos. Después, el modelo completo se incrusta en el binario del firmware.

ZK
Zhemal Khamidun — CPO de Alpina Digital, product manager de AlpinaGPT. Crea productos de IA desde 2019. Hamidun News es un proyecto personal que creció hasta ser un agregador en producción con más de 6.000 lectores.
✦ 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é te parece?
Cargando comentarios…