Curso de LangSmith

Crear o acceder a un workspace LangSmith corporativo con permisos adecuados.

Configurar API keys, variables de entorno y credenciales sin exponer secretos en código o repositorios.

Crear proyectos separados por aplicación, entorno, equipo, cliente o caso de uso.

Definir convenciones de nombres para proyectos, datasets, prompts, experimentos y deployments.

Configurar entorno Python y JavaScript para enviar trazas a LangSmith.

Verificar conectividad con una primera ejecución instrumentada.

Revisar la interfaz inicial: proyectos, trazas, datasets, prompts, playground, monitoring y settings.

Separar entornos de desarrollo, staging y producción para no mezclar datos ni métricas.

Evitar crear proyectos genéricos donde todas las aplicaciones envían trazas sin clasificación.

Realizar ejercicio de alta de proyecto, configuración local y primera traza visible.

Comprender cómo LangSmith registra entradas, salidas, pasos internos y metadatos de una ejecución.

Instrumentar una llamada simple a un modelo de lenguaje.

Registrar prompts, respuestas, modelo, parámetros, latencia, tokens y coste estimado cuando aplica.

Diferenciar trazas de desarrollo, trazas de evaluación y trazas productivas.

Añadir metadata útil: usuario simulado, versión, entorno, feature, canal, modelo y experimento.

Revisar trazas desde la UI para entender el flujo completo de una ejecución.

Filtrar runs por proyecto, tiempo, error, latencia, feedback, metadata y modelo.

Identificar problemas de entrada, salida, prompt y configuración del modelo.

Evitar capturar datos sensibles innecesarios dentro de inputs, outputs o metadatos.

Realizar ejercicio de instrumentación de una app LLM mínima con trazas completas.

Diferenciar run individual, trace completa, thread conversacional y ejecución anidada.

Comprender jerarquías entre llamadas LLM, retrieval, tool calls, chains, nodes y funciones auxiliares.

Revisar cómo se representan operaciones síncronas, asíncronas y multi-step.

Relacionar una conversación de usuario con varias trazas o varias ejecuciones dentro de un thread.

Usar tags y metadata para agrupar ejecuciones por versión, cliente, feature o escenario.

Entender por qué una buena estructura de metadata mejora dashboards, evaluación y depuración.

Diseñar taxonomía de etiquetas para apps internas, RAG, agentes, pruebas y producción.

Evitar trazas planas que no permiten distinguir qué paso falló.

Crear consultas y filtros útiles para revisar comportamientos concretos.

Realizar ejercicio de análisis de una trace compleja con varios runs anidados.

Instrumentar aplicaciones LangChain para capturar chains, prompts, LLM calls, retrievers y parsers.

Trazar agentes LangChain con tool calls, decisiones intermedias y pasos de razonamiento operativo.

Integrar LangGraph para visualizar nodos, transiciones, estado, herramientas y rutas de ejecución.

Depurar workflows agentic que toman caminos distintos según entrada y estado.

Relacionar trazas LangGraph con evaluación de trayectorias y comportamiento de herramientas.

Capturar errores en nodos, tools, retrievers, parsers y salidas estructuradas.

Comparar ejecuciones de distintos grafos, prompts o versiones de agente.

Evitar tratar LangGraph como caja negra sin instrumentar nodos clave.

Preparar trazas útiles para revisión técnica, QA y producto.

Realizar ejercicio de agente LangGraph instrumentado con tool calls y rutas alternativas.

Integrar LangSmith en aplicaciones Python propias con decoradores, wrappers o llamadas SDK.

Instrumentar servicios JavaScript/TypeScript que no usan LangChain.

Registrar funciones críticas como runs: retrieval, reranking, generación, parsing, validación y tools.

Crear trazas manuales cuando el framework no instrumenta automáticamente el flujo.

Añadir metadata, tags y nombres claros para cada paso.

Capturar excepciones y errores controlados dentro de la trace.

Diseñar wrappers internos para que varios equipos instrumenten de forma homogénea.

Evitar mezclar trazabilidad de infraestructura con trazabilidad de comportamiento LLM sin criterio.

