RAG y su implementación práctica con LangChain, Bun, Ollama y Qdrant

Los Modelos de Lenguaje de Gran Escala (LLMs) modernos son impresionantes, pero tienen una limitación importante: su conocimiento está fijado en sus pesos, lo que dificulta la actualización y extensión de su conocimiento. Retrieval-Augmented Generation (RAG) es un enfoque diseñado para abordar este problema. Introducido por Meta en 2020, conecta un modelo de lenguaje a una base de conocimiento externa (por ejemplo, un conjunto de documentos) para que pueda incorporar información actualizada y específica en sus respuestas. En la práctica, para cada pregunta formulada, el sistema RAG primero extrae contenido relevante de su base documental, luego genera una respuesta combinando este contexto recuperado con las capacidades lingüísticas del LLM.

Nota: El código fuente completo del proyecto de ejemplo mencionado en este artículo está disponible en GitHub.

Esquema del artículo

1. ¿Qué es RAG y por qué utilizarlo?

   • Principio de funcionamiento
   • Ventajas sobre enfoques clásicos
   • Casos de uso concretos

2. Arquitectura de un sistema RAG

   • Componentes esenciales
   • Flujo de datos
   • Elección tecnológica

3. Implementación práctica con TypeScript

   • Configuración del proyecto con Bun
   • Integración de LangChain
   • Configuración de Ollama y Qdrant

4. Análisis de código y mejores prácticas

   • Indexación de documentos
   • Búsqueda semántica
   • Generación de respuestas

5. Ventajas del stack tecnológico

   • Rendimiento de Bun vs. Node.js
   • Simplicidad de LangChain
   • Flexibilidad de Ollama
   • Escalabilidad de Qdrant

6. Temas avanzados

   • Optimizaciones avanzadas
   • Evaluación y métricas
   • Alternativas tecnológicas

¿Qué es RAG y por qué utilizarlo?

Retrieval-Augmented Generation (RAG) significa literalmente "generación aumentada por recuperación". La idea es separar el conocimiento del modelo. En lugar de intentar incorporar toda la información en los parámetros de un LLM (mediante costosos fine-tuning) o diseñar un modelo clásico que prediga respuestas a partir de datos, permitimos que el modelo principal genere texto y lo aumentamos con una fase intermedia de recuperación de información. Una típica pipeline RAG funciona así:

1. Consulta del usuario – El usuario plantea una pregunta o introduce una solicitud en lenguaje natural (por ejemplo, "¿Para qué se utiliza la clase X en este proyecto?").
2. Búsqueda de documentos relevantes – El sistema transforma esta pregunta en una representación vectorial (embedding) y luego consulta una base de datos vectorial para recuperar documentos o pasajes semánticamente más similares a la consulta. Esto identifica el contexto relevante (por ejemplo, un extracto de la documentación, código o un artículo que corresponde a la pregunta).
3. Combinación contexto + pregunta – Los documentos o extractos recuperados se proporcionan al modelo de lenguaje como contexto. En la práctica, se insertan en el prompt del LLM, típicamente a través de un mensaje de sistema o añadiendo el texto de los documentos encontrados a la pregunta del usuario.
4. Generación de respuesta – El modelo de lenguaje (LLM) genera entonces una respuesta basada tanto en la pregunta como en el contexto proporcionado. La respuesta debería contener información de los documentos, formulada de manera coherente gracias a las capacidades del LLM.

Este proceso permite al modelo basarse en conocimientos externos específicos en el momento de la generación, sin tener que memorizarlos permanentemente. Puede compararse con un ser humano que, ante una pregunta, consultaría libros o documentos de referencia antes de responder: el LLM "consulta su biblioteca" antes de hablar.

Casos de uso concretos para RAG

El enfoque RAG es particularmente útil cuando un asistente conversacional debe gestionar una base de conocimiento en evolución o extensa. Aquí hay algunos ejemplos de casos de uso concretos en los que RAG sobresale en comparación con los métodos clásicos:

Chatbots documentales: Un asistente alimentado por la documentación técnica de una empresa, capaz de responder a preguntas de desarrolladores o clientes extrayendo directamente de manuales, bases de conocimiento internas o incluso código fuente. Por ejemplo, el modelo puede estar conectado a especificaciones de API o al código de un proyecto de código abierto para explicar cómo funciona una función o por qué se eligió un diseño determinado.

FAQ dinámicas: En un contexto de servicio al cliente, un chatbot RAG puede responder a preguntas frecuentes (FAQ) basándose en las últimas políticas o datos de producto. Si una política (por ejemplo, condiciones de devolución) cambia, solo es necesario actualizar el documento de referencia y el bot lo tendrá en cuenta inmediatamente, sin necesidad de reentrenamiento. Esto lleva a FAQ siempre actualizadas con la posibilidad de citar la fuente de información para respaldar la respuesta.

Asistentes legales: Un asistente puede ayudar a abogados o juristas encontrando pasajes relevantes en una base de datos de leyes, jurisprudencia o contratos para una determinada pregunta, y luego formulando la respuesta en lenguaje natural. El modelo no necesita conocer de memoria todo el código civil; solo debe buscar los artículos pertinentes. Lo mismo se aplica a un asistente médico que podría consultar bases de datos de publicaciones científicas o protocolos médicos para proporcionar respuestas basadas en los conocimientos clínicos más recientes.

Asistente de programación: Este es el caso de nuestro proyecto de ejemplo – un asistente que conoce el contenido de un repositorio de código y puede responder a preguntas sobre este código (arquitectura, rol de un módulo, posibles errores, etc.). En lugar de entrenar un modelo especializado en programación, utilizamos un LLM generalista aumentado por la búsqueda de archivos de código relevantes en el repositorio.

Arquitectura de un sistema RAG

Componentes esenciales

Un sistema RAG completo típicamente incluye los siguientes componentes:

1. Indexación y almacenamiento

   • Procesador de documentos (extracción, limpieza, chunking)
   • Generador de embeddings (transformación en vectores)
   • Base de datos vectorial (almacenamiento y búsqueda)

2. Pipeline de consulta

   • Preprocesador de consultas
   • Motor de búsqueda semántica
   • Generador de prompts

3. Generación y postprocesamiento

   • Interfaz LLM
   • Evaluador de respuestas
   • Formateador de salida

Flujo de datos

typescript
1// Ejemplo simplificado del flujo de datos en un sistema RAG
2async function processQuery(query: string): Promise<string> {
3  // 1. Transforma la consulta en un embedding
4  const queryEmbedding = await embedder.embedQuery(query);
5  
6  // 2. Busca documentos relevantes
7  const relevantDocs = await vectorStore.similaritySearch(queryEmbedding);
8  
9  // 3. Construye el prompt con contexto
10  const prompt = buildPromptWithContext(query, relevantDocs);
11  
12  // 4. Genera la respuesta con el LLM
13  const response = await llm.generate(prompt);
14  
15  return response;
16}

Elección tecnológica

Para nuestra implementación, hemos elegido un stack moderno y potente:

• Bun: Entorno de ejecución JavaScript ultrarrápido, ideal para aplicaciones de servidor
• TypeScript: Tipado estático para una mejor mantenibilidad
• LangChain: Framework para crear aplicaciones basadas en LLM
• Ollama: Herramienta para ejecutar modelos de lenguaje localmente
• Qdrant: Base de datos vectorial potente y fácil de implementar

Esta combinación ofrece un excelente equilibrio entre rendimiento, comodidad de desarrollo y flexibilidad.

Implementación práctica con TypeScript

Configuración del proyecto con Bun

Comencemos con la inicialización de nuestro proyecto:

