La ingeniería de IA se ha convertido rápidamente en uno de los conjuntos de habilidades más valiosos en tecnología
El problema es que la mayoría de los principiantes no tienen una idea clara de lo que realmente deberían estudiar
Algunos comienzan con teoría de aprendizaje automático
Algunos se quedan atrapados viendo tutoriales sin parar
Otros saltan directamente a los prompts y agentes sin entender APIs, conceptos básicos de backend o cómo se construyen realmente los productos reales
El resultado suele ser el mismo: mucha confusión y muy poca habilidad práctica
Si tu objetivo es convertirte en ingeniero de IA, no necesitas dominar todos los campos de la inteligencia artificial
Necesitas aprender a construir sistemas de IA útiles en el mundo real
Eso significa aprender a:
- construir aplicaciones completas con LLMs
- trabajar con APIs de modelos como OpenAI y Anthropic
- diseñar correctamente prompts y contexto
- usar salidas estructuradas y llamadas a herramientas
- agregar recuperación cuando sea necesario
- desplegar proyectos para que la gente pueda usarlos realmente
Esta guía fue creada para darte un plan práctico de 6 meses
El artículo tiene más de 10,000 PALABRAS, por lo que leerlo puede tomar algunas horas o incluso más
Pero su valor real es que para cada habilidad que necesitas aprender, hay recursos y explicaciones claras de qué hacer
De esa manera, en seis meses puedes alcanzar el nivel de ingeniería de IA, y empezar a usarlo por ti mismo ya dentro de los primeros 1-2 meses
Escribir este artículo tomó más de 40 HORAS, y trabajé en él junto con mi amigo @andy_ai0
Él acaba de empezar a construir su marca personal en X, pero entiende muy bien la IA y ayudó mucho con este artículo
Definitivamente creo que merece tu seguimiento y apoyo mientras crece
Ahora empecemos a leer el artículo ⬇️
Lo que realmente hace un ingeniero de IA
Mucha gente escucha la frase "ingeniero de IA" e imagina a alguien entrenando modelos gigantes desde cero
En realidad, la mayoría de los ingenieros de IA modernos hacen algo mucho más práctico
Construyen productos y sistemas sobre modelos existentes
Eso generalmente incluye:
- conectarse a APIs de LLM
- diseñar prompts y flujos de contexto
- construir sistemas de chat, búsqueda o automatización
- integrar herramientas, bases de datos y APIs externas
- manejar salidas estructuradas
- mejorar fiabilidad, costo y latencia
- desplegar funciones de IA en aplicaciones reales
Así que en la práctica, un ingeniero de IA a menudo se sitúa entre:
- ingeniería de software
- ingeniería de producto
- automatización
- IA aplicada
Por eso el rol está creciendo tan rápido
Las empresas no solo necesitan investigadores
Necesitan personas que puedan tomar modelos y convertirlos en productos útiles
Por eso también esta hoja de ruta se centra menos en teoría pesada y más en ejecución práctica
Si puedes construir aplicaciones reales de LLM, sistemas de recuperación, automatizaciones y flujos de trabajo listos para producción, ya estás mucho más cerca de ser empleable que la mayoría de los principiantes
⏩------------------------------------------------------------------------⏪
Mes 1: Vuélvete lo suficientemente sólido en programación y fundamentos
Tu objetivo este mes: Convertirte en un desarrollador Python funcional
No necesitas ser un experto, solo necesitas dejar de buscar sintaxis básica en Google y poder construir programas simples con confianza
La ingeniería de IA es ante todo ingeniería de software
Todo lo que viene en los meses siguientes asume que puedes escribir Python limpio, usar la terminal, llamar APIs y gestionar un código base. Este mes es tu base
Qué aprender
1. Python
Python es el lenguaje de la ingeniería de IA. Punto final. Casi todas las bibliotecas, APIs y tutoriales que encontrarás en los próximos seis meses están en Python
Cómo aprenderlo:
Comienza con un curso estructurado que te obligue a escribir código, no solo a ver videos
El error más común que cometen los principiantes es consumir contenido pasivamente, leer, asentir y nunca abrir un editor de código
Combate esto programando cada ejemplo mientras avanzas
Recursos:
1. Python para Todos (Coursera, gratuito para auditar)
Enlace: https://www.coursera.org/specializations/python
El mejor punto de partida para principiantes absolutos. El Dr. Chuck es uno de los profesores de Python más amigables con principiantes en internet
2. Curso de Python de freeCodeCamp (YouTube, gratuito)
Enlace: https://www.youtube.com/watch?v=rfscVS0vtbw
Un video completo de 4 horas que cubre todos los fundamentos
3. CS50P: Introducción a la Programación con Python (Harvard, gratuito)
Enlace: https://cs50.harvard.edu/python/
Más riguroso. Incluye conjuntos de problemas y un proyecto final. Excelente si quieres estructura
4. Documentación oficial de Python (el tutorial)
Enlace: https://docs.python.org/3/tutorial/
Seca pero autorizada, úsala como referencia
Qué enfocar:
- Variables, tipos de datos, bucles, condicionales, funciones
- Listas, diccionarios, conjuntos, tuplas
- Entrada/salida de archivos y trabajo con JSON
- Clases y POO básica (suficiente para entender lo que lees)
- Manejo de errores con try/except
- Entornos virtuales (venv) y pip
- Gestión de paquetes – entender requirements.txt
Proyecto de práctica: Construye una herramienta CLI simple en Python. Algo como un rastreador de gastos personal que lea/escriba en un archivo JSON, o un script que llame a una API pública (como una API del clima) e imprima resultados formateados
2. Git y GitHub
Git es cómo los desarrolladores profesionales guardan y comparten código. Lo necesitarás constantemente para versionar tus proyectos, colaborar y mostrar tu trabajo de portafolio en GitHub
Cómo aprenderlo:
Git es confuso al principio porque el modelo mental no es obvio
No intentes memorizar comandos; en su lugar, entiende qué problema resuelve Git
(rastrear cambios, permitir colaboración, permitir deshacer errores) y los comandos tendrán sentido
Recursos:
1. GitHub Skills (gratuito, interactivo)
Enlace: https://skills.github.com/
Cursos interactivos oficiales dentro de GitHub. Empieza aquí
2. Aprende Git Branching (gratuito, interactivo)
Enlace: https://learngitbranching.js.org/
Sin duda la mejor herramienta visual para entender ramas y fusiones
3. Libro Pro Git (libro en línea gratuito)
Enlace: https://git-scm.com/book/es/v2
La referencia completa. Salta a los capítulos que necesites
Qué enfocar:
- git init, add, commit, push, pull
- Ramificación y fusión
- Entender .gitignore
- Crear repositorios en GitHub y subir proyectos locales
- Leer y escribir archivos README básicos
Práctica: De ahora en adelante, cada proyecto que construyas, incluso scripts pequeños, debe vivir en un repositorio de GitHub. Esto crea el hábito y te da un portafolio
3. Conceptos básicos de CLI / Terminal
Como ingeniero de IA, ejecutarás scripts, instalarás paquetes, gestionarás servidores y navegarás archivos completamente desde la línea de comandos
Ser lento o tener miedo en la terminal es un verdadero cuello de botella
Recursos:
1. Los 50 comandos más populares de Linux y Terminal (curso completo para principiantes)
Enlace: https://www.youtube.com/watch?v=ZtqBQ68cfJc
Bueno para principiantes absolutos en Linux/Mac
2. El Semestre Perdido de tu Educación en Ciencias de la Computación (MIT, gratuito)
Enlace: https://missing.csail.mit.edu/
Cubre scripting de shell, herramientas de terminal y la fluidez en línea de comandos que la mayoría de los cursos de CS omiten
Qué enfocar:
- Navegación: cd, ls, pwd, mkdir, rm
- Lectura de archivos: cat, less, grep
- Ejecutar scripts de Python desde la terminal
- Variables de entorno
- Comprensión básica de PATH
4. JSON, APIs, HTTP y Conceptos básicos de Async
Llamarás a APIs de LLM desde el primer día del Mes 2
Eso significa que necesitas entender cómo funcionan las APIs web antes de tocar los SDK de OpenAI o Anthropic
Recursos:
1. Conceptos básicos de HTTP – MDN Web Docs (gratuito)
Enlace: https://developer.mozilla.org/es/docs/Web/HTTP/Overview
La explicación más clara de cómo funcionan las solicitudes y respuestas HTTP
2. Tutorial de API REST
Enlace: https://restfulapi.net/
Corto y práctico
3. Documentación de la biblioteca requests de Python
Enlace: https://requests.readthedocs.io/en/latest/
Aprende a llamar a cualquier API web en Python
4. Async/await de Python (gratuito)
Enlace: https://realpython.com/async-io-python/
Entender async es esencial para trabajar con respuestas de LLM en streaming más adelante
Qué enfocar:
- Solicitudes GET, POST – qué son y cómo hacerlas en Python
- Leer y escribir JSON
- Códigos de estado HTTP (200, 400, 401, 404, 500 – qué significa cada uno)
- Qué es una clave de API y patrones básicos de autenticación
- Qué hacen async def y await y por qué existen
Proyecto de práctica: Escribe un script de Python que llame a una API pública gratuita (prueba Open-Meteo para datos meteorológicos – no se necesita clave de API) y formatee el resultado como una salida JSON limpia
5. SQL básico y Pandas
No necesitarás ser un científico de datos, pero necesitarás regularmente inspeccionar, consultar y manipular datos
Los conceptos básicos de SQL y la fluidez en Pandas te ahorrarán tiempo constantemente
Recursos:
1. SQLBolt (gratuito, interactivo)
Enlace: https://sqlbolt.com/
La forma más rápida de aprender SQL desde cero. 20 lecciones cortas con ejercicios en el navegador
2. Guía de inicio oficial de Pandas
Enlace: https://pandas.pydata.org/docs/getting_started/index.html
Trabaja con el tutorial "10 Minutes to Pandas"
3. Curso de Pandas de Kaggle (gratuito)
Enlace: https://www.kaggle.com/learn/pandas
Práctico, breve y directo
Qué enfocar:
- SQL: SELECT, WHERE, GROUP BY, JOIN, ORDER BY
- Pandas: cargar CSV, filtrar filas, seleccionar columnas, agregaciones básicas
6. FastAPI
Recursos:
1. Tutorial oficial de FastAPI (gratuito)
Enlace: https://fastapi.tiangolo.com/tutorial/
Sinceramente, una de las mejores documentaciones de framework jamás escritas
Trabájalo de principio a fin. Cubre parámetros de ruta, cuerpos de solicitud, validación con Pydantic y ejecución de un servidor de desarrollo
2. Desarrollo de API en Python (Curso de 19 horas, freeCodeCamp, YouTube, gratuito)
Enlace: https://www.youtube.com/watch?v=ZtqBQ68cfJc
Cubre fundamentos de diseño de API incluyendo rutas, serialización, validación de esquemas e integración con bases de datos SQL. Construye una API completa estilo red social desde cero
Qué enfocar: Crear endpoints GET y POST, parámetros de ruta y consulta, cuerpos de solicitud con Pydantic, ejecutar uvicorn y usar la interfaz /docs integrada de FastAPI para probar tu API sin escribir un cliente
Hito del Mes 1
Al final de este mes deberías ser capaz de:
- Escribir programas en Python que lean/escriban archivos, llamen APIs y manejen errores
- Versionar tu código con Git y subir proyectos a GitHub
- Navegar la terminal sin dudar
- Entender qué es una solicitud HTTP y hacer una en Python
- Consultar una base de datos SQLite con SQL básico
- Construir y ejecutar una aplicación FastAPI simple localmente
⏩------------------------------------------------------------------------⏪
Mes 2: Domina el Desarrollo de Aplicaciones con LLM
Tu objetivo este mes: Construir aplicaciones reales impulsadas por IA usando las APIs de OpenAI y Anthropic
Al final deberías sentirte cómodo escribiendo prompts que funcionen de manera confiable, obteniendo datos estructurados de los modelos, haciendo que llamen a tus funciones y manejando todo lo que pueda salir mal
Este es el núcleo de la ingeniería de IA. Todo lo demás en la hoja de ruta se construye sobre lo que aprendes aquí
Qué aprender
1. Fundamentos de Prompting
Hacer prompting no es solo hacer preguntas de forma amable. Es el arte de escribir instrucciones que generen resultados consistentes y confiables a partir de modelos que son fundamentalmente probabilísticos
Como ingeniero de IA, pasarás una cantidad sorprendente de tiempo aquí
Cómo aprenderlo:
Comienza con el tutorial interactivo de Anthropic porque es el más práctico
Luego lee la guía oficial de OpenAI. Después, la Guía de Ingeniería de Prompts consolida todo
Trabaja los tres en orden – cada uno refuerza a los demás
Recursos:
1. Tutorial Interactivo de Ingeniería de Prompts de Anthropic (gratuito, GitHub)
Enlace: https://github.com/anthropics/prompt-eng-interactive-tutorial
Un curso paso a paso dividido en 9 capítulos con ejercicios, diseñado para darte muchas oportunidades de practicar la escritura y depuración de prompts por ti mismo
Ejecútalo como cuadernos Jupyter con la API de Claude
2. Documentación de Ingeniería de Prompts de Anthropic (gratuito)
Enlace: https://docs.anthropic.com/en/docs/build-with-claude/prompt-engineering/overview
La referencia oficial. Cubre desde claridad básica hasta estructuración XML y sistemas agentes
3. Guía de Ingeniería de Prompts de OpenAI (gratuito)
Enlace: https://platform.openai.com/docs/guides/prompt-engineering
La guía oficial de OpenAI, que cubre formatos de prompt que funcionan bien con sus modelos y generan salidas más útiles
4. [PromptingGuide.ai](//PromptingGuide.ai) (gratuito)
Enlace: https://www.promptingguide.ai/
Cubre técnicas esenciales desde prompting básico hasta estrategias avanzadas, además de llamadas a funciones, integración de herramientas y sistemas agentes
Qué enfocar: La diferencia entre mensajes de sistema y usuario, por qué la especificidad importa, prompting de cadena de pensamiento (piensa paso a paso), usar ejemplos en prompts (few-shot) y cómo pequeños cambios en la redacción pueden alterar drásticamente la calidad de la salida
Práctica: Toma una tarea real – resumir un documento, extraer información clave de un texto, clasificar un comentario – y escribe 5 prompts diferentes para ella. Compara las salidas. Verás inmediatamente cómo el diseño del prompt afecta la fiabilidad
3. Salidas Estructuradas / Esquemas JSON
En aplicaciones reales, casi nunca quieres texto sin procesar de un LLM; quieres datos estructurados que puedas analizar, almacenar y usar en tu código
Las salidas estructuradas resuelven esto forzando al modelo a coincidir con un esquema que tú defines
Recursos:
1. Guía de Salidas Estructuradas de OpenAI (documentación oficial, gratuito)
Enlace: https://platform.openai.com/docs/guides/structured-outputs
Cubre la función que asegura que los modelos siempre generen respuestas que se adhieran a tu Esquema JSON, para que no tengas que preocuparte por claves faltantes o valores alucinados
2. Biblioteca Instructor (gratuito, código abierto)
Enlace: https://python.useinstructor.com/
La forma más limpia de obtener salidas estructuradas de cualquier proveedor de LLM usando modelos Pydantic
Funciona con OpenAI, Anthropic, Google y más de 15 proveedores usando la misma interfaz de código, con reintentos automáticos cuando la validación falla
Esto es lo que la mayoría de los ingenieros de IA en producción usan realmente
3. Cookbook de OpenAI: Introducción a Salidas Estructuradas (gratuito)
Enlace: https://developers.openai.com/cookbook/examples/structured_outputs_intro/
Ejemplos prácticos que cubren salidas de cadena de pensamiento, extracción estructurada de datos y generación de UI, bueno para entender casos de uso del mundo real
Qué enfocar: Definir modelos Pydantic para tus datos, pasar esquemas a la API, entender la diferencia entre salidas estructuradas y modo JSON, y manejar rechazos con gracia
Proyecto de práctica: Construye un analizador de facturas o recibos. Dale texto sin procesar (ej. "Factura #123, $45.99 por 3 artículos, vence el 30 de marzo") y haz que devuelva un objeto Python estructurado con campos como numero_factura, monto, articulos, fecha_vencimiento
4. Llamada a Funciones / Herramientas
La llamada a herramientas es lo que transforma a un LLM de un generador de texto en algo que puede tomar acciones – buscar en la web, consultar una base de datos, llamar a tu API, ejecutar código. Es una de las habilidades más importantes en toda esta guía
Cómo entenderlo: El modelo no ejecuta realmente tus funciones
Examina el prompt y devuelve una llamada estructurada con el nombre de la función y los argumentos cuando decide que se debe usar una herramienta
Tu código entonces ejecuta la llamada y envía el resultado de vuelta
Recursos:
1. Guía de Llamada a Funciones de OpenAI (documentación oficial, gratuito)
Enlace: https://platform.openai.com/docs/guides/function-calling
La referencia definitiva. Cubre definición de herramientas, el flujo de 5 pasos para llamar, llamadas paralelas y mejores prácticas
2. Documentación de Uso de Herramientas de Anthropic (gratuito)
Enlace: https://docs.anthropic.com/en/docs/build-with-claude/tool-use
La guía equivalente de Anthropic para Claude. Los conceptos son los mismos, la sintaxis es ligeramente diferente
3. Cookbook de OpenAI: Cómo Llamar Funciones con Modelos de Chat (gratuito, GitHub)
Un cuaderno ejecutable completo que recorre el bucle completo de llamada a herramientas con ejemplos reales
Qué enfocar: Describir funciones claramente en Esquema JSON, analizar respuestas de llamadas a herramientas, ejecutar la función y devolver los resultados, manejar casos donde no se necesita llamada a herramienta, y el concepto de tool_choice: "auto"
Proyecto de práctica: Construye un asistente simple que tenga tres herramientas: obtener_clima(ciudad), calcular(expresion) y buscar_notas(consulta) (solo busca en un diccionario fijo). Conéctalas todas y observa cómo el modelo decide cuál llamar según lo que le preguntes
5. Respuestas en Streaming
Streaming significa mostrar la salida del modelo mientras se genera – palabra por palabra – en lugar de esperar la respuesta completa. Hace que tus aplicaciones se sientan dramáticamente más rápidas y vivas
Recursos:
1. Documentación de Streaming de OpenAI (oficial, gratuito)
Enlace: https://platform.openai.com/docs/api-reference/streaming
La referencia para añadir stream=True a las solicitudes e iterar sobre fragmentos
2. Documentación de Streaming de Anthropic (oficial, gratuito)
Enlace: https://docs.anthropic.com/en/api/messages-streaming
Referencia de la API de streaming de Anthropic con ejemplos en Python
3. Cómo Funcionan las APIs de LLM en Streaming – Simon Willison (gratuito)
Enlace: https://til.simonwillison.net/llms/streaming-llm-apis
Un desglose técnico claro de cómo funcionan los Eventos Enviados por el Servidor (Server-Sent Events) bajo el capó para OpenAI, Anthropic y Google, útil para entender lo que realmente sucede a nivel HTTP
Qué enfocar: Establecer stream=True, iterar sobre fragmentos delta, ensamblar la respuesta completa a partir de partes y conectar el streaming a un endpoint de FastAPI usando StreamingResponse
Consejo: El streaming es casi siempre la opción correcta para aplicaciones orientadas al usuario. Nadie quiere mirar un indicador de carga durante 10 segundos esperando que aparezca una respuesta completa de una vez
5. Estado de la Conversación
Los LLM no tienen estado – no tienen memoria entre llamadas. El historial de la conversación es algo que gestionas enviando la lista completa de mensajes con cada solicitud. Entender esto es fundamental
Recursos:
1. Guía de Completaciones de Chat de OpenAI, Gestión de Conversaciones (oficial, gratuito)
Enlace: https://platform.openai.com/docs/guides/conversation-state
La explicación canónica de cómo funciona el array de mensajes y cómo gestionar conversaciones de múltiples turnos
2. Documentación de la API de Mensajes de Anthropic (oficial, gratuito)
Enlace: https://docs.anthropic.com/en/api/messages
El equivalente de Anthropic. Mismo concepto, vale la pena leer ambos para ver cómo difieren
Qué enfocar: La estructura del array de mensajes, por qué agregas tanto mensajes de usuario como de asistente, límites de la ventana de contexto y qué sucede cuando los excedes, y estrategias básicas de truncamiento (eliminar los mensajes más antiguos, resumir el historial)
Proyecto de práctica: Construye un chatbot simple de múltiples turnos en la terminal. Cada turno se agrega a la lista de mensajes. Añade un comando /reset para borrar el historial e imprime el conteo actual de tokens después de cada intercambio
6. Costo, Latencia y Conceptos Básicos de Tokens
Lanzar aplicaciones de IA sin entender costos y tokens es cómo terminas con facturas sorpresa y aplicaciones lentas. Esto es aburrido pero crítico
Recursos:
1. Página de Precios de OpenAI (oficial)
Enlace: https://openai.com/api/pricing
Conoce cuánto cuestan los tokens de entrada y salida por modelo. Marca esto como favorito y revísalo cada vez que elijas un modelo
2. Página de Precios de Anthropic (oficial)
Enlace: https://www.anthropic.com/pricing
Lo mismo para los modelos de Claude
3. Herramienta Tokenizer de OpenAI (gratuito, interactivo)
Enlace: https://platform.openai.com/tokenizer
Pega cualquier texto y ve exactamente cuántos tokens tiene. Úsalo constantemente mientras aprendes
4. Tiktoken (biblioteca de Python, gratuito)
Enlace: https://github.com/openai/tiktoken
La biblioteca tokenizer de OpenAI para contar tokens en código antes de enviar solicitudes
Qué enfocar: Qué es un token (aproximadamente 4 caracteres / 3/4 de una palabra), cómo los tokens de entrada vs salida tienen precios diferentes, cómo el tamaño de la ventana de contexto afecta lo que puedes hacer, y la compensación de latencia entre modelos más pequeños y rápidos frente a modelos más grandes e inteligentes
También: no uses GPT-4/Opus para todo – los modelos más baratos a menudo son suficientemente buenos para tareas simples
7. Manejo de Fallos
Las APIs de LLM fallan. Se alcanzan límites de tasa, las respuestas expiran, el modelo devuelve JSON malformado. Manejar los fallos con elegancia es lo que separa una demo de una aplicación en producción
Recursos:
1. Referencia de Códigos de Error de OpenAI (oficial, gratuito)
Enlace: https://platform.openai.com/docs/guides/error-codes
Cada tipo de error que encontrarás y qué hacer al respecto
2. Documentación de Manejo de Errores de Anthropic (oficial, gratuito)
Enlace: https://docs.anthropic.com/en/api/errors
Lo mismo para Claude
3. Tenacity (biblioteca de Python, gratuito)
Enlace: https://tenacity.readthedocs.io/
Una biblioteca limpia para añadir lógica de reintento con retroceso exponencial a cualquier función de Python. Un decorador y tus reintentos están gestionados
Qué enfocar: Errores de límite de tasa (429) y retroceso exponencial, manejo de tiempos de espera con httpx/requests, validar la salida del modelo antes de usarla, estrategias de respaldo (reintentar con un modelo diferente, devolver una respuesta en caché) y nunca hacer que tu aplicación se bloquee porque el LLM devolvió una salida inesperada
8. Conciencia de Inyección de Prompts
La inyección de prompts es el riesgo de seguridad #1 en aplicaciones de LLM
Ocurre cuando la entrada de usuario no confiable se combina con instrucciones del sistema, permitiendo que un usuario altere, anule o inyecte un nuevo comportamiento en el prompt – haciendo que el sistema realice acciones no deseadas o genere salidas manipuladas
No necesitas ser un experto en seguridad, pero necesitas saber que esto existe antes de lanzar cualquier cosa
Recursos:
1. OWASP Top 10 para Aplicaciones LLM – LLM01: Inyección de Prompts (gratuito)
Enlace: https://genai.owasp.org/llmrisk/llm01-prompt-injection/
La clasificación oficial que cubre inyecciones directas (jailbreaking), inyecciones indirectas a través de contenido externo como documentos o sitios web, y escenarios de ataque del mundo real
2. OWASP Prompt Injection Prevention Cheat Sheet (gratuito)
Enlace: https://cheatsheetseries.owasp.org/cheatsheets/LLM_Prompt_Injection_Prevention_Cheat_Sheet.html
Patrones defensivos prácticos: validación de entrada, control de privilegios y validación de salida
3. Evidently AI: What is Prompt Injection (gratuito)
Enlace: https://www.evidentlyai.com/llm-guide/prompt-injection-llm
Una explicación clara enfocada en desarrolladores sobre tipos de ataque, riesgos y patrones de diseño para mitigarlos
En qué centrarse: La diferencia entre inyección directa e indirecta, por qué los prompts del sistema no son realmente "seguros", el principio de mínimo privilegio para el acceso a herramientas, y nunca confiar en la salida no validada de un LLM para tomar decisiones consecuentes de forma automática
Hito del Mes 2
Al final de este mes deberías ser capaz de:
- Escribir prompts que produzcan salidas consistentes y confiables para una tarea determinada
- Obtener datos JSON estructurados de cualquier modelo usando Pydantic + Instructor
- Configurar llamadas a herramientas para que un modelo pueda invocar tus funciones en Python
- Transmitir respuestas en tiempo real a través de un endpoint de FastAPI
- Gestionar correctamente el historial de conversaciones de múltiples turnos
- Estimar el costo en tokens de una solicitud antes de enviarla
- Manejar errores de API, timeouts y salidas incorrectas sin que el sistema se caiga
- Explicar qué es la inyección de prompts y aplicar defensas básicas
⏩------------------------------------------------------------------------⏪
Mes 3: Aprende RAG a Fondo
Tu objetivo este mes: Construir sistemas que permitan a los LLMs responder preguntas a partir de tus documentos, no solo de sus datos de entrenamiento
Al final deberías ser capaz de ingerir documentos, incrustarlos y almacenarlos, recuperar los fragmentos correctos en el momento de la consulta, y producir respuestas fundamentadas, precisas y citables
RAG es la habilidad práctica más demandada en ingeniería de IA hoy en día. Casi todos los casos de uso empresarial reales de IA – chatbots de atención al cliente, bases de conocimiento internas, Q&A sobre documentos – se basan en esto
Entenderlo en profundidad, no solo copiar un tutorial, es lo que separa a los buenos ingenieros de los excelentes
1. Embeddings
Antes de construir un sistema RAG, necesitas entender qué son realmente los embeddings, porque son la base sobre la que se construye todo lo demás
Un embedding de texto es un fragmento de texto proyectado en un espacio vectorial de alta dimensión
La posición de ese texto en este espacio se representa como una larga secuencia de números
Lo crucial es que el texto semánticamente similar termina cerca en ese espacio, lo que hace posible la búsqueda por similitud
Recursos:
1. Stack Overflow Blog: An Intuitive Introduction to Text Embeddings (gratuito)
Enlace: https://stackoverflow.blog/2023/11/09/an-intuitive-introduction-to-text-embeddings/
La mejor explicación para principiantes. Escrito por un desarrollador que ha pasado años construyendo productos de NLP, centrado en desarrollar la intuición correcta más que en las matemáticas
2. Google ML Crash Course: Embeddings (gratuito)
Enlace: https://developers.google.com/machine-learning/crash-course/embeddings
Cubre por qué las representaciones vectoriales densas resuelven problemas que la codificación one-hot no puede – específicamente, capturar relaciones semánticas entre elementos
3. HuggingFace: Getting Started With Embeddings (gratuito)
Enlace: https://huggingface.co/blog/getting-started-with-embeddings
Guía práctica. Muestra cómo generar embeddings usando la librería sentence-transformers, alojarlos y usarlos para búsqueda semántica sobre un conjunto de datos real de FAQ
4. OpenAI Embeddings Guide (documentación oficial, gratuita)
Enlace: https://platform.openai.com/docs/guides/embeddings
La referencia para usar los modelos text-embedding-3-small y text-embedding-3-large de OpenAI en código
En qué centrarse: Qué es un vector conceptualmente, por qué el texto similar produce vectores similares, cómo funciona la similitud del coseno, la diferencia entre modelos de embedding (OpenAI, HuggingFace sentence-transformers), y qué significa la dimensión del embedding en la práctica
Práctica: Toma 20 oraciones sobre temas relacionados, incrústalas usando OpenAI o sentence-transformers, y escribe una búsqueda simple del vecino más cercano que devuelva las 3 más similares a una consulta. Esto es literalmente el corazón de RAG en miniatura
2. Chunking
Tus documentos son demasiado grandes para incrustarlos completos. El chunking es el proceso de dividirlos en piezas más pequeñas antes de incrustarlos
La forma en que fragmentes tus documentos afecta directamente la capacidad de tu sistema para encontrar información relevante y dar respuestas precisas; incluso un sistema de recuperación perfecto falla si busca sobre datos mal preparados
Recursos:
1. Weaviate: Chunking Strategies for RAG (gratuito)
Enlace: https://weaviate.io/blog/chunking-strategies-for-rag
La guía más práctica. Cubre chunking de tamaño fijo, recursivo y semántico, con indicaciones claras sobre cuándo usar cada uno
2. Unstructured: Chunking for RAG Best Practices (gratuito)
Enlace: https://unstructured.io/blog/chunking-for-rag-best-practices
Un análisis técnico profundo sobre tamaños de fragmento, solapamiento, y cómo la ventana de contexto del modelo de embedding impone límites estrictos
Un buen punto de partida para la experimentación es un tamaño de fragmento de alrededor de 250 tokens (aproximadamente 1000 caracteres), combinado con un solapamiento del 10-20% entre fragmentos consecutivos para evitar perder contexto en los límites
3. LangChain Text Splitters Docs (oficial, gratuito)
Enlace: https://python.langchain.com/docs/concepts/text_splitters/
La referencia práctica para usar RecursiveCharacterTextSplitter, MarkdownTextSplitter y divisores semánticos en código
En qué centrarse: Chunking de tamaño fijo con solapamiento como línea base, chunking recursivo para documentos estructurados, chunking semántico para una mejor detección de límites, y la compensación fundamental: fragmentos demasiado grandes pierden precisión en la recuperación; fragmentos demasiado pequeños pierden contexto
Consejo para principiantes: Comienza con RecursiveCharacterTextSplitter de LangChain con chunk_size=500 y chunk_overlap=50. Este es el valor predeterminado más sensato para la mayoría de los documentos y te da una línea base funcional desde la que mejorar
3. Bases de Datos Vectoriales
Una vez que tienes los embeddings, necesitas un lugar donde almacenarlos y buscarlos de manera eficiente. Para eso sirven las bases de datos vectoriales
La elección correcta depende de tu situación: usa Chroma para prototipado local rápido, Pinecone para escalabilidad gestionada llave en mano, Weaviate para flexibilidad open-source con potente búsqueda híbrida, Qdrant para filtros complejos y autoalojamiento rentable, y pgvector si ya usas PostgreSQL y quieres evitar añadir otro sistema
Recursos:
1. Chroma Official Docs (gratuito)
Enlace: https://docs.trychroma.com/
Chroma es perfecto para desarrolladores individuales y equipos pequeños que priorizan la velocidad de desarrollo y la simplicidad; funciona en memoria o localmente sin infraestructura que gestionar
2. Pinecone Learning Center (gratuito)
Enlace: https://www.pinecone.io/learn/
Excelentes tutoriales gratuitos que cubren conceptos de búsqueda vectorial, búsqueda híbrida y pipelines RAG. Buen material independiente del proveedor incluso si no usas Pinecone
3. Qdrant Documentation (gratuito)
Enlace: https://qdrant.tech/documentation/
La mejor opción open-source para producción con filtrado avanzado. Muy rápido, flexible y gratuito para autoalojar
4. pgvector (open source, gratuito)
Enlace: https://github.com/pgvector/pgvector
Si estás construyendo algo que ya usa PostgreSQL, pgvector añade búsqueda vectorial directamente a tu base de datos existente sin necesidad de nueva infraestructura
En qué centrarse: Crear una colección, insertar embeddings con metadatos, consultar por similitud con top_k, y filtrar por metadatos en tiempo de consulta
No necesitas entender los algoritmos de indexación (HNSW, IVF) – solo entender cómo usarlos
Proyecto práctico: Indexa 50-100 páginas de cualquier documentación pública (por ejemplo, la documentación de Python, o un volcado de artículos de Wikipedia) en Chroma con metadatos (URL de origen, título de sección). Escribe una función de consulta que recupere los 5 fragmentos más relevantes para cualquier pregunta
4. Filtrado por Metadatos
La búsqueda por similitud básica por sí sola no es suficiente para aplicaciones reales. El filtrado por metadatos te permite restringir la recuperación a un subconjunto relevante – por fecha, fuente, tipo de documento, usuario, categoría, o cualquier otro atributo que almacenes junto con cada fragmento
Recursos:
1. Pinecone: Metadata Filtering Guide (gratuito)
Enlace: https://docs.pinecone.io/guides/data/filter-with-metadata
Explicación clara con ejemplos de código sobre cómo filtrar vectores por campos de metadatos antes o durante la búsqueda por similitud
2. LlamaIndex: Metadata Filters Guide (documentación oficial, gratuita)
Enlace: https://docs.llamaindex.ai/en/stable/module_guides/querying/node_postprocessors/node_postprocessors/
Explica cómo aplicar filtros en tiempo de consulta en pipelines de LlamaIndex
En qué centrarse: Etiquetar cada fragmento con metadatos relevantes en el momento de la ingestión (nombre de archivo fuente, número de página, sección, fecha, categoría), y usar esos campos para filtrar resultados en el momento de la consulta. Esto es lo que marca la diferencia entre un demo de juguete y un sistema de producción donde los usuarios pueden preguntar "muéstrame solo resultados de los informes del Q4 2025-Q1 2026"
5. Reranking
El reranking es una técnica que añade un impulso semántico a la calidad de búsqueda de cualquier sistema de búsqueda por palabras clave o vectores
Después de que la recuperación de primera etapa devuelve un conjunto de candidatos, un reranker re-puntúa esos resultados basándose en la relevancia contextual real con respecto a la consulta – no solo en la proximidad vectorial
El patrón de dos etapas es: incrustar y buscar (rápido, aproximado) → rerankear top-k (más lento, más preciso). El resultado es una calidad de recuperación drásticamente mejor con solo un costo de latencia modesto
Recursos:
1. Cohere Reranking Docs (oficial, gratuito)
Enlace: https://docs.cohere.com/docs/reranking-with-cohere
El mejor lugar para empezar. Cubre el flujo de trabajo completo de reranking, incluyendo datos semiestructurados como correos electrónicos y documentos JSON. Requiere solo una línea de código para añadirlo a un pipeline de recuperación existente
2. LangChain: Cohere Reranker Integration (documentación oficial, gratuita)
Enlace: https://python.langchain.com/docs/integrations/retrievers/cohere-reranker/
Explica cómo conectar el reranking de Cohere en un recuperador de LangChain usando ContextualCompressionRetriever
En qué centrarse: El patrón de dos etapas recuperar-luego-rerankear, la diferencia entre un bi-encoder (usado para la búsqueda de embedding de primera etapa) y un cross-encoder (usado para reranking), y la compensación práctica entre latencia y calidad al rerankear top-20 vs top-5 resultados
6. Problemas de Calidad en la Recuperación
La mayoría de los fallos de RAG no son fallos del modelo, son fallos de recuperación. Entender las formas en que la recuperación puede salir mal es esencial para depurar sistemas reales
Problemas comunes a aprender:
- Deriva semántica: El embedding de la consulta no coincide con el embedding del fragmento relevante aunque la información esté ahí. Solución: prueba con reescritura de consultas o HyDE (Hypothetical Document Embeddings)
- Problemas de límites de fragmentos: La información relevante está dividida entre dos fragmentos. Solución: aumenta el solapamiento o usa chunking semántico
- Falta de contexto de metadatos: Los fragmentos son semánticamente similares a la consulta pero pertenecen al documento, fecha o usuario incorrecto. Solución: usa filtrado por metadatos
- Top-k demasiado pequeño: El fragmento correcto existe pero no está entre los 5 primeros recuperados. Solución: aumenta el top_k en la recuperación y reduce después del reranking
Recursos:
1. LangChain: Query Transformations (gratuito)
Enlace: https://python.langchain.com/docs/how_to/#query-analysis
Cubre reescritura de consultas, step-back prompting y HyDE
2. Pinecone: Improving Retrieval Quality (gratuito)
Enlace: https://www.pinecone.io/learn/retrieval-augmented-generation/#retrieval-quality
Recorrido práctico de modos de fallo comunes con soluciones
7. Reducción de Alucinaciones
RAG reduce drásticamente las alucinaciones en comparación con un LLM básico, pero no las elimina
Al proporcionar al modelo hechos recuperados en tiempo de ejecución, RAG ancla sus respuestas a fuentes reales en lugar de depender solo de los datos de entrenamiento, y la salida del modelo puede incluso citar esas fuentes, aumentando la transparencia y la confianza
Pero los fallos de recuperación, los fragmentos incorrectos y la información contradictoria aún pueden hacer que el modelo invente cosas
Recursos:
1. Zep: Reducing LLM Hallucinations – A Developer's Guide (gratuito)
Enlace: https://www.getzep.com/ai-agents/reducing-llm-hallucinations/
Guía práctica enfocada en desarrolladores que cubre estrategias de anclaje de prompts, cadena de pensamiento para tareas factuales y patrones de verificación de salida
2. Voiceflow: 5 Ways to Reduce LLM Hallucinations (gratuito)
Enlace: https://www.voiceflow.com/blog/prevent-llm-hallucinations
Buena visión general de la estrategia combinada: RAG + cadena de pensamiento + guardarraíles juntos superan a cualquier enfoque individual
En qué centrarse: Indicar al modelo que responda solo a partir del contexto proporcionado (y que diga "No lo sé" cuando la respuesta no esté ahí), añadir un umbral de confianza antes de mostrar las respuestas, y validar siempre la calidad de la recuperación antes de culpar al LLM
8. Citas y Fundamentación
Un sistema RAG fundamentado no solo responde – te dice de dónde vino la respuesta. Esto es crítico para la confianza del usuario y para la depuración
Recursos:
1. Anthropic: Giving Claude Sources (documentación, gratuita)
Enlace: https://docs.anthropic.com/en/docs/build-with-claude/citations
Explica cómo indicar a Claude que produzca respuestas citadas con referencias a las fuentes
2. LangChain: RAG with Sources (gratuito)
Enlace: https://python.langchain.com/docs/how_to/qa_sources/
Explica cómo devolver documentos fuente junto con las respuestas en un pipeline RAG de LangChain
En qué centrarse: Pasar los metadatos de los fragmentos (nombre de archivo fuente, número de página, URL) al contexto del prompt, instruir al modelo para que referencie las fuentes en su respuesta, y mostrar esas fuentes en tu interfaz de usuario o respuesta de API
9. Tu Framework de RAG: LangChain o LlamaIndex
No necesitas construir un pipeline RAG desde cero. Dos frameworks dominan el espacio y vale la pena conocerlos:
LlamaIndex está optimizado para poner la búsqueda y la indexación primero – abstrae la ingestión, el chunking, el embedding y la consulta en unas pocas líneas de código, permitiéndote construir un prototipo funcional en una tarde
LangChain brilla cuando tu aplicación se parece más a un motor de orquestación – destaca con flujos de trabajo multi-agente, llamadas a herramientas y cadenas condicionales que consultan múltiples LLMs o APIs externas antes de generar una respuesta
Para el Mes 3, comienza con LlamaIndex para RAG. Pasa a LangChain cuando llegues al trabajo con agentes del Mes 4
Recursos:
1. LlamaIndex: Introduction to RAG (documentación oficial, gratuita)
Enlace: https://developers.llamaindex.ai/python/framework/understanding/rag/
Cubre las cinco etapas clave de RAG: carga, indexación, almacenamiento, consulta y evaluación – y cómo LlamaIndex maneja cada una
2. LlamaIndex Starter Tutorial (documentación oficial, gratuito)
Enlace: https://developers.llamaindex.ai/python/framework/getting_started/starter_example/
El inicio rápido oficial. Construye un sistema RAG funcional en menos de 30 líneas
3. LangChain: Build a RAG Agent (documentación oficial, gratuita)
Enlace: https://docs.langchain.com/oss/python/langchain/rag
Muestra cómo construir una aplicación de Q&A sobre texto no estructurado usando un agente RAG, desde una versión mínima de 40 líneas hasta un pipeline de recuperación completo con reranking
Proyecto práctico: Construye una aplicación de "chatea con tus documentos". Ingiere 10-20 archivos PDF o de texto (tus propias notas, un capítulo de libro de texto, documentación de producto – cualquier cosa). Construye un endpoint de FastAPI que acepte una pregunta, recupere los 5 fragmentos más relevantes con reranking, y devuelva una respuesta citada desde Claude u OpenAI. Esta es una pieza real para tu portafolio
Hito del Mes 3
Al final de este mes deberías ser capaz de:
- Explicar qué es un embedding y por qué el texto similar produce vectores similares
- Fragmentar cualquier documento de forma inteligente usando estrategias apropiadas
- Almacenar y consultar embeddings en una base de datos vectorial con filtrado por metadatos
- Añadir un paso de reranking para mejorar la calidad de la recuperación
- Depurar fallos comunes de recuperación de forma sistemática
- Construir un pipeline RAG completo de extremo a extremo usando LlamaIndex o LangChain que ingiera documentos, recupere fragmentos relevantes y devuelva respuestas fundamentadas y citadas
⏩------------------------------------------------------------------------⏪
Mes 4: Agentes, Herramientas, Flujos de Trabajo y Evaluaciones
Tu objetivo este mes: Construir sistemas de IA que puedan tomar secuencias de acciones de forma autónoma, conectar flujos de trabajo de múltiples pasos y evaluar críticamente si están funcionando
Al final deberías ser capaz de construir un agente real desde cero, entender cuándo los agentes son la elección incorrecta y medir el rendimiento de cualquier cosa que construyas
Aquí es donde la ingeniería de IA se vuelve genuinamente compleja. Las habilidades del Mes 4 son lo que separa a los ingenieros de IA junior de las personas que pueden manejar una funcionalidad completa de IA de principio a fin
1. Bucles de Agentes
Un agente no es magia, es un patrón sorprendentemente simple
Piensa en los agentes como sistemas orientados a objetivos que continuamente recorren un ciclo de observar, razonar y actuar
Este bucle les permite abordar tareas que van más allá de simples preguntas y respuestas, adentrándose en la automatización real, el uso de herramientas y la adaptación sobre la marcha
El "pensamiento" ocurre en el prompt, la "ramificación" es cuando el agente elige entre las herramientas disponibles, y la "acción" ocurre cuando llamamos a funciones externas. Todo lo demás es solo fontanería
Una vez que interiorices esto, incluso los frameworks de agentes más complejos se vuelven legibles
Recursos:
1. Anthropic: Building Effective Agents (oficial, gratuito)
Enlace: https://www.anthropic.com/research/building-effective-agents
El mejor texto escrito sobre agentes en producción. Léelo antes de escribir una sola línea de código de agente
2. OpenAI: A Practical Guide to Building Agents (PDF oficial, gratuito)
Enlace: https://cdn.openai.com/business-guides-and-resources/a-practical-guide-to-building-agents.pdf
La guía complementaria de OpenAI que cubre patrones de agentes, guardarraíles y patrones de seguridad en producción
3. freeCodeCamp: The Open Source LLM Agent Handbook (gratuito)
Enlace: https://www.freecodecamp.org/news/the-open-source-llm-agent-handbook/
Una guía práctica completa que cubre el bucle del agente, LangGraph, CrewAI, planificación, memoria y uso de herramientas. Buena para ponerse manos a la obra rápidamente
4. LangChain Academy: Introduction to LangGraph (curso gratuito)
Enlace: https://academy.langchain.com/courses/intro-to-langgraph
El curso gratuito oficial para LangGraph, el framework de orquestación de agentes más utilizado. Cubre estado, memoria, humano-en-el-bucle y más
En qué centrarse: El ciclo percibir → planificar → actuar → observar, cómo termina el bucle del agente, qué sucede cuando una llamada a herramienta falla dentro de un bucle, y por qué los agentes son solo bucles while con un LLM tomando las decisiones de ramificación
Práctica: Construye un agente desde cero sin ningún framework – solo la API de OpenAI o Anthropic directamente. Asígnale 3 herramientas, un objetivo y un bucle. Esto es lo más valioso que puedes hacer para entender realmente lo que los frameworks están abstrayendo
2. Selección de Herramientas
Escribir buenas herramientas es la mitad del trabajo. Las descripciones de tus herramientas y sus parámetros son el manual de usuario para el LLM. Si el manual es vago, el LLM usará mal la herramienta. Sé dolorosamente, implacablemente explícito
Una herramienta mal descrita será llamada incorrectamente, llamada en el momento equivocado o ignorada por completo. Una herramienta bien descrita se comporta de manera predecible y se selecciona correctamente en una amplia gama de entradas
Recursos:
1. OpenAI: Function Calling Best Practices (documentación oficial, gratuita)
Enlace: https://platform.openai.com/docs/guides/function-calling/best-practices
La guía canónica para escribir descripciones de herramientas que funcionen de manera confiable, con convenciones de nomenclatura y patrones de documentación de parámetros
2. Anthropic: Tool Use Best Practices (documentación oficial, gratuita)
El equivalente de Anthropic. Presta especial atención a las indicaciones sobre cuándo dejar que el modelo elija vs forzar una herramienta específica
En qué centrarse: Escribir nombres de herramientas que sean verbos autoexplicativos, escribir descripciones que expliquen cuándo llamar a la herramienta (no solo qué hace), mantener los parámetros mínimos y bien tipados, y diseñar herramientas teniendo al LLM como el llamante
Consejo para principiantes: Prueba cada descripción de herramienta preguntándote: "Si no tuviera documentación y solo tuviera este esquema JSON, ¿sabría exactamente cuándo y cómo llamar a esto?" Si no, necesita más trabajo
3. Gestión de Estado
En LangGraph, el estado es un objeto de memoria compartida que fluye a través del grafo. Almacena toda la información relevante – mensajes, variables, resultados intermedios e historial de decisiones – y se gestiona automáticamente durante la ejecución
Entender el estado es la clave para construir agentes que puedan manejar tareas de múltiples turnos, recuperarse de fallos y realizar traspasos entre componentes de manera limpia
Recursos:
1. LangGraph Official Docs: State Management (gratuito)
Enlace: https://langchain-ai.github.io/langgraph/concepts/low_level/#state
La referencia definitiva. Cubre esquemas de estado, reductores y cómo fluye el estado a través de nodos y aristas
2. DataCamp: Tutorial de Agentes LangGraph (gratuito)
Enlace: https://www.datacamp.com/tutorial/langgraph-agents
Cubre los fundamentos del estado, nodos y aristas con código práctico, hasta llegar a agentes con estado y memoria persistente entre sesiones
3. Real Python: LangGraph en Python (gratuito)
Enlace: https://realpython.com/langgraph-python/
Un tutorial completo que construye un agente LangGraph con estado, con explicaciones detalladas del grafo de estado y aristas condicionales
En qué enfocarse: Definir esquemas de estado con TypedDict, cómo funcionan los reductores para fusionar actualizaciones paralelas, la diferencia entre estado en memoria y checkpointing persistente, y cómo las pausas con humano en el bucle funcionan inspeccionando y modificando el estado en medio de la ejecución
4. Reintentos y Manejo de Fallos en Agentes
Los agentes fallan de manera diferente a las llamadas LLM normales. Una mala llamada a herramienta en medio del bucle puede corromper el estado, causar bucles infinitos o producir respuestas incorrectas en silencio. Necesitas estrategias explícitas para todo esto
Recursos:
1. LangGraph: Manejo de Errores y Reintentos (documentación oficial, gratuita)
Enlace: https://langchain-ai.github.io/langgraph/how-tos/autofill-tool-errors/
Explica cómo añadir manejo automático de errores y lógica de reintentos a nivel de nodo de herramienta en LangGraph
2. Guía Práctica de Agentes de OpenAI: Sección de Guardrails (gratuita)
Enlace: https://cdn.openai.com/business-guides-and-resources/a-practical-guide-to-building-agents.pdf
Cubre los guardrails como una defensa en capas, combinando verificaciones basadas en LLM, filtros basados en reglas como regex y APIs de moderación para examinar tanto entradas como salidas en cada etapa del bucle del agente
En qué enfocarse: Límites máximos de iteración para evitar bucles infinitos, reintentos por herramienta con backoff exponencial, capturar y registrar excepciones en la capa de ejecución de herramientas sin colapsar el agente, y cuándo mostrar un fallo al usuario frente a reintentar en silencio
5. Cuándo NO Usar Agentes
Esta es una de las habilidades más importantes y más pasadas por alto en la ingeniería de IA. Los agentes son emocionantes, pero también son lentos, caros, impredecibles y difíciles de depurar. Saber cuándo optar por algo más simple es señal de buen criterio
Anthropic recomienda encontrar la solución más simple posible y solo aumentar la complejidad cuando sea necesario – esto puede significar no construir sistemas agentivos en absoluto
Los sistemas agentivos intercambian latencia y costo por un mejor rendimiento en la tarea, y debes considerar cuidadosamente cuándo tiene sentido este intercambio
El marco de decisión es:
- Usa una sola llamada LLM si la tarea se puede resolver en un solo prompt con el contexto adecuado
- Usa un workflow si los pasos son fijos y predecibles
- Usa un agente solo si el número de pasos es genuinamente impredecible y requiere toma de decisiones dinámica
Recursos:
1. Anthropic: Cómo construir agentes efectivos, cuándo usar agentes (oficial, gratuito)
Enlace: https://www.anthropic.com/research/building-effective-agents
La respuesta más autorizada a esta pregunta, directamente del equipo que construye los modelos
2. Simon Willison: Diseñando Bucles Agentivos (gratuito)
Enlace: https://simonwillison.net/2025/Sep/30/designing-agentic-loops/
La visión práctica de un ingeniero senior sobre cuándo la complejidad del agente está justificada y cómo pensar en el diseño de bucles agentivos
Qué memorizar: Una cadena de 3 llamadas LLM fijas siempre será más rápida, más barata y más depurable que un agente que podría hacer 3 llamadas. Reserva los agentes para tareas genuinamente abiertas
6. Workflows de Múltiples Pasos
Entre "un solo prompt" y "agente completo" hay un vasto terreno productivo intermedio: los workflows. Los workflows son ideales cuando la tarea se puede descomponer limpiamente en subtareas fijas – intercambiando latencia por mayor precisión al hacer que cada llamada LLM individual sea una tarea más fácil y enfocada
Los patrones comunes incluyen encadenamiento de prompts (la salida de una llamada es la entrada de la siguiente), enrutamiento (clasificar la entrada y enviarla a manejadores especializados), paralelización (ejecutar múltiples llamadas simultáneamente y agregar resultados), y orquestador-subagente (un LLM planifica, otros ejecutan)
Recursos:
1. Anthropic: Patrones de Workflow (oficial, gratuito)
Enlace: https://www.anthropic.com/research/building-effective-agents#workflow-patterns
Cubre todos los patrones principales con diagramas y ejemplos de código. Las secciones de paralelización y orquestación son particularmente útiles
2. LangGraph: Redes Multi-Agente (documentación oficial, gratuita)
Enlace: https://langchain-ai.github.io/langgraph/concepts/multi_agent/
Explica cómo conectar múltiples agentes como una red, con patrones de supervisor y traspaso
Proyecto práctico: Construye un pipeline de contenido de 3 pasos:
Paso 1 – un LLM extrae datos clave de un artículo
Paso 2 – otra llamada LLM usa esos datos para generar un tuit, una publicación de LinkedIn y un resumen en paralelo
Paso 3 – una llamada LLM final evalúa los tres por calidad y elige el mejor
No se necesita agente, workflow puro
7. Arneses de Evaluación
Las evaluaciones (evals) son cómo sabes si tu sistema de IA realmente funciona — no solo en los ejemplos que probaste manualmente, sino sistemáticamente con cientos de entradas
Los agentes de IA son potentes pero complejos de desplegar porque su comportamiento probabilístico y de múltiples pasos introduce muchos puntos de fallo
Diferentes partes de un agente – los LLMs, herramientas, recuperadores y workflows – necesitan su propio enfoque de evaluación
Recursos:
1. DeepEval (código abierto, gratuito)
Enlace: https://deepeval.com/docs/getting-started
Un framework de evaluación de LLM de código abierto inspirado en pytest. Escribe casos de prueba con entradas y salidas esperadas, ejecútalos con más de 50 métricas integradas que incluyen alucinación, relevancia de respuesta y consistencia factual, y detecta regresiones entre versiones
2. Promptfoo (código abierto, gratuito)
Enlace: https://github.com/promptfoo/promptfoo
Una CLI y biblioteca para probar y evaluar aplicaciones LLM con suites de prueba automatizadas. Admite comparación lado a lado de múltiples prompts en múltiples modelos, integración CI/CD y red teaming para vulnerabilidades de seguridad
3. LangSmith (nivel gratuito)
Enlace: https://smith.langchain.com/
Trazado, depuración y evaluación para aplicaciones LangChain y LangGraph. El nivel gratuito es generoso y la interfaz de trazado facilita enormemente la depuración de bucles de agente
4. Ragas (código abierto, gratuito)
Enlace: https://docs.ragas.io/
Framework de evaluación especializado para pipelines RAG. Mide fidelidad, relevancia de respuesta, precisión del contexto y recuperación del contexto. Esencial si estás evaluando sistemas RAG a partir del Mes 3
En qué enfocarse: Construir un conjunto de prueba dorado de 20-50 entradas representativas con salidas esperadas o rúbricas, escribir funciones de evaluación que puntúen salidas de forma determinista (coincidencia de cadenas, validación de esquema JSON) o con LLM como juez, y ejecutar evaluaciones automáticamente cuando cambies un prompt o intercambies un modelo
Mentalidad crítica: Las evaluaciones no son un pulido opcional. Cada cambio de prompt, intercambio de modelo o ajuste de recuperación que hagas sin ejecutar evaluaciones es una apuesta. Los ingenieros que envían productos de IA fiables ejecutan evaluaciones constantemente
8. Métricas de Éxito de Tareas
Más allá de las evaluaciones automatizadas, necesitas métricas que te digan si tu agente está logrando su objetivo real
Recursos:
1. Hamel Husain: Tu Producto de IA Necesita Evaluaciones (gratuito)
Enlace: https://hamel.dev/blog/posts/evals/
Uno de los escritos más prácticos sobre cómo construir pipelines de evaluación para sistemas de IA reales en producción, por alguien que lo ha hecho a escala
2. Framework de Evaluaciones de OpenAI (código abierto, gratuito)
Enlace: https://github.com/openai/evals
El propio framework de evaluación de OpenAI, con una gran biblioteca de patrones de evaluación aportados por la comunidad que puedes adaptar
En qué enfocarse: La diferencia entre métricas de proceso (¿llamó el agente a la herramienta correcta?) y métricas de resultado (¿tuvo éxito la tarea?), definir criterios de éxito claros antes de construir nada, y usar LLM como juez para la evaluación de salidas que resisten la coincidencia exacta (como respuestas largas o trazas de razonamiento de múltiples pasos)
Proyecto práctico: Toma tu pipeline RAG del Mes 3 y construye un arnés de evaluación adecuado alrededor. Crea 30 pares de preguntas y respuestas a partir de tus documentos, ejecútalos a través de tu pipeline y puntúa cada respuesta por relevancia, fidelidad y completitud usando DeepEval. Luego cambia una cosa (tamaño de fragmento, modelo, top-k) y vuelve a ejecutar para ver si mejoró
Hito del Mes 4
Al final de este mes deberías ser capaz de:
- Explicar qué es un bucle de agente e implementar uno desde cero sin un framework
- Escribir descripciones de herramientas que se seleccionen de forma correcta y fiable
- Gestionar el estado del agente correctamente usando LangGraph o equivalente
- Manejar fallos dentro de bucles de agente sin colapsar
- Decidir con confianza si una tarea necesita un agente, un workflow o un solo prompt
- Construir workflows de múltiples pasos que encadenen, enruten y paralelicen llamadas LLM
- Escribir evaluaciones automatizadas que detecten regresiones cuando cambies prompts o modelos
- Definir y medir métricas de éxito de tareas para cualquier sistema de IA que construyas
⏩------------------------------------------------------------------------⏪
Mes 5: Despliegue, Pensamiento de Producto y Fiabilidad
Tu objetivo este mes: Llevar todo lo que has construido a un estado listo para producción
Al final deberías ser capaz de desplegar una aplicación de IA que maneje usuarios reales, tráfico real y fallos reales sin desmoronarse a las 2 de la mañana
Aquí es donde la mayoría de los ingenieros de IA se estancan. Pueden construir un gran demo pero no pueden enviar un producto que sobreviva al contacto con el mundo real
Las habilidades aquí son por las que las empresas realmente pagan: fiabilidad, seguridad, control de costes y la capacidad de mantener las cosas funcionando cuando algo inevitablemente se rompe
1. Patrones de Producción con FastAPI
Ya sabes cómo construir una aplicación FastAPI desde el Mes 1. Ahora necesitas que sobreviva al tráfico de producción
La diferencia entre desarrollo y producción es brutal. Un solo proceso de uvicorn con --reload está bien para construir. En producción se convierte en el cuello de botella en cuanto llega tráfico real
Lo que realmente necesitas: configuración ASGI multi-worker, middleware de manejo de errores adecuado, endpoints de health check y políticas CORS
Recursos:
1. Documentación de Despliegue de FastAPI (oficial, gratuita)
Enlace: https://fastapi.tiangolo.com/deployment/
La guía oficial que cubre workers de Uvicorn, Gunicorn y despliegue con Docker. Empieza aquí antes que nada
2. Guía de Despliegue en Producción de FastAPI (CYS Docs, gratuita)
Enlace: https://craftyourstartup.com/cys-docs/fastapi-production-deployment/
Patrones completos de producción: configuración de Gunicorn, proxy inverso con Nginx, health checks, limitación de velocidad. Incluye archivos de configuración reales que puedes adaptar
3. Mejores Prácticas de FastAPI para Producción (FastLaunchAPI, gratuito)
Enlace: https://fastlaunchapi.dev/blog/fastapi-best-practices-production-2026
Cubre pooling de bases de datos asíncrono, caché con Redis, autenticación JWT y tareas en segundo plano. Patrones probados en producción de una plantilla real utilizada por más de 100 desarrolladores
En qué enfocarse: Ejecutar Gunicorn con workers de Uvicorn (no Uvicorn desnudo), configurar endpoints de health check, añadir middleware CORS, implementar sesiones de base de datos asíncronas adecuadas y usar tareas en segundo plano para cualquier cosa que no necesite bloquear la respuesta
2. Docker
Docker es cómo dejas de decir "funciona en mi máquina" y empiezas a enviar despliegues consistentes
Si estás construyendo aplicaciones de IA, Docker resuelve conflictos de dependencias, garantiza entornos consistentes y facilita la escalabilidad
No necesitas convertirte en un experto en Docker. Necesitas ser capaz de contenerizar tu aplicación FastAPI + LLM y desplegarla en cualquier lugar
Recursos:
1. Guía de Inicio Oficial de Docker (gratuita)
Enlace: https://docs.docker.com/get-started/
El punto de partida canónico. Cubre imágenes, contenedores, Dockerfiles y Docker Compose
2. freeCodeCamp: Cómo Construir y Desplegar un Sistema Multi-Agente de IA con Python y Docker (gratuito)
Enlace: https://www.freecodecamp.org/news/build-and-deploy-multi-agent-ai-with-python-and-docker/
Tutorial práctico de principio a fin que construye un pipeline multi-agente real con Docker Compose. Cubre separación de responsabilidades, programación con cron y consideraciones de seguridad
3. DataCamp: Desplegar Aplicaciones LLM Usando Docker (gratuito)
Enlace: https://www.datacamp.com/tutorial/deploy-llm-applications-using-docker
Guía paso a paso específica para aplicaciones LLM con pipelines RAG. Cubre creación de Dockerfile, gestión de entornos y despliegue
4. Contenerización Docker para Aplicaciones LLM (ApXML, gratuito)
Cubre selección de imagen base, gestión de dependencias, builds multi-etapa y Docker Compose para despliegues LLM multi-servicio
En qué enfocarse: Escribir un Dockerfile para una aplicación Python/FastAPI, usar builds multi-etapa para mantener las imágenes pequeñas, Docker Compose para configuraciones multi-servicio (aplicación + base de datos + Redis), variables de entorno para secretos y .dockerignore para evitar filtrar archivos sensibles
Proyecto práctico: Conteneriza tu aplicación RAG del Mes 3. Crea un docker-compose.yml que ejecute tu aplicación FastAPI, una base de datos vectorial (Chroma o Qdrant) y Redis para caché. Despliégalo de modo que docker compose up lo inicie todo
3. Trabajos en Segundo Plano y Colas
Las llamadas LLM son lentas. Si un usuario le pide a tu aplicación que procese un documento y le haces esperar 30 segundos por una respuesta, se irá
Los trabajos en segundo plano te permiten aceptar la solicitud de inmediato, procesarla de forma asíncrona y notificar al usuario cuando esté lista
Recursos:
1. Guía de Inicio Oficial de Celery (gratuita)
Enlace: https://docs.celeryq.dev/en/stable/getting-started/introduction.html
La cola de tareas estándar de Python. Cubre configuración básica, definición de tareas y gestión de workers
2. Documentación de Tareas en Segundo Plano de FastAPI (oficial, gratuita)
Enlace: https://fastapi.tiangolo.com/tutorial/background-tasks/
Tareas ligeras en segundo plano integradas para casos de uso simples. Usa esto para tareas rápidas de "disparar y olvidar", y Celery para cualquier cosa más pesada
En qué enfocarse: Comprender cuándo usar BackgroundTasks integrado de FastAPI frente a una cola de tareas adecuada como Celery, configurar Redis como intermediario de mensajes, manejar fallos y reintentos de tareas, y devolver el estado del trabajo al usuario
4. Autenticación y Seguridad de Claves API
Si tu aplicación de IA tiene una API, necesita autenticación. Sin ella, cualquiera puede usar tus endpoints, quemar tus créditos LLM y te despertarás con una factura de 5,000 dólares
Recursos:
1. Documentación de Seguridad de FastAPI (oficial, gratuita)
Enlace: https://fastapi.tiangolo.com/tutorial/security/
Cubre OAuth2, tokens JWT, claves API y patrones de autenticación basados en dependencias. La referencia oficial, trabaja a través del tutorial completo
2. OWASP API Security Top 10 (gratuito)
Enlace: https://owasp.org/API-Security/
La lista autorizada de riesgos de seguridad de API. Comprende autenticación rota, inyección y asignación masiva antes de enviar cualquier cosa
3. Auth0: Mejores Prácticas de Autenticación de API (gratuito)
Enlace: https://auth0.com/docs/get-started/authentication-and-authorization
Guía práctica para implementar autenticación y autorización en APIs
En qué enfocarse: Tokens JWT para autenticación de usuarios, gestión de claves API para comunicación entre servicios, limitación de velocidad por usuario/clave, nunca almacenar secretos en el código (usar variables de entorno) y comprender la diferencia entre autenticación (quién eres) y autorización (qué puedes hacer)
5. Registro y Observabilidad
En producción, si no puedes ver lo que está sucediendo, no puedes arreglar lo que está roto
Las aplicaciones LLM tienen un desafío único: el modelo puede devolver un código de estado 200 y aún así producir una respuesta inútil o alucinada. El monitoreo tradicional no captura esto. Necesitas observabilidad específica para LLM
Recursos:
1. Langfuse (código abierto, nivel gratuito)
Enlace: https://langfuse.com/docs/observability/overview
Plataforma de observabilidad LLM de código abierto. Traza cada solicitud: prompt enviado, respuesta recibida, uso de tokens, latencia, llamadas a herramientas. Admite versionado de prompts, evaluación y puntuación con LLM como juez. Se integra con OpenAI, Anthropic, LangChain, LlamaIndex
2. LangSmith (nivel gratuito)
Enlace: https://smith.langchain.com/
Del equipo de LangChain. Si estás usando LangChain/LangGraph, la configuración es una variable de entorno. Trazado, depuración, paneles de monitoreo y evaluaciones en línea. El nivel gratuito es generoso para desarrollo y producción a pequeña escala
3. Structlog de Python (gratuito)
Enlace: https://www.structlog.org/
Registro estructurado para Python. Produce logs JSON que son realmente buscables y analizables. Mucho mejor que print() o el registro básico para aplicaciones en producción
En qué enfocarse: Trazar cada llamada LLM (prompt de entrada, salida, tokens, latencia, costo), registro estructurado con salida JSON, configurar paneles que muestren volumen de solicitudes, tasas de error y costo por día, y alertas cuando algo se rompa o los costos se disparen
6. Gestión de Prompts y Versiones
En producción, tus prompts son código. Necesitan control de versiones, pruebas y capacidad de reversión
Cambiar un prompt en producción sin rastrear lo que cambiaste es cómo rompes cosas y no puedes averiguar por qué
Recursos:
1. Gestión de Prompts de Langfuse (gratuita)
Enlace: https://langfuse.com/docs/prompts
Versionado centralizado de prompts con un playground integrado para pruebas. Controla las versiones de tus prompts por separado del código de tu aplicación. Despliega cambios de prompt sin redesplegar tu aplicación
2. Mejores Prácticas de Gestión de Prompts de Anthropic (gratuitas)
Enlace: https://docs.anthropic.com/en/docs/build-with-claude/prompt-engineering/overview
Mejores prácticas para organizar, iterar y gestionar prompts a escala
En qué enfocarse: Almacenar prompts fuera del código de tu aplicación, versionar cada cambio de prompt, probar variantes de prompt en producción con A/B testing y tener una estrategia de reversión cuando un nuevo prompt rinda peor
7. Monitoreo de Costos y Límites de Velocidad
Las APIs LLM cobran por token. Sin controles de costos, un pico de tráfico o un error en tu prompt puede quemar cientos de dólares en minutos
Recursos:
1. Panel de Uso de OpenAI (oficial)
Enlace: https://platform.openai.com/usage
Rastrea el gasto por modelo, por día y establece límites de uso
2. Panel de Uso de Anthropic (oficial)
Enlace: https://console.anthropic.com/ Lo mismo para el uso de la API de Claude
3. Helicone (nivel gratuito)
Enlace: https://www.helicone.ai/
Observabilidad basada en proxy que captura cada llamada LLM con seguimiento automático de costos. Una línea de código para configurarlo: solo cambia tu URL base
4. LiteLLM (código abierto, gratuito)
Enlace: https://github.com/BerriAI/litellm
Interfaz unificada para más de 100 proveedores LLM. Incluye gestión de presupuesto, limitación de velocidad y seguimiento de gastos entre proveedores
En qué enfocarse: Establecer límites de gasto duros por día/mes, implementar límites de velocidad por usuario en tu API, usar modelos más baratos para tareas simples (no uses GPT-4/Opus para todo), almacenar en caché solicitudes repetidas idénticas con Redis y monitorear el costo por solicitud para detectar prompts caros temprano
8. Caché
Si el 20% de tus usuarios hacen preguntas similares, estás pagando por la misma llamada LLM 20 veces
El caché es la forma más simple de reducir costos y latencia simultáneamente
Recursos:
1. Documentación Oficial de Redis (gratuita)
Enlace: https://redis.io/docs/
El almacén de datos en memoria estándar. Rápido, simple y funciona perfectamente para el almacenamiento en caché de respuestas LLM
2. GPTCache (código abierto, gratuito)
Enlace: https://github.com/zilliztech/GPTCache
Caché semántico diseñado específicamente para aplicaciones LLM. Utiliza similitud de embeddings para encontrar respuestas almacenadas en caché para consultas semánticamente similares (no solo idénticas)
En qué enfocarse: Caché de coincidencia exacta para prompts idénticos, caché semántico para consultas similares, estrategias de invalidación de caché (basada en TTL es la más simple) y medir las tasas de acierto de caché para comprender el ahorro real de costos
Hito del Mes 5
Al final de este mes deberías ser capaz de:
- Desplegar una aplicación FastAPI + LLM en Docker con configuración de producción adecuada
- Manejar tareas de larga duración con trabajos en segundo plano y colas
- Asegurar tu API con autenticación, límites de velocidad y gestión de claves API
- Trazar y depurar llamadas LLM usando Langfuse o LangSmith
- Gestionar prompts con control de versiones y capacidad de reversión
- Monitorear costos en tiempo real y establecer límites de gasto
- Almacenar en caché respuestas LLM para reducir latencia y costo
⏩------------------------------------------------------------------------⏪
Mes 6: Especialízate y Vuélvete Contratable
Estos conocimientos y habilidades que has adquirido se pueden aplicar en tres direcciones (seguro que solo son las que yo veo)
Necesitas elegir una de ellas y enfocarte en la práctica
Aunque todo lo mencionado anteriormente también se aprende mejor puramente a través de la práctica
Dirección 1: Ingeniero de Producto de IA
Mejor si quieres trabajos en startups rápido
Este es el camino más común. Construyes productos impulsados por IA con los que los usuarios reales interactúan
Ya tienes la mayoría de las habilidades de los Meses 1-5. Ahora profundiza en el lado del producto
Enfócate en:
- Aplicaciones LLM
- RAG
- Agentes
- Despliegue
- Experiencia de usuario del producto
Qué aprender este mes:
1. Construcción de Productos de Principio a Fin
Deja de construir tutoriales. Construye productos que la gente pueda usar
Recursos:
1. Vercel AI SDK (gratuito)
Enlace: https://sdk.vercel.ai/docs
La forma más rápida de construir interfaces de usuario impulsadas por IA con soporte de streaming. Integraciones con React, Next.js y Vue con componentes de UI de streaming integrados
2. Streamlit (gratuito)
Enlace: https://docs.streamlit.io/
Construye aplicaciones de datos y demos de IA en Python puro. Ideal para herramientas internas y MVP, no para interfaces de producción a escala
3. Gradio (gratuito)
Enlace: https://www.gradio.app/docsQuick Interfaces de ML/IA con código mínimo. Especialmente útil para mostrar modelos y crear prototipos.
En qué centrarse: Crear 2 o 3 proyectos completos este mes que puedas mostrar. Una app de "chatea con tus documentos", una herramienta interna impulsada por IA, o un agente que automatice un flujo de trabajo real. Lánzalos. Súbelos a GitHub. Despliégalos en algún lugar donde la gente pueda probarlos.
2. UX de producto para IA
Los productos de IA fallan cuando la experiencia de usuario no tiene en cuenta las limitaciones del modelo.
Recursos:
1. Google: Guía Personas + IA (gratuita)
Enlace: https://pair.withgoogle.com/guidebook/
El mejor recurso para diseñar la interacción humano-IA. Cubre cómo establecer expectativas, manejar errores y generar confianza.
2. Nielsen Norman Group: Directrices de UX para IA (gratuita)
Enlace: https://www.nngroup.com/topic/artificial-intelligence/
Directrices basadas en investigación para interfaces de IA.
En qué centrarse: Cómo manejar los estados de carga con streaming, qué mostrar cuando el modelo se equivoca, cómo permitir que los usuarios den retroalimentación, y diseñar teniendo en cuenta que la salida de la IA es probabilística – a veces estará mal.
Dirección 2: Ingeniero de ML / LLM aplicado
Ideal si buscas roles técnicos más profundos.
Esta dirección es para ingenieros que quieren ir más allá de las llamadas a APIs y entender lo que ocurre bajo el capó.
Enfócate en:
- fine-tuning
- cuándo fine-tune vs. prompt engineering
- evaluación
- optimización de inferencia
- modelos de código abierto
- pipelines de entrenamiento
Qué aprender este mes:
1. Cuándo hacer fine-tuning vs. prompt engineering
La decisión más importante en ML aplicado: ¿necesitas cambiar el modelo o solo cambiar cómo te comunicas con él?
Recursos:
1. Google ML Crash Course: Fine-tuning, destilación y prompt engineering (gratuito)
Enlace: https://developers.google.com/machine-learning/crash-course/llm/tuning
La explicación más clara de los tres enfoques y cuándo usar cada uno.
2. Codecademy: Prompt engineering vs. fine-tuning (gratuito)
Enlace: https://www.codecademy.com/article/prompt-engineering-vs-fine-tuning
Marco de decisión práctico con casos de uso claros para cada enfoque.
3. IBM: RAG vs. fine-tuning vs. prompt engineering (gratuito)
Enlace: https://www.ibm.com/think/topics/rag-vs-fine-tuning-vs-prompt-engineering
Cubre todo el espacio de decisión, incluyendo cuándo combinar enfoques.
Marco de decisión para memorizar: Empieza con prompt engineering (más barato, más rápido). Añade RAG si el modelo necesita acceso a datos específicos. Haz fine-tuning solo cuando prompt + RAG no logren la calidad, consistencia o latencia requeridas.
2. Fine-tuning en la práctica
Cuando sí necesites hacer fine-tuning, así se hace.
Recursos:
1. Guía de fine-tuning de OpenAI (oficial, gratuita)
Enlace: https://platform.openai.com/docs/guides/fine-tuning
La forma más fácil de empezar con fine-tuning. Sube un dataset en JSONL, ejecuta un trabajo, obtén un modelo personalizado. Bueno para aprender el flujo de trabajo incluso si luego te pasas a modelos de código abierto.
2. Tutorial de fine-tuning con HuggingFace Transformers (gratuito)
Enlace: https://huggingface.co/docs/transformers/training
La biblioteca estándar para trabajar con modelos de código abierto. Cubre entrenamiento, evaluación y guardado de modelos.
3. Unsloth (código abierto, gratuito)
Enlace: https://github.com/unslothai/unsloth
Fine-tuning 2x más rápido con un 80% menos de memoria. Soporta LoRA y QLoRA directamente. La ruta más rápida para ajustar modelos de código abierto en hardware de consumo.
4. LLaMA-Factory (código abierto, gratuito)
Enlace: https://github.com/hiyouga/LLaMA-Factory
Marco unificado para fine-tuning de más de 100 LLMs. Incluye una interfaz web para fine-tuning sin código. Soporta LoRA, QLoRA, fine-tuning completo, RLHF y DPO.
En qué centrarse: Preparar datasets de entrenamiento (formato JSONL), entender LoRA y QLoRA (fine-tuning eficiente en parámetros), ejecutar un trabajo de fine-tuning en OpenAI o con HuggingFace, evaluar el modelo ajustado contra el modelo base, y saber cuándo el fine-tuning no vale la pena.
3. Modelos de código abierto
No todo tiene que pasar por OpenAI o Anthropic. Los modelos de código abierto te dan control total, sin costos de API y la posibilidad de ejecutarlos localmente.
Recursos:
1. Ollama (gratuito)
Enlace: https://ollama.ai/
Ejecuta LLMs de código abierto localmente con un solo comando. Soporta Llama, Mistral, Gemma y docenas más. La forma más rápida de experimentar con modelos de código abierto.
2. HuggingFace Model Hub (gratuito)
Enlace: https://huggingface.co/models
El repositorio más grande de modelos de código abierto. Navega, descarga y despliega modelos para cualquier tarea.
3. vLLM (código abierto, gratuito)
Enlace: https://github.com/vllm-project/vllm
Motor de inferencia de LLM de alto rendimiento. 2-4x más rápido que el servicio ingenuo de HuggingFace. El estándar para servir modelos de código abierto en producción.
En qué centrarse: Ejecutar modelos localmente con Ollama para pruebas, entender la cuantización (GGUF, GPTQ, AWQ) y por qué es importante para el despliegue, comparar modelos de código abierto con modelos de API para tu caso de uso, y servir modelos en producción con vLLM.
4. Optimización de inferencia
Hacer que los modelos funcionen más rápido y más barato en producción.
Recursos:
1. HuggingFace: Optimizando la inferencia de LLM (gratuito)
Enlace: https://huggingface.co/docs/transformers/llm_optims
Cubre optimización de caché KV, cuantización y estrategias de batching.
2. NVIDIA TensorRT-LLM (gratuito)
Enlace: https://github.com/NVIDIA/TensorRT-LLM
Máximo rendimiento de inferencia en GPUs NVIDIA. Utilizado por la mayoría de los servicios de LLM en producción a gran escala.
En qué centrarse: Estrategias de batching para rendimiento, cuantización para reducir memoria y costos, optimización de caché KV para generación más rápida, y elegir el hardware adecuado para tu carga de trabajo de inferencia.
Dirección 3: Ingeniero de automatización con IA
Ideal si quieres construir para empresas de inmediato.
Esta dirección trata de automatizar flujos de trabajo empresariales reales con IA. Menos sobre construir productos, más sobre resolver problemas operativos.
Enfócate en:
- orquestación de flujos de trabajo
- automatización de procesos de negocio
- sistemas multi-herramienta
- casos de uso en CRM, documentos, correo electrónico, soporte, operaciones
Qué aprender este mes:
1. Orquestación de flujos de trabajo
La automatización empresarial real casi nunca es una sola llamada a un LLM. Son cadenas de acciones a través de múltiples sistemas.
Recursos:
1. n8n (código abierto, gratuito para auto-alojar)
Enlace: https://docs.n8n.io/
Automatización visual de flujos de trabajo con nodos de IA. Conecta LLMs a más de 400 integraciones (Slack, Gmail, Notion, CRMs, etc.). La mejor opción sin código/poco código para automatización con IA.
2. LangGraph: Flujos de trabajo multi-agente (gratuito)
Enlace: https://langchain-ai.github.io/langgraph/concepts/multi_agent/
Orquestación basada en código para sistemas multi-agente complejos. Cuando n8n no es suficiente y necesitas control programático completo.
3. Temporal (código abierto, gratuito)
Enlace: https://docs.temporal.io/
Motor de flujo de trabajo duradero para procesos de larga duración y tolerantes a fallos. Cuando tu automatización necesita sobrevivir a caídas, reintentos y tiempos de espera.
En qué centrarse: Diseñar flujos de trabajo que manejen fallos con elegancia, conectar la IA a herramientas empresariales reales (correo electrónico, CRM, bases de datos, hojas de cálculo), construir pasos de aprobación con un humano en el bucle, y registrar cada acción automatizada para pistas de auditoría.
2. Automatización de procesos de negocio
El dinero en la automatización con IA está en resolver problemas empresariales específicos y costosos.
Recursos:
1. Zapier AI Actions (nivel gratuito)
Enlace: https://zapier.com/ai
Conecta la IA a más de 6,000 aplicaciones sin código. Bueno para prototipar automatizaciones antes de construir soluciones personalizadas.
2. Make (Integromat) (nivel gratuito)
Enlace: https://www.make.com/
Plataforma de automatización visual con lógica avanzada e integraciones de IA. Más potente que Zapier para flujos de trabajo complejos.
En qué centrarse: Identificar los objetivos de automatización con mayor retorno de inversión (normalmente tareas repetitivas, que consumen tiempo y basadas en reglas), construir automatizaciones que aumenten las capacidades humanas en lugar de reemplazarlas, y medir el tiempo y el dinero realmente ahorrados.
3. Automatización de CRM, documentos, correo electrónico y soporte
Los casos de uso más comunes y más valiosos de automatización con IA.
Recursos:
1. OpenAI Cookbook: Procesamiento de correo electrónico con IA (gratuito)
Enlace: https://github.com/openai/openai-cookbook
Patrones para clasificar, enrutar y responder correos electrónicos con IA.
2. LangChain: Pipelines de procesamiento de documentos (gratuito)
Enlace: https://python.langchain.com/docs/how_to/#document-loaders
Ingestión y procesamiento de documentos de más de 80 fuentes.
En qué centrarse: Construir un clasificador y respondedor automático de correos electrónicos con IA, crear un pipeline de procesamiento de documentos que extraiga datos estructurados, construir un chatbot de soporte que use RAG sobre tu base de conocimiento, e integrar la IA en flujos de trabajo CRM existentes (HubSpot, Salesforce, etc.).
Proyecto práctico para la Dirección 3: Construye un sistema de calificación de leads de extremo a extremo. Debe:
Extraer o importar leads de una fuente (CSV, API o formulario)
Usar un LLM para investigar cada lead (información de la empresa, evaluación de ajuste)
Puntuar y clasificar leads según tu ICP (perfil de cliente ideal)
Redactar mensajes de contacto personalizados
Registrar todo en una hoja de cálculo o CRM
Esta es una automatización real y vendible por la que las empresas realmente pagan.
⏩------------------------------------------------------------------------⏪
CONCLUSIÓN
¿Qué puedes esperar después de estos 6 meses?
Voy a ser honesto contigo: sin una montaña de dinero,
esta hoja de ruta no te convertirá en un ingeniero senior de IA en 6 meses.
Pero te convertirá en alguien que puede construir, lanzar y desplegar sistemas de IA reales que resuelven problemas reales.
Y ahora mismo, eso es exactamente lo que el mercado está pagando.
La demanda de ingenieros de IA no se está desacelerando. Las ofertas de empleo crecieron un 25% interanual.
PwC encontró una prima salarial del 56% para roles que requieren habilidades de IA frente a los mismos roles sin ellas.
Solo el 1% de las empresas se consideran "maduras en IA", lo que significa que el 99% todavía necesita ayuda. La Oficina de Estadísticas Laborales de EE. UU. proyecta un crecimiento del 26% en el empleo hasta 2034.
Estos no son números de hype. Son números reales basados en análisis (tomados de Claude, jeje).
Si trabajas a tiempo completo en EE. UU.:
Ingenieros de IA junior empiezan en $90,000–$130,000
Nivel medio (3–5 años) está en $155,000–$200,000
Roles senior llegan a $195,000–$350,000+
Según Glassdoor (marzo de 2026), el promedio es $184,757
La banda de nivel medio es la que crece más rápido, al 9.2% interanual, porque las empresas necesitan desesperadamente personas que puedan enviar IA a producción sin supervisión constante.
Si prefieres el freelance:
Desarrollo de agentes de IA se cobra entre $175–$300/hora
Implementación de RAG $150–$250/hora
Integración de LLM $125–$200/hora
Un desarrollador en Reddit construyó una herramienta de resumen de documentos para un bufete de abogados en dos semanas y ganó $8,000. Un freelancer facturando 25 horas/semana a $150/hora obtiene $195,000/año.
Y si optas por la consultoría, que es de lo que hablé en mi publicación anterior, puedes cobrar:
$300–$5,000 por configurar un agente de IA para un negocio
$500–$2,000/mes por gestión de contenido con IA
$1,000–$4,000 por automatizar el servicio al cliente
$500–$2,000 por configuración de prospección en frío
El espectro de servicios es aún más amplio, pero una vez que domines las habilidades de esta hoja de ruta, ya eres un especialista demandado en 2026.
Estos son números reales de personas reales haciendo trabajo real.
Ahora, esto es lo que realmente quiero que te lleves de todo esto:
Elige un proyecto de cada mes y constrúyelo. No leas sobre él. No veas un tutorial. Constrúyelo, rómpelo, arréglalo, despliégalo, súbelo a GitHub. Los ingenieros que consiguen trabajo son los que muestran lo que han construido, no lo que han estudiado.
Empieza a compartir lo que aprendes. Escribe sobre ello en X, LinkedIn, donde sea. Enseñar es la forma más rápida de aprender y, al mismo tiempo, construye tu reputación. Las mejores oportunidades que he visto provienen de personas que eran visibles, no de personas que enviaron 500 solicitudes de empleo.
Y por favor, no esperes hasta sentirte listo. Nunca te sentirás listo. La brecha entre "estoy aprendiendo" y "estoy construyendo" es donde la mayoría de la gente se queda atascada para siempre.
Empieza a postularte, empieza a hacer freelance, empieza a ofrecer servicios en cuanto tengas proyectos funcionales. Aunque no sean perfectos. El mercado no recompensa la perfección. Recompensa a quienes pueden enviar.
6 meses son suficientes para cambiarlo todo si realmente pones el trabajo.
Y de verdad creo que cada uno de ustedes que lee esto puede lograrlo.
Solo nunca dejen de construir y nunca dejen de aprender.
Espero que esto te haya sido útil, familia ❤️
