Módulo 1: RAG Pipeline Completo (Architecture Overview)

Arquitectura Overview: Módulos 2-8

Descripción de la cápsula

Esta guía tiene 8 módulos. Módulo 1 (este) te dio el baseline: RAG pipeline completo, decisiones de arquitectura, métricas, casos reales. Módulos 2-8 te enseñan técnicas avanzadas que mejoran cada componente del pipeline.

Esta cápsula te muestra el roadmap completo: qué aprenderás en cada módulo, cómo se conectan entre sí, qué mejoras de performance esperar, y cómo el proyecto evolutivo integra todas las técnicas en un sistema RAG production-ready.

Sin este overview, módulos 2-8 parecerían desconectados. Con este overview, entenderás que chunking (M2) optimiza Indexing, re-ranking (M4) optimiza Retrieval, metadata filtering (M6) optimiza search space, y evaluation (M8) mide todo el sistema para identificar gaps y aplicar mejoras iterativamente.

🗺️ Roadmap de la Guía

Vista de alto nivel:

Módulo 1: RAG Pipeline Completo (Baseline)
   ↓
Phase 1: Fundamentos Avanzados
├─ Módulo 2: Chunking Strategies
├─ Módulo 3: Query Optimization
└─ Módulo 4: Re-ranking Techniques
   ↓
Phase 2: Técnicas de Retrieval
├─ Módulo 5: Hybrid Search (BM25 + Embeddings)
└─ Módulo 6: Metadata Filtering
   ↓
Phase 3: Production & Integration
├─ Módulo 7: Production Vector DBs (Pinecone)
└─ Módulo 8: RAG Evaluation & Testing (RAGAS)

📐 Arquitectura RAG Completa

Pipeline baseline (Módulo 1):

┌─────────────────────────────────────────┐
│          INDEXING (Offline)             │
├─────────────────────────────────────────┤
│ 1. Chunking: Fixed-size (naive)        │
│ 2. Embeddings: OpenAI ada-002          │
│ 3. Storage: ChromaDB (local)           │
└─────────────────────────────────────────┘
              ↓
┌─────────────────────────────────────────┐
│         RETRIEVAL (Query time)          │
├─────────────────────────────────────────┤
│ 1. Query: Direct (sin optimización)    │
│ 2. Search: Semantic (embeddings)       │
│ 3. Ranking: Cosine similarity           │
└─────────────────────────────────────────┘
              ↓
┌─────────────────────────────────────────┐
│        GENERATION (Query time)          │
├─────────────────────────────────────────┤
│ 1. Context: Top-K docs                 │
│ 2. LLM: GPT-3.5-turbo                  │
│ 3. Response: Text                       │
└─────────────────────────────────────────┘
              ↓
┌─────────────────────────────────────────┐
│          EVALUATION (Manual)            │
├─────────────────────────────────────────┤
│ 1. Métricas: Latency, Precision (manual)│
│ 2. Testing: Ad-hoc queries              │
└─────────────────────────────────────────┘

Performance baseline:

Latency P95: 800ms
Precision@5: 68%
Recall@50: 52%
Faithfulness: N/A (sin framework)

Pipeline avanzado (Módulos 2-8):

┌─────────────────────────────────────────┐
│          INDEXING (Offline)             │
├─────────────────────────────────────────┤
│ 1. Chunking: Recursive + Semantic (M2) │ ← +15% precision
│ 2. Embeddings: OpenAI ada-002          │
│ 3. Storage: Pinecone (production) (M7) │ ← Scalability
│ 4. Metadata: date, type, source (M6)   │ ← Filtering
└─────────────────────────────────────────┘
              ↓
┌─────────────────────────────────────────┐
│         RETRIEVAL (Query time)          │
├─────────────────────────────────────────┤
│ 1. Query Optimization: Expansion (M3)  │ ← +25% recall
│ 2. Hybrid Search: BM25 + Semantic (M5) │ ← +18% precision
│ 3. Metadata Filter: Pre-filtering (M6) │ ← -90% search space
│ 4. Re-ranking: Cross-encoder (M4)      │ ← +20% precision
└─────────────────────────────────────────┘
              ↓
┌─────────────────────────────────────────┐
│        GENERATION (Query time)          │
├─────────────────────────────────────────┤
│ 1. Context: Top-K re-ranked docs       │
│ 2. LLM: GPT-3.5-turbo                  │
│ 3. Response: Text + Sources             │
└─────────────────────────────────────────┘
              ↓