Crear librería corporativa de observabilidad LLM reutilizable.

Realizar ejercicio de instrumentación manual de una API FastAPI o Node.js.

Instrumentar preguntas, consultas reformuladas, recuperación, documentos, scores, prompts y respuesta final.

Registrar chunks recuperados con fuente, metadata, ranking, score y versión documental.

Detectar fallos de RAG causados por retrieval irrelevante, contexto insuficiente o prompt débil.

Analizar si la respuesta está fundamentada en los documentos recuperados.

Comparar distintas configuraciones de embeddings, chunking, top_k, filtros y reranking.

Añadir feedback de usuario sobre utilidad, precisión y fuentes.

Crear filtros para revisar preguntas sin respuesta, documentos mal recuperados o baja calidad.

Evitar logs con documentos sensibles completos si no son necesarios para evaluación.

Diseñar dashboards específicos para RAG: groundedness, relevancia, coste, latencia y satisfacción.

Realizar ejercicio de tracing completo de una aplicación RAG con recuperación y respuesta citada.

Registrar decisiones de un agente, herramientas disponibles, tool calls, argumentos y resultados.

Analizar trayectorias donde el agente elige bien o mal una herramienta.

Detectar bucles, llamadas innecesarias, argumentos incorrectos, errores de tool y respuestas incompletas.

Revisar cómo cambian las rutas del agente según prompt, modelo, contexto y estado.

Medir latencia y coste por herramienta, paso y ejecución completa.

Añadir metadata sobre permisos, usuario, entorno y tipo de acción.

Distinguir herramientas de lectura, escritura, acción crítica y aprobación humana.

Evitar agentes que ejecutan acciones sin trazabilidad suficiente.

Crear análisis de trayectorias para evaluar comportamiento agentic.

Realizar ejercicio de agente con varias herramientas, errores simulados y revisión de trace.

Comprender el papel de los datasets para evaluar calidad de aplicaciones LLM de forma repetible.

Crear datasets desde ejemplos manuales, casos de usuario, trazas productivas y datos sintéticos.

Definir inputs, reference outputs, metadata, splits y campos relevantes para evaluación.

Versionar datasets para mantener trazabilidad entre experimentos.

Filtrar y segmentar datasets por tipo de pregunta, riesgo, idioma, cliente, dominio o escenario.

Exportar e importar datasets cuando el flujo de trabajo lo requiere.

Evitar datasets con ejemplos poco representativos, duplicados o sesgados hacia casos fáciles.

Crear datasets pequeños de smoke testing y datasets amplios de regresión.

Revisar calidad de ejemplos antes de usarlos como verdad de referencia.

Realizar ejercicio de creación de dataset desde trazas reales y casos manuales.

Ejecutar evaluaciones offline sobre datasets antes de desplegar cambios.

Definir target function, aplicación evaluada, dataset, evaluadores y configuración de experimento.

Comparar versiones de prompt, modelo, retriever, agente o pipeline RAG.

Analizar métricas agregadas y ejemplos individuales fallidos.

Guardar experimentos con nombres, metadata, versión y explicación de cambios.

Usar evaluaciones para decidir si un cambio mejora realmente la aplicación.

Crear experimentos reproducibles desde SDK y desde UI cuando procede.

Evitar comparar experimentos si cambiaron varias variables a la vez sin control.

Documentar conclusiones, riesgos y decisión final de release.

Realizar ejercicio de evaluación offline de dos versiones de una app RAG.

Comprender cuándo usar evaluaciones online sobre tráfico real o muestreado.

Configurar reglas para evaluar runs productivos con criterios automáticos.

Aplicar evaluadores en producción sin impactar negativamente en latencia del usuario.

Medir calidad continua: satisfacción, groundedness, exactitud, formato, seguridad y errores.

Usar muestreo para controlar coste de evaluación en aplicaciones de alto volumen.

Crear alertas si una métrica baja, sube el coste o aumenta la tasa de errores.

Revisar muestras de producción para detectar drift de usuarios, documentos o modelos.

