Fine-tuning vs RAG: Cuándo Usar Cada Uno [Guía Práctica 2026]

1Proceso de Fine-tuning:
2 
3Pre-trained Model (GPT-4)
4    ↓
5+ Tus datos (dataset)
6    ↓
7[Entramiento en GPU]
8    ↓
9Nuevo Modelo Personalizado

11. Inicio: Modelo pre-entrenado (sabé de todo pero genérico)
22. Proporcionas ejemplos: "Pregunta" → "Respuesta Correcta"
33. Entrenamiento: Ajusta pesos y parámetros
44. Resultado: Modelo especializado en tu dominio

1Dataset Original (GPT-4):
2"¿Qué es Python?"
3→ Respuesta genérica sobre lenguaje de programación
4 
5Después de Fine-tuning con tu data:
6"¿Qué es Python?"
7→ Respuesta específica sobre Python en tu empresa
8  (incluyendo frameworks, librerías y prácticas internas)

1Paso 1: Preparar Dataset
2├── Recopilar ejemplos: 100 - 1,000+ pares (pregunta, respuesta)
3├── Formato JSONL:
4│   {"messages": [
5│     {"role": "user", "content": "¿Cuál es nuestra política?"},
6│     {"role": "assistant", "content": "Nuestra política es..."}
7│   ]}
8└── Validar calidad
9 
10Paso 2: Configurar Fine-tuning
11├── Elegir modelo base (gpt-4, gpt-3.5-turbo)
12├── Configurar parámetros:
13│   └── learning_rate: 2e-5
14│   └── epochs: 3
15│   └── batch_size: 4
16└── Estimar costo y tiempo
17 
18Paso 3: Ejecutar Entrenamiento
19├── OpenAI API / Replicate / Modal / tu GPU
20├── Monitorear progreso
21└── Esperar a completar (horas o días)
22 
23Paso 4: Usar Modelo Fine-tuned
24├── Acceso vía API
25├── Integrar en tu aplicación
26└── Monitorear performance

1{"messages": [{"role": "user", "content": "¿Cuál es la política de retorno?"}, {"role": "assistant", "content": "Aceptamos devoluciones dentro de 30 días con recibo original. El producto debe estar sin usar."}]}
2{"messages": [{"role": "user", "content": "¿Cuánto cuesta el envío?"}, {"role": "assistant", "content": "Envío gratis para órdenes mayores a €50. Para órdenes menores, el envío cuesta €4.99."}]}
3{"messages": [{"role": "user", "content": "¿Aceptan PayPal?"}, {"role": "assistant", "content": "Sí, aceptamos PayPal, Stripe, transferencia bancaria y Apple Pay."}]}
4{"messages": [{"role": "user", "content": "¿Tienen garantía?"}, {"role": "assistant", "content": "Todos nuestros productos incluyen garantía de 1 año contra defectos de fabricación."}]}
5{"messages": [{"role": "user", "content": "¿Puedo cancelar mi orden?"}, {"role": "assistant", "content": "Sí, pero debe ser dentro de 24 horas de realizar la compra. Después, la orden estará en preparación."}]}

1OpenAI Fine-tuning (2026):
2├── GPT-3.5 Turbo:
3│   ├── Training: $0.03 por 1K tokens
4│   ├── Inference: $0.15 por 1K input tokens
5│   ├── Ejemplo: 100K tokens input × $0.03 = $3
6│   └── Uso posterior: 1M tokens × $0.15 = $150/mes
7│
8├── GPT-4 (si disponible):
9│   ├── Training: $0.09 por 1K tokens
10│   ├── Ejemplo: 100K tokens × $0.09 = $9
11│   └── Luego: $0.30+ por 1K para uso
12 
13Estimación Realista:
14├── Dataset pequeño (1-5K ejemplos): $5-50
15├── Dataset mediano (5-20K ejemplos): $50-300
16├── Dataset grande (20-100K ejemplos): $300-1,500+
17└── Luego pagar por uso mensual

