Embeddings explicados sin matemáticas (pero con criterio)

La pregunta que lo desbloquea todo

¿Cómo sabe un ordenador que “perro” y “cachorro” se parecen, pero “perro” y “lavadora” no?

No lo sabe por el diccionario. Lo sabe porque, en algún momento, convirtió cada palabra en una lista de números colocada en un espacio donde lo parecido cae cerca y lo distinto cae lejos. Esa lista de números es un embedding.

Suena abstracto, pero es la pieza que está detrás de medio sistema de IA moderno: la búsqueda semántica, los RAG, los recomendadores, la detección de duplicados. Si entiendes los embeddings, dejas de tratar esas herramientas como magia y empiezas a saber por qué fallan.

Un mapa, no un diccionario

Imagina un mapa enorme donde cada concepto es un punto.

“Madrid” y “Barcelona” están cerca: las dos son ciudades. “París” cae en la misma zona. “Croqueta” está en otro barrio completamente distinto, junto a “tortilla” y “paella”.

Un embedding es exactamente eso: las coordenadas de un punto en ese mapa. La diferencia es que el mapa no tiene dos dimensiones, sino cientos o miles. No lo puedes dibujar, pero la idea se mantiene: la cercanía es significado.

Y lo importante es que esas coordenadas no las pone nadie a mano. Las aprende un modelo leyendo cantidades enormes de texto y observando qué palabras aparecen en contextos parecidos. “Médico” y “enfermera” acaban cerca porque viven rodeadas de las mismas palabras: hospital, paciente, turno, guardia.

Cerca o lejos: cómo se mide

Una vez tienes dos puntos, necesitas medir cuánto se parecen. La medida habitual no es la distancia en línea recta, sino el ángulo entre los dos vectores: la similitud del coseno. Dos textos sobre el mismo tema apuntan casi en la misma dirección, aunque uno sea más largo que el otro.

En la práctica casi nunca la calculas a mano. Pides el embedding a un modelo y comparas:

from openai import OpenAI
import numpy as np

client = OpenAI()

def embed(texto):
    r = client.embeddings.create(model="text-embedding-3-small", input=texto)
    return np.array(r.data[0].embedding)

def similitud(a, b):
    a, b = embed(a), embed(b)
    return float(a @ b / (np.linalg.norm(a) * np.linalg.norm(b)))

print(similitud("¿cómo cancelo mi suscripción?", "quiero darme de baja"))  # ~0.6
print(similitud("¿cómo cancelo mi suscripción?", "recetas de pasta"))       # ~0.1

La primera pareja no comparte ni una palabra y aun así puntúa alto: eso es lo que la búsqueda por palabras clave no puede hacer y los embeddings sí.

Por qué esto te importa en producción

En todos los casos, la calidad del resultado depende de la calidad de los embeddings y de un detalle que se ignora demasiado: solo puedes comparar embeddings del mismo modelo. Las coordenadas que genera un modelo no tienen ningún sentido en el mapa de otro. Si cambias de modelo, tienes que regenerar todo el índice. No es opcional.

Tres trampas habituales

Mezclar modelos. Indexaste con un modelo y consultas con otro. Las distancias salen ruido. Mismo modelo siempre, en indexación y en consulta.

Olvidar que el idioma importa. Un modelo entrenado sobre todo en inglés coloca peor los matices del español. Para contenido en español, elige un modelo multilingüe o específico y compruébalo con tus propios textos.

Creer que la semántica lo resuelve todo. Los embeddings fallan con lo literal: un SKU, un código de error, una referencia exacta. Ahí la búsqueda por palabras clave gana. Lo robusto suele ser combinar ambas (búsqueda híbrida).

En resumen

Un embedding es la dirección de un concepto en un mapa de significado que el modelo ha aprendido solo. Comparar embeddings es comparar direcciones, y eso permite buscar por sentido en vez de por letra. No es magia: es geometría aplicada a las palabras. Y, como toda herramienta, rinde cuando entiendes dónde acierta y dónde no.