bash
1# Creación del proyecto
2mkdir rag-code-assistant
3cd rag-code-assistant
4bun init
5
6# Instalación de dependencias
7bun add langchain @langchain/community @langchain/openai
8bun add qdrant-js ollama
9bun add -d typescript @types/node

Configuración básica

typescript
1// src/config.ts
2export const CONFIG = {
3  // Configuración de Ollama
4  OLLAMA_BASE_URL: 'http://localhost:11434',
5  OLLAMA_MODEL_NAME: 'llama3',
6  
7  // Configuración de Qdrant
8  QDRANT_URL: 'http://localhost:6333',
9  QDRANT_COLLECTION_NAME: 'code_repository',
10  
11  // Configuración de indexación
12  CHUNK_SIZE: 1000,
13  CHUNK_OVERLAP: 200,
14  
15  // Ruta al repositorio de código a indexar
16  REPOSITORY_PATH: './repository',
17};

Indexación de documentos

La indexación es una fase crucial en un sistema RAG. Implica la conversión de documentos en bruto en chunks de tamaño apropiado y luego la generación de embeddings para cada chunk.

typescript
1// src/indexer.ts
2import { DirectoryLoader } from 'langchain/document_loaders/fs/directory';
3import { RecursiveCharacterTextSplitter } from 'langchain/text_splitter';
4import { OllamaEmbeddings } from '@langchain/community/embeddings/ollama';
5import { QdrantClient } from 'qdrant-js';
6import { CONFIG } from './config';
7
8export async function indexRepository() {
9  // 1. Carga de archivos del repositorio
10  const loader = new DirectoryLoader(
11    CONFIG.REPOSITORY_PATH,
12    {
13      '.ts': (path) => new TextLoader(path),
14      '.js': (path) => new TextLoader(path),
15      '.tsx': (path) => new TextLoader(path),
16      '.jsx': (path) => new TextLoader(path),
17      '.md': (path) => new TextLoader(path),
18    }
19  );
20  
21  const docs = await loader.load();
22  console.log(`Carga de ${docs.length} archivos completada`);
23  
24  // 2. División en chunks
25  const textSplitter = new RecursiveCharacterTextSplitter({
26    chunkSize: CONFIG.CHUNK_SIZE,
27    chunkOverlap: CONFIG.CHUNK_OVERLAP,
28  });
29  
30  const chunks = await textSplitter.splitDocuments(docs);
31  console.log(`Creación de ${chunks.length} chunks completada`);
32  
33  // 3. Generación de embeddings
34  const embeddings = new OllamaEmbeddings({
35    baseUrl: CONFIG.OLLAMA_BASE_URL,
36    model: CONFIG.OLLAMA_MODEL_NAME,
37  });
38  
39  // 4. Almacenamiento en Qdrant
40  const qdrant = new QdrantClient({ url: CONFIG.QDRANT_URL });
41  
42  // Creación de la colección si no existe
43  try {
44    await qdrant.createCollection(CONFIG.QDRANT_COLLECTION_NAME, {
45      vectors: {
46        size: 1536, // Tamaño de los vectores de embedding
47        distance: 'Cosine',
48      },
49    });
50  } catch (e) {
51    console.log('Colección ya existente o error:', e.message);
52  }
53  
54  // Inserción de documentos con sus embeddings
55  for (let i = 0; i < chunks.length; i += 100) {
56    const batch = chunks.slice(i, i + 100);
57    const batchEmbeddings = await embeddings.embedDocuments(
58      batch.map(chunk => chunk.pageContent)
59    );
60    
61    await qdrant.upsert(CONFIG.QDRANT_COLLECTION_NAME, {
62      points: batchEmbeddings.map((vector, idx) => ({
63        id: `${i + idx}`,
64        vector,
65        payload: {
66          text: batch[idx].pageContent,
67          metadata: batch[idx].metadata,
68        },
69      })),
70    });
71    
72    console.log(`Procesamiento del lote ${i}-${i + batch.length} completado`);
73  }
74  
75  console.log('Indexación completada con éxito!');
76}