1Flujo RAG:
2 
3Usuario pregunta:
4"¿Cuál es nuestra política de devoluciones?"
5    ↓
6Buscar documentos relevantes:
7(Busca en tu base de conocimiento)
8    ↓
9Documentos encontrados:
10"Aceptamos devoluciones dentro de 30 días..."
11    ↓
12Enviar al LLM:
13Pregunta + Contexto relevante
14    ↓
15LLM genera respuesta
16basada en información actualizada

11. VECTOR DATABASE
2   ├── Almacena documentos como vectores
3   ├── Ejemplos: Pinecone, Weaviate, Qdrant
4   └── Busca por similitud semántica
5 
62. EMBEDDING MODEL
7   ├── Convierte texto a vectores
8   ├── Ejemplos: text-embedding-3-large, all-MiniLM-L6-v2
9   └── Captura significado semántico
10 
113. RETRIEVER
12   ├── Busca documentos relevantes
13   ├── Ranking por relevancia
14   └── Top-K documentos
15 
164. GENERATOR (LLM)
17   ├── Recibe pregunta + contexto
18   ├── Genera respuesta coherente
19   └── Cita fuentes
20 
215. PROMPT ENGINEERING
22   ├── Instrucciones al LLM
23   ├── Formato de salida
24   └── Instrucciones de citación

1┌─────────────────────────────────────────────┐
2│         Documentos Nuevos                    │
3│   (PDFs, Blogs, Manuales, Wikis)           │
4└────────────────┬────────────────────────────┘
5                 ↓
6        [Embedding Model]
7        (text-embedding-3)
8                 ↓
9    ┌───────────────────────────┐
10    │  Vector Database          │
11    │  (Pinecone, Qdrant)       │
12    │  Almacena: vectores       │
13    │  + metadata                │
14    └───────────────┬───────────┘
15                    ↑
16                    │
17    ┌───────────────┴───────────┐
18    │    Query (Pregunta)        │
19    │  "¿Cuál es nuestra        │
20    │   política de retorno?"   │
21    └───────────────┬───────────┘
22                    ↓
23            [Embedding Query]
24                    ↓
25    ┌────────────────────────────┐
26    │  Vector Search             │
27    │  (Similitud Coseno)        │
28    │  → Top 3 documentos        │
29    └────────────┬───────────────┘
30                 ↓
31    ┌────────────────────────────────────┐
32    │  Prompt Constructor               │
33    │  "Responde basado en:              │
34    │   [Documento 1]                    │
35    │   [Documento 2]                    │
36    │   [Documento 3]                    │
37    │   Pregunta: ..."                   │
38    └────────────┬───────────────────────┘
39                 ↓
40         ┌───────────────────┐
41         │  LLM (GPT-4o)     │
42         │  Genera respuesta │
43         └───────────┬───────┘
44                     ↓
45            [Respuesta Final]
46        "Basado en nuestra política,
47         aceptamos devoluciones
48         dentro de 30 días..."

1Paso 1: Obtener Documentos
2├── Exportar de PDFs
3├── Scrapear de sitios web
4├── APIs de conectores
5└── Importar de bases de datos
6 
7Paso 2: Preparar Documentos
8├── Dividir en chunks (300-500 tokens)
9├── Limpiar formato
10├── Agregar metadata
11└── Eliminar duplicados
12 
13Paso 3: Generar Embeddings
14├── Usar modelo: text-embedding-3-large
15├── Procesar en batch
16├── Guardar en vector DB
17└── Crear índices de búsqueda
18 
19Paso 4: Configurar Retriever
20├── Elegir algoritmo búsqueda
21├── Establecer top-K (ej: 3 docs)
22├── Configurar threshold mínimo
23└── Implementar re-ranking
24 
25Paso 5: Construir Prompt
26├── Template de sistema
27├── Inyectar documentos
28├── Instrucciones al LLM
29└── Instrucciones de citas
30 
31Paso 6: Desplegar y Monitorear
32├── API endpoint
33├── Monitoreo de latencia
34├── Tracking de preguntas fallidas
35└── Feedback del usuario

