Curso de LLMO - Large Language Model Optimization

Identificar casos de uso candidatos a optimización dentro de una empresa.

Evaluar valor de negocio, frecuencia, criticidad, riesgo, usuarios afectados y ahorro potencial.

Diferenciar casos internos, casos externos, procesos críticos, asistentes de baja exposición y automatizaciones sensibles.

Revisar restricciones de datos, privacidad, normativa, seguridad, presupuesto, latencia y disponibilidad.

Analizar el estado actual de la solución: prompt simple, RAG, agente, fine-tuning, modelo local o integración SaaS.

Identificar cuellos de botella: coste, calidad, contexto, retrieval, latencia, infraestructura, tooling o adopción.

Crear una ficha de diagnóstico por caso de uso con owner, usuarios, datos, modelo, métricas y riesgos.

Establecer línea base antes de optimizar para evitar mejoras subjetivas sin evidencia.

Priorizar optimizaciones según impacto, esfuerzo, coste, riesgo y velocidad de implantación.

Definir roadmap LLMO por fases: estabilizar, medir, optimizar, automatizar, escalar y gobernar.

Comparar modelos propietarios, modelos open source, modelos locales y modelos gestionados por cloud.

Evaluar modelos según calidad, razonamiento, contexto, idioma, coste, velocidad, disponibilidad y seguridad.

Diferenciar modelos generalistas, modelos pequeños, modelos razonadores, modelos multimodales y modelos especializados.

Analizar cuándo usar un modelo grande y cuándo basta un modelo más pequeño, rápido y barato.

Diseñar benchmarks internos para comparar modelos sobre tareas reales de la empresa.

Evaluar compatibilidad con herramientas, function calling, structured outputs, visión, audio, documentos o agentes.

Revisar restricciones de licencia, uso comercial, residencia de datos, privacidad y dependencia de proveedor.

Diseñar estrategia multi-modelo para equilibrar coste, calidad y resiliencia.

Definir criterios de cambio de modelo sin romper comportamiento, calidad ni contratos de salida.

Crear una matriz de selección y decisión de modelo por caso de uso empresarial.

Convertir prompts informales en instrucciones profesionales, evaluables y versionables.

Diseñar prompts con rol, objetivo, contexto, formato, restricciones, ejemplos, criterios de calidad y límites.

Separar instrucciones de sistema, instrucciones de tarea, contexto dinámico, datos del usuario y formato de salida.

Usar few-shot examples para mejorar consistencia sin sobrecargar el contexto.

Aplicar patrones de razonamiento controlado sin pedir explicaciones innecesarias al usuario final.

Optimizar prompts para clasificación, extracción, resumen, generación, análisis, Q&A y workflows.

Crear plantillas con variables, validaciones y salidas estructuradas.

Comparar prompts con datasets y métricas, no solo por sensación del equipo.

Gestionar versiones de prompts, rollback, pruebas A/B y aprobación antes de producción.

Evitar prompts frágiles, largos, ambiguos, contradictorios o dependientes de un modelo concreto.

Comprender qué consume tokens: instrucciones, historial, documentos, ejemplos, tools, retrieval y salidas.

Diseñar contexto mínimo suficiente para maximizar calidad sin aumentar coste innecesario.

Separar contexto estático, contexto dinámico, memoria de usuario, historial conversacional y documentos recuperados.

Usar compresión, resúmenes, jerarquías y ventanas deslizantes para sesiones largas.

Optimizar salidas para reducir tokens sin perder claridad ni utilidad.

Gestionar modelos con ventanas de contexto grandes evitando meter información irrelevante.

Aplicar prompt caching cuando existe contexto repetitivo y compatible con el proveedor.

Diseñar estrategias de caché de sistema, documentos base, instrucciones, ejemplos y contexto común.

Evitar invalidar cachés con timestamps, datos volátiles o bloques dinámicos mal ubicados.

Crear criterios de coste por interacción, coste por tarea, coste por usuario y coste por flujo completo.

Identificar qué datos necesita un modelo o aplicación para mejorar una tarea concreta.

Diferenciar datos de entrenamiento, datos de evaluación, datos de producción, logs e información documental.

Crear golden sets con ejemplos reales, respuestas esperadas, criterios y casos límite.

