Curso de Trulens

Crear entorno Python aislado con venv, conda, uv o herramienta equivalente.

Instalar TruLens y paquetes opcionales según proveedores, frameworks y dashboards necesarios.

Preparar variables de entorno para API keys, modelos evaluadores, proveedores LLM y configuraciones sensibles.

Revisar estructura de proyecto para notebooks, código fuente, datasets, logs, informes y evaluaciones.

Crear una primera aplicación mínima evaluable con una llamada LLM sencilla.

Inicializar sesión de trabajo con TruSession y revisar su papel dentro del flujo de evaluación.

Entender dónde se almacenan registros, feedbacks, aplicaciones, evaluaciones y metadatos.

Configurar entorno local para ejecutar dashboard y revisar resultados.

Resolver errores habituales de instalación, dependencias, versiones de Python, paquetes opcionales y credenciales.

Crear repositorio Git base con documentación, `.gitignore`, requirements y primer ejemplo funcional.

Comprender la instrumentación como proceso de capturar el comportamiento interno de una aplicación IA.

Relacionar TruLens con OpenTelemetry para representar ejecución mediante traces, spans y atributos.

Identificar qué partes conviene instrumentar: prompt, LLM call, retriever, reranker, tool call, parser y respuesta final.

Capturar inputs, outputs, metadatos, tiempos, modelos, parámetros, documentos recuperados y errores.

Diferenciar trazas de desarrollo, trazas de evaluación y trazas útiles para producción.

Evitar registrar información sensible innecesaria en spans, logs o metadatos.

Crear spans personalizados para funciones propias de negocio.

Revisar cómo la instrumentación permite después aplicar feedback functions sobre partes concretas del flujo.

Diseñar una estrategia de trazabilidad para aplicaciones RAG y agentes multi-step.

Realizar ejercicio de instrumentación de una app LLM con spans y atributos relevantes.

Comprender el concepto de app registrada dentro de TruLens.

Entender qué es un record y cómo representa una ejecución concreta de la aplicación.

Registrar prompts, outputs, contexto, configuración, modelo, versión, usuario simulado y metadatos de experimento.

Usar metadata para distinguir versiones de prompt, retriever, modelo, dataset, entorno y configuración.

Crear convenciones de nombres para apps, runs, experimentos, datasets y versiones.

Evitar mezclar resultados de pruebas diferentes sin metadatos claros.

Diseñar experimentos comparables entre versiones de la misma aplicación.

Consultar registros para analizar comportamientos individuales y patrones agregados.

Preparar datos de evaluación para comparar experimentos en el dashboard.

Realizar ejercicio de registro de varias versiones de una aplicación con metadatos consistentes.

Comprender qué son las feedback functions y cómo permiten puntuar aspectos concretos de una ejecución.

Diferenciar métricas basadas en LLM, métricas con ground truth, métricas heurísticas y métricas personalizadas.

Configurar evaluaciones de relevance, groundedness, answer relevance, toxicity, sentiment, bias y quality.

Seleccionar qué parte del record se evalúa: input, output, contexto recuperado, tool call o artifact generado.

Diseñar feedback functions alineadas con criterios reales de producto y no solo con métricas genéricas.

Evitar usar una métrica sin entender qué mide, qué no mide y qué sesgos puede introducir.

Interpretar puntuaciones, razones, explicaciones y evidencias de cada feedback.

Combinar varias métricas para obtener una visión más fiable de calidad.

Crear umbrales mínimos para decidir si una ejecución es aceptable, dudosa o fallida.

Realizar ejercicio de configuración de feedback functions sobre una app de preguntas y respuestas.

Comprender la RAG Triad como evaluación central de sistemas RAG.

Medir context relevance para comprobar si los fragmentos recuperados responden realmente a la pregunta.

Medir groundedness para comprobar si la respuesta está respaldada por el contexto recuperado.

Medir answer relevance para comprobar si la respuesta final responde a la pregunta del usuario.