┌─────────────────────────────────────────┐
│       EVALUATION (Automated) (M8)       │
├─────────────────────────────────────────┤
│ 1. RAGAS: faithfulness, relevancy      │ ← Automated metrics
│ 2. Golden Dataset: 50 test queries     │ ← Regression testing
│ 3. CI/CD: Auto-eval en cada deploy     │ ← Continuous quality
└─────────────────────────────────────────┘

Performance avanzado (target Módulo 8):

Latency P95: 1,200ms (+400ms por optimizations)
Precision@5: 88% (+20% vs baseline)
Recall@50: 77% (+25% vs baseline)
Faithfulness: 0.92 (automated con RAGAS)

Trade-off aceptado: +400ms latency por +20-25% accuracy (vale la pena para most cases).

📦 Módulo 2: Chunking Strategies

Objetivo:

Optimizar cómo divides documentos largos en chunks para maximizar retrieval quality.

Problema del baseline:

# Fixed-size chunking (naive)
chunks = [document[i:i+500] for i in range(0, len(document), 500)]

# Problema 1: Corta en medio de oración
# "FastAPI es un framework web. Fue crea..." ← Oración cortada

# Problema 2: Pierde contexto semántico
# Chunk 1: "Python es..."
# Chunk 2: "...un lenguaje interpretado"
# Problema: "Python" y "lenguaje" están en chunks diferentes

Técnicas que aprenderás:

1. Recursive Chunking (LangChain):

from langchain.text_splitter import RecursiveCharacterTextSplitter

splitter = RecursiveCharacterTextSplitter(
    chunk_size=500,
    chunk_overlap=50,  # Overlap preserva contexto
    separators=["\n\n", "\n", ". ", " ", ""]
)

chunks = splitter.split_text(document)

# Beneficio: Respeta párrafos y oraciones

Mejora esperada: +10-15% precision (chunks más coherentes)

2. Semantic Chunking (Embeddings-based):

from langchain.text_splitter import SemanticChunker
from langchain_openai import OpenAIEmbeddings

splitter = SemanticChunker(OpenAIEmbeddings())
chunks = splitter.split_text(document)

# Beneficio: Divide por temas (coherencia semántica)

Mejora esperada: +15-20% precision (best quality)
Trade-off: +costo embeddings, +latency en indexing

3. Structural Chunking (Code, HTML, Markdown):

# Para código: Chunking por funciones
import ast

def chunk_by_functions(python_code):
    tree = ast.parse(python_code)
    return [ast.get_source_segment(python_code, node) 
            for node in ast.walk(tree) 
            if isinstance(node, ast.FunctionDef)]

# Para HTML: Chunking por secciones
from bs4 import BeautifulSoup

def chunk_by_sections(html):
    soup = BeautifulSoup(html, 'html.parser')
    return [section.get_text() for section in soup.find_all('section')]

Mejora esperada: +20-25% precision para código/HTML (respeta estructura)

Proyecto Módulo 2:

Implementar 3 chunking strategies en baseline RAG, comparar performance:

# Comparación de chunking
baseline_fixed = benchmark_rag(chunking="fixed")
# Precision@5: 68%

recursive = benchmark_rag(chunking="recursive")
# Precision@5: 78% (+10%)

semantic = benchmark_rag(chunking="semantic")
# Precision@5: 83% (+15%)

🔍 Módulo 3: Query Optimization

Objetivo:

Optimizar la query del usuario antes de buscar para aumentar recall y precision.

Problema del baseline:

# Query directa sin optimización
user_query = "¿Qué es FastAPI?"

# Problema: Query puede ser ambigua, incompleta, o mal formulada
# "FastAPI" → ¿El usuario busca qué es, cómo instalarlo, o ejemplos?

Técnicas que aprenderás:

1. Query Expansion (Aumentar recall):

# Generar múltiples queries similares
expanded_queries = [
    "¿Qué es FastAPI?",
    "FastAPI framework explicación",
    "Características de FastAPI",
    "FastAPI vs Flask"
]

# Buscar con todas y merge resultados

Mejora esperada: +20-30% recall (encuentras más docs relevantes)

2. Query Rewriting (Claridad):

# Reformular query para claridad
user_query = "fastapi auth"  # Ambiguo

rewritten_query = llm.invoke(f"""
Reformula esta query para búsqueda en documentación:
Query: {user_query}
Reformulada:
""")

# Output: "How to implement authentication in FastAPI using OAuth2"

Mejora esperada: +10-15% precision (queries más claras)

3. Query Decomposition (Multi-hop):