Preparar datasets de prompts, respuestas, etiquetas, preferencias y escenarios de prueba.

Limpiar datos duplicados, obsoletos, contradictorios, sensibles o irrelevantes.

Anonimizar información antes de usarla en evaluación, fine-tuning o distillation.

Generar datos sintéticos con revisión humana cuando faltan ejemplos suficientes.

Controlar sesgos, cobertura, balance de clases, diversidad de casos y dificultad progresiva.

Separar datasets de entrenamiento, validación, test y evaluación de regresión.

Documentar origen, licencia, calidad, limitaciones y uso permitido de cada dataset.

Comprender cuándo RAG mejora una solución LLM frente a aumentar prompt o fine-tuning.

Diseñar chunking por estructura, significado, tamaño, jerarquía, metadatos y unidad de conocimiento.

Elegir embeddings según idioma, dominio, coste, latencia, precisión y compatibilidad.

Optimizar recuperación semántica, búsqueda híbrida, filtros, metadatos y búsqueda por palabras clave.

Usar rerankers para mejorar relevancia de documentos antes de generar respuesta.

Controlar groundedness, citabilidad, alucinaciones y uso correcto de fuentes.

Diseñar prompts RAG que separen contexto recuperado, pregunta, reglas y formato de salida.

Medir retrieval hit rate, precision@k, recall@k, MRR, groundedness y answer correctness.

Revisar fallos típicos: chunks pobres, demasiados documentos, metadata débil, embeddings inadecuados o respuestas sin evidencia.

Crear una estrategia de mantenimiento de índice, actualización documental, permisos y calidad de conocimiento.

Comprender el papel de embeddings en búsqueda semántica, clustering, clasificación y recomendación.

Comparar bases vectoriales, motores híbridos y soluciones gestionadas según volumen, latencia, seguridad y operación.

Diseñar esquemas de metadatos útiles para permisos, fechas, áreas, clientes, productos, versiones y tipo documental.

Gestionar documentos largos, PDFs, tablas, presentaciones, tickets, emails, wikis, código y FAQs.

Aplicar deduplicación, normalización, OCR controlado, segmentación y enriquecimiento semántico.

Integrar conocimiento corporativo con permisos de usuario y control de acceso por fuente.

Diseñar estrategias multiíndice por departamento, idioma, sensibilidad, cliente o caso de uso.

Medir calidad del índice con consultas reales, casos límite, errores y feedback de usuarios.

Optimizar latencia y coste de recuperación mediante caching, filtros previos y selección de k.

Documentar pipeline de ingesta, actualización, versionado, borrado y auditoría de conocimiento.

Comprender cuándo el fine-tuning aporta valor frente a prompting, RAG o cambio de modelo.

Diferenciar supervised fine-tuning, preference tuning, DPO, RLHF y reinforcement fine-tuning.

Evaluar si el objetivo es estilo, formato, clasificación, razonamiento, herramienta, dominio o reducción de coste.

Preparar datasets de entrenamiento con ejemplos consistentes, limpios y representativos.

Usar PEFT para adaptar modelos con menos coste y menor necesidad de recursos.

Aplicar LoRA y QLoRA cuando se requiere adaptación eficiente de modelos open source.

Controlar hiperparámetros, validación, overfitting, degradación de capacidades y regresiones.

Evaluar modelos fine-tuned frente a baseline, prompts optimizados y modelos alternativos.

Documentar datos usados, licencia, finalidad, métricas, riesgos y limitaciones del modelo ajustado.

Evitar fine-tuning cuando el problema real es mala documentación, mal retrieval o prompts deficientes.

Comprender la destilación como transferencia de comportamiento desde un modelo teacher a un modelo student.

Identificar casos donde un modelo grande enseña a uno más pequeño, rápido y económico.

Generar datos de entrenamiento mediante respuestas de un modelo de mayor calidad con revisión y filtrado.

Usar logs de producción para seleccionar ejemplos representativos y casos frecuentes.

Diseñar student models especializados por tarea, idioma, departamento, cliente o flujo operativo.

Evaluar calidad del modelo destilado frente a teacher, baseline y requisitos mínimos.

Medir reducción de coste, latencia, throughput y dependencia de modelos premium.

Controlar pérdida de capacidades, errores en casos raros y sesgos heredados del teacher.

