Inicio / Artículos

Cómo RAG permite a un LLM acceder a sus datos privados: fragmentos, vectores, prompts

Comprenda la generación mejorada por recuperación de información, desde su ingesta hasta la consulta, a través de un pequeño ejemplo en Node.js, tres modos de fallo comunes y una tabla que compara RAG con el ajuste fino de modelos.

Editor: REACTAPP.TOP8 min de lectura1766 palabras

Fuentes: RAG Explained: How Applications Give AI Access to Their Own Data

Los modelos de lenguaje escriben código, explican temas complejos y redactan ensayos, pero se detienen ante cualquier información privada. Si le preguntas a un modelo estándar sobre la hoja de ruta de un producto interno, una base de datos de clientes o los tickets de soporte de ayer, o bien admite su ignorancia o, peor aún, genera una falsedad creíble. Esa falsa confianza se denomina alucinación.

Una suposición común es que enseñar datos privados a un modelo implica un ajuste fino, que consiste en volver a entrenar sus pesos con conjuntos de datos personalizados. Para un acceso sencillo a datos en entornos de producción, el ajuste fino suele ser la opción incorrecta. Cuesta mucho, las actualizaciones son lentas y no evita de manera fiable las alucinaciones. En cambio, las aplicaciones de producción utilizan la generación reforzada por recuperación de información (RAG), que proporciona datos externos según sea necesario sin necesidad de volver a entrenar el modelo. Mientras que el ajuste fino equivale a semanas de estudio para un estudiante, RAG es como un examen con el libro abierto y la página correcta ya marcada.

Las tres palabras del nombre

  • Retrieval significa buscar en tu propia base de datos o almacén de documentos pasajes relacionados con la pregunta.
  • Augmented significa pegar esos pasajes directamente en el contexto de la instrucción.
  • Generation significa enviar la instrucción ampliada al LLM, el cual responde a partir de los hechos recuperados.

Sin RAG, el flujo es breve:

Without RAG:
[User Question] ──> [LLM] ──> [Answer based on generic training data]

Con RAG, hay un paso de búsqueda en el medio:

With RAG:
[User Question] ──> [Search Engine / Vector DB]
                          │
                          └──> [Relevant Documents]
                                     │
[User Question] + [Relevant Documents] ──> [LLM] ──> [Factual Answer]

Dado que el material de origen viaja junto con la instrucción, el modelo ya no necesita recordar hechos de sus parámetros congelados.

Por qué lo eligen los equipos

Surgen tres obstáculos al añadir funciones de IA a sistemas existentes:

  • Corte de conocimiento. Los datos de entrenamiento finalizan en una fecha específica, por lo que el modelo no puede saber qué ocurrió esta mañana ni qué devolvió una API hace dos segundos.
  • Privacidad. Los modelos públicos no pueden leer una wiki interna, un espacio de trabajo de Notion ni una base de datos de MongoDB.
  • Verificabilidad. Una respuesta generada a partir de la memoria no puede rastrearse hasta un registro de origen. Con RAG se sabe exactamente qué fragmento se incluyó en la instrucción, por lo que las citaciones son sencillas.

Un concepto erróneo frecuente es que el ajuste fino enseña nuevos hechos. En realidad, solo ajusta el tono, el estilo o el formato de salida. La recuperación de conocimientos factuales es para lo que sirve RAG.

Dos etapas

Un sistema de producción cuenta con una etapa de ingestión, que prepara los archivos con antelación, y una etapa de consulta, que atiende al usuario en tiempo real. La ingestión se ejecuta sin conexión:

1. Ingestion Pipeline (Offline / Background):
[Raw Documents] ──> [Chunking] ──> [Embedding Model] ──> [Vector Database]

La ruta de consulta se ejecuta en el momento de la solicitud:

2. Query Pipeline (Runtime):
[User Question] ──> [Embedding Model] ──> [Vector Search in DB]
                                                  │
                                                  ▼
[User Question] + [Top Matching Chunks] ──> [LLM] ──> [Final Answer]

Fragmentación

Un PDF de 300 páginas no puede procesarse con una sola consulta. Los documentos grandes se dividen en segmentos llamados fragmentos, generalmente de 200 a 800 palabras. Un fragmento debe ser lo suficientemente pequeño como para centrarse en una sola idea y lo suficientemente grande como para mantener su contexto.