Detectar fallos de retrieval cuando el contexto recuperado es irrelevante o insuficiente.

Detectar alucinaciones cuando la respuesta incluye información no respaldada por las fuentes.

Detectar respuestas evasivas, incompletas, demasiado amplias o desviadas de la pregunta.

Diseñar dashboards de RAG Triad para comparar chunking, embeddings, retrievers, prompts y modelos.

Crear tests con preguntas representativas, preguntas límite y preguntas sin respuesta disponible.

Realizar ejercicio de diagnóstico de una aplicación RAG con fallos intencionados.

Instrumentar una aplicación RAG desarrollada con LangChain.

Registrar cadenas, retrievers, llamadas LLM, documentos recuperados, prompts y respuestas.

Evaluar internamente el flujo para entender qué paso introduce errores.

Configurar feedback functions sobre contexto, respuesta y relación entre ambos.

Comparar diferentes retrievers, k values, prompts, modelos y fuentes documentales.

Analizar cómo los cambios en chunking afectan a context relevance y groundedness.

Revisar trazas de LangChain para detectar pasos lentos, irrelevantes o mal configurados.

Crear métricas de calidad por tipo de pregunta, documento, dominio o fuente.

Evitar tratar LangChain como caja negra sin revisar componentes internos.

Realizar ejercicio de mejora iterativa de una app LangChain RAG con TruLens.

Instrumentar una aplicación LlamaIndex con TruLens.

Registrar queries, nodos recuperados, respuestas, retrievers, índices y configuración de consulta.

Evaluar groundedness, context relevance y answer relevance en flujos LlamaIndex.

Comparar índices, chunk sizes, top_k, reranking, prompts y modelos generadores.

Usar feedback functions para detectar nodos irrelevantes, respuestas no fundamentadas y pérdidas de contexto.

Analizar respuestas con documentos largos, múltiples fuentes y preguntas ambiguas.

Evaluar configuraciones de query engine, chat engine o agentes basados en LlamaIndex.

Revisar trazas para comprender qué componentes tienen mayor impacto en calidad.

Crear informes de comparación para decidir la mejor configuración de RAG.

Realizar ejercicio de optimización de un RAG LlamaIndex con métricas TruLens.

Instrumentar aplicaciones Python propias que no usan LangChain ni LlamaIndex.

Crear wrappers o decoradores para capturar inputs, outputs y pasos internos relevantes.

Definir componentes propios: retriever, generator, reranker, classifier, summarizer, planner o tool executor.

Usar Virtual Apps para evaluar logs generados fuera de TruLens.

Mapear datos externos a una representación evaluable dentro del framework.

Reaprovechar trazas, registros históricos o outputs ya almacenados para evaluación offline.

Evaluar aplicaciones legacy sin reescribir completamente la solución.

Diseñar estructura de datos para que las feedback functions puedan seleccionar campos correctos.

Evitar logs incompletos que impiden evaluar groundedness, contexto o respuesta.

Realizar ejercicio de evaluación de logs externos mediante Virtual Apps.

Configurar providers para ejecutar feedback functions con distintos modelos LLM.

Usar modelos comerciales, modelos locales, modelos open source o proveedores compatibles según política del cliente.

Comprender ventajas y riesgos de usar LLM-as-a-judge para evaluar respuestas LLM.

Comparar calidad, coste, latencia y estabilidad de distintos modelos evaluadores.

Configurar evaluadores con OpenAI, Azure OpenAI, Hugging Face, LiteLLM, Google, Ollama u opciones equivalentes.

Identificar cuándo conviene usar un evaluador fuerte aunque sea más costoso.

Calibrar evaluadores con ejemplos buenos, malos y dudosos.

Revisar discrepancias entre evaluación automática y revisión humana.

Evitar delegar decisiones críticas exclusivamente en un juez LLM.

Realizar ejercicio de comparación de evaluadores sobre la misma suite de respuestas.

Comprender cuándo una evaluación necesita respuestas verificadas o referencias humanas.