# Query compleja → Sub-queries simples
user_query = "Compare FastAPI and Flask authentication approaches"

decomposed = [
    "FastAPI authentication methods",
    "Flask authentication methods",
    "Compare FastAPI vs Flask"
]

# Buscar cada sub-query y agregar resultados

Mejora esperada: +15-20% precision para queries complejas

4. HyDE (Hypothetical Document Embeddings):

# Generar documento hipotético que respondería la query
hypothetical_doc = llm.invoke(f"""
Write a document that would answer: {user_query}
""")

# Buscar con embedding del documento hipotético (no query)
hyde_embedding = create_embedding(hypothetical_doc)
results = collection.query(query_embeddings=[hyde_embedding])

Mejora esperada: +15-25% recall (embeddings de docs > embeddings de queries)

Proyecto Módulo 3:

Implementar query optimization en baseline RAG:

baseline = benchmark_rag(query_optimization=None)
# Recall@50: 52%

expansion = benchmark_rag(query_optimization="expansion")
# Recall@50: 67% (+15%)

hyde = benchmark_rag(query_optimization="hyde")
# Recall@50: 72% (+20%)

🎯 Módulo 4: Re-ranking Techniques

Objetivo:

Mejorar precision de retrieval re-ordenando top-K documentos con modelos más sofisticados.

Problema del baseline:

# Similarity search devuelve top-5
results = collection.query(query_embeddings=[...], n_results=5)

# Problema: Cosine similarity no es perfecto
# Algunos docs con similarity alta son false positives
# Precision@5: 68% (32% son irrelevantes)

Técnicas que aprenderás:

1. Cross-Encoder Re-ranking:

from sentence_transformers import CrossEncoder

# 1. Retrieval amplio (top-20)
results = collection.query(query_embeddings=[...], n_results=20)

# 2. Re-ranking con cross-encoder
model = CrossEncoder('cross-encoder/ms-marco-MiniLM-L-6-v2')
scores = model.predict([(user_query, doc) for doc in results['documents'][0]])

# 3. Seleccionar top-5 re-rankeados
top_5 = [results['documents'][0][i] for i in np.argsort(scores)[::-1][:5]]

Mejora esperada: +20-25% precision
Trade-off: +150-200ms latency

2. LLM-based Re-ranking:

# Re-rankear con LLM
reranking_prompt = f"""
Query: {user_query}

Documents:
1. {doc1}
2. {doc2}
3. {doc3}

Rank documents by relevance (output: 2,1,3 for example):
"""

ranking = llm.invoke(reranking_prompt)
# Output: "2,1,3" (doc2 más relevante, luego doc1, luego doc3)

Mejora esperada: +25-30% precision (best quality)
Trade-off: +500-800ms latency, +costo LLM

3. Cohere Rerank API:

import cohere

co = cohere.Client("api_key")

reranked = co.rerank(
    query=user_query,
    documents=[doc1, doc2, doc3],
    top_n=5,
    model="rerank-english-v2.0"
)

# Output: Documentos re-rankeados por Cohere

Mejora esperada: +22-27% precision
Trade-off: +100-150ms latency, $2/1K rerank calls

Proyecto Módulo 4:

Implementar re-ranking en baseline RAG:

baseline = benchmark_rag(reranking=None)
# Precision@5: 68%

cross_encoder = benchmark_rag(reranking="cross_encoder")
# Precision@5: 88% (+20%)
# Latency: +180ms

cohere = benchmark_rag(reranking="cohere")
# Precision@5: 90% (+22%)
# Latency: +120ms

🔀 Módulo 5: Hybrid Search (BM25 + Embeddings)

Objetivo:

Combinar keyword search (BM25) y semantic search (embeddings) para mejor cobertura.

Problema del baseline:

# Semantic search solo
query = "FastAPI OAuth2PasswordBearer"

# Problema 1: Miss exact match de "OAuth2PasswordBearer" (nombre de clase)
# Semantic puede confundir con "OAuth2AuthorizationCodeBearer"

# Problema 2: Miss keyword-heavy queries ("API endpoint /users/{id}")

Técnicas que aprenderás:

1. BM25 + Embeddings con RRF:

from rank_bm25 import BM25Okapi

# 1. BM25 keyword search
bm25_results = bm25.get_top_n(query.split(), corpus, n=50)

# 2. Semantic search
semantic_results = collection.query(query_embeddings=[...], n_results=50)

