IA: mapa de arquitecturas, transformers, LLM, RAG y agentes de IA

La Inteligencia Artificial (IA) ha dejado de ser un tema de investigación para convertirse en infraestructura crítica de producto, negocio y ciencia. Esta guía condensa los conceptos, arquitecturas y patrones que todo desarrollador, arquitecto o decisor técnico necesita para diseñar, construir y gobernar sistemas con IA en 2024-2025.

“La IA no es magia. Es estadística a escala, ingeniería de datos y arquitectura de sistemas.” — Principio de ingeniería de IA

---

1. Mapa Mental: Jerarquía de Conceptos

INTELIGENCIA ARTIFICIAL (campo amplio)
├── MACHINE LEARNING (aprendizaje automático)
│   ├── Supervisado (clasificación, regresión)
│   ├── No supervisado (clustering, reducción dimensionalidad)
│   ├── Auto-supervisado (pretext tasks, masking) ← base de LLMs
│   └── Por refuerzo (RL, RLHF, RLAIF)
├── DEEP LEARNING (redes neuronales profundas)
│   ├── CNN (visión), RNN/LSTM/GRU (secuencias)
│   ├── **Transformers** (atención, base de LLMs)
│   ├── Diffusion models (generación imagen/video/audio)
│   └── GNN (grafos), MLP-Mixer, etc.
├── FOUNDATION MODELS (modelos base)
│   ├── LLMs (GPT, LLaMA, Claude, Gemini, Mistral...)
│   ├── VLMs (GPT-4V, LLaVA, Qwen-VL...)
│   ├── Audio models (Whisper, SeamlessM4T...)
│   └── Multimodales nativos (GPT-4o, Gemini 1.5)
└── SISTEMAS DE IA (arquitectura de aplicación)
    ├── RAG (Retrieval-Augmented Generation)
    ├── Agentes / Multi-agentes
    ├── Fine-tuning / LoRA / RLHF
    ├── Eval, Guardrails, Observabilidad
    └── Despliegue: Inferencia, Serving, Edge

---

2. Fundamentos Técnicos (Lo que no se puede ignorar)

2.1 Transformers: La Arquitectura Universal

Componente	Función	Clave para entender LLMs
Self-Attention	Relaciona cada token con todos los demás	Contexto global, paralizable
Multi-Head Attention	Múltiples “miradas” simultáneas	Captura relaciones sintácticas + semánticas
Positional Encoding	Inyecta orden (transformers son permutación-invariantes)	Sin él, “perro muerde hombre” = “hombre muerde perro”
Feed-Forward (FFN)	Procesamiento por token independiente	2/3 de parámetros; “memoria” factual
LayerNorm + Residual	Estabilidad de gradientes, flujo de información	Permite profundidad (100+ capas)

Regla práctica: Un transformer solo predice el siguiente token. Todo lo demás (razonamiento, código, herramienta) es emergente de escala + datos + RLHF.

2.2 Escalado (Scaling Laws)

Loss ≈ a * N^(-α) + b * D^(-β) + c
  N = parámetros, D = tokens de entrenamiento
  α ≈ 0.076, β ≈ 0.095 (Chinchilla / Hoffmann et al. 2022)

Implicación: Para mejorar loss, escalar datos y parámetros en proporción (compute-optimal). No entrenes un modelo grande con pocos datos ni uno pequeño con muchos.

2.3 Tokenización

• BPE / Unigram / WordPiece: Subword, vocabulario 32k-256k
• 1 token ≈ 0.75 palabras (es) / 4 chars (en)
• Contexto: 4k → 128k → 1M+ tokens (Gemini 1.5)
• Costo: Cuadrático en atención (salvo FlashAttention, Ring Attention, Linear Attention)

---

3. Patrones de Arquitectura de Aplicación (2024-2025)

3.1 RAG (Retrieval-Augmented Generation) — El patrón base

Usuario → Query → Embedding → Vector DB (top-k) → Contexto + Prompt → LLM → Respuesta
                    ↑                                          ↑
              Chunking +                              Citas / Grounding
              Indexing