Crear datasets de preguntas, respuestas esperadas, documentos fuente y metadatos.

Usar ground truth para medir similitud, exactitud, cobertura y desviaciones relevantes.

Diferenciar evaluación con referencia de evaluación sin referencia.

Diseñar datasets críticos con casos que la aplicación debe responder correctamente.

Mantener datasets versionados y alineados con cambios del producto o documentación.

Usar ground truth para comparar modelos, prompts, retrievers y pipelines.

Detectar falsos positivos cuando una respuesta alternativa es válida aunque no coincida literalmente.

Integrar revisión humana para validar ejemplos y actualizar respuestas esperadas.

Realizar ejercicio de creación de dataset ground truth para un asistente interno.

Instrumentar agentes que planifican, llaman herramientas, consultan memoria o ejecutan pasos intermedios.

Capturar tool calls, argumentos, resultados, errores, decisiones y respuesta final.

Evaluar si el agente selecciona la herramienta correcta para cada tarea.

Medir calidad de planes, pasos intermedios, uso de contexto y resultados finales.

Detectar bucles, llamadas innecesarias, herramientas mal usadas y respuestas sin evidencia.

Evaluar agentes que trabajan con RAG, APIs, bases de datos, documentos o workflows empresariales.

Diseñar métricas específicas para agentes: éxito de tarea, seguridad, coste, latencia y necesidad de intervención humana.

Crear trazabilidad entre instrucción del usuario, herramienta usada, dato recuperado y output generado.

Evitar agentes que parecen funcionar en conversación pero fallan en acciones reales.

Realizar ejercicio de evaluación de un agente con herramientas y varias etapas.

Evaluar aplicaciones de resumen midiendo fidelidad, cobertura, concisión y ausencia de información inventada.

Medir si un resumen mantiene los hechos importantes y no omite riesgos críticos.

Evaluar clasificadores LLM con etiquetas esperadas, confusión, precisión y revisión de errores.

Evaluar extractores que devuelven JSON, tablas, entidades, fechas, importes, cláusulas o campos estructurados.

Diseñar métricas de formato para salidas que deben ser parseables por sistemas posteriores.

Detectar datos inventados en procesos de extracción documental.

Comparar métricas con ground truth y métricas LLM-as-a-judge según tarea.

Diseñar datasets por dominio: legal, soporte, RRHH, finanzas, ventas, operaciones o producto.

Evitar evaluar todas las tareas con las mismas métricas genéricas.

Realizar ejercicio de evaluación de resumen, clasificación y extracción estructurada.

Lanzar y navegar el dashboard de TruLens para revisar apps, records, feedbacks y experimentos.

Analizar leaderboard para comparar versiones de aplicación, prompts, modelos y configuraciones.

Identificar ejecuciones con baja relevancia, baja groundedness, alta toxicidad o respuestas fallidas.

Revisar registros individuales para comprender por qué una métrica ha dado una puntuación baja.

Usar filtros, metadatos y agrupaciones para encontrar patrones de fallo.

Comparar versiones de RAG en función de calidad, coste y latencia.

Preparar capturas e informes para equipos de producto, QA, dirección técnica o cliente.

Evitar interpretar promedios sin revisar distribución, outliers y casos críticos.

Crear criterios para decidir si una versión mejora realmente a la anterior.

Realizar ejercicio de análisis de dashboard y priorización de mejoras.

Diseñar experimentos controlados cambiando una variable cada vez: prompt, modelo, embeddings, retriever o chunking.

Comparar prompts alternativos midiendo calidad de respuesta, groundedness, coste y estabilidad.

Comparar modelos generadores por precisión, estilo, latencia, precio y robustez.

Comparar modelos evaluadores para entender sensibilidad de las métricas.

Comparar retrievers por relevancia de contexto, cobertura, ruido y rendimiento.

Comparar configuraciones de chunking, overlap, top_k, reranking y filtros de metadata.

Crear matriz de decisión basada en métricas y revisión humana.

Evitar elegir una configuración solo por una métrica aislada.