1# Librería: LangChain
2 
3from langchain.embeddings.openai import OpenAIEmbeddings
4from langchain.vectorstores import Pinecone
5from langchain.chains import RetrievalQA
6from langchain.llms import ChatOpenAI
7from langchain.document_loaders import PDFLoader
8 
9# 1. Cargar documentos
10loader = PDFLoader("politicas-empresa.pdf")
11documents = loader.load_and_split()
12 
13# 2. Crear embeddings
14embeddings = OpenAIEmbeddings(model="text-embedding-3-large")
15 
16# 3. Guardar en vector database (Pinecone)
17vectorstore = Pinecone.from_documents(
18    documents,
19    embeddings,
20    index_name="mi-indice"
21)
22 
23# 4. Configurar retriever
24retriever = vectorstore.as_retriever(
25    search_type="similarity",
26    search_kwargs={"k": 3}
27)
28 
29# 5. Crear cadena RAG
30llm = ChatOpenAI(model="gpt-4o", temperature=0)
31 
32qa_chain = RetrievalQA.from_chain_type(
33    llm=llm,
34    chain_type="stuff",
35    retriever=retriever,
36    return_source_documents=True
37)
38 
39# 6. Usar
40response = qa_chain(
41    "¿Cuál es la política de devoluciones?"
42)
43 
44print(response["result"])
45# Output: "Aceptamos devoluciones dentro de 30 días..."

1Infraestructura RAG (2026):
2 
31. Vector Database:
4   ├── Pinecone Starter: $0
5   ├── Pinecone Standard: $0.15 por 1M embeddings
6   ├── Self-hosted (Qdrant): Costo servidor
7   └── Estimado: $0-200/mes
8 
92. Embedding API:
10   ├── OpenAI text-embedding-3-small: $0.02 per 1M
11   ├── OpenAI text-embedding-3-large: $0.13 per 1M
12   ├── Self-hosted (local): Gratis pero GPU
13   └── Para 10K documentos: $0.13 - $1.30
14 
153. LLM API (inference):
16   ├── gpt-4o: $0.005 por 1K input
17   ├── Estimado 1,000 queries/mes: $5-50
18   └── Escalable a millones
19 
20Costo Total RAG Estimado:
21├── Startup: $0 (Pinecone free)
22├── Pequeño (1-10K docs): $10-50/mes
23├── Mediano (10-100K docs): $50-200/mes
24├── Grande (100K+ docs): $200-1000+/mes

1┌─────────────────────────────────────────────────────────┐
2│ CARACTERÍSTICA     │ FINE-TUNING    │ RAG              │
3├─────────────────────────────────────────────────────────┤
4│ Tiempo Setup       │ 1-7 días       │ 1-24 horas       │
5│ Costo Inicial      │ $50-1,500      │ $0-200           │
6│ Costo Mensual      │ $100-500+      │ $10-200          │
7│ Actualizar Info    │ Re-entrenar    │ Añadir documentos│
8│                    │ (horas/días)   │ (minutos)        │
9│ Velocidad          │ 50ms (rápido)  │ 100-500ms (ok)   │
10│ Precisión          │ 85-95%         │ 80-92%           │
11│ Hallucinations     │ Moderadas      │ Bajas (cita)     │
12│ Contexto Externo   │ ❌ No          │ ✓ Sí             │
13│ Datos Sensibles    │ ✓ Privados     │ ⚠️ En vector DB  │
14│ Escalabilidad      │ Compleja       │ Excelente        │
15│ Cambios Datos      │ Lentos         │ Rápidos          │
16└─────────────────────────────────────────────────────────┘

1✓ Datos estables y no cambian frecuentemente
2  Ej: Estilo de escritura, terminología específica
3 
4✓ Comportamiento muy específico y consistente
5  Ej: Traductor de lenguaje especial
6 
7✓ Quieres máxima velocidad de respuesta
8  Ej: Chat en tiempo real con latencia <50ms
9 
10✓ Necesitas que se "olvide" de información
11  Ej: Evitar sesgos del entrenamiento original
12 
13✓ Datos muy sensibles y privados
14  Ej: Información médica o legal confidencial
15 
16✓ Presupuesto ilimitado para entrenamiento
17  Ej: Empresa grande con recursos
18 
19✓ Patrones complejos que requieren aprendizaje profundo
20  Ej: Análisis de código complejo, inferencias matemáticas