Documentar criterios para cuándo enrutar a student y cuándo escalar a teacher.

Integrar distillation dentro de una estrategia de routing, fallback y mejora continua.

Comprender cuantización como reducción de precisión para disminuir memoria y acelerar inferencia.

Diferenciar cuantización post-training, quantization-aware training y formatos habituales de modelos cuantizados.

Trabajar conceptos de 8-bit, 4-bit, GPTQ, AWQ, GGUF, bitsandbytes, EETQ y variantes del ecosistema.

Evaluar impacto de cuantización en calidad, latencia, memoria, compatibilidad y coste.

Usar modelos cuantizados para despliegues locales, edge, servidores con menos VRAM o pruebas internas.

Revisar técnicas de compression, pruning, sparsity y optimización de pesos cuando aplique.

Combinar LoRA o QLoRA con modelos cuantizados en escenarios de adaptación eficiente.

Medir degradación con evals antes de aceptar un modelo comprimido.

Documentar hardware, formato, librerías, versión, precisión y métricas del modelo optimizado.

Evitar elegir la cuantización más agresiva si destruye calidad o genera errores de negocio.

Comprender qué ocurre durante la inferencia de un LLM y qué factores afectan latencia y coste.

Diferenciar prefill, decode, tokens de entrada, tokens de salida, KV cache y throughput.

Usar batching continuo para mejorar utilización de GPU en cargas concurrentes.

Aplicar streaming para mejorar experiencia de usuario en respuestas largas.

Gestionar límites de contexto, longitud de salida, timeouts, colas y prioridad de solicitudes.

Comparar motores de serving como vLLM, TensorRT-LLM, TGI, Ollama, llama.cpp, Triton o soluciones cloud.

Diseñar despliegues con CPU, GPU, multi-GPU, instancias dedicadas, autoscaling y colas.

Medir p50, p95, p99, tokens por segundo, tiempo hasta primer token y uso de memoria.

Optimizar carga de modelo, cold starts, concurrencia, cache warming y reutilización de contexto.

Crear criterios para decidir entre API externa, modelo local, serving propio o plataforma gestionada.

Diseñar rutas inteligentes entre modelos pequeños, grandes, baratos, rápidos, especializados y multimodales.

Usar cascadas para resolver tareas simples con modelos eficientes y escalar solo casos complejos.

Definir fallback cuando un proveedor falla, responde lento o incumple calidad mínima.

Aplicar routing por idioma, departamento, sensibilidad, longitud, coste, tarea o riesgo.

Usar gateways para centralizar credenciales, logs, políticas, modelos, límites y observabilidad.

Evaluar semantic routing, intent classification y reglas de negocio para seleccionar modelo.

Combinar routing con prompt caching, batch processing, rate limits y cuotas por usuario.

Evitar rutas opacas que impiden explicar por qué se usó un modelo concreto.

Medir ahorro, latencia, precisión y degradación por estrategia de enrutado.

Documentar modelos permitidos, criterios de escalado, fallbacks y responsables de cambio.

Identificar cargas aptas para batch: clasificación documental, extracción, resúmenes, informes y etiquetado.

Diferenciar inferencia interactiva, asíncrona, batch, programada y near real-time.

Diseñar colas para procesar grandes volúmenes sin bloquear al usuario.

Usar caché de respuestas cuando la misma consulta o contexto se repite.

Gestionar invalidación de caché, expiración, versión de prompt, versión de modelo y permisos.

Reducir coste agrupando tareas, reutilizando contexto y eliminando llamadas redundantes.

Diseñar procesamiento incremental para documentos, tickets, emails o bases de conocimiento.

Controlar rate limits, retries, timeouts, backoff, idempotencia y reanudación de trabajos.

Medir coste por lote, errores, velocidad, throughput y calidad de salida.

Crear patrones seguros para cargas masivas con datos corporativos y resultados auditables.

Comprender cómo cambia la optimización cuando el LLM llama herramientas o actúa como agente.

Diseñar tools claras, acotadas, tipadas, documentadas y con errores previsibles.

Optimizar prompts de agente para planificación, uso de herramientas, verificación y parada.

Reducir llamadas innecesarias a herramientas mediante contexto, caching, planning y restricciones.

