¿Qué son los embeddings y por qué son clave en la Inteligencia Artificial?

Laura Ocampo
5 days ago
5 min read

La Inteligencia Artificial (IA) avanza a pasos gigantes, pero detrás de todo chatbot, buscador inteligente o recomendador de películas, existe un ingrediente silencioso pero fundamental: los embeddings.

Si nunca habías escuchado este término, piensa en ellos como un traductor entre el lenguaje humano y el lenguaje de las máquinas.

Image from https://qdrant.tech/articles/what-are-embeddings/

¿Qué son los embeddings?

Un embedding es una representación matemática (un vector de números) que captura el significado y el contexto de un dato: puede ser una palabra, una frase, una imagen o incluso un registro dentro de una base de datos.

En lugar de guardar “solo texto” como “cliente interesado en zapatos deportivos”, la IA lo transforma en una serie de números que reflejan el sentido de esa frase. Gracias a eso, puede compararla con otras frases y encontrar similitudes, aunque no coincidan las palabras exactas.

Ejemplo simple:

“Perro” y “Gato” tendrán vectores cercanos.
“Perro”, “Banana” y "Avión" estarán mucho más alejados en este espacio numérico.

Image from https://weaviate.io/blog/vector-embeddings-explained

¿Por qué son tan importantes en IA?

Los embeddings son la base de cómo la IA entiende, compara y organiza información. Algunas aplicaciones:

Búsquedas inteligentes: encuentras lo que necesitas sin tener que recordar las palabras exactas.
Sistemas de recomendación: Netflix, Spotify o Amazon detectan patrones de gustos gracias a la proximidad entre vectores.
Asistentes virtuales: ChatGPT puede responder con contexto porque compara significados en lugar de solo palabras.
Análisis de sentimientos: detectar si una reseña es positiva, negativa o neutral.

Embeddings en bases de datos: ejemplos prácticos

Aquí es donde se pone interesante. Tradicionalmente, las bases de datos almacenan información estructurada: nombres, fechas, productos, etc. Pero con embeddings, podemos ir mucho más allá:

Búsqueda semántica en bases de datos Supongamos que tienes una tabla con reseñas de clientes:
idcomentario 1“El envío fue rapidísimo” 2“El paquete llegó antes de lo esperado” 3“El producto es de buena calidad”
- Si buscas “entrega rápida”, una consulta tradicional en SQL no encontraría coincidencias exactas.
- Con embeddings, el sistema entiende que “rapidísimo” y “antes de lo esperado” están relacionados con “entrega rápida”.
Laura Ocampo Campo

Resultado: obtienes todas las reseñas relevantes aunque no coincidan las palabras exactas.
Detección de duplicados o similares En una base de datos de productos, puedes tener:
- “Tenis Nike para correr”
- “Zapatillas deportivas Nike running”
Aunque el texto es distinto, los embeddings los ubicarán en vectores cercanos, indicando que se trata prácticamente del mismo producto. Esto ayuda a limpiar y normalizar datos.
Laura Ocampo Campo
Recomendaciones dentro de un sistema CRM Si guardas las interacciones de clientes, puedes usar embeddings para recomendar acciones:
- Cliente A escribió: “Busco un seguro económico para mi auto”.
- Cliente B escribió: “Necesito pólizas baratas para coche”.
Aunque las palabras difieren, la IA entiende que ambos buscan lo mismo. Eso permite recomendar el mismo producto o respuesta comercial, optimizando la experiencia del cliente.

El impacto a futuro

Los embeddings están transformando la forma en que trabajamos con datos. No se trata solo de almacenar información, sino de darle un contexto que la haga más útil y accesible.

En el futuro cercano veremos bases de datos híbridas:

Tablas clásicas con números, fechas y texto.
Columnas adicionales con embeddings que permitan búsquedas semánticas y recomendaciones inteligentes.

Esto significa que la IA podrá conectarse de forma mucho más natural con la información empresarial, generando valor en áreas como atención al cliente, análisis de datos y automatización.

Cómo se vería en la práctica?

Hasta ahora vimos qué son los embeddings y cómo funcionan en bases de datos de forma conceptual. Pero… ¿cómo se implementa esto realmente?

La respuesta está en combinar una base de datos que soporte vectores (como PostgreSQL con la extensión pgvector) y una librería de IA que genere embeddings (como sentence-transformers en Python).

De esta forma, podemos guardar reseñas, productos o cualquier texto en una tabla, generar sus embeddings y luego hacer búsquedas semánticas: es decir, recuperar registros aunque no coincidan literalmente las palabras, porque lo que se compara es el significado.

Aquí te muestro un ejemplo sencillo con reseñas de clientes: primero creamos la tabla en SQL, luego generamos embeddings en Python, y finalmente consultamos con búsquedas inteligentes:

