Artículo

Qué es RAG y cómo implementarlo en Java con Spring AI

Qué es RAG (Retrieval-Augmented Generation), cómo funciona paso a paso y cómo implementarlo en Java con Spring AI 2.0, con la diferencia real con y sin RAG.

En resumen: RAG (Retrieval-Augmented Generation) consiste en buscar primero los fragmentos de tus documentos relevantes para la pregunta y pasarlos al modelo junto con ella, para que responda con tu información y no con lo que memorizó al entrenarse. En Spring AI se monta con un VectorStore (donde guardas los documentos como embeddings) y el advisor QuestionAnswerAdvisor. En nuestra prueba, sin RAG el modelo no sabía el plazo de reembolso; con RAG respondió «14 días» citando el documento. Probado con Spring AI 2.0.2 y modelos locales en Ollama.

Vídeo explicativo

Por qué hace falta

Un modelo de lenguaje no conoce tus documentos internos, tus precios ni nada posterior a su entrenamiento. Si le preguntas, puede inventar una respuesta convincente. Reentrenarlo es caro y lento; RAG le da la información en el momento de la pregunta.

Cómo funciona

INGESTA (una vez, o cuando cambian los documentos)
  documentos ──► trocear (chunks) ──► embeddings ──► vector store

CONSULTA (en cada pregunta)
  pregunta ──► embedding ──► búsqueda por similitud ──► top-K fragmentos
           └─────────────────────────────────────────────────┐
                                                             ▼
                        prompt = instrucciones + fragmentos + pregunta ──► LLM ──► respuesta
  1. Trocear los documentos en fragmentos de unos cientos de palabras.
  2. Convertir cada fragmento en un embedding: un vector de números que representa su significado. Lo explicamos en embeddings y bases de datos vectoriales.
  3. Guardarlos en un vector store (PGVector, Redis, Qdrant, Chroma…).
  4. En cada pregunta, buscar los fragmentos más parecidos y añadirlos al prompt.

Implementación con Spring AI

Dependencias (versiones del BOM spring-ai-bom:2.0.2):

<dependency>
  <groupId>org.springframework.ai</groupId>
  <artifactId>spring-ai-starter-model-ollama</artifactId>
</dependency>
<dependency>
  <groupId>org.springframework.ai</groupId>
  <artifactId>spring-ai-vector-store</artifactId>
</dependency>
<dependency>
  <groupId>org.springframework.ai</groupId>
  <artifactId>spring-ai-vector-store-advisor</artifactId>
</dependency>
spring.ai.ollama.chat.options.model=gpt-oss
spring.ai.ollama.embedding.options.model=mxbai-embed-large

Ingesta y consulta:

SimpleVectorStore store = SimpleVectorStore.builder(embeddingModel).build();
store.add(List.of(
        new Document("La academia ofrece reembolso completo durante los primeros 14 días tras la compra.", Map.of("fuente", "faq-pagos")),
        new Document("Los certificados se emiten al completar el 100% de las lecciones de un curso.", Map.of("fuente", "faq-certificados")),
        new Document("El máster de arquitectura incluye mentorías en directo cada dos semanas.", Map.of("fuente", "masters")),
        new Document("Los cursos gratuitos no incluyen certificado.", Map.of("fuente", "faq-certificados"))));

String pregunta = "¿Cuántos días tengo para pedir que me devuelvan el dinero?";

// Solo la búsqueda, para ver qué se recupera
List<Document> encontrados = store.similaritySearch(SearchRequest.builder().query(pregunta).topK(2).build());

ChatClient chat = builder.defaultSystem("Responde en español, en una frase, solo con la información del contexto.").build();
String sinRag = chat.prompt().user(pregunta).call().content();
String conRag = chat.prompt().user(pregunta)
        .advisors(QuestionAnswerAdvisor.builder(store).searchRequest(SearchRequest.builder().topK(2).build()).build())
        .call().content();

Resultado real:

Fragmentos recuperados para: ¿Cuántos días tengo para pedir que me devuelvan el dinero?
  0.589  [faq-pagos] La academia ofrece reembolso completo durante los primeros 14 días tras la compra.
  0.557  [faq-certificados] Los cursos gratuitos no incluyen certificado.
SIN RAG: No se especifica el número de días en el contexto.
CON RAG: Tienes 14 días para solicitar el reembolso completo.

La pregunta no contiene la palabra «reembolso», y aun así la búsqueda por significado encontró el fragmento correcto. El segundo fragmento no tiene relación: con topK(2) siempre se recuperan dos, por eso conviene fijar un umbral de similitud (similarityThreshold) en producción.

Una lección de la prueba: en una primera versión preguntamos «¿me dan certificado si hago un curso gratis?» y el modelo acertó también sin RAG, deduciéndolo por sentido común. Para comprobar que tu RAG aporta algo, pregunta cosas que el modelo no pueda adivinar.

SimpleVectorStore guarda todo en memoria y sirve para aprender y para pruebas. En producción usa un almacén persistente; con PostgreSQL, el starter de PGVector es el camino corto.

Qué hace que un RAG funcione bien

  • El troceado importa más que el modelo. Fragmentos demasiado grandes diluyen el significado; demasiado pequeños pierden contexto. Un solapamiento entre fragmentos ayuda.
  • Metadatos para filtrar (producto, idioma, fecha) y para citar la fuente en la respuesta.
  • Umbral de similitud para no meter fragmentos irrelevantes en el prompt.
  • Instrucciones claras: «responde solo con el contexto y di que no lo sabes si no aparece».
  • Evaluación: un conjunto de preguntas con su respuesta esperada para medir si los cambios mejoran o empeoran.
  • Permisos: si los documentos tienen distintos niveles de acceso, filtra la búsqueda por usuario; si no, el modelo puede revelar lo que el usuario no debería ver.

Preguntas frecuentes

¿RAG o fine-tuning?

RAG para que el modelo use información actualizada o privada. Fine-tuning para cambiar su estilo o enseñarle un formato. Lo habitual es empezar por RAG: es más barato y los datos se actualizan sin reentrenar.

¿Qué modelo de embeddings uso?

Uno que funcione bien en tu idioma. En la prueba usamos mxbai-embed-large (1.024 dimensiones) en local. Debes usar el mismo para indexar y para buscar.

¿Cómo meto PDFs o páginas web?

Spring AI incluye lectores de documentos (PDF, Tika, Markdown, JSON) y un TokenTextSplitter para trocear antes de añadir al vector store.

Sigue aprendiendo

RAG con PGVector, troceado, evaluación y despliegue se construyen en el curso de Spring AI 2.0 y en el máster AI Engineer con Java y Spring AI. Para que el modelo además ejecute acciones, tienes tool calling en Spring AI.

rag retrieval augmented generation spring ai llm java embeddings vector store

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