GuíaIntermedio
Modelos locales para ingenieros: de GGUF a producción
Ya sabes levantar un modelo en tu máquina y llamarlo por API. Esta guía empieza ahí y te da lo que falta para usarlo en serio: el porqué técnico y los casos de ingeniería. Vas a entender qué ocupa memoria cuando corre un modelo (los pesos, la cuantización, el KV cache que crece con cada palabra de la conversación) y qué limita su velocidad, para calcular antes de descargar nada si un modelo cabe en tu hardware y qué tan rápido va a ir. Vas a elegir modelo con mediciones propias de velocidad y calidad, no con rankings; a escoger entre llama.cpp, Ollama (con su motor MLX en Apple Silicon), LM Studio sin interfaz, mlx-lm y vLLM según el caso; y a escribir un solo cliente que funciona igual contra un modelo local, uno en la nube o ambos con respaldo, con un candado que impide por diseño que un dato sensible salga a internet. Después vienen los casos que más fallan en local: la salida estructurada y el tool calling, con sus límites reales y medidos; un RAG que funciona con la red apagada, con el retrieval evaluado y citas verificables; y los agentes de código con modelo local, con la configuración que los hace usables y una forma de medirlos en tu propio repositorio. La guía cierra con privacidad verificada (qué sale de la máquina y cómo comprobarlo), las licencias de los modelos abiertos y el proyecto final: un asistente privado de documentos empaquetado en Docker, que responde con citas y no tiene salida a internet. Todo ocurre en un mismo caso: la Clínica Altamira, una red de tres clínicas que necesita un asistente para su personal con una condición que no se negocia: ningún documento sale del edificio.
- 64
- lecciones
- 8
- módulos
- Inglés · Español
- disponible en
- Gratis
- acceso
Resultados
Lo que vas a poder hacer
- Calcular la memoria que necesita un modelo (pesos según la cuantización, KV cache según el contexto y las peticiones en paralelo) y estimar su velocidad a partir del ancho de banda de memoria
- Distinguir GGUF, safetensors y MLX, y elegir una cuantización (Q8, Q5, Q4) sabiendo qué se gana y qué se pierde
- Explicar por qué un modelo de mezcla de expertos (MoE) ocupa memoria por sus parámetros totales y avanza a la velocidad de sus parámetros activos
- Elegir un modelo para un hardware concreto con un benchmark de velocidad y un set de evaluación de calidad propios
- Operar llama.cpp (`llama-server`), Ollama, LM Studio sin interfaz (`lms`), mlx-lm y vLLM, y decidir cuál conviene en cada caso
- Escribir un cliente compatible con la API de OpenAI que sirve para local, nube y respaldo, con timeouts, health checks, streaming y un candado de privacidad probado con tests
- Obtener salida estructurada y tool calling de un modelo local con validación, reintentos y límites, y medir cuánto fallan
- Construir un RAG 100% local con embeddings locales y un almacén en SQLite, y evaluar su retrieval con hit@k y MRR
- Configurar un agente de código con un modelo local (contexto, runtime, permisos) y medirlo con tareas de tu propio repositorio
- Verificar qué sale de tu máquina, leer la licencia de un modelo abierto y entregar la aplicación en Docker sin salida a internet
Antes de empezar
Qué necesitas traer
Es para ti si...
- Ingenieros de software que ya llamaron a un modelo local por API y quieren entender qué pasa por dentro antes de ponerlo en un producto
- Equipos con datos que no pueden salir a la nube (salud, legal, finanzas, código confidencial) y que necesitan una alternativa medida, no una promesa
- Quien tiene que decidir qué hardware comprar o qué modelo correr y quiere números en vez de opiniones
- Devs que usan agentes de código y quieren saber cuándo un modelo local alcanza y cuándo no
Requisitos y materiales
- Python intermedio: funciones, clases, `dataclass`, entornos virtuales, `pip`
- Haber instalado un runtime local y haberlo llamado por API. Si todavía no, haz primero los módulos 3 (LM Studio) y 4 (Ollama) de la guía [Estrategias de acceso a LLMs](../llm-access-strategies-guide/)
- Terminal básica y Docker instalado para el último módulo
- Una computadora con 16 GB de RAM sigue toda la guía con un modelo pequeño. No necesitas GPU NVIDIA: lo que la requiere se explica con su alternativa
Contenido
El temario, módulo por módulo
Abre cualquiera para ver sus lecciones.
- 1. Introducción: la Clínica Altamira y lo que pasa dentro de la máquina
- 2. Pesos, parámetros y qué es un archivo de modelo
- 3. Formatos: GGUF, safetensors y MLX
- 4. Cuantización: Q4, Q5, Q8 y qué se pierde
- 5. KV cache y ventana de contexto
- 6. Prefill, decode y ancho de banda de memoria
- 7. Modelos densos contra mezcla de expertos (MoE)
- 8. Proyecto: calculadora de presupuesto de memoria
- 1. Introducción: elegir con evidencia, no con rankings
- 2. La fórmula de dimensionamiento: RAM, VRAM y margen
- 3. Leer la ficha de un modelo y su repositorio
- 4. Familias de modelos abiertos a octubre de 2026
- 5. Cuando un modelo pequeño no alcanza
- 6. Medir velocidad: TTFT y tokens por segundo
- 7. Tu propio set de evaluación de calidad
- 8. Proyecto: la ficha de selección de modelo
- 1. Introducción: la ventanilla de comandas estándar
- 2. El contrato compatible con OpenAI
- 3. Configuración sin nada escrito en el código
- 4. Timeouts, health checks y arranques en frío
- 5. Streaming y conteo de tokens
- 6. El respaldo y el candado de privacidad
- 7. Probar el cliente sin un modelo
- 8. Proyecto: el cliente de la Clínica Altamira
- 1. Introducción: el molde y el ayudante
- 2. Decodificación restringida: gramáticas y esquemas
- 3. `chat_json` con validación Pydantic
- 4. Dónde se rompe la salida estructurada local
- 5. Tool calling con un modelo local
- 6. Barandales para el ciclo de herramientas
- 7. Medir la fiabilidad
- 8. Proyecto: herramientas de citas y políticas
- 1. Introducción: la despensa y la mesa
- 2. Modelos de embeddings locales
- 3. Partir los documentos para un contexto chico
- 4. Un almacén de vectores en SQLite
- 5. Recuperación y presupuesto de contexto
- 6. Respuestas fundamentadas con citas
- 7. Evaluar un RAG local
- 8. Proyecto: el asistente de documentos de Altamira
- 1. Introducción: el cocinero que reacomoda la cocina
- 2. Qué le exige al modelo el ciclo de un agente
- 3. El contexto es el primer ajuste
- 4. OpenCode con un runtime local
- 5. Claude Code con un modelo local
- 6. Medir un agente en tu propio repositorio
- 7. Configuraciones híbridas y permisos seguros
- 8. Proyecto: la tarjeta de resultados de un agente local
- 1. Introducción: puertas y ventanas
- 2. Un modelo de amenazas para IA local
- 3. Telemetría y modo sin conexión
- 4. Licencias de modelos en la práctica
- 5. Empaquetar la aplicación en Docker
- 6. Compose, redes y el runtime
- 7. Operarlo: salud, logs y actualizaciones
- 8. Proyecto: un asistente de documentos privado en Docker
Dudas frecuentes
Lo que suele preguntarse
Sin límite. Es una guía gratuita: entras cuando quieras, las veces que quieras.
No. Los módulos están ordenados de menos a más, pero puedes saltar al que necesites. Tu progreso se guarda por lección.
Lo que haga falta está en «Qué necesitas traer», arriba. Si no aparece nada ahí, puedes empezar desde cero.
En el grupo de WhatsApp, y cada quince días hay un live con un instructor donde se resuelven dudas en vivo.
Empieza cuando quieras
Lo que dicen los estudiantes
Estas reseñas son de estudiantes inscritos que completaron al menos el 50% del curso. Moderamos las reseñas solo por motivos de contenido (spam, lenguaje ofensivo, datos personales), nunca por ser críticas o negativas.
Aún no hay reseñas aprobadas.
¡Sé el primero en compartir tu experiencia!