1) SQL: prepara la base (Postgres + pgvector)

-- 1) Instala la extensión (una vez por base)
CREATE EXTENSION IF NOT EXISTS vector;

-- 2) Tabla con texto + embedding (384 dim para all-MiniLM-L6-v2)
CREATE TABLE reviews (
  id BIGSERIAL PRIMARY KEY,
  text TEXT NOT NULL,
  embedding vector(384)  -- <- cambia el 384 si usas otro modelo
);

-- 3) Índice para acelerar la similitud (cosine)
CREATE INDEX ON reviews USING ivfflat (embedding vector_cosine_ops)
WITH (lists = 100);

-- 4) Algunos datos crudos (sin embedding aún)
INSERT INTO reviews (text) VALUES
('El envío fue rapidísimo y llegó un día antes'),
('Buena calidad, repetiría la compra'),
('El empaque llegó dañado, pero atención al cliente respondió bien'),
('Me gustaría opciones más económicas'),
('Entrega tardía, experiencia regular');

2) Python: genera embeddings e inserta/actualiza

# pip install sentence-transformers psycopg2-binary
from sentence_transformers import SentenceTransformer
import psycopg2
import numpy as np

# Modelo liviano y popular (384 dims)
MODEL_NAME = "sentence-transformers/all-MiniLM-L6-v2"
model = SentenceTransformer(MODEL_NAME)

# Conexión a Postgres
conn = psycopg2.connect(
    host="localhost", port=5432,
    dbname="tu_db", user="tu_user", password="tu_pass"
)
conn.autocommit = True

# 1) Cargar textos sin embedding
with conn.cursor() as cur:
    cur.execute("SELECT id, text FROM reviews WHERE embedding IS NULL;")
    rows = cur.fetchall()

# 2) Generar embeddings y guardarlos
def to_pgvector(v: np.ndarray) -> list[float]:
    return [float(x) for x in v.tolist()]

for _id, txt in rows:
    emb = model.encode([txt], normalize_embeddings=True)[0]  # normaliza para cosine
    with conn.cursor() as cur:
        cur.execute(
            "UPDATE reviews SET embedding = %s WHERE id = %s;",
            (to_pgvector(emb), _id)
        )

3) Búsqueda semántica (consulta ≠ palabras exactas)

def search_reviews(query: str, k: int = 3):
    q_emb = model.encode([query], normalize_embeddings=True)[0]
    with conn.cursor() as cur:
        # <=> es distancia coseno en pgvector; cuanto menor, más parecido
        cur.execute("""
            SELECT id, text, 1 - (embedding <#> %s) AS cosine_similarity
            FROM reviews
            ORDER BY embedding <=> %s
            LIMIT %s;
        """, (to_pgvector(q_emb), to_pgvector(q_emb), k))
        return cur.fetchall()

# Ejemplos:
print(search_reviews("entrega rápida"))
print(search_reviews("busco alternativas baratas"))
print(search_reviews("mala experiencia con la entrega"))

En el SELECT:
- embedding <=> %s ordena por distancia coseno (menor = más similar).
- 1 - (embedding <#> %s) devuelve similitud coseno (mayor = más similar) solo para que la veas en el resultado.
Asegúrate de normalizar los embeddings (normalize_embeddings=True) si usarás coseno.

4) Variación para productos (catálogo)

Cambia el nombre de la tabla y los campos; el patrón es el mismo:

CREATE TABLE products (
  sku TEXT PRIMARY KEY,
  title TEXT NOT NULL,
  description TEXT,
  embedding vector(384)
);

CREATE INDEX ON products USING ivfflat (embedding vector_cosine_ops) WITH (lists = 200);

Embebe title || ' ' || description y consulta con frases como:

“zapatillas running económicas”
“notebook liviana para viajes”
“silla ergonómica para espalda”

5) Buenas prácticas rápidas

Dimensión del vector = la del modelo (p.ej., 384, 768, 1024…).
Normaliza embeddings para coseno (o usa inner product sin normalizar).
Batching al generar embeddings (mejor rendimiento).
Actualiza el índice IVFFLAT tras grandes cargas: REINDEX si hace falta.
Evalúa con consultas reales; guarda umbrales de similitud para filtrar ruido.

Lo interesante es que este mismo patrón se puede aplicar a:

E-commerce → buscar productos por intención, no solo por palabra exacta.
Soporte al cliente → encontrar tickets o FAQs similares aunque estén redactados distinto.
Gestión documental → navegar grandes volúmenes de textos de forma más humana.

En resumen, los embeddings no solo enriquecen la teoría, sino que están al alcance para transformar bases de datos tradicionales en motores de búsqueda inteligentes.