Capítulo 3: Descripción general de la arquitectura RAG

Introducción

Un sistema RAG consta de tres fases principales: Indexación, Recuperación y Generación. Comprender cada fase es crucial para construir aplicaciones RAG efectivas.

Las tres fases

---

Fase 1: Indexación (Offline)

La fase de indexación prepara sus documentos para una recuperación eficiente. Esto ocurre antes de cualquier consulta de usuario.

Paso 1: Carga de documentos

Cargue documentos desde varias fuentes:

from langchain.document_loaders import (
    PyPDFLoader,
    TextLoader,
    CSVLoader,
    WebBaseLoader
)

# Load a PDF
pdf_loader = PyPDFLoader("company_handbook.pdf")
pdf_docs = pdf_loader.load()

# Load from web
web_loader = WebBaseLoader("https://example.com/docs")
web_docs = web_loader.load()

# Combine all documents
all_docs = pdf_docs + web_docs

Paso 2: División de texto (fragmentación)

Los documentos se dividen en fragmentos más pequeños para una mejor recuperación:

from langchain.text_splitter import RecursiveCharacterTextSplitter

splitter = RecursiveCharacterTextSplitter(
    chunk_size=1000,      # Characters per chunk
    chunk_overlap=200,    # Overlap between chunks
    separators=["\n\n", "\n", ".", " "]
)

chunks = splitter.split_documents(all_docs)
# Result: List of smaller text chunks

¿Por qué fragmentar?

• Unidades de texto más pequeñas = recuperación más precisa
• Evita recuperar contenido irrelevante
• Permite ajustarse a las ventanas de contexto del LLM

Paso 3: Generación de embeddings

Convierta los fragmentos de texto en vectores numéricos:

from langchain.embeddings import OpenAIEmbeddings

embeddings = OpenAIEmbeddings(model="text-embedding-3-small")

# Each chunk becomes a vector
# "The return policy states..." → [0.023, -0.891, 0.156, ...]

¿Qué son los embeddings?

• Representaciones vectoriales densas del texto
• Capturan el significado semántico
• Textos similares tienen vectores similares
• Típicamente de 384 a 3072 dimensiones

Paso 4: Almacenamiento vectorial

Almacene los vectores en una base de datos especializada:

from langchain.vectorstores import Chroma

# Create vector store
vectorstore = Chroma.from_documents(
    documents=chunks,
    embedding=embeddings,
    persist_directory="./chroma_db"
)

# Now we have an indexed, searchable knowledge base

Resumen del pipeline de indexación

Raw Documents
    ↓ (Load)
Document Objects
    ↓ (Split)
Text Chunks
    ↓ (Embed)
Vectors
    ↓ (Store)
Vector Database ✓

---

Fase 2: Recuperación (Online)

Cuando un usuario realiza una pregunta, recuperamos los fragmentos relevantes de nuestra base de conocimiento indexada.

Paso 1: Embedding de la consulta

La consulta del usuario se convierte al mismo espacio vectorial:

user_query = "What is the return policy?"

# Convert to embedding using same model
query_vector = embeddings.embed_query(user_query)
# Result: [0.034, -0.782, 0.234, ...]

Paso 2: Búsqueda por similitud

Encuentre los fragmentos con vectores similares a la consulta:

# Search for top 5 most similar chunks
retriever = vectorstore.as_retriever(
    search_type="similarity",
    search_kwargs={"k": 5}
)

relevant_chunks = retriever.get_relevant_documents(user_query)

Cómo funciona la similitud:

Query Vector:  [0.034, -0.782, 0.234, ...]

Chunk 1:       [0.038, -0.791, 0.228, ...]  → 0.98 similarity ✓
Chunk 2:       [0.890, 0.123, -0.456, ...]  → 0.23 similarity ✗
Chunk 3:       [0.041, -0.768, 0.241, ...]  → 0.95 similarity ✓

Estrategias de recuperación