Componente	Decisiones clave
Chunking	Tamaño (256-1024), overlap (10-20%), semántico vs fijo
Embedding	text-embedding-3-large, bge-large, e5-mistral, jina-embeddings
Vector DB	pgvector, Qdrant, Weaviate, Pinecone, Chroma, Milvus
Retrieval	Híbrido (vector + BM25), reranker (bge-reranker, cohere-rerank)
Generación	Citación obligatoria, grounding check, faithfulness eval

Anti-patrones RAG: Chunking naïve (corta en medio de concepto), sin reranker, sin eval de faithfulness, contexto > ventana del modelo.

3.2 Agentes (Agentic Workflows)

┌─────────────────────────────────────┐
│           ORQUESTADOR               │  (Planner / Router / Supervisor)
└──────────────┬──────────────────────┘
               │
    ┌──────────┼──────────┐
    ▼          ▼          ▼
┌───────┐ ┌───────┐ ┌─────────┐
│ Tool  │ │ Tool  │ │ Tool    │  (Search, Code, DB, API, Browser...)
│  A    │ │  B    │ │  C      │
└───────┘ └───────┘ └─────────┘
    │          │          │
    └──────────┼──────────┘
               ▼
        ┌───────────┐
        │  MEMORIA  │  (Short-term: chat history / Long-term: vector store)
        └───────────┘

Patrones de agentes:

• ReAct (Reason + Act): Pensar → Herramienta → Observar → Repetir
• Plan-and-Execute: Planner genera DAG → Executor lo recorre
• Multi-agent: Especialistas (coder, reviewer, researcher) + coordinador
• Reflexion / Self-Correction: Crítico interno evalúa y reintenta

Frameworks: LangGraph, AutoGen, CrewAI, LlamaIndex Agents, OpenAI Assistants API, PydanticAI

3.3 Fine-tuning vs RAG vs Prompting

Necesidad	Solución	Cuándo
Conocimiento privado/dinámico	RAG	Cambia a menudo, grande, necesita citas
Estilo/formato/estructura fija	Prompting / Few-shot	Rápido, barato, suficiente
Comportamiento específico de dominio	Fine-tuning (LoRA/QLoRA)	RAG no basta, latencia crítica, edge
Alineación seguridad/valores	RLHF / DPO / KTO	Producción expuesta a usuarios

Realidad 2024: RAG + buen prompting + eval resuelve 80% de casos. Fine-tuning es optimización, no arquitectura base.

---

4. Stack de Inferencia y Despliegue

4.1 Serving Engines (Producción)

Engine	Fortaleza	Caso de uso
vLLM	PagedAttention, continuous batching, OpenAI API compatible	Estándar de facto para LLMs open-source
TGI (Text Generation Inference)	Heterogéneo (GPU/CPU), quantización nativa, streaming	Enterprise, HF Hub integration
TensorRT-LLM	Máximo throughput en NVIDIA, kernels fusionados	Latencia ultra-baja, alto volumen
Ollama / LM Studio	DX local, modelo en archivo único, fácil	Desarrollo local, edge, prototipado
llama.cpp	CPU/Metal/GPU, GGUF, cuantización 2-8 bit	Edge, móvil, Mac, CPU-only
SGLang	RadixAttention, structured output, compilación JIT	Agentes, function calling intensivo

4.2 Cuantización (Compresión sin morir en el intento)

| Método | Bits | Calidad | Velocidad | Uso | |--------|------|---------|-----------|-----| | AWQ / GPTQ | 4-bit | ~99% FP16 | 2-3x | GPU serving estándar | | GGUF (llama.cpp) | 2-8 bit | 8-bit ≈ FP16 | CPU/Metal/GPU | Edge, local, Mac | | FP8 / INT8 (TensorRT) | 8-bit | ~99.5% | 2x H100 | Hopper+ nativo | | BitsAndBytes (QLoRA) | 4-bit NF4 | Entrenamiento LoRA | 4x VRAM | Fine-tuning consumer GPU |

Regla: Empieza en FP16/BF16. Cuantiza a 4-bit AWQ/GPTQ para serving GPU. GGUF q8_0 / q4_K_M para CPU/edge. Evalúa perplexity y task accuracy tras cuantizar.

4.3 Observabilidad y Eval (No opcional)