Documentar decisiones de arquitectura a partir de evidencia de evaluación.

Realizar ejercicio de benchmark de tres configuraciones RAG distintas.

Usar evaluaciones para detectar respuestas peligrosas, irrelevantes, tóxicas, sesgadas o no fundamentadas.

Diseñar guardrails basados en feedback cuando la aplicación necesita bloquear o pedir revisión.

Aplicar filtros de contexto para reducir fragmentos irrelevantes antes de generar respuesta.

Crear umbrales para decidir si responder, pedir aclaración, rechazar o escalar.

Diferenciar guardrail preventivo, evaluación posterior y monitorización en producción.

Evitar bloqueos excesivos que impiden respuestas útiles o generan mala experiencia de usuario.

Diseñar mensajes de fallback claros cuando la confianza es insuficiente.

Registrar decisiones de guardrail para auditoría y mejora continua.

Evaluar impacto de guardrails sobre precisión, recall, latencia y satisfacción.

Realizar ejercicio de aplicación RAG con filtro de contexto y control de groundedness.

Medir latencia de llamadas LLM, retrieval, reranking, herramientas y evaluación.

Registrar coste estimado por modelo generador, modelo evaluador y ejecución de feedback functions.

Analizar trade-offs entre calidad, coste, velocidad y complejidad.

Identificar cuellos de botella en retrievers, modelos, evaluadores, tool calls o parsing.

Diseñar suites de evaluación rápidas para desarrollo y suites completas para validación.

Evitar ejecutar evaluaciones costosas en cada cambio pequeño sin segmentar criticidad.

Crear métricas de coste por respuesta, coste por experimento y coste por mejora.

Comparar configuraciones baratas y caras con datos, no con intuición.

Definir umbrales de latencia aceptables por tipo de aplicación.

Realizar ejercicio de optimización de coste y latencia manteniendo calidad mínima.

Integrar TruLens en flujos de desarrollo con Git, ramas, pull requests y revisión técnica.

Ejecutar evaluaciones automáticas tras cambios de prompts, retrievers, modelos o código.

Definir quality gates para bloquear despliegues si bajan métricas críticas.

Separar evaluaciones smoke, regresión completa, seguridad, RAG, agentes y producción.

Guardar resultados de evaluación como evidencia de cambios.

Automatizar generación de informes para revisiones de release.

Gestionar variabilidad de LLMs mediante repetición, tolerancias y revisión de casos críticos.

Evitar pipelines inestables por métricas mal calibradas o tests demasiado ambiguos.

Integrar evaluación con issue tracking, MLOps, LLMOps y observabilidad empresarial.

Realizar ejercicio de pipeline CI/CD con evaluación TruLens y decisión de release.

Diseñar qué debe evaluarse en desarrollo y qué debe monitorizarse en producción.

Capturar trazas de usuarios reales con control de privacidad, minimización y permisos.

Medir drift de calidad cuando cambian documentos, modelos, prompts o comportamiento de usuarios.

Detectar degradaciones de retrieval por contenido obsoleto, nuevos documentos o cambios de embeddings.

Crear alertas ante caída de groundedness, aumento de toxicidad, latencia excesiva o errores recurrentes.

Integrar trazas TruLens con stack de observabilidad, OpenTelemetry, dashboards y sistemas internos.

Separar datos de producción sensibles de datasets de evaluación reutilizables.

Diseñar revisión periódica de muestras reales con feedback humano.

Crear runbooks para investigar respuestas problemáticas.

Realizar ejercicio de plan de monitorización productiva de una app RAG.

Identificar datos personales, confidenciales, estratégicos o regulados dentro de inputs, outputs, trazas y logs.

Aplicar minimización antes de almacenar prompts, documentos, respuestas y metadatos.

Evitar que feedback functions envíen información sensible a proveedores no autorizados.

Configurar proveedores y modelos evaluadores según política interna de seguridad.

Anonimizar datasets de evaluación y separar datos reales de datos sintéticos.

