La ingeniería en 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 qué deberían estudiar realmente
Algunos comienzan con teoría de aprendizaje automático
Otros se quedan atrapados viendo tutoriales sin fin
Otros más saltan directamente a prompts y agentes sin entender APIs, conceptos básicos de backend o cómo se construyen realmente los productos
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 cada campo de la inteligencia artificial
Necesitas aprender a construir sistemas de IA útiles en el mundo real
Eso significa aprender a:
- construir aplicaciones integrales 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 tomarte algunas horas o incluso más
Pero su verdadero valor 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 en 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 confiabilidad, costo y latencia
- desplegar funciones de IA en aplicaciones reales
Entonces, 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
También es por eso que este roadmap se enfoca menos en teoría pesada y más en ejecución práctica
Si puedes construir aplicaciones reales con 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 en IA es, ante todo, ingeniería de software
Todo 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 fundamento
Qué aprender
1. Python
Python es el lenguaje de la ingeniería en IA. Punto. 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 de forma pasiva, leer, asentir y nunca abrir un editor de código
Combate esto codificando cada ejemplo a medida que avanzas
Recursos:
1. Python for Everybody (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 para 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. Ideal si quieres estructura
4. Documentación oficial de Python (el tutorial)
Enlace: https://docs.python.org/3/tutorial/
Seca pero autorizada, úsala como referencia
En qué enfocarte:
- 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 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 portafolio en GitHub
Cómo aprenderlo:
Git es confuso al principio porque el modelo mental no es obvio
No intentes memorizar comandos; en cambio, comprende qué problema resuelve Git
(rastrear cambios, permitir colaboración, 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. Learn Git Branching (gratuito, interactivo)
Enlace: https://learngitbranching.js.org/
Sin duda la mejor herramienta visual para entender ramas y fusiones
3. Pro Git Book (libro gratuito en línea)
Enlace: https://git-scm.com/book/en/v2
La referencia completa. Salta a los capítulos que necesites
En qué enfocarte:
- git init, add, commit, push, pull
- Ramificación y fusión
- Entender .gitignore
- Crear repos 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. The Missing Semester of Your CS Education (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
En qué enfocarte:
- 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
Estarás llamando 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 SDKs 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 REST API
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 cualquier API web en Python
4. Python async/await (gratuito)
Enlace: https://realpython.com/async-io-python/
Entender async es esencial para trabajar con respuestas de LLM en streaming más adelante
En qué enfocarte:
- 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 en Python que llame a una API pública gratuita (prueba Open-Meteo para datos meteorológicos – no necesita clave 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 sí necesitarás inspeccionar, consultar y manipular datos con regularidad
Los conceptos básicos de SQL y la fluidez con pandas te ahorrarán 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
En qué enfocarte:
- 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/es/tutorial/
Sinceramente, una de las mejores documentaciones de frameworks jamás escritas
Trabaja en ella 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
En qué enfocarte: 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
- Versione tu código con Git y subir proyectos a GitHub
- Navegar por 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 simple de FastAPI 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 en IA. Todo lo demás en el roadmap se basa en lo que aprendes aquí
Qué aprender
1. Fundamentos de Prompting
El prompting no es solo hacer preguntas amablemente. Es el arte de escribir instrucciones que produzcan 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 con los tres en orden – cada uno refuerza a los otros
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 solución de problemas de prompts tú mismo
Ejecútalo como notebooks de Jupyter con la API de Claude
2. Documentación de ingeniería de prompts de Anthropic (gratuita)
Enlace: https://docs.anthropic.com/en/docs/build-with-claude/prompt-engineering/overview
La referencia oficial. Cubre todo, desde claridad básica hasta estructuración con XML y sistemas agentivos
3. Guía de ingeniería de prompts de OpenAI (gratuita)
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 resultados 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 agentivos
En qué enfocarte: La diferencia entre mensajes de sistema y de usuario, por qué la especificidad importa, el prompting de cadena de pensamiento (piensa paso a paso), usar ejemplos en los 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 confiabilidad
3. Salidas Estructuradas / Esquemas JSON
En aplicaciones reales, casi nunca quieres texto sin formato 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, gratuita)
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 (gratuita, código abierto)
Enlace: https://python.useinstructor.com/
La forma más limpia de obtener salidas estructuradas de cualquier proveedor de LLM utilizando modelos de Pydantic
Funciona con OpenAI, Anthropic, Google y más de 15 proveedores usando la misma interfaz de código, con reintentos automáticos cuando falla la validación
Esto es lo que la mayoría de los ingenieros de IA en producción usan realmente
3. OpenAI Cookbook: 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 de datos estructurados y generación de UI, buenos para entender casos de uso del mundo real
En qué enfocarte: Definir modelos de Pydantic para tus datos, pasar esquemas a la API, entender la diferencia entre salidas estructuradas y modo JSON, y manejar rechazos con elegancia
Proyecto de práctica: Construye un analizador de facturas o recibos. Dale texto sin formato (por ejemplo, "Factura #123, $45.99 por 3 widgets, vence el 30 de marzo") y haz que devuelva un objeto Python estructurado con campos como numero_factura, monto, articulos, fecha_vencimiento
4. Llamadas a Funciones / Herramientas
La llamada a herramientas es lo que transforma un LLM de un generador de texto a 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 Llamadas a Funciones de OpenAI (documentación oficial, gratuita)
Enlace: https://platform.openai.com/docs/guides/function-calling
La referencia definitiva. Cubre la definición de herramientas, el flujo de llamada de 5 pasos, llamadas paralelas y mejores prácticas
2. Documentación de Uso de Herramientas de Anthropic (gratuita)
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. OpenAI Cookbook: Cómo Llamar Funciones con Modelos de Chat (gratuito, GitHub)
Un notebook completo y ejecutable que recorre el bucle completo de llamada a herramientas con ejemplos reales
En qué enfocarte: Describir funciones claramente en JSON Schema, analizar las respuestas de llamadas a herramientas, ejecutar la función y devolver los resultados, manejar casos donde no se necesita ninguna 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(expresión) 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
El streaming significa mostrar la salida del modelo a medida que 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, gratuita)
Enlace: https://platform.openai.com/docs/api-reference/streaming
La referencia para agregar stream=True a las solicitudes e iterar sobre los fragmentos
2. Documentación de Streaming de Anthropic (oficial, gratuita)
Enlace: https://docs.anthropic.com/en/api/messages-streaming
La 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 internamente los Eventos Enviados por el Servidor (Server-Sent Events) para OpenAI, Anthropic y Google, útil para entender lo que realmente sucede a nivel HTTP
En qué enfocarte: Configurar 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 ícono de carga durante 10 segundos esperando que aparezca una respuesta completa de una sola 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 tú gestionas enviando la lista completa de mensajes en cada solicitud. Entender esto es fundamental
Recursos:
1. Guía de Completaciones de Chat de OpenAI, Gestión de Conversaciones (oficial, gratuita)
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, gratuita)
Enlace: https://docs.anthropic.com/en/api/messages
El equivalente de Anthropic. Mismo concepto, vale la pena leer ambas para ver cómo difieren
En qué enfocarte: La estructura del array de mensajes, por qué agregas tanto los mensajes de usuario como los del asistente, los límites de la ventana de contexto y qué sucede cuando los superas, y estrategias básicas de truncamiento (descartar 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 de tokens actual después de cada intercambio
6. Conceptos Básicos de Costo, Latencia y Tokens
Implementar 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 esta página y revísala 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 Claude
3. Herramienta de Tokenización de OpenAI (gratuita, interactiva)
Enlace: https://platform.openai.com/tokenizer
Pega cualquier texto y ve exactamente cuántos tokens tiene. Úsala constantemente mientras aprendes
4. Tiktoken (biblioteca de Python, gratuita)
Enlace: https://github.com/openai/tiktoken
La biblioteca de tokenización de OpenAI para contar tokens en código antes de enviar solicitudes
En qué enfocarte: Qué es un token (aproximadamente 4 caracteres / 3/4 de una palabra), cómo se diferencian los precios de tokens de entrada vs salida, cómo el tamaño de la ventana de contexto afecta lo que puedes hacer, y el equilibrio entre latencia de modelos más pequeños y rápidos frente a modelos más grandes e inteligentes
Además: 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 velocidad, las respuestas se agotan, 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, gratuita)
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, gratuita)
Enlace: https://docs.anthropic.com/en/api/errors
Lo mismo para Claude
3. Tenacity (biblioteca de Python, gratuita)
Enlace: https://tenacity.readthedocs.io/
Una biblioteca limpia para agregar lógica de reintento con retroceso exponencial a cualquier función de Python. Un decorador y tus reintentos están gestionados
En qué enfocarte: Errores de límite de velocidad (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 colgar tu aplicación 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 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 implementar 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 autorizada 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 orientada a desarrolladores sobre tipos de ataque, riesgos y patrones de diseño para mitigarlos
En qué enfocarse: 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 consecuenciales de forma automática
Hito del Mes 2
Al final de este mes deberías ser capaz de:
- Escribir prompts que produzcan resultados 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 de 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, tiempos de espera y salidas incorrectas sin que el sistema colapse
- Explicar qué es la inyección de prompts y aplicar defensas básicas
⏩------------------------------------------------------------------------⏪
Mes 3: Aprende RAG Correctamente
Tu objetivo este mes: Construir sistemas que permitan a los LLM responder preguntas a partir de tus documentos, no solo de sus datos de entrenamiento
Al final deberías ser capaz de ingerir documentos, incrustarlos (embedding) y almacenarlos, recuperar los fragmentos correctos al momento de la consulta, y producir respuestas que estén fundamentadas, sean 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 – bots de atención al cliente, bases de conocimiento internas, Q&A sobre documentos – están construidos sobre él
Entenderlo en profundidad, no solo copiar un tutorial, es lo que separa a los buenos ingenieros de los excelentes
1. Embeddings (Incrustaciones)
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 secuencia larga de números
Fundamentalmente, el texto que es 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, con un enfoque en desarrollar la intuición correcta en lugar de 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 el one-hot encoding 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 preguntas frecuentes
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é enfocarse: Qué es un vector conceptualmente, por qué el texto similar produce vectores similares, cómo funciona la similitud por 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. Fragmentación (Chunking)
Tus documentos son demasiado grandes para incrustarlos completos. La fragmentación es el proceso de dividirlos en partes más pequeñas antes de incrustarlos
Cómo 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 fragmentación de tamaño fijo, recursiva y semántica, con pautas claras sobre cuándo usar cada una
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, superposición 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 una superposición 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é enfocarse: Fragmentación de tamaño fijo con superposición como línea base, fragmentación recursiva para documentos estructurados, fragmentación semántica 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 para 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 escala gestionada llave en mano, Weaviate para flexibilidad de código abierto con búsqueda híbrida robusta, Qdrant para filtros complejos y autoalojamiento eficiente, 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. Se ejecuta en memoria o localmente sin necesidad de gestionar infraestructura
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 de código abierto para producción con filtrado avanzado. Muy rápida, flexible y gratuita para autoalojar
4. pgvector (código abierto, 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 nueva infraestructura
En qué enfocarse: Crear una colección, insertar embeddings con metadatos, consultar por similitud con top_k, y filtrar por metadatos al momento de la consulta
No necesitas entender los algoritmos de indexación (HNSW, IVF) – solo entiende 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 pura 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 a 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é enfocarse: Etiquetar cada fragmento con metadatos relevantes en el momento de la ingesta (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 una demostración de juguete y un sistema de producción donde los usuarios pueden preguntar "muéstrame solo resultados de los informes del Q4 2025 al Q1 2026"
5. Reordenamiento (Reranking)
El reordenamiento 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 candidato, un reranker vuelve a puntuar 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) → reordenar top-k (más lento, más preciso). El resultado es una calidad de recuperación drásticamente mejor con 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 reordenamiento, incluyendo datos semiestructurados como correos electrónicos y documentos JSON. Solo requiere 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 reordenamiento de Cohere en un recuperador de LangChain usando ContextualCompressionRetriever
En qué enfocarse: El patrón de dos etapas: recuperar y luego reordenar, la diferencia entre un bi-encoder (usado para la búsqueda de embeddings de primera etapa) y un cross-encoder (usado para el reordenamiento), y la compensación práctica entre latencia y calidad al reordenar 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 fallar 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 la superposición o usa fragmentación semántica
- Falta de contexto de metadatos: Los fragmentos son semánticamente similares a la consulta pero pertenecen al documento, fecha o usuario incorrectos. Solución: usa filtrado por metadatos
- Top_k demasiado pequeño: El fragmento correcto existe pero no está entre los 5 primeros resultados recuperados. Solución: aumenta top_k en la recuperación y reduce después del reordenamiento
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 estándar, 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 únicamente 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 centrada en desarrolladores que cubre estrategias de anclaje de prompts, cadenas de pensamiento (chain-of-thought) 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 + chain-of-thought + guardrails juntos superan a cualquier enfoque individual
En qué enfocarse: 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 respuestas, y validar siempre la calidad de la recuperación antes de culpar al LLM
8. Citas y Fundamentalización (Grounding)
Un sistema RAG bien fundamentalizado 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é enfocarse: Pasar metadatos de fragmentos (nombre de archivo fuente, número de página, URL) en tu contexto de prompt, instruir al modelo para que haga referencia a 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 ingesta, fragmentación, incrustación y 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 LLM 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, gratuita)
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 preguntas y respuestas 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 reordenamiento
Proyecto práctico: Construye una aplicación "chatea con tus documentos". Ingresa 10-20 archivos PDF o de texto (tus propias notas, un capítulo de un libro de texto, documentación de un producto, cualquier cosa). Construye un endpoint de FastAPI que acepte una pregunta, recupere los 5 fragmentos más relevantes con reordenamiento, y devuelva una respuesta citada de Claude o 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 manera inteligente usando estrategias apropiadas
- Almacenar y consultar embeddings en una base de datos vectorial con filtrado por metadatos
- Añadir un paso de reordenamiento para mejorar la calidad de la recuperación
- Depurar fallos comunes de recuperación de manera 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, orquestar 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 ser dueñas de una funcionalidad completa de IA de principio a fin
1. Bucles de Agentes (Agent Loops)
Un agente no es magia, es un patrón sorprendentemente simple
Piensa en los agentes como sistemas orientados a objetivos que ciclan constantemente a través 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 plomerí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 artículo jamás 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, barreras de protección 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 de 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 de LangGraph, el framework de orquestación de agentes más utilizado. Cubre estado, memoria, humano-en-el-bucle y más
En qué enfocarse: El ciclo percibir → planificar → actuar → observar, cómo termina el bucle del agente, qué sucede cuando una llamada a una 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 usando la API de OpenAI o Anthropic directamente. Dale 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é dolorosa e 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 pautas sobre cuándo dejar que el modelo elija vs forzar una herramienta específica
En qué enfocarse: 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 pensando en el LLM como el invocador
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 transiciones 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 LangGraph Agents (gratuito)
Enlace: https://www.datacamp.com/tutorial/langgraph-agents
Cubre los fundamentos del estado, nodos y aristas con código práctico, construyendo 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 funcionan las pausas con intervención humana inspeccionando y modificando el estado a medio camino
4. Reintentos y Manejo de Fallos en Agentes
Los agentes fallan de manera diferente a las llamadas LLM normales. Una mala llamada a herramienta a medio camino 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, gratuito)
Enlace: https://langchain-ai.github.io/langgraph/how-tos/autofill-tool-errors/
Explica cómo agregar manejo automático de errores y lógica de reintento a nivel de nodo de herramienta en LangGraph
2. Guía Práctica de OpenAI para Agentes: sección Guardrails (gratuito)
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 prevenir bucles infinitos, reintento por herramienta con backoff exponencial, capturar y registrar excepciones en la capa de ejecución de herramientas sin bloquear el agente, y cuándo mostrar un fallo al usuario vs reintentar en silencio
5. Cuándo NO Usar Agentes
Esta es una de las habilidades más importantes y a la vez más ignoradas en la ingeniería de IA. Los agentes son emocionantes, pero también son lentos, costosos, impredecibles y difíciles de depurar. Saber cuándo usar 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 podría 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 con un prompt y el contexto adecuado
- Usa un workflow si los pasos son fijos y predecibles
- Usa un agente solo si la cantidad de pasos es genuinamente impredecible y requiere toma de decisiones dinámica
Recursos:
1. Anthropic: Construyendo 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 se justifica la complejidad de un agente 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 verdaderamente abiertas
6. Workflows de Múltiples Pasos
Entre "un solo prompt" y "agente completo" hay un vasto y productivo término medio: 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 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, gratuito)
Enlace: https://langchain-ai.github.io/langgraph/concepts/multi_agent/
Explica cómo conectar múltiples agentes en una red, con patrones de supervisor y traspaso
Proyecto práctico: Construye un pipeline de contenido de 3 pasos:
Paso 1 – un LLM extrae hechos clave de un artículo
Paso 2 – otra llamada LLM usa esos hechos para generar un tweet, una publicación de LinkedIn y un resumen en paralelo
Paso 3 – una llamada LLM final califica los tres por calidad y elige el mejor
No se necesita agente, es workflow puro
7. Arneses de Evaluación
Las evaluaciones son cómo sabes si tu sistema de IA realmente funciona — no solo en los ejemplos que probaste manualmente, sino sistemáticamente en cientos de entradas
Los agentes de IA son poderosos pero complejos de implementar porque su comportamiento probabilístico de múltiples pasos introduce muchos puntos de fallo
Diferentes partes de un agente – los LLM, 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 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 pruebas 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 evalúas 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 califiquen salidas de forma determinista (coincidencia de cadenas, validación de esquemas 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 la construcción de pipelines de evaluación para sistemas de IA de producción real, por alguien que lo ha hecho a escala
2. Framework de Evaluaciones 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 (¿el agente llamó a la herramienta correcta?) y métricas de resultado (¿la tarea tuvo éxito?), definir criterios de éxito claros antes de construir cualquier cosa, 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 a su alrededor. Crea 30 pares de preguntas y respuestas de tus documentos, ejecútalos a través de tu pipeline y califica 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 sean seleccionadas correctamente y de forma fiable
- Gestionar correctamente el estado del agente usando LangGraph o equivalente
- Manejar fallos dentro de los bucles del agente sin bloquearse
- 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 del Mes 1. Ahora necesitas hacer que sobreviva al tráfico de producción
La diferencia entre desarrollo y producción es brutal. Un solo proceso 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 multiworker, middleware de manejo de errores adecuado, endpoints de health check y políticas CORS
Recursos:
1. Documentación de Despliegue de FastAPI (oficial, gratuito)
Enlace: https://fastapi.tiangolo.com/deployment/
La guía oficial que cubre workers de Uvicorn, Gunicorn y despliegue con Docker. Empieza aquí antes que cualquier otra cosa
2. Guía de Despliegue en Producción de FastAPI (CYS Docs, gratuito)
Enlace: https://craftyourstartup.com/cys-docs/fastapi-production-deployment/
Patrones completos de producción: configuración de Gunicorn, proxy inverso con Nginx, health checks, límite de tasa. 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, almacenamiento en 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 solo), configurar endpoints de health check, agregar 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, asegura 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 (gratuito)
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 de IA multiagente 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 multiagente real con Docker Compose. Cubre separación de preocupaciones, programación de 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íficamente para aplicaciones LLM con pipelines RAG. Cubre creación de Dockerfile, gestión de entornos y despliegue
4. Contenerización con 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 con múltiples servicios
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 para 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 lo 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 (gratuito)
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, gratuito)
Enlace: https://fastapi.tiangolo.com/tutorial/background-tasks/
Tareas en segundo plano ligeras integradas para casos de uso simples. Úsalas para tareas rápidas de "dispara y olvida", Celery para cualquier cosa más pesada
En qué enfocarse: Entender cuándo usar BackgroundTasks integrado de FastAPI vs una cola de tareas adecuada como Celery, configurar Redis como broker 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
Recursos:
1. Documentación de Seguridad de FastAPI (oficial, gratuito)
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 en APIs. Comprende autenticación rota, inyección y asignación masiva antes de enviar cualquier cosa
3. Auth0: Mejores Prácticas de Autenticación en APIs (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, límite de tasa por usuario/clave, nunca almacenar secretos en el código (usar variables de entorno) y entender 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á pasando, 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 aun así producir una respuesta inútil o alucinada. El monitoreo tradicional no detecta 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 usas 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. Python Structlog (gratuito)
Enlace: https://www.structlog.org/
Registro estructurado para Python. Produce registros JSON que son realmente buscables y analizables. Mucho mejor que print() o el registro básico para aplicaciones de 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 Versiones de Prompts
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 descubrir por qué
Recursos:
1. Gestión de Prompts de Langfuse (gratuito)
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 redeployar tu aplicación
2. Mejores Prácticas de Gestión de Prompts de Anthropic (gratuito)
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 prompts A/B en producción y tener una estrategia de reversión cuando un nuevo prompt tenga peor rendimiento
7. Monitoreo de Costos y Límites de Tasa
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
Seguimiento del gasto por modelo, por día y configuración de 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 configurar: 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, límite de tasa y seguimiento de gastos entre proveedores
En qué enfocarse: Establecer límites de gasto duros por día/mes, implementar límites de tasa por usuario en tu API, usar modelos más baratos para tareas simples (no uses GPT-4/Opus para todo), almacenar en caché solicitudes idénticas repetidas con Redis y monitorear el costo por solicitud para detectar prompts costosos temprano
8. Almacenamiento en Caché
Si el 20% de tus usuarios hacen preguntas similares, estás pagando por la misma llamada LLM 20 veces
El almacenamiento en caché es la forma más simple de reducir costos y latencia simultáneamente
Recursos:
1. Documentación oficial de Redis (gratuito)
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. Usa similitud de embeddings para encontrar respuestas 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é (basado en TTL es lo más simple) y medir tasas de acierto de caché para entender 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 tasa 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 arriba también se aprende mejor puramente a través de la práctica
Dirección 1: Ingeniero de Producto de IA
Ideal si quieres trabajos en startups rápido
Este es el camino más común. Construyes productos potenciados 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
- UX de producto
Qué aprender este mes:
1. Construcción de Producto de Principio a Fin
Deja de construir tutoriales. Construye productos que la gente pueda usar
Recursos:
1. SDK de IA de Vercel (gratuito)
Enlace: https://sdk.vercel.ai/docs
La forma más rápida de construir interfaces de usuario potenciadas 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 MVPs, no para UI a escala de producción
3. Gradio (gratuito)
Enlace: https://www.gradio.app/docsQuick Interfaces ML/IA con código mínimo. Especialmente útil para demostrar modelos y crear prototipos.
En qué enfocarte: Construir 2-3 proyectos completos este mes que puedas demostrar. Una app de "chatea con tus documentos", una herramienta interna potenciada por IA, o un agente que automatice un flujo de trabajo real. Publícalos. Ponlos en 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 UX no contempla las limitaciones del modelo
Recursos:
1. Google: Guía Personas + IA (gratis)
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: Guías de UX para IA (gratis)
Enlace: https://www.nngroup.com/topic/artificial-intelligence/
Directrices basadas en investigación para interfaces de IA.
En qué enfocarte: 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 para el hecho de que el resultado de la IA es probabilístico: a veces estará equivocado.
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 qué sucede bajo el capó.
Enfócate en:
- fine-tuning
- cuándo fine-tunear vs. usar 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 necesitas cambiar la forma en que te comunicas con él?
Recursos:
1. Curráculo Acelerado de ML de Google: Fine-tuning, Destilación y Prompt Engineering (gratis)
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 (gratis)
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 (gratis)
Enlace: https://www.ibm.com/think/topics/rag-vs-fine-tuning-vs-prompt-engineering
Cubre el espacio de decisión completo, incluyendo cuándo combinar enfoques.
Marco de decisión para memorizar: Empieza con prompt engineering (más barato, más rápido). Agrega RAG si el modelo necesita acceso a datos específicos. Haz fine-tuning solo cuando prompt + RAG no puedan lograr la calidad, consistencia o latencia requeridas.
2. Fine-Tuning en la Práctica
Cuando sí necesitas hacer fine-tuning, aquí te explicamos cómo.
Recursos:
1. Guía de Fine-Tuning de OpenAI (oficial, gratis)
Enlace: https://platform.openai.com/docs/guides/fine-tuning
La forma más fácil de empezar con fine-tuning. Sube un dataset 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 (gratis)
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, gratis)
Enlace: https://github.com/unslothai/unsloth
Fine-tuning 2x más rápido con 80% menos memoria. Soporta LoRA y QLoRA listos para usar. El camino más rápido para hacer fine-tuning de modelos de código abierto en hardware de consumo.
4. LLaMA-Factory (código abierto, gratis)
Enlace: https://github.com/hiyouga/LLaMA-Factory
Framework unificado para hacer 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é enfocarte: 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 por el costo.
3. Modelos de Código Abierto
No todo necesita pasar por OpenAI o Anthropic. Los modelos de código abierto te dan control total, sin costos de API y la capacidad de ejecutarlos localmente.
Recursos:
1. Ollama (gratis)
Enlace: https://ollama.ai/
Ejecuta LLMs de código abierto localmente con un solo comando. Soporta Llama, Mistral, Gemma y docenas de otros. La forma más rápida de experimentar con modelos de código abierto.
2. HuggingFace Model Hub (gratis)
Enlace: https://huggingface.co/models
El repositorio más grande de modelos de código abierto. Explora, descarga e implementa modelos para cualquier tarea.
3. vLLM (código abierto, gratis)
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é enfocarte: 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 contra 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: Optimización de Inferencia de LLMs (gratis)
Enlace: https://huggingface.co/docs/transformers/llm_optims
Cubre optimización de caché KV, cuantización y estrategias de batching.
2. NVIDIA TensorRT-LLM (gratis)
Enlace: https://github.com/NVIDIA/TensorRT-LLM
Máximo rendimiento de inferencia en GPUs NVIDIA. Usado por la mayoría del servicio de LLM en producción a gran escala.
En qué enfocarte: Estrategias de batching para rendimiento, cuantización para reducir memoria y costo, 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 negocios de inmediato.
Esta dirección trata sobre 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 con 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, gratis para autoalojar)
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 (gratis)
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, gratis)
Enlace: https://docs.temporal.io/
Motor de flujos de trabajo durable 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é enfocarte: 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 supervisión humana, 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 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é enfocarte: Identificar los objetivos de automatización con mayor retorno de inversión (generalmente tareas repetitivas, que consumen tiempo y se basan en reglas), construir automatizaciones que aumenten las capacidades humanas en lugar de reemplazarlas, y medir el tiempo y dinero realmente ahorrados.
3. Automatización de CRM, Documentos, Correo Electrónico y Soporte
Los casos de uso más comunes y valiosos de automatización con IA.
Recursos:
1. OpenAI Cookbook: Procesamiento de Correo Electrónico con IA (gratis)
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 (gratis)
Enlace: https://python.langchain.com/docs/how_to/#document-loaders
Ingesta y procesamiento de documentos desde más de 80 fuentes.
En qué enfocarte: Construir un clasificador y auto-respondedor 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 IA en flujos de trabajo CRM existentes (HubSpot, Salesforce, etc.)
Proyecto práctico para la Dirección 3: Construye un sistema integral de calificación de leads. 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 los leads según tu 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 montañas de dinero
Este roadmap no te convertirá en un ingeniero de IA senior en 6 meses
Pero te convertirá en alguien que puede construir, publicar y desplegar sistemas de IA reales que resuelvan problemas reales
Y justo ahora, eso es exactamente lo que el mercado está pagando
La demanda de ingenieros de IA no se está desacelerando. Las ofertas de trabajo crecieron un 25% interanual
PwC encontró una prima salarial del 56% para roles que requieren habilidades de IA en comparación con 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 laboral del 26% hasta 2034
Estos no son números de hype. Son números reales basados en análisis (tomados de Claude kek)
Si trabajas a tiempo completo en EE.UU.:
Ingenieros de IA Jr. comienzan 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 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 lo tuyo es más el trabajo independiente:
Desarrollo de agentes de IA se paga a $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 ruta de consultoría, de la 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 soporte al cliente
$500-$2,000 por configuración de contacto en frío
El espectro de servicios es aún más amplio, pero una vez que domines las habilidades de este roadmap, ya serás 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. Créalo, rómpelo, arréglalo, despliégalo, ponlo en 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, en cualquier lugar. 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 su currículum a 500 ofertas de trabajo
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 trabajos independientes, empieza a ofrecer servicios en el momento en que tengas proyectos funcionales. Incluso si no son perfectos. El mercado no recompensa la perfección. Recompensa a las personas que pueden entregar
6 meses es suficiente para cambiarlo todo si realmente pones el esfuerzo
Y realmente creo que cada uno de ustedes que está leyendo esto puede lograrlo
Solo nunca dejen de construir y nunca dejen de aprender
Espero que esto les haya sido útil, mi gente ❤️