Capa	Qué medir	Herramientas
Retrieval	Recall@k, MRR, nDCG, latencia	Ragas, LlamaIndex Eval, LangSmith
Generación	Faithfulness, Answer Relevancy, Hallucination Rate	Ragas, DeepEval, PromptFoo
Sistema	Latencia p50/p95/p99, throughput, error rate, cost/1k tokens	LangFuse, LangSmith, Helicone, OpenLIT, Datadog
Seguridad	PII leakage, injection, jailbreak, bias	Guardrails AI, Lakera, PromptGuard, NVIDIA NeMo Guardrails

---

5. Ecosistema Open-Source Clave (2024)

Categoría	Proyectos Referencia
Modelos Base	LLaMA 3.1 (8B/70B/405B), Mistral Large 2, Nemotron 3 Ultra, Qwen 2.5, Gemma 2, Phi-3.5, DeepSeek V2.5
Embeddings	BGE-M3, E5-Mistral, Jina v3, Nomic v1.5, SFR-Embedding
Rerankers	BGE-Reranker v2, Cohere Rerank 3.5, Jina Reranker
Vector DB	Qdrant (Rust, filtro payload), Weaviate (GraphQL, módulos), pgvector (Postgres nativo), Milvus (escala masiva)
Frameworks	LangGraph (stateful agents), LlamaIndex (RAG + agents), Haystack (pipelines), DSPy (optimización programática)
Eval	Ragas, DeepEval, PromptFoo, OpenAI Evals
Guardrails	Guardrails AI, NeMo Guardrails, Lakera
Observabilidad	LangFuse (open-source), LangSmith, Helicone, OpenLIT

---

6. Seguridad, Ética y Gobernanza (Checklist Mínimo)