Evaluar calidad de agentes por éxito de tarea, pasos, coste, latencia, seguridad y necesidad de intervención humana.

Gestionar memoria de agente, historial, trazas, decisiones intermedias y recuperación ante errores.

Proteger herramientas sensibles con permisos, confirmación humana, límites y auditoría.

Evitar agentes excesivamente autónomos en procesos financieros, legales, laborales o de producción.

Medir tool success rate, loops, acciones fallidas, coste por tarea y cumplimiento de política.

Diseñar optimización de agentes con evals, simulaciones, traces y revisión humana.

Optimizar modelos que procesan texto, PDF, imágenes, capturas, audio, vídeo o datos mixtos.

Diseñar preprocesamiento para documentos complejos, tablas, formularios, facturas, contratos y presentaciones.

Evaluar cuándo usar OCR, visión nativa, extracción estructurada o pipelines híbridos.

Optimizar prompts multimodales con instrucciones de lectura, zonas relevantes, formato y criterios de extracción.

Medir precisión en extracción de campos, clasificación, resumen visual y análisis documental.

Gestionar coste y latencia de inputs multimodales, especialmente documentos largos o vídeos.

Diseñar flujos con validación humana cuando la salida alimenta decisiones o sistemas internos.

Controlar privacidad de imágenes, documentos, audio y vídeo con datos personales o información sensible.

Comparar modelos multimodales según calidad, formato, coste, idioma y capacidad de razonamiento.

Documentar límites de precisión, errores habituales y criterios de revisión por tipo de contenido.

Crear una estrategia de evaluación antes de optimizar prompts, RAG, modelos o agentes.

Definir métricas por tarea: exactitud, groundedness, relevancia, completitud, formato, seguridad y utilidad.

Construir golden datasets con preguntas reales, respuestas esperadas, fuentes y casos límite.

Usar evaluación humana para calibrar criterios y detectar fallos no capturados por métricas automáticas.

Aplicar LLM-as-judge con rúbricas claras, escalas, criterios, ejemplos y control de sesgos.

Comparar modelos, prompts, retrievers, configuraciones y versiones con experimentos reproducibles.

Diseñar evals de regresión para evitar que una mejora rompa casos ya resueltos.

Evaluar agentes con herramientas, pasos intermedios, éxito de tarea y cumplimiento de instrucciones.

Integrar evals en CI/CD para bloquear cambios inseguros o degradaciones relevantes.

Crear dashboards de calidad para producto, ingeniería, dirección, soporte y gobierno de IA.

Instrumentar aplicaciones LLM con trazas por prompt, modelo, retrieval, tool call, respuesta y usuario.

Medir latencia, coste, tokens, errores, retries, fallback, calidad y uso por caso de negocio.

Usar herramientas de observabilidad para depurar cadenas, agentes, RAG y workflows complejos.

Registrar inputs y outputs de forma segura, anonimizada o filtrada según política corporativa.

Incorporar feedback explícito e implícito de usuarios para mejorar prompts, retrieval y modelos.

Detectar drift, cambios de comportamiento, subida de costes, caída de calidad o aumento de errores.

Crear alertas para latencia alta, coste anómalo, respuestas inseguras, loops de agente o fallos de tool.

Analizar trazas para encontrar pasos inútiles, contexto excesivo, retrieval pobre o prompts poco eficientes.

Conectar observabilidad con backlog de mejora y decisiones de producto.

Establecer un ciclo continuo de medición, análisis, optimización, validación y despliegue.

Identificar amenazas específicas de sistemas LLM: prompt injection, jailbreak, data exfiltration y tool misuse.

Proteger aplicaciones RAG frente a instrucciones maliciosas dentro de documentos recuperados.

Diseñar validadores de entrada, filtros de salida, controles de herramientas y políticas de permisos.

Separar datos sensibles, secretos, credenciales, prompts internos y contexto visible al usuario.

Aplicar mínimos privilegios en herramientas, conectores, bases de datos, APIs y agentes.

Usar guardrails para formato, contenido, cumplimiento, PII, toxicidad, seguridad y acciones críticas.

Diseñar confirmación humana para operaciones irreversibles o sensibles.

Gestionar logs y trazas evitando almacenar información confidencial innecesaria.

Evaluar seguridad con red teaming, pruebas adversariales, ataques de prompt y casos límite.