1✓ Información cambia frecuentemente
2  Ej: Precios, catálogos, noticias
3 
4✓ Necesitas actualizar sin volver a entrenar
5  Ej: Agregar nuevos documentos semanalmente
6 
7✓ Múltiples dominios o temas
8  Ej: Asistente multiusos corporativo
9 
10✓ Presupuesto limitado
11  Ej: Startups, pequeñas empresas
12 
13✓ Necesitas citar fuentes
14  Ej: Soporte técnico con referencias a documentos
15 
16✓ Quieres reducir alucinaciones
17  Ej: Atención al cliente donde exactitud es crítica
18 
19✓ Datos corporativos dispersos
20  Ej: Información en PDFs, wikis, bases de datos
21 
22✓ Escalabilidad importante
23  Ej: Crecer de 100 a 1M usuarios

1Escenario: Centro de soporte con 200 tickets/día
2 
3Solución: RAG
4├── Documentos: Base de conocimiento (100+ PDFs)
5├── Vector DB: Pinecone gratis
6├── LLM: GPT-4o mini ($0.15/1M tokens)
7└── Beneficios:
8    ├── Actualizar base de conocimiento es trivial
9    ├── Agentes citan fuentes (reduce confusión)
10    ├── Bajo costo mensual (~$30-50)
11    ├── Setup rápido (1 día)
12 
13¿Por qué no fine-tuning?
14└── La base de conocimiento se actualiza cada semana
15└── Tendríamos que re-entrenar constantemente

1Escenario: Chatbot que habla como la marca X
2 
3Solución: Fine-tuning
4├── Dataset: 500+ ejemplos de conversaciones
5├── Objetivo: Imitar tono, estilo, personalidad
6├── Entrenamiento: Una sola vez (3-5K)
7└── Beneficios:
8    ├── Respuestas muy consistentes en tono
9    ├── Velocidad máxima (50ms latencia)
10    ├── Usa parámetros optimizados
11    ├── Modelo especializado
12 
13¿Por qué no RAG?
14└── No es sobre información, es sobre comportamiento
15└── Actualizar base de conocimiento no ayuda
16└── Queremos que "sepa" exactamente cómo hablar

1Escenario: Abogados necesitan buscar jurisprudencia
2 
3Solución: Combinación (Fine-tuning + RAG)
4├── RAG para:
5│   ├── Almacenar 10,000+ sentencias
6│   ├── Buscar rápidamente por similitud
7│   ├── Citar fuentes exactas
8│   └── Actualizar con nuevas sentencias
9│
10├── Fine-tuning para:
11│   ├── Análisis legal específico
12│   ├── Interpretación de leyes
13│   ├── Terminología legal precisa
14│   └── Razonamiento legal consistente
15│
16└── Flujo:
17    1. RAG busca sentencias relevantes
18    2. Fine-tuned LLM interpreta + analiza
19    3. Respuesta con análisis + citas

1Escenario: IDE con IA que conoce tu codebase
2 
3Solución: RAG
4├── Documentos: Tu código fuente
5├── Chunks: Archivos o funciones
6├── Contexto: Proporciona snippets de código
7└── Beneficios:
8    ├── Completamente al día con cambios
9    ├── Busca por similitud semántica
10    ├── Bajo overhead comparado a indexación
11    ├── Integrable en editor (VS Code, JetBrains)
12 
13¿Por qué no fine-tuning?
14└── Tu código cambia constantemente
15└── Fine-tuning sería obsoleto en semanas

1Usuario Pregunta
2                 ↓
3          [RAG: Buscar Contexto]
4                 ↓
5     Documentos Relevantes
6                 ↓
7    [Fine-tuned LLM: Generar Respuesta]
8                 ↓
9           Respuesta Mejorada

