La tecnología RAG (Retrieval-Augmented Generation) permite a los sistemas combinar la recuperación de información con la generación de texto, mejorando la precisión y actualización de las respuestas. Para los desarrolladores, dominar sus componentes esenciales es clave para implementar soluciones robustas.

Componentes Principales de RAG

Un sistema RAG típico consta de módulos para vectorización, búsqueda, construcción de contexto y generación. A continuación, se detalla cada uno.

1. Vectorización de Textos: De Palabras a Representaciones Numéricas

Los embeddings convierten texto en vectores de alta dimensionalidad, capturando relaciones semánticas. Modelos como Qwen3 o BGE ofrecen distintas dimensiones para equilibrar precisión y eficiencia.

import numpy as np

def calcular_similitud_coseno(vector_a, vector_b):
    producto_escalar = np.dot(vector_a, vector_b)
    norma_a = np.linalg.norm(vector_a)
    norma_b = np.linalg.norm(vector_b)
    if norma_a == 0 or norma_b == 0:
        return 0.0
    return producto_escalar / (norma_a * norma_b)

# Ejemplo simplificado de embeddings
embeddings_ejemplo = {
    "tecnología": [0.8, 0.2, 0.1],
    "informática": [0.7, 0.3, 0.15],
    "cocina": [0.1, 0.9, 0.05]
}

# Calcular similitud entre conceptos
sim_tec_info = calcular_similitud_coseno(embeddings_ejemplo["tecnología"], embeddings_ejemplo["informática"])
sim_tec_coc = calcular_similitud_coseno(embeddings_ejemplo["tecnología"], embeddings_ejemplo["cocina"])
print(f"Similitud tecnología-informática: {sim_tec_info:.4f}")
print(f"Similitud tecnología-cocina: {sim_tec_coc:.4f}")

2. Búsqueda por Similitud: Recuperación Eficiente de Documentos

La búsqueda vectorial identifica documentos relevantes mediante métricas como la similitud coseno. Esto reemplaza las limitaciones de la búsqueda por palabras clave.

def busqueda_vectorial(consulta_vector, vectores_documentos, k=3):
    puntuaciones = []
    for doc_id, vector_doc in vectores_documentos.items():
        puntuacion = calcular_similitud_coseno(consulta_vector, vector_doc)
        puntuaciones.append((doc_id, puntuacion))
    puntuaciones.sort(key=lambda x: x[1], reverse=True)
    return puntuaciones[:k]

# Datos de ejemplo
vector_consulta = [0.75, 0.25, 0.12]
vectores_docs = {
    "doc1": [0.7, 0.3, 0.1],
    "doc2": [0.1, 0.9, 0.05],
    "doc3": [0.65, 0.28, 0.13]
}

resultados = busqueda_vectorial(vector_consulta, vectores_docs)
print("Documentos más relevantes:", resultados)

3. Construcción de Contexto: Organización Inteligente de la Información

El contexto se ensambla a partir de los documentos recuperados, controlando la longitud y priorizando la relevancia para optimizar la entrada al modelo de lenguaje.

def ensamblar_contexto(documentos_recuperados, max_caracteres=3000):
    fragmentos = []
    longitud_actual = 0
    for i, (doc_id, contenido) in enumerate(documentos_recuperados, 1):
        texto_formateado = f"[Fuente {i}]: {contenido}\n"
        if longitud_actual + len(texto_formateado) > max_caracteres:
            break
        fragmentos.append(texto_formateado)
        longitud_actual += len(texto_formateado)
    return "\n".join(fragmentos)

4. Generación de Respuestas: Integración con Modelos de Lenguaej

La genercaión utiliza prompts estructurados que incluyen el contexto y la consulta del usuario, guando al LLM para producir respuestas basadas en evidencia.

def crear_prompt_rag(consulta, contexto):
    plantilla = """Basándote exclusivamente en la siguiente información, responde de manera precisa y concisa.

Información proporcionada:
{contexto}

Pregunta del usuario:
{consulta}

Respuesta:"""
    return plantilla.format(contexto=contexto, consulta=consulta)

5. Evaluación del Sistema: Métricas de Calidad

La evaluación incluye métricas de recuperación (precisión, recall) y de generación (exactitud, relevancia) para garantizar el rendimiento del sistema.

def evaluar_recuperacion(documentos_recuperados_ids, documentos_relevantes_ids, k=5):
    recuperados = set(documentos_recuperados_ids[:k])
    relevantes = set(documentos_relevantes_ids)
    aciertos = len(recuperados.intersection(relevantes))
    precision = aciertos / k if k > 0 else 0
    recall = aciertos / len(relevantes) if relevantes else 0
    return {"precision": precision, "recall": recall}

# Ejemplo de uso
docs_recuperados = ["id1", "id3", "id5", "id7", "id9"]
docs_relevantes = ["id1", "id3", "id4"]
metricas = evaluar_recuperacion(docs_recuperados, docs_relevantes)
print("Métricas de recuperación:", metricas)

Consideraciones Prácticas y Tendencias

En 2025, los modelos como Qwen3-Ebmedding soportan tecnologías como MRL para flexibilidad dimensional, y la optimización de chunks y caché es crucial para el rendimiento en producción. La elección del modelo depende del idioma, precisión requerida y restricciones de costo.