Documentar riesgos, controles, responsables, incidentes y planes de mitigación.

Clasificar datos usados por modelos según sensibilidad, finalidad, permisos y base legal.

Evaluar privacidad en prompts, datasets, embeddings, logs, fine-tuning, distillation y observabilidad.

Aplicar minimización, anonimización, retención limitada y control de acceso por rol.

Revisar derechos de uso de modelos, outputs, datos de entrenamiento y contenido generado.

Gestionar proveedores LLM con due diligence, contratos, ubicación de datos, retención y subprocesadores.

Evaluar riesgos de sistemas de IA según impacto en personas, decisiones y procesos críticos.

Documentar model cards, data cards, evaluaciones, limitaciones, uso previsto y uso no recomendado.

Preparar trazabilidad para auditoría interna, clientes, reguladores y comité de IA.

Controlar sesgos, discriminación, transparencia, explicabilidad y revisión humana en procesos sensibles.

Integrar LLMO con gobierno corporativo de IA, seguridad, legal, DPO, compliance y dirección.

Integrar prompts, modelos, datasets, evaluaciones y configuraciones dentro de un flujo versionado.

Crear entornos de desarrollo, testing, staging y producción para aplicaciones LLM.

Versionar prompts, reglas, modelos, índices, embeddings, datasets, evaluadores y pipelines.

Automatizar pruebas antes de desplegar cambios de prompt, modelo, RAG o agente.

Crear gates de calidad, seguridad, latencia y coste en CI/CD.

Gestionar releases, rollback, canary deployments, A/B testing y feature flags.

Documentar cambios con impacto esperado, métricas, riesgos y resultados de evaluación.

Integrar MLflow, LangSmith, Langfuse, W&B, OpenTelemetry u otras herramientas según arquitectura.

Evitar cambios manuales en producción sin trazabilidad, aprobación y prueba previa.

Construir una operación LLM madura, reproducible, auditable y mantenible.

Diseñar arquitecturas LLM en cloud, on-premise, híbridas o multi-cloud.

Evaluar requisitos de GPU, CPU, memoria, almacenamiento, red, latencia y seguridad.

Desplegar modelos con contenedores, Kubernetes, servicios gestionados o motores especializados.

Planificar autoscaling, colas, balanceo, afinidad de GPU y aislamiento de workloads.

Diseñar alta disponibilidad, recuperación, redundancia y resiliencia ante fallo de proveedor.

Gestionar secretos, credenciales, endpoints, certificados, rate limits y seguridad de red.

Integrar modelos con APIs internas, bases de datos, vector stores, colas y observabilidad.

Optimizar costes de infraestructura mediante dimensionamiento, apagado, batch, spot y modelos pequeños.

Definir entornos seguros para datos sensibles, pruebas, fine-tuning y modelos locales.

Documentar arquitectura, dependencias, RTO, RPO, runbooks y responsabilidades de operación.

Identificar todos los componentes de coste: tokens, embeddings, retrieval, storage, GPU, licencias, logs y observabilidad.

Medir coste por usuario, caso de uso, departamento, tarea, cliente, modelo y flujo completo.

Crear presupuestos, límites, cuotas, alertas y reporting financiero para uso de IA.

Optimizar coste mediante selección de modelo, caching, routing, batch, prompts compactos y respuestas acotadas.

Calcular coste de RAG incluyendo ingesta, embeddings, base vectorial, retrieval, reranking y generación.

Comparar coste de APIs externas frente a serving propio y modelos open source.

Medir retorno de inversión con productividad, reducción de incidencias, automatización y mejora de calidad.

Detectar anomalías de consumo, bucles de agentes, prompts demasiado largos y modelos mal dimensionados.

Preparar reporting para dirección con valor, coste, riesgo, adopción y decisiones pendientes.

Diseñar un modelo de FinOps IA integrado con ingeniería, producto, finanzas y gobierno.

Optimizar asistentes de soporte para resolver tickets con precisión, fuentes y escalado adecuado.

Optimizar agentes comerciales para preparar respuestas, propuestas, CRM y seguimiento de oportunidades.

Optimizar IA para finanzas con control de cifras, trazabilidad, fuentes y revisión humana.

Optimizar IA legal con grounding documental, confidencialidad, citas internas y límites claros.