Evitar evaluar datos sensibles con jueces externos no autorizados.

Diseñar proceso de revisión y mejora a partir de hallazgos productivos.

Realizar ejercicio de evaluación online simulada con reglas y feedback.

Diferenciar evaluadores deterministas, evaluadores de código, LLM-as-judge y evaluación humana.

Crear evaluadores simples para formato, JSON válido, campos obligatorios y restricciones.

Crear evaluadores LLM-as-judge para calidad, relevancia, tono, utilidad, groundedness y seguridad.

Diseñar rubricas claras para reducir subjetividad del juez.

Usar pairwise comparison para elegir entre dos respuestas, prompts o modelos.

Calibrar evaluadores con ejemplos buenos, malos y dudosos.

Revisar falsos positivos y falsos negativos de evaluadores automáticos.

Combinar varios evaluadores para tener una visión más fiable.

Evitar usar evaluadores genéricos sin alinearlos con negocio y riesgo.

Realizar ejercicio de creación de evaluadores para chatbot, RAG y agente.

Configurar criterios de feedback humano continuos, categóricos o cualitativos.

Crear annotation queues para que expertos revisen runs de forma ordenada.

Usar single-run queues para revisar respuestas individuales con rubricas.

Usar pairwise annotation queues para comparar dos outputs lado a lado.

Capturar notas de revisores y convertir hallazgos en datasets de evaluación.

Asignar revisores por dominio: legal, soporte, producto, datos, seguridad o negocio.

Definir permisos, instrucciones y criterios comunes para revisores humanos.

Evitar que cada revisor evalúe con estándares distintos.

Medir acuerdo entre revisores y detectar criterios ambiguos.

Realizar ejercicio de revisión humana de trazas y creación de dataset mejorado.

Comprender assertions como estándares en lenguaje natural asociados a ejemplos.

Convertir observaciones de un revisor en criterios verificables en futuras evaluaciones.

Crear assertions sobre lo que una respuesta debe incluir, evitar o cumplir.

Usar assertions para capturar aceptación funcional sin escribir código complejo.

Ejecutar evaluadores que comprueban si nuevas respuestas satisfacen esas assertions.

Revisar cuándo una assertion es demasiado amplia, ambigua o difícil de evaluar.

Mantener assertions junto al dataset y actualizarlas cuando cambia el producto.

Evitar convertir opiniones subjetivas en reglas rígidas sin consenso.

Usar assertions para reducir repetición de fallos ya detectados.

Realizar ejercicio de transformar feedback humano en assertions reutilizables.

Crear prompts en LangSmith con variables, mensajes, modelos y configuración asociada.

Versionar prompts para controlar cambios, comparar resultados y facilitar rollback.

Gestionar entornos de prompt como desarrollo, staging y producción.

Definir permisos de acceso a prompts según equipo, criticidad y aplicación.

Usar prompt caching cuando la aplicación necesita reducir latencia y llamadas de gestión.

Recuperar prompts programáticamente desde la aplicación usando SDK.

Documentar cambios de prompt con motivo, owner, experimento y evaluación asociada.

Evitar prompts hardcodeados en código productivo sin versión ni trazabilidad.

Crear estándares de naming, tags y descripciones para prompts corporativos.

Realizar ejercicio de gestión de prompt versionado con promoción entre entornos.

Usar Playground para iterar prompts sin desplegar cambios en código.

Probar distintos modelos, parámetros, input variables y configuraciones.

Añadir output schemas para forzar salidas estructuradas cuando el caso lo requiere.

Configurar herramientas disponibles para prompts y sesiones de prueba.

Comparar respuestas de varios modelos o prompts sobre el mismo input.

Ejecutar evaluaciones desde Playground sobre un dataset existente.

Usar el Playground para detectar errores de formato, tono, contenido o tool calling.

Evitar validar prompts solo con ejemplos manuales sin dataset ni evaluación.

Documentar configuraciones ganadoras antes de promoverlas a producción.

Realizar ejercicio de optimización de prompt en Playground con evaluación sobre dataset.

Usar dashboards prebuilt para revisar salud general del proyecto.