Definir política de retención de records, feedbacks, reports, artifacts y trazas.

Revisar riesgos de prompts internos, documentos privados, secretos, credenciales y datos de clientes.

Crear controles para no registrar contenidos prohibidos o excesivos.

Documentar decisiones de privacidad y cumplimiento dentro del modelo LLMOps.

Realizar ejercicio de revisión de privacidad de una implementación TruLens.

Diseñar métricas específicas para sectores como legal, salud, finanzas, soporte, educación o ingeniería.

Crear feedback functions personalizadas cuando las métricas genéricas no capturan el criterio de negocio.

Incorporar criterios de estilo, tono, formato, cobertura, prudencia, citación, exhaustividad o cumplimiento interno.

Usar ejemplos few-shot para calibrar evaluaciones de relevancia, groundedness o calidad.

Combinar métricas automáticas, reglas deterministas, LLM-as-a-judge y revisión humana.

Evaluar outputs estructurados con validaciones de schema, campos obligatorios y consistencia.

Definir umbrales por nivel de riesgo y tipo de usuario.

Evitar métricas personalizadas imposibles de explicar o mantener.

Documentar cada métrica: objetivo, fórmula, inputs, límites, owner y frecuencia de revisión.

Realizar ejercicio de creación de métrica de evaluación para un dominio corporativo.

Crear inventario de aplicaciones LLM, prompts, retrievers, modelos, datasets y métricas.

Clasificar aplicaciones por criticidad, usuarios, datos tratados, impacto y nivel de riesgo.

Definir owners de calidad, responsables de evaluación, revisores humanos y aprobadores de release.

Establecer estándares mínimos de evaluación antes de pasar una app LLM a producción.

Crear política de cambios para prompts, modelos, embeddings, documentos y herramientas.

Definir documentación obligatoria: métricas, datasets, resultados, riesgos, límites y decisiones.

Integrar TruLens en gobierno de IA, LLMOps, seguridad, privacidad y gestión de proveedores.

Medir madurez de evaluación: manual, automatizada, versionada, monitorizada y gobernada.

Evitar que cada equipo evalúe con criterios distintos y no comparables.

Realizar ejercicio de diseño de modelo de gobierno GenAI con TruLens.

Seleccionar una aplicación LLM realista: RAG, chatbot, agente, clasificador, extractor o resumidor.

Crear entorno Python, instalar TruLens, configurar providers, API keys, repositorio y estructura de proyecto.

Construir o adaptar una aplicación RAG con documentos, embeddings, retriever, prompt y modelo generador.

Instrumentar la aplicación capturando inputs, outputs, retrieved context, pasos internos, tiempos y metadatos.

Registrar varias versiones de app con cambios en prompt, modelo, chunking, retriever o top_k.

Configurar feedback functions para context relevance, groundedness y answer relevance.

Añadir métricas adicionales: toxicidad, sentimiento, calidad, concisión, formato o métrica personalizada.

Crear dataset de evaluación con preguntas normales, preguntas límite, preguntas sin respuesta y casos críticos.

Ejecutar evaluaciones sobre varias configuraciones y comparar resultados en dashboard.

Analizar records individuales para detectar causas de fallos y documentar mejoras.

Optimizar la aplicación a partir de métricas: prompt, retrieval, chunks, fuentes, modelos o filtros.

Evaluar coste, latencia y calidad de cada versión.

Crear una Virtual App o evaluación offline de logs externos.

Integrar evaluación en un flujo Git/CI simulado con criterios de calidad mínimos.

Diseñar política de privacidad para trazas, records, prompts, outputs y datos evaluados.

Crear informe técnico con métricas, resultados, comparativa, decisiones y limitaciones.

Preparar dashboard o resumen ejecutivo con evolución de calidad, riesgos y recomendación final.

Definir plan de monitorización productiva con alertas, muestras, revisión humana y mejora continua.

Presentar la solución final defendiendo trazabilidad, métricas, calidad, seguridad, costes y estrategia LLMOps.