Incrustación

Las computadoras no entienden las palabras, y la coincidencia de palabras clave como SQL LIKE '%refund%' falla cuando se utilizan sinónimos. Por eso cada fragmento pasa por un modelo de incrustación que devuelve una lista de números de punto flotante, un vector con quizás 1,536 entradas. Estos vectores ubican el significado en un espacio geométrico. Las frases con significados similares, como “¿Cómo cancelo?” y “Pasos para cerrar la cuenta”, quedan cerca unas de otras, mientras que las no relacionadas, como “Cómo hornear pan de masa madre”, quedan lejos.

Los vectores se almacenan junto al texto original en una base de datos vectorial como Pinecone, Qdrant, Milvus o PostgreSQL con la extensión pgvector.

Recuperación e inducción

Cuando llega una pregunta, el servidor la incrusta con el mismo modelo. La base de datos mide el ángulo entre el vector de la pregunta y cada vector almacenado (similitud coseno) y devuelve de tres a cinco fragmentos más cercanos. La aplicación luego los inserta en el prompt del sistema e instruye al LLM a responder utilizando únicamente ese material.

Un pequeño ejemplo funcional

Imaginemos una empresa de software que desea un asistente para responder preguntas relacionadas con su política interna de reembolsos. El archivo de ingesta comienza con la importación del cliente de OpenAI:

// ingest.js
import { OpenAI } from "openai";

y crea al cliente:

const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });

Una aplicación real cargaría documentos desde Markdown o un CMS, y esta muestra incluye algunos de forma codificada:

// In a real application, you would load these from Markdown files or a CMS
const documents = [
  {
    id: "doc_1",
    text: "Enterprise customers can request a full refund within 30 days of contract signing. Contact enterprise-support@example.com."
  },
  {
    id: "doc_2",
    text: "Monthly self-serve subscriptions are non-refundable once the billing cycle begins. Users can cancel anytime to avoid future charges."
  },
  {
    id: "doc_3",
    text: "Custom engineering work and onboarding packages are strictly non-refundable once the kickoff meeting has taken place."
  }
];

Un asistente convierte el texto en un embedding:

async function createEmbedding(text) {
  const response = await openai.embeddings.create({
    model: "text-embedding-3-small",
    input: text,
  });
  return response.data[0].embedding;
}

Otro construye la base de conocimientos incrustando cada documento:

export async function buildKnowledgeBase() {
  const embeddedDocs = [];
  for (const doc of documents) {
    const vector = await createEmbedding(doc.text);
    embeddedDocs.push({ ...doc, vector });
  }
  return embeddedDocs;
}

En producción, la base de datos vectorial realiza el cálculo de distancias entre millones de filas en milisegundos. Para una demostración, la similitud coseno puede calcularse a mano:

// search.js
function cosineSimilarity(vecA, vecB) {
  let dotProduct = 0;
  let normA = 0;
  let normB = 0;
  for (let i = 0; i < vecA.length; i++) {
    dotProduct += vecA[i] * vecB[i];
    normA += vecA[i] * vecA[i];
    normB += vecB[i] * vecB[i];
  }
  return dotProduct / (Math.sqrt(normA) * Math.sqrt(normB));
}

Y las mejores coincidencias seleccionadas:

export function findTopMatches(queryVector, knowledgeBase, topK = 2) {
  return knowledgeBase
    .map(doc => ({
      ...doc,
      score: cosineSimilarity(queryVector, doc.vector)
    }))
    .sort((a, b) => b.score - a.score)
    .slice(0, topK);
}

A continuación, un archivo une la consulta, los resultados de búsqueda y el LLM, comenzando por las importaciones:

// answer.js
import { OpenAI } from "openai";
import { createEmbedding, buildKnowledgeBase } from "./ingest.js";
import { findTopMatches } from "./search.js";

luego el cliente de nuevo:

const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });

La función principal primero incrusta la pregunta del usuario:

async function askKnowledgeBase(userQuestion, knowledgeBase) {
  // 1. Convert user question into an embedding
  const questionVector = await createEmbedding(userQuestion);

luego recupera los fragmentos principales:

  // 2. Retrieve top matching chunks
  const matches = findTopMatches(questionVector, knowledgeBase, 1);
  const contextText = matches.map(m => m.text).join("\n---\n");

luego crea un prompt ampliado:

  // 3. Augment prompt with retrieved context
  const systemPrompt = `
You are a helpful customer service assistant.
Answer the user's question using ONLY the context provided below.
If the context does not contain the answer, say "I do not have enough information to answer that."

que termina con el contexto inyectado:

Context:
${contextText}
`;

Y finalmente genera la respuesta:

  // 4. Generate answer
  const completion = await openai.chat.completions.create({
    model: "gpt-4o-mini",
    messages: [
      { role: "system", content: systemPrompt },
      { role: "user", content: userQuestion }
    ],
    temperature: 0.2, // Low temperature minimizes creative liberties
  });

Devolviendo el texto del modelo:

  return completion.choices[0].message.content;
}

El uso es así, con una pregunta sobre cómo obtener el reembolso tras un acuerdo empresarial:

// Example usage:
const knowledgeBase = await buildKnowledgeBase();
const answer = await askKnowledgeBase("I signed an enterprise deal 2 weeks ago, can I get my money back?", knowledgeBase);
console.log(answer);
// Output: Yes, enterprise customers can request a full refund within 30 days of contract signing. You can email enterprise-support@example.com to initiate the process.

La respuesta no provino de los pesos de entrenamiento generales del modelo. Obtuvo la respuesta precisa del pequeño fragmento inyectado en tiempo de ejecución.

Tres errores comunes

Un script breve hace que RAG parezca sencillo, pero los sistemas reales fallan de tres maneras recurrentes.

Cortar el texto en longitudes fijas. Dividir cada 500 caracteres separa palabras, oraciones y tablas. Si una oración que describe una condición vital se divide en dos fragmentos, ambos pierden su significado. La solución es dividir el texto siguiendo límites naturales como párrafos, encabezados o secciones de Markdown, y añadir solapamiento, por ejemplo, fragmentos de 500 tokens que compartan 50 tokens.

Depender únicamente de los vectores. La búsqueda vectorial comprende conceptos, pero maneja mal las cadenas de texto exactas. Una búsqueda de un número de factura como INV-2026-09 puede devolver facturas que solo parecen similares. La solución es la búsqueda híbrida: combinar la búsqueda por palabras clave como BM25 o texto completo con la búsqueda vectorial, y fusionar las puntuaciones mediante un método como Reciprocal Rank Fusion (RRF).

Sobrecargar el prompt. Las ventanas de contexto siguen creciendo, pero enviar 50 fragmentos disminuye la calidad. Los modelos recuerdan mejor el material al principio o al final de un prompt, y la parte central tiende a perderse. Obtenga solo los tres o cinco fragmentos más confiables. Si es necesario examinar más documentos, ejecute un reclasificador ligero como Cohere Rerank antes del LLM principal.

RAG o ajuste fino

<语存储 y llamadas API habituales
Dimensión RAG Ajuste fino
Objetivo principal Suministrar datos factuales y actualizables Enseñar un estilo, dialecto o sintaxis estricta
Actualizaciones Inmediatas, al editar los registros de la base de datos Lentas, requieren nuevos datos y reentrenamiento
Riesgo de alucinaciones Bajo, limitado por el contexto proporcionado De moderado a alto
Citas Están integradas, ya que se conoce el ID del fragmento Imposibles, los hechos se mezclan con los pesos
Costo de mantenimientoAlto costo de entrenamiento y alojamiento en GPU

Cuando los datos cambian diariamente, semanalmente o por hora, el ajuste fino resulta impráctico, y RAG es la arquitectura diseñada para conocimiento dinámico.

Comenzando

La parte más difícil al desarrollar con LLMs es el respaldo en hechos, no la inteligencia del modelo. RAG conecta un modelo base estático con datos privados y en constante cambio, y al combinar una buena capa de recuperación con un prompt mejorado, se convierte a un generador de texto impredecible en un sistema que ofrece respuestas verificables. Un punto de partida sensato: elegir un almacén de vectores, dividir los documentos en fragmentos adecuados y verificar que la recuperación realmente encuentre el contexto correcto antes de culpar al LLM por una respuesta deficiente.