Crear dashboards personalizados con métricas relevantes para el equipo.

Monitorizar latencia, errores, coste, tokens, feedback, volumen, calidad y runs críticos.

Crear gráficos por modelo, prompt, versión, endpoint, usuario, feature o metadata.

Identificar tendencias, outliers, degradaciones y patrones de uso.

Separar dashboards técnicos de dashboards ejecutivos.

Evitar interpretar promedios sin revisar ejemplos concretos y distribución.

Preparar informes periódicos para producto, QA, plataforma, seguridad y dirección.

Conectar hallazgos de dashboards con acciones de mejora y backlog.

Realizar ejercicio de dashboard para aplicación RAG en producción simulada.

Configurar alertas por run count, error rate, coste, latencia, feedback negativo o métricas personalizadas.

Definir umbrales razonables por aplicación, entorno y criticidad.

Crear alertas para detectar caídas de trazas, picos de coste o fallos de modelos.

Usar reglas y webhooks para automatizar flujos ante eventos concretos.

Enviar runs problemáticos a annotation queues o sistemas internos.

Integrar alertas con Slack, Teams, correo, incident management o herramientas de soporte.

Evitar alertas demasiado sensibles que generan ruido operativo.

Crear runbooks asociados a cada alerta importante.

Revisar alertas periódicamente para ajustar umbrales y responsables.

Realizar ejercicio de configuración de alertas y automatización de revisión.

Registrar uso de tokens, coste estimado, modelo, proveedor y endpoint.

Analizar coste por proyecto, feature, usuario, prompt, modelo o workflow.

Detectar prompts demasiado largos, retrieval excesivo o agentes con demasiadas llamadas.

Crear dashboards de coste y consumo para responsables técnicos y negocio.

Configurar alertas de coste ante desviaciones o picos inesperados.

Comparar alternativas de modelo según calidad, coste y latencia.

Identificar operaciones candidatas a caching, batching, prompt compression o modelo más barato.

Evitar optimizar coste sacrificando seguridad o calidad crítica sin evidencias.

Documentar decisiones de modelo con métricas económicas y funcionales.

Realizar ejercicio de análisis de coste y reducción controlada sin pérdida de calidad.

Usar Insights para detectar patrones de uso, comportamientos comunes y modos de fallo.

Analizar agrupaciones jerárquicas de errores y casos frecuentes.

Priorizar mejoras según frecuencia, impacto y criticidad.

Detectar categorías de prompts mal respondidos, herramientas fallidas o usuarios bloqueados.

Usar Insights como apoyo, no como sustituto de análisis técnico y revisión humana.

Convertir patrones detectados en datasets, evaluaciones, prompts mejorados o incidencias.

Crear ritual de revisión periódica de Insights con producto y desarrollo.

Evitar revisar miles de trazas manualmente cuando puede agruparse el problema.

Documentar acciones derivadas de Insights y medir su efecto posterior.

Realizar ejercicio de análisis de fallos recurrentes y plan de mejora.

Comprender Studio como entorno especializado para visualizar e interactuar con sistemas agentic.

Conectar Studio con agentes que implementan protocolos o servidores compatibles.

Revisar estado, nodos, rutas, mensajes, herramientas y ejecución del agente.

Depurar decisiones del agente antes de promover cambios a producción.

Integrar Studio con trazas, evaluaciones y prompt engineering.

Probar cambios en prompts, herramientas o rutas con feedback inmediato.

Comparar comportamiento local, staging y producción cuando el entorno lo permite.

Evitar depurar agentes solo desde logs lineales difíciles de interpretar.

Crear flujo de trabajo para desarrolladores de agentes con Studio y LangSmith.

Realizar ejercicio de depuración de agente con comportamiento inesperado.

Comprender las opciones de deployment para agentes y aplicaciones compatibles.

Revisar despliegue cloud desde UI o CLI cuando el proyecto usa LangGraph.

Configurar repositorio, dependencias, variables, entorno y parámetros de despliegue.

Gestionar versiones, actualizaciones, rollbacks y cambios controlados.

