Artículo

Embeddings y bases de datos vectoriales explicados con Java

Qué es un embedding, cómo se mide la similitud entre textos con el coseno y para qué sirve una base de datos vectorial, con ejemplos en Java.

En resumen: un embedding convierte un texto en un vector de números de forma que textos con significado parecido quedan cerca. La cercanía se mide normalmente con la similitud del coseno (1 = misma dirección). Una base de datos vectorial guarda millones de esos vectores y encuentra los más cercanos a una consulta en milisegundos. Es la base de la búsqueda semántica y de RAG. Ejemplos probados en Java 25 y con Spring AI 2.0.2 y el modelo mxbai-embed-large.

Vídeo explicativo

La idea con vectores de juguete

Imagina vectores de cuatro dimensiones, una por tema: programación, comida, deporte y viajes. Un modelo real usa cientos o miles de dimensiones que no tienen un significado legible, pero el cálculo es el mismo.

import java.util.Comparator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

public class Main {
    // Vectores de juguete de 4 dimensiones: [programación, comida, deporte, viajes]
    // Un modelo real produce cientos o miles de dimensiones; la idea es la misma.
    static final Map<String, double[]> DOCUMENTOS = new LinkedHashMap<>();

    static {
        DOCUMENTOS.put("Cómo crear una API REST con Spring Boot", new double[] {0.95, 0.02, 0.01, 0.05});
        DOCUMENTOS.put("Receta de paella valenciana", new double[] {0.01, 0.97, 0.02, 0.20});
        DOCUMENTOS.put("Rutina de entrenamiento para correr 10 km", new double[] {0.03, 0.10, 0.96, 0.05});
        DOCUMENTOS.put("Guía de JUnit 5 y Mockito", new double[] {0.90, 0.01, 0.02, 0.01});
        DOCUMENTOS.put("Qué ver en Valencia en dos días", new double[] {0.02, 0.45, 0.05, 0.92});
    }

    static double coseno(double[] a, double[] b) {
        double punto = 0;
        double na = 0;
        double nb = 0;
        for (int i = 0; i < a.length; i++) {
            punto += a[i] * b[i];
            na += a[i] * a[i];
            nb += b[i] * b[i];
        }
        return punto / (Math.sqrt(na) * Math.sqrt(nb));
    }

    static void buscar(String pregunta, double[] vector, int k) {
        System.out.println("Pregunta: " + pregunta);
        List<Map.Entry<String, double[]>> top = DOCUMENTOS.entrySet().stream()
                .sorted(Comparator.comparingDouble((Map.Entry<String, double[]> e) -> coseno(vector, e.getValue())).reversed())
                .limit(k)
                .toList();
        for (Map.Entry<String, double[]> e : top) {
            System.out.printf("  %.3f  %s%n", coseno(vector, e.getValue()), e.getKey());
        }
    }

    public static void main(String[] args) {
        buscar("¿Cómo pruebo mi código Java?", new double[] {0.92, 0.0, 0.03, 0.0}, 2);
        buscar("Dónde comer arroz en Valencia", new double[] {0.0, 0.80, 0.0, 0.55}, 2);
    }
}

Salida:

Pregunta: ¿Cómo pruebo mi código Java?
  1.000  Guía de JUnit 5 y Mockito
  0.998  Cómo crear una API REST con Spring Boot
Pregunta: Dónde comer arroz en Valencia
  0.921  Receta de paella valenciana
  0.870  Qué ver en Valencia en dos días

Ninguna búsqueda comparte palabras exactas con el documento que encuentra: se compara el significado representado en el vector, no el texto. Eso es la búsqueda semántica.

Con un modelo de embeddings real

Con Spring AI, un EmbeddingModel genera los vectores. Usamos mxbai-embed-large en Ollama:

float[] base = embeddingModel.embed("¿Cómo hago pruebas unitarias en Java?");
System.out.println("Dimensiones del vector: " + base.length);
for (String frase : List.of(
        "Tutorial de JUnit 5 y Mockito",
        "Testing de código Java con mocks",
        "Receta de tortilla de patatas",
        "How do I write unit tests in Java?")) {
    System.out.printf("  %.3f  %s%n", coseno(base, embeddingModel.embed(frase)), frase);
}
Dimensiones del vector: 1024
  0.721  Tutorial de JUnit 5 y Mockito
  0.707  Testing de código Java con mocks
  0.540  Receta de tortilla de patatas
  0.683  How do I write unit tests in Java?

Tres observaciones. Las frases relacionadas puntúan alto aunque no compartan palabras. La receta puntúa 0,54, no 0: en modelos reales las puntuaciones se concentran en un rango y lo que importa es el orden, no el valor absoluto. Y la pregunta en inglés queda muy cerca de la española: muchos modelos de embeddings son multilingües.

Para qué sirve una base de datos vectorial

Comparar la consulta con cada vector uno a uno (como en el ejemplo) funciona con cientos de documentos. Con millones es demasiado lento. Una base de datos vectorial usa índices de vecinos más cercanos aproximados (por ejemplo, HNSW) que encuentran los vectores más parecidos sin recorrerlos todos, a cambio de una pequeña pérdida de precisión.

OpciónCuándo encaja
PGVector (extensión de PostgreSQL)Ya usas PostgreSQL y quieres una sola base de datos
RedisYa lo tienes y buscas latencia muy baja
Qdrant, Milvus, Weaviate, ChromaAlmacén vectorial dedicado, mucho volumen
Elasticsearch u OpenSearchCombinar búsqueda por texto y por vector
SimpleVectorStore de Spring AIAprender y hacer pruebas: vive en memoria

Spring AI ofrece la misma interfaz VectorStore para todas, así que cambiar de una a otra apenas toca el código.

Usos más allá de RAG

  • Búsqueda semántica en una tienda o una documentación.
  • Recomendaciones: artículos parecidos al que estás leyendo.
  • Detección de duplicados: tickets de soporte que describen el mismo problema.
  • Clasificación y agrupación de textos sin etiquetas previas.
  • Caché semántica: reutilizar la respuesta a una pregunta casi idéntica a otra anterior.

Preguntas frecuentes

¿Puedo comparar vectores de modelos distintos?

No. Cada modelo tiene su propio espacio: indexa y busca siempre con el mismo modelo, y reindexa si lo cambias.

¿Coseno, producto escalar o distancia euclídea?

Si los vectores están normalizados (longitud 1), el coseno y el producto escalar ordenan igual. Usa la métrica que recomiende el modelo; la mayoría están pensados para coseno.

¿Cuánto ocupa un embedding?

Un vector de 1.024 números float ocupa unos 4 KB. Un millón de fragmentos son unos 4 GB solo en vectores, sin contar el índice.

Sigue aprendiendo

Embeddings, almacenes vectoriales y búsqueda semántica en producción son parte del curso de Spring AI 2.0 y del máster AI Engineer con Java y Spring AI. El siguiente paso es RAG con Spring AI.

embeddings base de datos vectorial búsqueda semántica similitud coseno spring ai java

Newsletter Semanal de Java

Cada viernes recibe lo más nuevo del ecosistema Java: frameworks, herramientas y mejores prácticas.

Sin spam. Cancela cuando quieras.

Compartir artículo