Optimizar IA de RRHH evitando sesgos, datos sensibles y decisiones automatizadas no revisadas.

Optimizar IA para marketing con consistencia de marca, revisión legal, variantes y medición de calidad.

Optimizar IA para IT y DevOps con documentación, logs, runbooks, código y soporte técnico.

Optimizar IA para operaciones con clasificación, extracción, planificación, incidencias y automatización de procesos.

Crear patrones reutilizables por área: prompt, datos, modelo, métricas, riesgo y validación.

Priorizar mejoras transversales que reduzcan coste y aumenten calidad en varios departamentos.

Auditar bots, asistentes, scripts, prompts y prototipos creados sin gobierno inicial.

Identificar deuda técnica en aplicaciones LLM: prompts incrustados, sin evals, sin logs, sin versiones y sin ownership.

Migrar soluciones de prueba a arquitectura productiva con observabilidad, seguridad y CI/CD.

Sustituir prompts manuales por plantillas versionadas y evaluables.

Rehacer RAGs deficientes mejorando ingesta, metadatos, chunking, retrieval y permisos.

Modernizar integraciones con gateways, herramientas, APIs, colas y control de errores.

Reducir dependencia de un proveedor incorporando abstracción, routing o fallback.

Crear plan de refactorización incremental sin interrumpir usuarios actuales.

Documentar decisiones, limitaciones, riesgos y roadmap de mejora.

Convertir pilotos aislados en productos internos sostenibles y medibles.

Crear documentación técnica de modelos, prompts, datasets, RAG, arquitectura y herramientas.

Preparar playbooks de operación para incidencias, cambios, evaluación, despliegue y rollback.

Documentar decisiones mediante ADRs, model cards, data cards, prompt cards y fichas de caso de uso.

Crear guías para usuarios finales con límites, uso previsto, ejemplos y errores conocidos.

Mantener repositorio de prompts, evaluaciones, datasets, resultados y configuraciones.

Establecer responsables de modelo, responsable de caso de uso, responsable de datos y responsable de operación.

Definir proceso de revisión periódica de calidad, coste, seguridad, privacidad y adopción.

Crear formación interna para equipos técnicos, negocio, soporte, seguridad y dirección.

Evitar dependencia de una sola persona o proveedor para entender el sistema.

Construir una base de conocimiento LLMO que permita escalar y mantener la optimización en el tiempo.

Seleccionar un caso empresarial realista basado en LLM: RAG, agente, chatbot, automatización documental o asistente interno.

Definir objetivo, usuarios, datos, restricciones, riesgos, métricas y valor esperado.

Diagnosticar la solución inicial midiendo calidad, coste, latencia, seguridad, tokens y experiencia de usuario.

Comparar varios modelos candidatos según calidad, coste, contexto, privacidad, modalidad y disponibilidad.

Optimizar prompts con versiones, ejemplos, formato, instrucciones, salidas estructuradas y pruebas comparativas.

Rediseñar gestión de contexto para reducir tokens, mejorar relevancia y aprovechar caché cuando proceda.

Optimizar RAG con chunking, embeddings, metadatos, búsqueda híbrida, reranking y groundedness.

Preparar golden dataset, evals automáticas, revisión humana y LLM-as-judge con rúbricas claras.

Evaluar si conviene fine-tuning, LoRA, QLoRA, distillation, quantization, routing o cambio de modelo.

Diseñar arquitectura de inferencia con API externa, modelo local, gateway, serving, colas o batch processing.

Crear estrategia de observabilidad con trazas, métricas, feedback, tokens, costes, latencia y errores.

Diseñar controles de seguridad frente a prompt injection, datos sensibles, jailbreaks, herramientas y permisos.

Preparar modelo de FinOps con coste por caso de uso, presupuesto, alertas, cuotas y decisiones de optimización.

Integrar el flujo LLMO en CI/CD con versionado, pruebas, gates, despliegue controlado y rollback.

Documentar model card, data card, prompt card, arquitectura, riesgos, límites y guía de usuario.

Preparar roadmap de mejora con quick wins, deuda técnica, acciones de seguridad y próximos experimentos.

Presentar el proyecto final defendiendo decisiones técnicas, métricas, trade-offs, coste, calidad, seguridad y escalabilidad.