1# Combinación: RAG + Fine-tuned Model
2 
3from langchain.chains import RetrievalQA
4from openai import OpenAI
5 
6class HybridQASystem:
7    def __init__(self):
8        # Cargar fine-tuned model
9        self.ft_model = "ft:gpt-3.5-turbo:ejemplo:abc123"
10 
11        # Cargar RAG
12        self.rag_chain = self._setup_rag()
13 
14    def _setup_rag(self):
15        # ... RAG setup (similar al ejemplo anterior)
16        pass
17 
18    def answer(self, question):
19        # Paso 1: Buscar documentos relevantes (RAG)
20        context_docs = self.rag_chain.retriever.get_relevant_documents(question)
21 
22        # Paso 2: Construir prompt con contexto
23        context_text = "\n".join([
24            f"Documento: {doc.page_content}"
25            for doc in context_docs
26        ])
27 
28        prompt = f"""Basándose en los siguientes documentos, responda la pregunta.
29 
30Documentos:
31{context_text}
32 
33Pregunta: {question}
34 
35Respuesta:"""
36 
37        # Paso 3: Usar fine-tuned model para mejor precisión
38        client = OpenAI()
39        response = client.chat.completions.create(
40            model=self.ft_model,
41            messages=[
42                {
43                    "role": "system",
44                    "content": "Eres un experto en la empresa. Responde concisamente."
45                },
46                {
47                    "role": "user",
48                    "content": prompt
49                }
50            ],
51            temperature=0.3,
52            max_tokens=300
53        )
54 
55        return response.choices[0].message.content

1Ventajas:
2├── Setup rápido (horas)
3├── Bajo costo inicial
4├── Fácil de iterar
5└── Data siempre actualizada
6 
7Métricas a monitorear:
8├── % respuestas útiles
9├── Consultas que fallan
10├── Latencia
11└── Feedback de usuarios

1Después de 2-4 semanas de datos:
2 
3Analizar:
4├── ¿Hay preguntas que RAG siempre falla?
5├── ¿Hay respuestas donde el tone no es consistente?
6├── ¿Hay tipos de consultas recurrentes?
7└── ¿Hay patrones de razonamiento complejos?
8 
9Si identifies patrón → Candidato para fine-tuning

1Fine-tuning selectivo:
2├── Solo para 200-500 ejemplos clave
3├── Enfocado en:
4│   ├── Casos de uso críticos
5│   ├── Comportamiento específico de marca
6│   └── Razonamientos complejos
7├── Costo bajo (2-10 USD)
8└── Ganancias medibles (~5-15% mejor)
9 
10Resultado: Sistema híbrido optimizado

1RAG Only:
2├── Vector DB: Pinecone Free = $0
3├── Embeddings (1K docs): $0.01
4├── LLM queries (1,000/día × 30): ~$15/mes
5├── Mantenimiento: 2 horas/semana
6└── Total: ~$15-20/mes
7 
8Fine-tuning:
9├── Training (1-shot): $5
10├── Inference (1,000/día): $30/mes
11├── Re-training (mensual): $5/mes
12└── Total: ~$40/mes
13 
14GANADOR: RAG ($20 vs $40)

1RAG Only:
2├── Vector DB (10K docs): $15/mes
3├── Embeddings: $0.10
4├── LLM queries (10K/día): $150/mes
5└── Total: ~$165/mes
6 
7Fine-tuned Only:
8├── Training: $20
9├── Inference (10K/día): $300/mes
10├── Re-training (mensual): $20/mes
11└── Total: ~$340/mes
12 
13Hybrid (80% RAG, 20% Fine-tuned):
14├── RAG: $132/mes
15├── Fine-tuned (2K queries): $60/mes
16├── Training: $5/mes
17└── Total: ~$197/mes
18 
19GANADOR: Hybrid ($197 vs $165 vs $340)
20Explicación: Mejor calidad, costo contenido

1RAG Only:
2├── Vector DB managed: $500/mes
3├── Embeddings: $1
4├── LLM queries (100K/día): $1,500/mes
5├── SLA/Support: $500/mes
6└── Total: ~$2,500/mes
7 
8Fine-tuned Only:
9├── Custom model hosting: $2,000/mes
10├── Training/re-training: $300/mes
11├── Inference: $3,000/mes
12└── Total: ~$5,300/mes
13 
14Hybrid (75% RAG, 25% Fine-tuned):
15├── RAG: $1,875/mes
16├── Fine-tuned (25K queries): $750/mes
17├── Model hosting: $1,000/mes
18└── Total: ~$3,625/mes
19 
20GANADOR: Hybrid ($3,625) - mejor calidad + costos