Estrategia	Descripción	Caso de uso
Similarity	Similitud pura de vectores	Propósito general
MMR	Maximum Marginal Relevance (diversidad)	Evitar redundancia
Hybrid	Combina palabras clave + semántica	Mejor recuperación

# MMR - balances relevance and diversity
retriever_mmr = vectorstore.as_retriever(
    search_type="mmr",
    search_kwargs={
        "k": 5,
        "fetch_k": 20,
        "lambda_mult": 0.7
    }
)

---

Fase 3: Generación (Online)

Combine la consulta del usuario con el contexto recuperado para generar una respuesta.

Paso 1: Construcción del prompt

Construya un prompt que incluya el contexto:

def build_prompt(query, retrieved_chunks):
    context = "\n\n".join([
        chunk.page_content for chunk in retrieved_chunks
    ])
    
    prompt = f"""You are a helpful assistant. Use the following context 
to answer the question. If you don't know the answer based on the 
context, say "I don't have enough information."

Context:
{context}

Question: {query}

Answer:"""
    
    return prompt

Paso 2: Generación con LLM

Envíe el prompt al LLM:

from langchain.chat_models import ChatOpenAI

llm = ChatOpenAI(model="gpt-4", temperature=0)

prompt = build_prompt(user_query, relevant_chunks)
response = llm.invoke(prompt)

print(response.content)

Paso 3: Entrega de la respuesta

La respuesta final está fundamentada en los documentos recuperados:

User: "What is the return policy?"

Retrieved Context:
"Our return policy allows returns within 30 days of purchase. 
Items must be unused and in original packaging. Refunds are 
processed within 5-7 business days."

Generated Response:
"According to the company policy, you can return items within 
30 days of purchase, provided they are unused and in their 
original packaging. Refunds typically take 5-7 business days 
to process."

---

Código completo del pipeline RAG

from langchain.document_loaders import PyPDFLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.embeddings import OpenAIEmbeddings
from langchain.vectorstores import Chroma
from langchain.chat_models import ChatOpenAI
from langchain.chains import RetrievalQA

# Phase 1: Indexing
loader = PyPDFLoader("documents/handbook.pdf")
documents = loader.load()

splitter = RecursiveCharacterTextSplitter(
    chunk_size=1000,
    chunk_overlap=200
)
chunks = splitter.split_documents(documents)

embeddings = OpenAIEmbeddings()
vectorstore = Chroma.from_documents(chunks, embeddings)

# Phase 2 & 3: Retrieval + Generation
llm = ChatOpenAI(model="gpt-4")

qa_chain = RetrievalQA.from_chain_type(
    llm=llm,
    chain_type="stuff",
    retriever=vectorstore.as_retriever()
)

# Query the system
response = qa_chain.invoke("What is the return policy?")
print(response["result"])

---

Diagrama de arquitectura

---

Métricas clave

Fase	Métrica	Objetivo
Indexing	Throughput	100+ docs/min
Indexing	Chunk size	500-1500 chars
Retrieval	Latency	<100ms
Retrieval	Top-K	3-10 chunks
Generation	Latency	<3s
Generation	Context fit	<75% of limit

---

Resumen

Fase	Cuándo	Qué	Salida
Indexing	Offline (una vez)	Procesar y almacenar documentos	Base de datos vectorial
Retrieval	Online (por consulta)	Encontrar fragmentos relevantes	Documentos de contexto
Generation	Online (por consulta)	Crear respuesta	Respuesta final

Puntos clave

1. Tres fases distintas con diferentes tiempos y propósitos
2. La indexación es offline: se realiza una vez o periódicamente
3. Recuperación + generación son online: ocurren por cada consulta
4. El tamaño del fragmento es importante: afecta tanto la calidad de la recuperación como el costo
5. El pipeline es modular: cada componente puede optimizarse por separado

---

Próximos pasos

¡Ponga a prueba sus conocimientos con el Cuestionario del Módulo 1!