Búsqueda y generación de respuestas

typescript
1// src/rag.ts
2import { OllamaEmbeddings } from '@langchain/community/embeddings/ollama';
3import { QdrantClient } from 'qdrant-js';
4import { Ollama } from '@langchain/community/llms/ollama';
5import { CONFIG } from './config';
6
7export async function generateResponse(query: string): Promise<string> {
8  // 1. Inicialización de componentes
9  const embeddings = new OllamaEmbeddings({
10    baseUrl: CONFIG.OLLAMA_BASE_URL,
11    model: CONFIG.OLLAMA_MODEL_NAME,
12  });
13  
14  const qdrant = new QdrantClient({ url: CONFIG.QDRANT_URL });
15  
16  const llm = new Ollama({
17    baseUrl: CONFIG.OLLAMA_BASE_URL,
18    model: CONFIG.OLLAMA_MODEL_NAME,
19  });
20  
21  // 2. Generación del embedding de la consulta
22  const queryEmbedding = await embeddings.embedQuery(query);
23  
24  // 3. Búsqueda de documentos relevantes
25  const searchResults = await qdrant.search(CONFIG.QDRANT_COLLECTION_NAME, {
26    vector: queryEmbedding,
27    limit: 5,
28  });
29  
30  const relevantDocs = searchResults.map(result => result.payload.text).join('\n\n');
31  
32  // 4. Creación del prompt con contexto
33  const prompt = `
34  Eres un asistente de programación experto que ayuda a entender el código fuente de un proyecto.
35  Utiliza el siguiente contexto para responder a la pregunta del usuario.
36  Si no puedes encontrar la información en el contexto, indícalo claramente.
37  
38  CONTEXTO:
39  ${relevantDocs}
40  
41  PREGUNTA: ${query}
42  
43  RESPUESTA:
44  `;
45  
46  // 5. Generación de la respuesta
47  const response = await llm.call(prompt);
48  
49  return response;
50}

Interfaz de usuario simple

typescript
1// src/index.ts
2import { indexRepository } from './indexer';
3import { generateResponse } from './rag';
4
5async function main() {
6  // Argumento para indexación o consulta
7  const args = process.argv.slice(2);
8  
9  if (args[0] === 'index') {
10    console.log('Iniciando indexación...');
11    await indexRepository();
12  } else if (args[0] === 'query') {
13    const query = args.slice(1).join(' ');
14    if (!query) {
15      console.log('Uso: bun run src/index.ts query "Tu pregunta sobre el código"');
16      process.exit(1);
17    }
18    
19    console.log(`Pregunta: ${query}`);
20    console.log('Generando respuesta...');
21    const response = await generateResponse(query);
22    console.log('\nRespuesta:');
23    console.log(response);
24  } else {
25    console.log('Uso: bun run src/index.ts [index|query "Tu pregunta"]');
26  }
27}
28
29main().catch(console.error);

Análisis de código y mejores prácticas

Chunking eficiente

La división de documentos en chunks es una fase crítica que influye directamente en la calidad de los resultados. Algunas mejores prácticas:

• Tamaño apropiado: Los chunks deberían ser lo suficientemente grandes para contener contexto, pero no demasiado grandes para seguir siendo relevantes (típicamente entre 500 y 1500 caracteres).
• Solapamiento: El solapamiento entre chunks previene la pérdida de contexto en los límites.
• División semántica: Idealmente, la división debería respetar la estructura semántica de los documentos (párrafos, funciones, etc.).

Optimización de búsqueda

La calidad de la búsqueda semántica es esencial:

• Filtros de metadatos: Utilizar metadatos (tipo de archivo, fecha, autor) para refinar búsquedas.
• Re-ranking: Aplicar un segundo nivel de filtro para mejorar la relevancia.
• Diversidad: Asegurar la diversidad de resultados para cubrir diferentes aspectos de la pregunta.

