Módulo 7: RAG y Semantic Search

3. Arquitectura de RAG: Componentes y Flujos

Siguiente →

Descripción

Aquí diseñas la arquitectura conceptual de RAG: componentes (vector DB, embeddings, LLM), flujos de datos (indexación, query), y cómo todo se integra.

Arquitectura completa de RAG

┌────────────────────────────────────────────────┐
│                RAG SYSTEM                      │
├────────────────────────────────────────────────┤
│                                                │
│  FASE 1: INDEXACIÓN (Offline)                 │
│  ┌──────────────────────────────────┐         │
│  │ Docs → Chunks → Embeddings → DB │         │
│  └──────────────────────────────────┘         │
│                                                │
│  FASE 2: RETRIEVAL (Online)                   │
│  ┌──────────────────────────────────┐         │
│  │ Query → Embedding → kNN → Chunks│         │
│  └──────────────────────────────────┘         │
│                                                │
│  FASE 3: AUGMENTATION (Online)                │
│  ┌──────────────────────────────────┐         │
│  │ Query + Chunks → Prompt          │         │
│  └──────────────────────────────────┘         │
│                                                │
│  FASE 4: GENERATION (Online)                  │
│  ┌──────────────────────────────────┐         │
│  │ Prompt → LLM → Response          │         │
│  └──────────────────────────────────┘         │
│                                                │
└────────────────────────────────────────────────┘

Componentes de RAG

1. Vector Database

Función: Almacenar embeddings de documentos

Ejemplos:

  • Pinecone (managed)
  • Weaviate (open-source)
  • Qdrant (open-source)
  • FAISS (library)

Datos almacenados:

  • Embeddings (vectores 1536D)
  • Metadata (source, page, timestamp)
  • Texto original (chunks)

2. Embedding Model

Función: Convertir texto a vectores

Ejemplos:

  • OpenAI text-embedding-3-small (1536D)
  • OpenAI text-embedding-3-large (3072D)
  • Cohere embed-v3 (1024D)
  • Sentence-BERT (768D, local)

Uso:

  • Indexación: Convertir documentos a embeddings
  • Query: Convertir pregunta del usuario a embedding

3. LLM (Large Language Model)

Función: Generar respuesta basada en contexto

Ejemplos:

  • GPT-4 Turbo (128K context)
  • GPT-4o (128K context)
  • Claude 3 Opus (200K context)
  • Llama 3 (8K context, local)

Input: Prompt = Query + Retrieved chunks
Output: Respuesta generada

4. Orchestration Layer

Función: Coordinar flujo completo (retrieval → augmentation → generation)

Frameworks:

  • LangChain (Python/JS)
  • LlamaIndex (Python)
  • Haystack (Python)
  • Custom (FastAPI + OpenAI SDK)

Flujo detallado: De query a respuesta

Fase 1: Indexación (una vez, offline)

1. Ingestión de documentos
   Input: 1000 PDFs
   Output: Texto extraído

2. Chunking
   Input: Texto largo
   Output: 10K chunks (500 tokens cada uno)

3. Embedding
   Input: 10K chunks
   Output: 10K embeddings (1536D)
   API: OpenAI text-embedding-3-small

4. Almacenamiento
   Input: 10K embeddings + metadata + texto
   Output: Índice en Pinecone

Costo: ~$0.10 (10K chunks × 500 tokens = 5M tokens; 5,000 × $0.00002/1K tokens)
Tiempo: 5-10 minutos

Fase 2: Retrieval (cada query)

User Query: "¿Cómo usar Pinecone con OpenAI?"

1. Query embedding
   Input: "¿Cómo usar Pinecone con OpenAI?"
   Output: [0.23, -0.45, ..., -0.34]
   API: OpenAI text-embedding-3-small
   Latencia: 50-200ms

2. kNN search
   Input: Query embedding
   Vector DB: Pinecone
   Top-K: 5
   Output: 5 chunks más relevantes
   Latencia: 10-50ms

Ejemplo de chunks retornados:
- Chunk 1: "Guía de integración Pinecone con OpenAI..." (score: 0.92)
- Chunk 2: "Ejemplo de código: OpenAI embeddings..." (score: 0.88)
- Chunk 3: "FAQ: ¿Cómo conectar Pinecone?" (score: 0.85)
- Chunk 4: "Setup inicial de Pinecone..." (score: 0.82)
- Chunk 5: "Troubleshooting común..." (score: 0.80)

Fase 3: Augmentation (construcción de prompt)

Prompt construido:

"""
Eres un asistente experto en Pinecone y OpenAI.

Contexto (documentación oficial):

[Chunk 1]
Guía de integración Pinecone con OpenAI:
1. Generar embeddings con OpenAI API
2. Upsert embeddings a Pinecone
3. Query con cosine similarity
...

[Chunk 2]
Ejemplo de código: OpenAI embeddings
```python
embedding = openai.Embedding.create(
    input="texto",
    model="text-embedding-3-small"
)

...

[Chunk 3-5] ...

Pregunta del usuario: ¿Cómo usar Pinecone con OpenAI?

Instrucciones:

  • Responde basándote SOLO en el contexto provisto
  • Si el contexto no contiene la respuesta, di "No tengo información suficiente"
  • Cita las fuentes cuando sea relevante """

**Tamaño del prompt:** ~2500 tokens (5 chunks × 500 tokens)

---

### **Fase 4: Generation (LLM genera respuesta)**

Input: Prompt completo (2500 tokens) LLM: GPT-4 Turbo Output:

"Para usar Pinecone con OpenAI, sigue estos pasos:

  1. Generar embeddings con OpenAI: Usa el modelo text-embedding-3-small para convertir tu texto en vectores de 1536 dimensiones.

    embedding = openai.Embedding.create(
    input="tu texto aquí",
    model="text-embedding-3-small"
)

  2. Upsert a Pinecone: Almacena los embeddings en tu índice de Pinecone:

    index.upsert(vectors=[(id, embedding, metadata)])

  3. Query con similaridad coseno: Busca vectores similares usando cosine similarity (por defecto en Pinecone).

Para más detalles, consulta la guía oficial de integración."

Latencia: 2-5 segundos (generación)


---

## Latencia total del flujo
  1. Query embedding: 50-200ms
  2. kNN search: 10-50ms
  3. Prompt construction: <10ms
  4. LLM generation: 2-5 segundos

Total: 2.1-5.3 segundos


**Optimizaciones:**
- Cache query embeddings frecuentes
- Streaming LLM (usuario ve respuesta mientras genera)
- Modelo más rápido (GPT-3.5 vs GPT-4)

---

## Diagrama de flujo completo

User Query ↓ [Embed Query] (OpenAI) ↓ [kNN Search] (Pinecone) ↓ [Top-K Chunks] ↓ [Build Prompt] (Query + Chunks) ↓ [LLM Generate] (GPT-4) ↓ Response to User


---

## Resumen

**Puntos clave:**
- **Arquitectura:** Vector DB + Embeddings + LLM + Orchestration
- **Flujo:** Indexación (offline) → Retrieval → Augmentation → Generation
- **Componentes:** Pinecone, OpenAI embeddings, GPT-4, LangChain
- **Latencia:** 2-5 segundos típica (con LLM generation)

---

**Próxima cápsula:** `04-the-rag-flow-step-by-step.md` — Ejemplo detallado con datos reales.
← Anterior2. El Problema que RAG ResuelveSiguiente →4. Flujo RAG Paso a Paso con Ejemplo Real