Riesgo	Mitigación Técnica	Gobernanza
Alucinación	RAG + citations + faithfulness eval + grounding check	[[corrupcion-politica-presuncion-culpabilidad
Inyección de Prompt	System prompt hardening, input sanitization, instruction hierarchy	Revisión de prompts en CI
Fuga de PII	Detección regex/ML pre/post, local inference para datos sensibles	DPA, clasificación de datos
Sesgo / Discriminación	Bias benchmarks (BBQ, StereoSet), counterfactual eval	Auditoría trimestral, model cards
Dependencia de proveedor	Multi-model routing, abstracción (LiteLLM, LangChain), modelos locales	Estrategia multi-cloud + open
Coste descontrolado	Token budgets, caching (semántico + exacto), routing por complejidad	Alertas de coste, chargeback por equipo

Model Card / System Card: Documenta intended use, limitations, eval results, data provenance, licensing. Exigido por EU AI Act para high-risk.

---

7. Casos de Uso por Patrón (Decision Matrix)

Problema	Patrón Recomendado	Ejemplo Concreto
Chat sobre docs internas (PDF, Confluence, código)	RAG híbrido + reranker	Asistente onboarding, soporte técnico
Análisis de código / refactor / tests	Agente ReAct + herramientas (AST, grep, LSP)	Cursor, Copilot Workspace, Aider, agente custom
Extracción estructurada (facturas, contratos, logs)	Function calling + JSON Schema + few-shot	ETL inteligente, compliance automatizado
Generación de contenido SEO / marketing	Prompt chaining + RAG (brand guidelines) + eval	Blog posts, emails, landing pages
Asistente de voz / call center	STT → LLM → TTS + RAG + guardrails + streaming	Voice agents, IVR inteligente
Investigación profunda (web + papers + datos)	Multi-agente (planner + researcher + synthesizer)	GPT Researcher, LangGraph Researcher
Edge / Offline / Privacidad total	GGUF quantizado (llama.cpp / Ollama) + RAG local	Móvil, industrial, salud, defensa

---

8. Checklist de Lanzamiento a Producción (Go/No-Go)

☐ Eval automatizada (RAGAS/DeepEval) > umbrales definidos
☐ Guardrails (PII, injection, jailbreak) activos y probados
☐ Observabilidad: traces, métricas, logs, alertas (p95 latency, error rate, cost)
☐ Canary / Blue-Green deploy del modelo/serving
☐ Rollback < 5 min (modelo anterior + config)
☐ Load test: throughput objetivo + 30% headroom
☐ Cuantización validada (perplexity + task accuracy)
☐ Data lineage: qué datos entrenaron/embedding/indexaron
☐ Model Card / System Card publicada internamente
☐ Runbook de incidencias (alucinación masiva, latencia, coste)
☐ Revisión legal: licencias modelos/datos, EU AI Act, sectorial

---

9. Recursos de Referencia (Curated)

Papers Fundamentales

• Attention Is All You Need (Vaswani et al., 2017)
• Chinchilla Scaling Laws (Hoffmann et al., 2022)
• LoRA / QLoRA (Hu et al. / Dettmers et al.)
• RAG (Lewis et al., 2020) + RAGAS (Es et al., 2023)
• ReAct (Yao et al., 2022) / Reflexion (Shinn et al., 2023)
• Constitutional AI / RLHF (Bai et al., 2022) / DPO (Rafailov et al., 2023)

Cursos / Certificaciones Técnicas

• Fast.ai (Practical Deep Learning)
• Hugging Face Course (Transformers, PEFT, RAG)
• DeepLearning.AI (LLM App Dev, RAG, Agents — Andrew Ng)
• vLLM / TGI / TensorRT-LLM docs (Inferencia)
• LangGraph / LlamaIndex / DSPy tutorials (Arquitectura)

Newsletters / Tracking

• The Batch (Andrew Ng), Import AI (Jack Clark), TLDR AI
• Hugging Face Daily Papers, Papers with Code
• Latent Space Podcast (Swyx + Alessio) — ingeniería real, no hype

---

10. Conclusión: Ingeniería > Hype

La IA en 2024-2025 no se trata de “qué modelo usar”, sino de:

1. Definir el problema con métricas de negocio claras
2. Empezar simple: RAG + prompting + eval → mide → itera
3. Arquitectura observable: traces, costes, calidad, seguridad desde el día 1
4. Evitar vendor lock-in: abstracción, multi-model, open-source first
5. Gobernanza proporcional: model cards, eval continua, runbooks

El mejor sistema de IA no es el que usa el modelo más grande. Es el que resuelve el problema con coste, latencia, fiabilidad y seguridad controlados.

---

Fuentes y Aclaraciones

Fuentes

1. Vaswani et al. Attention Is All You Need (NeurIPS 2017)
2. Hoffmann et al. Training Compute-Optimal Large Language Models (Chinchilla, 2022)
3. Lewis et al. Retrieval-Augmented Generation for Knowledge-Intensive NLP Tasks (2020)
4. Es et al. RAGAS: Automated Evaluation of Retrieval Augmented Generation (2023)
5. Yao et al. ReAct: Synergizing Reasoning and Acting in Language Models (2022)
6. Dettmers et al. QLoRA: Efficient Finetuning of Quantized LLMs (2023)
7. Kwon et al. vLLM: Easy, Fast, and Cheap LLM Serving with PagedAttention (2023)
8. EU AI Act (Regulation 2024/1689) — High-risk AI systems requirements

Aclaraciones

1. [1] LLM (Large Language Model): Modelo transformer entrenado a escala masiva con objetivo de modelado de lenguaje (next-token prediction + RLHF).
2. [2] RAG (Retrieval-Augmented Generation): Patrón que combina búsqueda semántica en base de conocimiento propio + generación condicionada a ese contexto.
3. [3] Agente IA: Sistema que usa un LMM como “cerebro” para planificar, invocar herramientas, observar resultados y iterar hacia una meta.
4. [4] Cuantización: Reducción de precisión numérica de pesos (FP16 → INT4/INT8) para reducir VRAM y latencia con pérdida mínima de calidad.
5. [5] Faithfulness / Grounding: Métrica de si la respuesta del LLM se apoya exclusivamente en el contexto recuperado (no inventa).
6. [6] Scaling Laws: Relaciones empítricas entre compute, parámetros, datos y loss final; guían asignación óptima de presupuesto de entrenamiento.
7. [7] LoRA / QLoRA: Low-Rank Adaptation; fine-tuning eficiente congelando pesos base y entrenando solo matrices de bajo rango (r=8-64).
8. [8] Guardrails: Capa de validación programática (regex, ML, LLM-as-judge) que intercepta entradas/salidas inseguras antes de llegar al usuario.

Documental

YouTube¿Quién mandará en la inteligencia artificial? (DW Documental)