# 3. Reciprocal Rank Fusion
def rrf(bm25_results, semantic_results, k=60):
    scores = {}
    for rank, doc in enumerate(bm25_results, 1):
        scores[doc] = scores.get(doc, 0) + 1/(k + rank)
    for rank, doc in enumerate(semantic_results, 1):
        scores[doc] = scores.get(doc, 0) + 1/(k + rank)
    return sorted(scores.items(), key=lambda x: x[1], reverse=True)

merged = rrf(bm25_results, semantic_results)

Mejora esperada: +15-20% precision, +10-15% recall

2. Weighted Hybrid (α blending):

# Combinar scores con peso
alpha = 0.7  # 70% semantic, 30% BM25

hybrid_score = alpha * semantic_score + (1 - alpha) * bm25_score

Mejora esperada: +12-18% precision (tunable con α)

Proyecto Módulo 5:

Implementar hybrid search:

baseline_semantic = benchmark_rag(search="semantic")
# Precision@5: 68%, Recall@50: 52%

baseline_bm25 = benchmark_rag(search="bm25")
# Precision@5: 72%, Recall@50: 48%

hybrid_rrf = benchmark_rag(search="hybrid_rrf")
# Precision@5: 83% (+15%), Recall@50: 62% (+10%)

🏷️ Módulo 6: Metadata Filtering

Objetivo:

Filtrar search space con metadata (date, type, source) antes de semantic search.

Problema del baseline:

# Search sin filtering
results = collection.query(query_embeddings=[...], n_results=5)

# Problema: Busca en TODO el corpus (100K docs)
# Muchos docs irrelevantes por contexto (ej: docs de hace 5 años)

Técnicas que aprenderás:

1. Pre-filtering (Metadata WHERE):

# Filtrar ANTES de semantic search
results = collection.query(
    query_embeddings=[...],
    n_results=5,
    where={
        "date": {"$gte": "2024-01-01"},  # Solo docs de 2024
        "type": "tutorial",               # Solo tutorials
        "source": "official_docs"         # Solo docs oficiales
    }
)

# Beneficio: Search space reducido 95% (100K → 5K docs)

Mejora esperada: +10-15% precision, -90% search space

2. Post-filtering (Filter después):

# Retrieval primero, filtrar después
results = collection.query(query_embeddings=[...], n_results=50)

# Filtrar por metadata
filtered = [doc for doc in results['documents'][0] 
            if doc['metadata']['type'] == 'tutorial'][:5]

Trade-off: Pre-filtering > post-filtering (más eficiente)

3. Multi-tenant Filtering (Privacy):

# Cada usuario tiene workspace_id
results = collection.query(
    query_embeddings=[...],
    n_results=5,
    where={"workspace_id": user.workspace_id}  # Privacy-critical
)

# Beneficio: Zero cross-workspace leakage

Proyecto Módulo 6:

Implementar metadata filtering:

baseline = benchmark_rag(filtering=None)
# Precision@5: 68%, Search space: 100K docs

pre_filtering = benchmark_rag(filtering="pre", metadata=["date", "type"])
# Precision@5: 81% (+13%), Search space: 8K docs (-92%)

🚀 Módulo 7: Production Vector DBs (Pinecone)

Objetivo:

Migrar de ChromaDB (dev, local) a Pinecone (production, managed) para escalabilidad.

Problema del baseline:

# ChromaDB local
client = chromadb.Client()

# Problema 1: Performance degrada con >100K docs
# 10K docs: 30ms query ✅
# 100K docs: 300ms query ⚠️
# 1M docs: 3,000ms query ❌

# Problema 2: Single-machine (no distributed)
# Problema 3: No managed (tú administras backups, updates, etc.)

Técnicas que aprenderás:

1. Migrar ChromaDB → Pinecone:

from pinecone import Pinecone

# Setup Pinecone
pc = Pinecone(api_key="...")
index = pc.create_index(name="my-index", dimension=1536, metric="cosine")

# Migrar datos de ChromaDB
chroma_docs = chroma_collection.get()

# Batch upsert a Pinecone
index.upsert(
    vectors=[
        (id, embedding, metadata)
        for id, embedding, metadata in zip(
            chroma_docs['ids'],
            chroma_docs['embeddings'],
            chroma_docs['metadatas']
        )
    ],
    batch_size=100
)

2. Pinecone Features:

# Namespaces (multi-tenant)
index.upsert(vectors=[...], namespace="user_123")
index.query(vector=[...], namespace="user_123")

# Metadata filtering (pre-filtering)
index.query(
    vector=[...],
    filter={"type": {"$eq": "tutorial"}},
    top_k=5
)