Relacionar deployment con observabilidad, evaluación, trazas y monitoring.

Separar desarrollo local, staging y producción.

Preparar checks antes de desplegar: tests, evals, seguridad, coste y rendimiento.

Evitar despliegues de agentes sin owner, métricas ni plan de soporte.

Documentar configuración productiva y dependencias externas.

Realizar ejercicio de diseño de pipeline de despliegue para agente LangGraph.

Comprender cómo OpenTelemetry complementa la observabilidad específica de LangSmith.

Evaluar cuándo conviene emitir trazas OTel hacia LangSmith.

Relacionar traces de infraestructura con traces de aplicación LLM.

Integrar LangSmith con stacks corporativos de logs, métricas, tracing y dashboards.

Crear correlation IDs entre backend, frontend, LLM calls, retrievers y herramientas.

Evitar duplicar telemetría sin criterios de filtrado y retención.

Diseñar una estrategia de observabilidad que cubra infraestructura, aplicación y calidad LLM.

Preparar trazabilidad para auditoría, soporte y análisis de incidentes.

Documentar límites entre LangSmith, APM, SIEM, Grafana, Prometheus u observabilidad cloud.

Realizar ejercicio de evaluación usando trazas OpenTelemetry en LangSmith.

Identificar datos personales, secretos, documentos internos, prompts sensibles y outputs confidenciales.

Aplicar minimización de datos en trazas, inputs, outputs, metadata y feedback.

Redactar políticas de redacción, masking o exclusión de campos sensibles.

Definir qué proyectos pueden enviar datos a LangSmith Cloud, hybrid o self-hosted.

Controlar API keys, roles, permisos, workspaces y acceso a datasets.

Revisar riesgos de almacenar prompts estratégicos, conversaciones reales o documentos internos.

Configurar retención, exportación, auditoría y eliminación de datos según política corporativa.

Evitar usar tráfico productivo sensible en evaluaciones sin autorización.

Coordinar LangSmith con seguridad, legal, privacidad, compliance y arquitectura.

Realizar ejercicio de análisis de privacidad de una app RAG instrumentada.

Comparar modelos de despliegue: cloud gestionado, hybrid y self-hosted.

Identificar criterios de elección: residencia de datos, regulación, red, seguridad, volumen y operación.

Comprender qué implica operar LangSmith self-hosted en infraestructura propia.

Revisar componentes como Kubernetes, bases de datos, Redis, almacenamiento, red y observabilidad.

Preparar requisitos de plataforma para self-hosted o hybrid.

Configurar usuarios, permisos, roles, SSO, auditoría y control administrativo cuando aplica.

Revisar audit logs para acciones administrativas y cumplimiento.

Diseñar backups, actualizaciones, monitorización y soporte de plataforma.

Evitar elegir self-hosted sin equipo capaz de operar la plataforma.

Realizar ejercicio de arquitectura LangSmith enterprise para entorno regulado.

Ejecutar evaluaciones LangSmith desde pipelines de GitHub Actions, GitLab CI, Azure DevOps o Jenkins.

Bloquear merges si fallan evaluaciones críticas o baja una métrica clave.

Crear datasets de smoke testing para cambios rápidos y datasets completos para releases.

Ejecutar evals al cambiar prompts, modelos, retrievers, tools o código de agente.

Guardar resultados de experimento como evidencia del release.

Crear comentarios automáticos en pull requests con métricas de evaluación.

Gestionar API keys de LangSmith como secrets de CI/CD.

Evitar pipelines inestables por evaluadores mal calibrados o datasets débiles.

Documentar criterios de aprobación por riesgo y criticidad.

Realizar ejercicio de quality gate para un cambio de prompt y modelo.

Situar LangSmith frente a herramientas como Langfuse, Phoenix, Helicone, TruLens, PromptTest u opciones internas.

Diferenciar observabilidad, evaluación, prompt management, feedback, tracing y deployment.

Evaluar cuándo LangSmith encaja mejor por integración con LangChain, LangGraph y flujos agentic.

Comparar ventajas de una plataforma gestionada frente a soluciones open source self-hosted.