Prompting avanzado

La construcción de prompts es un arte que influye fuertemente en la calidad de las respuestas:

typescript
1// Ejemplo de un prompt más avanzado
2const prompt = `
3# ROL
4Eres un asistente de programación experto especializado en el análisis de código fuente.
5
6# CONTEXTO
7${relevantDocs}
8
9# INSTRUCCIONES
10- Responde a la pregunta del usuario basándote solo en el contexto proporcionado
11- Si el contexto no contiene la información necesaria, indícalo claramente
12- Cita fragmentos de código relevantes en tu respuesta
13- Explica el código de manera pedagógica
14- Sugiere mejoras si identificas alguna
15
16# PREGUNTA
17${query}
18`;

Ventajas del stack tecnológico

Rendimiento de Bun vs. Node.js

Bun ofrece ventajas significativas para este tipo de aplicación:

• Inicio rápido: Tiempo de inicio hasta 4 veces más rápido que Node.js
• Ejecución optimizada: Rendimiento de ejecución superior, especialmente para operaciones I/O
• Bundler integrado: Simplificación del flujo de trabajo de desarrollo

Simplicidad de LangChain

LangChain simplifica notablemente el desarrollo de aplicaciones basadas en LLM:

• Abstracción: Interfaz unificada para diferentes modelos y proveedores
• Componentes reutilizables: Chains, Agents y Tools listos para usar
• Patrones establecidos: Implementaciones de referencia para casos de uso comunes

Flexibilidad de Ollama

Ollama permite ejecutar modelos de lenguaje localmente con gran flexibilidad:

• Modelos locales: Sin dependencia de APIs externas
• Privacidad: Los datos permanecen en tu infraestructura
• Personalización: Posibilidad de adaptar los modelos a tus necesidades

Escalabilidad de Qdrant

Qdrant es una base de datos vectorial moderna diseñada para búsqueda semántica:

• Rendimiento: Optimizado para búsquedas de similitud rápidas
• Filtrado: Capacidades de filtrado avanzadas para metadatos
• Despliegue flexible: Utilizable en modo embebido o como servicio

Temas avanzados

Optimizaciones avanzadas

• Búsqueda híbrida: Combinación de búsqueda vectorial y búsqueda por palabras clave
• Chunking jerárquico: Uso de diferentes niveles de granularidad para los chunks
• Caching: Almacenamiento en caché de resultados de búsqueda y respuestas frecuentes

Evaluación y métricas

Para medir la calidad de un sistema RAG:

• Relevancia: ¿Los documentos recuperados son relevantes para la pregunta?
• Fidelidad: ¿La respuesta es fiel a los documentos de origen?
• Utilidad: ¿La respuesta responde eficazmente a la pregunta del usuario?

Alternativas tecnológicas

• Frameworks: Haystack, LlamaIndex como alternativas a LangChain
• Bases de datos vectoriales: Pinecone, Weaviate, Milvus como alternativas a Qdrant
• Modelos: Varios modelos locales (Llama, Mistral) o APIs (OpenAI, Anthropic)

Conclusión

El Retrieval-Augmented Generation representa un avance significativo en la forma en que podemos utilizar los modelos de lenguaje para casos de uso específicos. Al separar el conocimiento del modelo de generación, RAG permite crear asistentes de IA más precisos, actualizados y transparentes.

Nuestra implementación con TypeScript, Bun, LangChain, Ollama y Qdrant demuestra que ahora es posible construir potentes sistemas RAG con tecnologías modernas y accesibles. Este enfoque allana el camino para una nueva generación de asistentes de IA capaces de razonar sobre bases de conocimiento específicas mientras mantienen la fluidez y coherencia de los grandes modelos de lenguaje.

No dudes en explorar el código fuente completo en GitHub y adaptarlo a tus propios casos de uso. RAG es una tecnología en evolución, y hay numerosas oportunidades de innovación en este emocionante campo.