# Sparse-dense vectors (hybrid search nativo)
index.upsert(
    vectors=[
        ("id1", dense_vector, sparse_vector, metadata)
    ]
)

Performance comparison:

Vector DB	10K docs	100K docs	1M docs	Costo
ChromaDB	30ms	300ms	3,000ms	Gratis
Pinecone	40ms	45ms	50ms	$70/mes

Decisión: Pinecone si dataset >100K docs o necesitas <100ms garantizado.

Proyecto Módulo 7:

Migrar baseline RAG a Pinecone:

# Antes (ChromaDB, 100K docs)
latency_p95 = 850ms

# Después (Pinecone, 100K docs)
latency_p95 = 520ms (-40%)

📊 Módulo 8: RAG Evaluation & Testing (RAGAS)

Objetivo:

Evaluar calidad del sistema RAG con métricas automatizadas (faithfulness, relevancy).

Problema del baseline:

# Evaluation manual
# 1. Generar respuesta
answer = rag_system.query("¿Qué es FastAPI?")

# 2. Leer respuesta y juzgar manualmente
# "¿Es correcta? ¿Está grounded en docs? ¿Responde la pregunta?"

# Problema: No escala, no es consistente, no es automatizado

Técnicas que aprenderás:

1. RAGAS Framework (Automated Metrics):

from ragas import evaluate
from ragas.metrics import faithfulness, answer_relevancy, context_recall

# Dataset de evaluación
dataset = {
    "question": ["¿Qué es FastAPI?"],
    "answer": ["FastAPI es un framework web..."],
    "contexts": [["FastAPI es un framework web moderno..."]],
    "ground_truth": ["FastAPI es un framework web de Python"]
}

# Evaluar
results = evaluate(
    dataset,
    metrics=[faithfulness, answer_relevancy, context_recall]
)

print(results)
# Output:
# {
#   'faithfulness': 0.92,      # ¿Grounded en contexto?
#   'answer_relevancy': 0.89,  # ¿Responde pregunta?
#   'context_recall': 0.75     # ¿Recuperamos docs relevantes?
# }

2. Golden Dataset (Regression Testing):

# Crear dataset de 50 test queries + ground truth
golden_dataset = [
    {
        "question": "¿Qué es FastAPI?",
        "ground_truth": "FastAPI es un framework web...",
        "relevant_docs": ["doc_123", "doc_456"]
    },
    # ... 49 más
]

# Evaluar cada deploy
def regression_test(rag_system):
    results = evaluate(rag_system, golden_dataset)
    assert results['faithfulness'] > 0.85, "Faithfulness degraded!"
    assert results['answer_relevancy'] > 0.80, "Relevancy degraded!"
    return results

3. CI/CD Integration (Continuous Evaluation):

# En cada PR/deploy, auto-eval
# .github/workflows/rag-eval.yml

steps:
  - name: Run RAG evaluation
    run: |
      python test_rag.py
      # Si metrics < threshold, fail CI

Proyecto Módulo 8:

Implementar evaluation completa:

# Baseline (manual)
faithfulness = "Unknown"
answer_relevancy = "Unknown"

# Con RAGAS (automated)
results = evaluate(rag_system, golden_dataset)
# faithfulness: 0.92
# answer_relevancy: 0.89
# context_recall: 0.75

# Identificar gaps y aplicar mejoras
if results['context_recall'] < 0.80:
    apply_improvement("query_expansion")  # Módulo 3

🔗 Cómo se Conectan los Módulos

Pipeline evolutivo:

Módulo 1: Baseline RAG
   ↓ (Precision 68%, Recall 52%)
   
Módulo 2: + Chunking optimizado
   ↓ (Precision 78%, Recall 52%) [+10% precision]
   
Módulo 3: + Query optimization
   ↓ (Precision 78%, Recall 67%) [+15% recall]
   
Módulo 4: + Re-ranking
   ↓ (Precision 88%, Recall 67%) [+10% precision]
   
Módulo 5: + Hybrid search
   ↓ (Precision 91%, Recall 77%) [+3% precision, +10% recall]
   
Módulo 6: + Metadata filtering
   ↓ (Precision 93%, Recall 77%) [+2% precision, -90% search space]
   
Módulo 7: + Pinecone migration
   ↓ (Latency -40%, Scalability ∞)
   
Módulo 8: + RAGAS evaluation
   ↓ (Automated quality gates, CI/CD integration)

Performance final:

Precision@5: 93% (baseline: 68%, mejora: +25%)
Recall@50: 77% (baseline: 52%, mejora: +25%)
Latency P95: 1,200ms (baseline: 800ms, trade-off: +400ms por calidad)
Faithfulness: 0.92 (baseline: N/A)
Cost per query: $0.003 (acceptable para production)

🎯 Proyecto Evolutivo (Módulo 8)

Objetivo final:

Sistema RAG production-ready que integra TODAS las técnicas:

# advanced_rag_system.py (Módulo 8 final)

class AdvancedRAGSystem:
    def __init__(self):
        # Módulo 2: Chunking
        self.chunker = RecursiveCharacterTextSplitter(...)
        
        # Módulo 3: Query optimization
        self.query_optimizer = QueryExpansionOptimizer(...)
        
        # Módulo 4: Re-ranking
        self.reranker = CrossEncoder('cross-encoder/...')
        
        # Módulo 5: Hybrid search
        self.bm25 = BM25Okapi(...)
        self.semantic_search = PineconeIndex(...)
        
        # Módulo 6: Metadata filtering
        self.metadata_filters = {...}
        
        # Módulo 7: Production vector DB
        self.vector_db = Pinecone(...)
        
        # Módulo 8: Evaluation
        self.evaluator = RAGASEvaluator(...)
    
    def query(self, user_query: str) -> dict:
        # 1. Query optimization (M3)
        optimized_queries = self.query_optimizer.expand(user_query)
        
        # 2. Hybrid retrieval (M5) con metadata filtering (M6)
        bm25_results = self.bm25.search(user_query)
        semantic_results = self.semantic_search.query(
            optimized_queries[0],
            filter=self.metadata_filters
        )
        merged = reciprocal_rank_fusion(bm25_results, semantic_results)
        
        # 3. Re-ranking (M4)
        reranked = self.reranker.predict([(user_query, doc) for doc in merged])
        top_k = select_top_k(reranked, k=5)
        
        # 4. Generation
        answer = self.llm.invoke(context=top_k, query=user_query)
        
        # 5. Evaluation (M8)
        metrics = self.evaluator.evaluate(
            question=user_query,
            answer=answer,
            contexts=top_k
        )
        
        return {
            "answer": answer,
            "sources": top_k,
            "metrics": metrics
        }

# Benchmarking final
rag_system = AdvancedRAGSystem()
final_results = benchmark(rag_system, golden_dataset)

print(f"""
Advanced RAG System Results:
- Precision@5: {final_results['precision']:.2%}
- Recall@50: {final_results['recall']:.2%}
- Faithfulness: {final_results['faithfulness']:.2f}
- Latency P95: {final_results['latency_p95']:.0f}ms
- Cost per query: ${final_results['cost_per_query']:.4f}
""")

Output esperado:

Advanced RAG System Results:
- Precision@5: 93%
- Recall@50: 77%
- Faithfulness: 0.92
- Latency P95: 1,200ms
- Cost per query: $0.0031

🎯 Resumen

Conceptos clave:

✅ Módulo 1: Baseline RAG (68% precision, 52% recall)
✅ Módulo 2: Chunking strategies → +10-15% precision
✅ Módulo 3: Query optimization → +15-25% recall
✅ Módulo 4: Re-ranking → +20-25% precision
✅ Módulo 5: Hybrid search → +15-18% precision, +10-15% recall
✅ Módulo 6: Metadata filtering → +10-13% precision, -90% search space
✅ Módulo 7: Pinecone migration → -40% latency, ∞ scalability
✅ Módulo 8: RAGAS evaluation → Automated quality gates
✅ Pipeline evolutivo: Baseline → Avanzado (68% → 93% precision)
✅ Trade-off aceptado: +400ms latency por +25% accuracy

Qué sigue:

Cápsula 08 te da el mini-proyecto de Módulo 1: implementar baseline RAG con ChromaDB + OpenAI, medir performance, y documentar decisiones para comparar con mejoras en módulos 2-8.

📚 Recursos Adicionales

RAG Architecture Patterns - Patterns de LangChain
Advanced RAG Techniques - Pinecone guide
Production RAG Best Practices - LlamaIndex blog
RAGAS Documentation - Framework de evaluation
Hybrid Search Deep Dive - Elasticsearch guide
Chunking Strategies Comparison - Análisis de chunk size

Creado: Febrero 6, 2026
Versión: 1.0

← AnteriorRAG vs Búsqueda Tradicional (Keywords)Siguiente →Proyecto: Baseline RAG System