Analizar criterios de selección: coste, seguridad, equipo, stack, despliegue, gobierno y madurez.

Evitar seleccionar herramienta solo por popularidad sin revisar requisitos reales.

Diseñar arquitectura donde LangSmith convive con APM, SIEM, métricas cloud y herramientas QA.

Documentar decisión técnica con matriz de pros, contras y riesgos.

Crear estrategia gradual: tracing primero, evaluaciones después, monitorización y gobierno al final.

Realizar ejercicio de selección de stack de observabilidad LLM para tres escenarios.

Crear inventario de aplicaciones LLM, agentes, prompts, datasets, evaluaciones y deployments.

Definir owners de aplicación, prompt, dataset, evaluador, seguridad, plataforma y producto.

Clasificar aplicaciones por criticidad, datos tratados, usuarios, coste y riesgo.

Establecer estándares mínimos de observabilidad antes de producción.

Definir qué métricas deben existir para RAG, chatbots, agentes, extractores y clasificadores.

Crear proceso de cambio para prompts, modelos, tools, retrievers y workflows.

Diseñar revisión periódica de calidad, coste, feedback, errores y patrones de uso.

Mantener documentación de límites conocidos, riesgos aceptados y decisiones de mejora.

Evitar que cada equipo use LangSmith con convenciones distintas e incomparables.

Realizar ejercicio de modelo operativo LLMOps con LangSmith para empresa.

Diagnosticar por qué una aplicación no envía trazas a LangSmith.

Resolver problemas de variables de entorno, API keys, proyecto incorrecto o permisos insuficientes.

Detectar trazas incompletas por instrumentación parcial o wrappers mal ubicados.

Corregir metadata inconsistente que impide filtrar y crear dashboards útiles.

Revisar errores de evaluadores por formato, dataset, schema, target function o dependencia externa.

Analizar fallos de coste tracking por modelos no configurados o llamadas no capturadas.

Resolver problemas de latencia provocados por evaluaciones online mal configuradas.

Depurar prompts que funcionan en Playground pero fallan en aplicación real.

Crear checklist de diagnóstico para equipos de soporte y desarrollo.

Realizar ejercicio de reparación de un proyecto LangSmith con fallos provocados.

Seleccionar una aplicación LLM empresarial: RAG, chatbot, agente, extractor, clasificador o asistente interno.

Configurar workspace, proyecto, API keys, variables, repositorio y entorno de desarrollo.

Instrumentar la aplicación para registrar trazas completas con inputs, outputs, modelo, prompts, retrieval y tools.

Añadir metadata y tags por entorno, versión, usuario simulado, feature, modelo y experimento.

Crear un dataset inicial con casos manuales, trazas reales filtradas y ejemplos críticos.

Diseñar evaluadores para calidad, formato, groundedness, relevancia, seguridad, coste y latencia.

Ejecutar evaluación offline sobre dos versiones de prompt, modelo o pipeline.

Analizar resultados agregados y fallos individuales para decidir mejoras.

Crear annotation queue para revisión humana con rubrica y criterios claros.

Convertir feedback experto en ejemplos de dataset y assertions reutilizables.

Crear prompt versionado en LangSmith con variables, entorno y configuración documentada.

Probar prompt en Playground con modelos, structured output y dataset de evaluación.

Configurar dashboards para latencia, coste, tokens, errores, feedback y métricas de calidad.

Crear alertas por coste, error rate, feedback negativo, baja calidad o caída de volumen de runs.

Usar Insights o análisis de trazas para detectar patrones de fallo y oportunidades de mejora.

Integrar evaluación en CI/CD como quality gate antes de promover cambios.

Diseñar política de seguridad: datos sensibles, masking, retención, permisos, audit logs y acceso a proyectos.

Preparar arquitectura de despliegue cloud, hybrid o self-hosted según requisitos de la empresa.

Crear documentación técnica con observabilidad, evaluación, prompts, datasets, alertas, roles y runbooks.

Presentar la solución final defendiendo calidad, trazabilidad, seguridad, coste, gobierno y valor empresarial.