RAG (Retrieval-Augmented Generation)

El Retrieval-Augmented Generation representa una de las técnicas más efectivas para superar las limitaciones de los modelos de lenguaje tradicionales. Mientras que los LLMs poseen un conocimiento extenso pero estático, los sistemas RAG les permiten acceder a información actualizada y específica del dominio mediante la recuperación de documentos relevantes.

Esta aproximación combina lo mejor de dos mundos: la capacidad de generación natural de los modelos de lenguaje con la precisión y actualidad de la búsqueda de información. En lugar de depender únicamente del conocimiento preentrenado, un sistema RAG puede consultar bases de datos, documentos corporativos o cualquier fuente de información estructurada para proporcionar respuestas más precisas y contextualizadas.

Arquitectura fundamental de RAG

Un sistema RAG típico opera mediante un pipeline de varios componentes interconectados. El proceso comienza con la indexación de documentos, donde el contenido se divide en fragmentos manejables y se convierte en representaciones vectoriales mediante embeddings.

Durante la fase de consulta, el sistema realiza una búsqueda semántica en el índice vectorial para identificar los fragmentos más relevantes. Estos fragmentos recuperados se incorporan como contexto en el prompt enviado al modelo de lenguaje, que genera una respuesta informada por esta información adicional.

from langchain_openai import ChatOpenAI, OpenAIEmbeddings
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
from langchain_core.runnables import RunnablePassthrough

# Configuración básica del modelo y embeddings
llm = ChatOpenAI(model="gpt-4")
embeddings = OpenAIEmbeddings()

# Template para RAG
template = """Responde la pregunta basándote únicamente en el siguiente contexto:

{context}

Pregunta: {question}
"""

prompt = ChatPromptTemplate.from_template(template)

La efectividad de un sistema RAG depende crucialmente de la calidad de cada componente. Los embeddings deben capturar adecuadamente la semántica del contenido, la estrategia de chunking debe preservar la coherencia contextual, y el sistema de recuperación debe identificar los fragmentos más relevantes para cada consulta.

Procesamiento y segmentación de documentos

El chunking constituye uno de los aspectos más críticos en la implementación de RAG. La división inadecuada de documentos puede resultar en pérdida de contexto o fragmentos demasiado grandes que diluyen la relevancia. LangChain 0.3 proporciona múltiples estrategias de segmentación adaptadas a diferentes tipos de contenido.

from langchain_text_splitters import RecursiveCharacterTextSplitter
from langchain_community.document_loaders import TextLoader

# Carga de documentos
loader = TextLoader("documento.txt")
documents = loader.load()

# Configuración del splitter
text_splitter = RecursiveCharacterTextSplitter(
    chunk_size=1000,
    chunk_overlap=200,
    length_function=len,
    separators=["\n\n", "\n", " ", ""]
)

# Segmentación de documentos
chunks = text_splitter.split_documents(documents)

La superposición entre chunks (overlap) resulta esencial para mantener la continuidad contextual. Un overlap del 10-20% del tamaño del chunk suele proporcionar un equilibrio adecuado entre coherencia y eficiencia. Para documentos técnicos o académicos, puede ser necesario ajustar estos parámetros según la estructura específica del contenido.

Los separadores jerárquicos del RecursiveCharacterTextSplitter intentan dividir el texto en puntos naturales, priorizando párrafos completos antes de recurrir a divisiones por oraciones o palabras. Esta aproximación preserva mejor la coherencia semántica de los fragmentos resultantes.

Almacenamiento vectorial y recuperación

El vector store actúa como el núcleo del sistema de recuperación, almacenando las representaciones vectoriales de los documentos junto con sus metadatos. LangChain 0.3 soporta múltiples backends de almacenamiento vectorial, desde soluciones en memoria hasta bases de datos especializadas.

from langchain_community.vectorstores import FAISS
from langchain_core.documents import Document

# Creación del vector store
vectorstore = FAISS.from_documents(
    documents=chunks,
    embedding=embeddings
)

# Configuración del retriever
retriever = vectorstore.as_retriever(
    search_type="similarity",
    search_kwargs={"k": 4}
)

La configuración del retriever determina cómo se seleccionan los documentos relevantes. El parámetro k especifica el número de fragmentos a recuperar, mientras que search_type define el algoritmo de búsqueda. La búsqueda por similitud coseno representa la aproximación más común, aunque existen alternativas como la búsqueda por similitud con umbral o la búsqueda híbrida.

Los metadatos asociados a cada documento pueden utilizarse para implementar filtrado avanzado durante la recuperación. Esto permite crear sistemas RAG que consideren no solo la relevancia semántica, sino también criterios como la fecha de publicación, el autor o la categoría del documento.

Implementación del pipeline RAG con LCEL

LangChain Expression Language (LCEL) proporciona una sintaxis declarativa para construir pipelines RAG complejos de manera elegante y mantenible. Esta aproximación facilita la composición de componentes y permite optimizaciones automáticas del flujo de ejecución.

from langchain_core.runnables import RunnableParallel

# Función para formatear documentos
def format_docs(docs):
    return "\n\n".join(doc.page_content for doc in docs)

# Pipeline RAG con LCEL
rag_chain = (
    RunnableParallel({
        "context": retriever | format_docs,
        "question": RunnablePassthrough()
    })
    | prompt
    | llm
    | StrOutputParser()
)

# Ejecución del pipeline
response = rag_chain.invoke("¿Cuál es el tema principal del documento?")

La composición paralela permite ejecutar la recuperación de documentos y el procesamiento de la pregunta simultáneamente, mejorando la eficiencia del sistema. El operador | encadena las operaciones de manera intuitiva, creando un flujo de datos claro y fácil de seguir.

El formateo de documentos recuperados requiere consideración cuidadosa. Simplemente concatenar el contenido puede no ser óptimo para todos los casos de uso. Algunas implementaciones incluyen metadatos como títulos o fuentes, mientras que otras aplican técnicas de resumen para documentos muy largos.

Técnicas avanzadas de recuperación

Los sistemas RAG modernos van más allá de la búsqueda vectorial básica, incorporando técnicas híbridas que combinan búsqueda semántica con métodos tradicionales como BM25. Esta aproximación aprovecha las fortalezas de ambos paradigmas: la comprensión semántica de los embeddings y la precisión léxica de la búsqueda por palabras clave.

from langchain.retrievers import EnsembleRetriever
from langchain_community.retrievers import BM25Retriever

# Retriever basado en BM25
bm25_retriever = BM25Retriever.from_documents(chunks)
bm25_retriever.k = 4

# Ensemble retriever que combina ambos métodos
ensemble_retriever = EnsembleRetriever(
    retrievers=[vectorstore.as_retriever(), bm25_retriever],
    weights=[0.7, 0.3]
)

El reranking constituye otra técnica avanzada que mejora la calidad de los documentos recuperados. Después de la recuperación inicial, un modelo especializado reordena los resultados según su relevancia específica para la consulta, refinando la selección de contexto.

La recuperación contextual considera no solo la consulta actual, sino también el historial de la conversación. Esto resulta especialmente importante en aplicaciones de chat donde las preguntas pueden hacer referencia a información mencionada anteriormente.