Curso de Databricks: Gestión y Análisis de Grandes Volúmenes de Datos

Diseñar la arquitectura lógica de un agente con entrada de usuario, orquestador, modelo, herramientas, recuperación, evaluación y respuesta final.

Diferenciar agentes basados en RAG, agentes tool-calling, agentes analíticos, agentes de automatización y sistemas multiagente.

Evaluar cuándo usar Databricks Apps, cuándo usar Model Serving y cuándo separar frontend, backend, endpoint y lógica de agente.

Comprender el papel de ResponsesAgent como interfaz recomendada para empaquetar aplicaciones GenAI orientadas a serving.

Definir qué datos necesita el agente y qué parte debe venir de tablas Delta, documentos, APIs, funciones, búsquedas vectoriales o herramientas externas.

Diseñar límites de autonomía: qué puede consultar, qué puede ejecutar, qué debe pedir, qué debe rechazar y cuándo debe escalar a humano.

Separar instrucciones del sistema, herramientas disponibles, contexto recuperado, estado de sesión y salida generada.

Preparar una arquitectura que permita observabilidad desde el primer día mediante trazas, request IDs, datasets, evaluaciones y feedback.

Evitar diseños monolíticos donde prompt, retrieval, tools, logging y UI quedan mezclados en un único notebook difícil de desplegar.

Documentar decisiones de arquitectura para que el agente pueda mantenerse por equipos distintos a quienes hicieron la demo inicial.

Configurar un workspace Databricks con Unity Catalog, SQL Warehouse, clusters, notebooks, repositorios, secrets y permisos adecuados al laboratorio.

Crear catálogos, esquemas, volúmenes, tablas y funciones de prueba siguiendo una nomenclatura clara por entorno y equipo.

Configurar Databricks CLI, perfiles, tokens, autenticación, repositorios y conexión desde entorno local.

Preparar un proyecto Python con estructura de app, agente, herramientas, evaluaciones, configuración, tests y despliegue.

Instalar librerías necesarias para MLflow 3, Databricks SDK, clientes de modelos, frameworks de agente y utilidades de evaluación.

Separar configuración local, staging y producción mediante variables, secretos, archivos YAML y parámetros de despliegue.

Crear datos de laboratorio con documentos, tablas, preguntas esperadas, respuestas de referencia y casos negativos.

Configurar permisos de usuario, service principals y grupos para evitar trabajar siempre con credenciales personales de administrador.

Validar conectividad con modelos, tablas, Vector Search, endpoints y recursos antes de escribir lógica del agente.

Documentar el entorno para que el laboratorio sea reproducible por otros equipos o futuras convocatorias.

Comprender Unity Catalog como capa de gobierno para datos, modelos, funciones, volúmenes, permisos y activos de IA usados por agentes.

Diseñar catálogos y esquemas específicos para agentes, separando datos fuente, embeddings, evaluaciones, logs, herramientas y resultados.

Configurar permisos mínimos sobre tablas, vistas, funciones y modelos para que el agente solo acceda a lo necesario.

Utilizar views o funciones controladas para exponer datos al agente sin abrir tablas sensibles completas.

Revisar lineage y ownership de datos usados por el agente para saber quién responde por calidad, actualización y significado.

Gestionar datos personales, información sensible y columnas restringidas antes de permitir uso en prompts o herramientas.

Controlar funciones de Unity Catalog como herramientas legacy, entendiendo cuándo son adecuadas y cuándo conviene usar MCP tools.

Documentar políticas de acceso por tipo de agente, entorno, usuario, dominio de negocio y criticidad.

Preparar una checklist de seguridad de Unity Catalog antes de desplegar agentes que consultan datos reales.

Convertir Unity Catalog en pieza central del gobierno de agentes, no solo en catálogo pasivo de tablas.

Identificar qué datos estructurados, semiestructurados y no estructurados necesita el agente para responder con utilidad.

Preparar tablas Delta con datos limpios, actualizados y documentados para alimentar herramientas analíticas o recuperación contextual.

Diseñar vistas semánticas que traduzcan tablas técnicas en conceptos comprensibles para el agente y sus usuarios.

Preparar documentos corporativos con estructura, metadatos, fechas, propietarios y clasificación de sensibilidad.

Gestionar versiones de documentos y datasets para saber qué información alimentó cada respuesta en cada momento.

Separar datos de entrenamiento, evaluación, grounding, feedback y monitorización para evitar mezclas poco auditables.

Crear datasets de preguntas frecuentes, casos límite, consultas de negocio y respuestas esperadas para desarrollo.

Evitar que el agente use tablas experimentales, columnas sin definición o documentos obsoletos como fuente de verdad.

Incorporar señales de negocio como cliente, canal, producto, región, periodo o criticidad para respuestas más útiles.

Documentar calidad, actualización, limitaciones y propietario de cada fuente conectada al agente.

Diseñar una arquitectura RAG sobre Databricks combinando documentos, chunking, embeddings, Vector Search, filtros y generación final.

Crear estrategias de partición de documentos que respeten secciones, contexto, tablas, FAQs y fragmentos con significado propio.

Generar embeddings con modelos aprobados y almacenar metadatos que permitan filtros por fuente, versión, idioma, fecha o permisos.

Crear índices de Vector Search y validar recuperación con consultas representativas antes de conectar el flujo al agente.

Diseñar filtros de seguridad y metadata para impedir que un usuario reciba contexto de documentos no autorizados.

Comparar retrieval por similitud, filtros, reranking y estrategias híbridas cuando el dominio lo requiere.

Medir calidad de recuperación usando ejemplos reales y evaluaciones de relevancia, cobertura y groundedness.

Detectar problemas habituales: chunks demasiado grandes, documentos duplicados, embeddings pobres, metadatos ausentes o recuperación fuera de contexto.

Preparar un flujo de actualización de índices cuando cambian documentos, políticas, contratos o fuentes internas.

Documentar el pipeline RAG para que sea mantenible por data engineering, no solo por el equipo IA.

Evaluar modelos disponibles en Databricks o proveedores conectados según calidad, coste, latencia, seguridad y soporte de tool calling.

Diferenciar modelos para razonamiento, generación, clasificación, resumen, extracción, embeddings y evaluación.

Configurar endpoints de Foundation Model APIs o Model Serving según necesidades del agente.

Diseñar una política de selección de modelo por tarea en lugar de utilizar siempre el modelo más potente.

Medir impacto de temperatura, max tokens, contexto, streaming, herramientas y prompts sobre coste y latencia.

Preparar fallback entre modelos cuando el proveedor falla o cuando una tarea puede degradarse de forma aceptable.

Documentar modelos permitidos por entorno, tipo de dato, criticidad y caso de uso.

Evitar mezclar modelos en producción sin evaluación comparativa, trazabilidad y revisión de seguridad.

Configurar secrets y credenciales para proveedores externos sin exponer claves en notebooks o repositorios.

Crear una matriz de decisión para escoger modelo durante diseño, evaluación y operación.

Crear un agente en Python con estructura modular separando entrada, orquestación, herramientas, recuperación, evaluación y respuesta.

Implementar la interfaz ResponsesAgent o patrón equivalente recomendado para empaquetar la app de agente.

Diseñar funciones pequeñas y testeables para retrieval, tool selection, validación, formateo de respuesta y manejo de errores.

Gestionar estado de conversación sin mezclar datos sensibles, memoria no gobernada o contexto innecesario.

Preparar configuración externa para modelos, endpoints, índices, prompts, límites, herramientas y entornos.

Incorporar logs estructurados, trace IDs y metadata desde la primera versión del agente.

Evitar notebooks monolíticos como artefacto final cuando el agente debe desplegarse, versionarse y operar.

Crear tests unitarios para herramientas, prompts críticos, filtros, parsing, validaciones y tratamiento de errores.

Documentar contratos de entrada y salida para que frontend, evaluadores y herramientas externas puedan integrarse.

Diseñar el código pensando en CI/CD, rollback, monitorización y mantenimiento por un equipo.

Diseñar herramientas que permitan al agente consultar información, ejecutar lógica, llamar APIs o realizar cálculos bajo control.

Incorporar MCP servers cuando se necesita conectar el agente con sistemas externos de forma estándar y mantenible.

Usar el code interpreter `system.ai.python_exec` para permitir ejecución Python dinámica en escenarios controlados.

Evaluar Unity Catalog functions como herramientas legacy cuando ya existen funciones gobernadas o lógica interna reutilizable.

Crear tools con contratos claros: descripción, entradas, salidas, errores, límites, permisos y ejemplos.

Evitar herramientas demasiado amplias que permiten al agente ejecutar acciones sin suficiente contexto o validación.

Gestionar credenciales de APIs externas mediante secrets, managed OAuth o patrones autorizados por seguridad.

Diseñar herramientas read-only para exploración y herramientas de escritura con confirmación, auditoría y permisos reforzados.

Probar herramientas de forma aislada antes de incorporarlas al flujo conversacional del agente.

Documentar cada tool con owner, finalidad, sistemas afectados, riesgo y criterios de desactivación.

Configurar el agente para elegir herramientas según intención, contexto, restricciones y disponibilidad de datos.

Diseñar descripciones de herramientas suficientemente precisas para reducir llamadas incorrectas o innecesarias.

Validar argumentos generados por el modelo antes de ejecutar acciones que consultan datos o sistemas externos.

Implementar confirmaciones humanas cuando una acción modifica información, crea recursos o envía comunicaciones.

Controlar errores de herramienta diferenciando fallo técnico, dato no encontrado, permiso insuficiente y acción fuera de alcance.

Evitar bucles de tool calling cuando el agente insiste en una acción que falla o no devuelve información útil.

Registrar cada invocación con inputs, outputs, usuario, sesión, duración, coste y resultado.

Crear políticas de herramienta por entorno: desarrollo, pruebas, staging, producción y datos sensibles.

Evaluar la calidad del tool calling con datasets de conversación y casos adversariales.

Construir una capa de seguridad que limite lo que el modelo puede ejecutar aunque intente invocar una herramienta válida.

Crear un agente RAG que reciba una pregunta, recupere documentos, cite fuentes internas y responda de forma limitada al contexto disponible.

Diseñar prompts que obliguen al agente a reconocer falta de evidencia, pedir aclaraciones o escalar cuando no hay base suficiente.

Incorporar filtros por usuario, departamento, idioma, fecha, producto o permiso antes de recuperar contexto.

Añadir trazabilidad de fuentes para que el usuario pueda revisar documentos, fragmentos o tablas usados en la respuesta.

Evaluar si el agente responde con información recuperada o si introduce conocimiento externo no autorizado.

Medir latencia total separando retrieval, generación, reranking, herramientas y respuesta final.

Crear pruebas de preguntas con respuesta conocida, preguntas ambiguas, preguntas sin respuesta y preguntas con información contradictoria.

Ajustar chunking, embeddings, filtros, prompt y modelo según resultados de evaluación.

Preparar actualización incremental de documentos y reindexación controlada.

Documentar arquitectura RAG, fuentes conectadas, riesgos, métricas y plan de mantenimiento.

Diseñar agentes capaces de responder preguntas de negocio consultando tablas gobernadas, vistas semánticas o SQL controlado.

Crear herramientas SQL seguras que eviten consultas arbitrarias sobre todo el Lakehouse sin permisos ni límites.

Exponer vistas certificadas en lugar de tablas crudas cuando el agente responde a usuarios de negocio.

Validar consultas generadas antes de ejecutarlas, aplicando límites, filtros, timeouts y control de coste.

Diseñar respuestas que incluyan explicación, resultado, periodo, filtros, limitaciones y enlace a datos cuando corresponda.

Evitar que el agente invente métricas si no existe definición certificada en el Lakehouse.

Incorporar control de acceso mediante Unity Catalog para que cada usuario consulte solo datos permitidos.

Registrar SQL ejecutado, duración, volumen procesado, usuario y resultado para auditoría y mejora.

Evaluar respuestas analíticas con preguntas de referencia, SQL esperado y resultados validados.

Construir un agente de datos que complemente BI y SQL, sin reemplazar gobierno de métricas ni reporting oficial.

Comprender cuándo un sistema multiagente aporta valor frente a un agente único con varias herramientas.

Diseñar un Supervisor Agent que coordine agentes especializados por dominio, herramienta, etapa o tipo de razonamiento.

Separar responsabilidades entre agente de planificación, agente RAG, agente analítico, agente de código, agente de revisión y agente de respuesta.

Definir protocolos de comunicación entre agentes para evitar contradicciones, duplicidad de trabajo o pérdida de contexto.

Controlar permisos diferenciados por agente para que un subagente no pueda acceder a herramientas que no necesita.

Medir coste y latencia adicional de sistemas multiagente antes de llevarlos a producción.

Evaluar calidad de coordinación, selección de agente y consolidación de respuesta final.

Evitar arquitecturas multiagente por moda cuando el caso se resuelve con un flujo más simple.

Documentar el rol, herramientas, límites y owner de cada agente especializado.

Diseñar pruebas end-to-end que cubran colaboración, fallos parciales y escalado humano.

Situar Agent Bricks como enfoque para acelerar la construcción de agentes especializados optimizados sobre datos empresariales.

Evaluar cuándo Agent Bricks aporta rapidez frente a un desarrollo de agente custom desde cero.

Identificar casos de uso candidatos: agentes de conocimiento, analítica, extracción, clasificación, soporte o automatización.

Revisar cómo conectar datos, permisos, modelos y herramientas dentro del patrón de Agent Bricks disponible en la plataforma.

Comparar calidad, control, tiempo de desarrollo y capacidad de personalización frente a agentes escritos manualmente.

Diseñar pruebas para validar que el agente generado cumple requisitos funcionales, seguridad y groundedness.

Preparar criterios de salida cuando un prototipo creado con Agent Bricks debe evolucionar hacia una app mantenida por ingeniería.

Documentar configuración, fuentes, versiones, métricas y límites del agente acelerado.

Evaluar coste y rendimiento antes de escalar uso a muchos equipos o casos de negocio.

Incorporar Agent Bricks dentro de una estrategia de adopción gradual, no como sustituto del gobierno técnico.

Crear una Databricks App que exponga el agente mediante una interfaz controlada, segura y alineada con usuarios internos.

Separar lógica de agente, capa de API, interfaz, configuración y observabilidad para facilitar mantenimiento.

Diseñar una experiencia conversacional con historial, feedback, fuentes, disclaimers y mensajes de error comprensibles.

Gestionar autenticación, permisos de usuario y acceso a datos desde la app sin exponer credenciales de servicio innecesarias.

Incorporar streaming de respuestas cuando mejora experiencia sin complicar trazabilidad o evaluación.

Preparar variables de entorno, dependencias, configuración de despliegue y runtime de la app.

Validar que la app funciona con distintos perfiles de usuario y límites de acceso definidos por Unity Catalog.

Añadir controles de feedback humano para capturar utilidad, errores, comentarios y casos de mejora.

Diseñar logs de aplicación que puedan correlacionarse con MLflow traces e inference tables.

Documentar la app como producto interno con owner, soporte, versiones, changelog y procedimiento de rollback.

Desplegar agentes o aplicaciones GenAI en Model Serving cuando el caso requiere endpoint gestionado, escalado y consumo vía API.

Empaquetar código, dependencias, archivos y configuración siguiendo patrones compatibles con MLflow y Databricks serving.

Configurar endpoints, permisos, service principals, secrets, escalado, límites y acceso de clientes.

Comparar Model Serving con Databricks Apps según control de UI, configuración, experiencia, despliegue y operación.

Preparar payloads de entrada y salida para clientes internos, aplicaciones web, integraciones o pipelines.

Validar endpoints con pruebas funcionales, carga básica, errores y comportamiento ante timeouts.

Controlar versiones de modelo o agente para poder actualizar sin romper consumidores.

Medir latencia, coste, errores, cold starts, saturación y comportamiento bajo concurrencia.

Configurar inference tables o mecanismos equivalentes para capturar requests y responses del endpoint.

Documentar contrato de API, autenticación, límites, errores, SLA y procedimiento de soporte.

Enviar requests a agentes desplegados mediante SDK, API, notebooks, apps internas o clientes externos autorizados.

Diseñar payloads con mensaje, historial, contexto, usuario, metadata y parámetros necesarios para reproducibilidad.

Gestionar sesiones conversacionales sin exponer datos sensibles ni depender de memoria no gobernada.

Incorporar retries, timeouts, backoff y manejo de errores en clientes que consumen endpoints de agente.

Validar streaming, respuesta final, tool calls, citas, trazas y metadatos devueltos por el agente.

Separar llamadas de desarrollo, pruebas y producción mediante endpoints, tokens, usuarios o entornos diferenciados.

Diseñar clientes internos que muestren fuentes, confianza, limitaciones y feedback de usuario.

Evitar que aplicaciones externas puedan enviar instrucciones que fuerzan acceso indebido a herramientas o datos.

Registrar consumo por aplicación, usuario, cliente, caso de uso y feature para análisis de coste y adopción.

Documentar patrones de integración para que otros equipos consuman agentes Databricks de forma segura.

Utilizar MLflow Tracing para registrar pasos del agente, llamadas a modelos, retrieval, herramientas, errores y tiempos.

Diferenciar trazas de desarrollo, trazas de evaluación y trazas de producción para analizarlas con contexto correcto.

Registrar metadata como usuario, sesión, versión, modelo, prompt, dataset, herramienta y fuente de datos.

Revisar trazas para detectar razonamientos fallidos, tool calls innecesarias, retrieval pobre o respuestas sin grounding.

Versionar agentes, prompts, configuraciones, datasets y evaluaciones para comparar cambios con evidencia.

Incorporar feedback humano en el ciclo de mejora del agente.

Evitar que trazas almacenen información sensible sin redacción, minimización o permisos adecuados.

Crear experimentos MLflow que agrupen variantes de agente, modelo, prompt, retrieval y herramientas.

Analizar latencia y coste por componente del agente para optimizar donde realmente importa.

Convertir tracing en práctica obligatoria antes de desplegar agentes empresariales.

Crear datasets de evaluación con preguntas, contexto esperado, respuestas de referencia y criterios de calidad.

Utilizar `mlflow.genai.evaluate()` para probar sistemáticamente la calidad del agente durante desarrollo.

Aplicar scorers para relevancia, groundedness, seguridad, corrección, formato, retrieval y utilidad de respuesta.

Incorporar built-in LLM judges cuando se necesita empezar rápido con evaluación de calidad.

Crear scorers personalizados para métricas específicas del negocio, compliance, tono, formato o reglas internas.

Comparar versiones del agente antes de aprobar cambios de prompt, modelo, retrieval o tools.

Diseñar evaluaciones offline con casos positivos, negativos, adversariales y sin respuesta esperada.

Evitar datasets de evaluación demasiado pequeños o preparados solo para que el agente “apruebe” la demo.

Documentar resultados de evaluación, umbrales mínimos, fallos aceptados y decisiones de release.

Integrar evaluación en CI/CD para bloquear cambios que degradan calidad, seguridad o coste.

Medir groundedness verificando que la respuesta se apoya en documentos, tablas o herramientas realmente utilizadas.

Evaluar correctness cuando existe una respuesta esperada o una regla de negocio verificable.

Revisar relevancia para comprobar si la respuesta atiende la pregunta del usuario sin desviarse ni añadir ruido.

Evaluar seguridad para detectar respuestas peligrosas, datos no autorizados, instrucciones indebidas o contenido fuera de política.

Crear pruebas de prompt injection, datos contradictorios, preguntas ambiguas y solicitudes de extracción de información sensible.

Diseñar criterios de evaluación por dominio, evitando utilizar una única métrica genérica para todos los agentes.

Analizar falsos positivos y falsos negativos de judges para no aceptar evaluaciones automáticas sin revisión humana.

Combinar evaluación automática con revisión experta en casos críticos o regulados.

Registrar fallos recurrentes para mejorar retrieval, prompt, herramientas, datos o permisos.

Crear un informe de calidad de agente que pueda revisarse por negocio, seguridad e ingeniería.

Capturar feedback humano sobre respuestas del agente, fuentes utilizadas, precisión, utilidad y calidad conversacional.

Utilizar review workflows para que expertos de negocio evalúen respuestas sin necesidad de revisar código.

Diseñar escalas de feedback simples pero útiles: correcto, incorrecto, incompleto, inseguro, sin evidencia o no útil.

Asociar feedback a trace, usuario, pregunta, versión de agente, modelo, prompt, retrieval y herramienta usada.

Convertir feedback en datasets de evaluación, casos de regresión, mejoras de prompt o cambios de fuente documental.

Evitar feedback informal en chats o documentos sueltos que no se puede conectar con la versión exacta del agente.

Priorizar mejoras por impacto, frecuencia, riesgo y coste de corrección.

Crear procesos de revisión con expertos legales, soporte, ventas, datos o seguridad según el dominio del agente.

Medir si la calidad mejora con cada iteración comparando evaluaciones y feedback histórico.

Incorporar revisión humana como parte del ciclo de vida, no como actividad puntual de validación inicial.

Activar inference tables habilitadas por AI Gateway para capturar requests, responses y trazas de agentes desplegados.

Analizar tablas Delta generadas con datos de inferencia para revisar coste, latencia, errores, usuarios, prompts y outputs.

Conectar inference tables con dashboards, evaluaciones, Lakehouse Monitoring y procesos de auditoría.

Separar datos de monitorización por endpoint, agente, versión, entorno, cliente o aplicación consumidora.

Diseñar retención, acceso y redacción de logs de inferencia según sensibilidad de prompts y respuestas.

Detectar anomalías de producción: aumento de errores, latencia, coste, respuestas vacías, tool failures o caída de groundedness.

Crear queries SQL sobre inference tables para investigar incidentes, comparar versiones y revisar adopción.

Integrar monitorización de agentes con alertas operativas y runbooks de soporte.

Evitar monitorización que captura todo sin gobierno ni revisión de privacidad.

Convertir inference tables en base objetiva para mejorar calidad, coste y seguridad del agente.

Configurar monitorización sobre agentes y aplicaciones GenAI para seguir calidad, latencia, coste y comportamiento en producción.

Definir métricas de producción alineadas con evaluaciones de desarrollo para no medir cosas distintas antes y después del despliegue.

Crear dashboards de salud del agente con volumen, errores, latencia, coste, feedback, groundedness y uso de herramientas.

Detectar drift funcional cuando cambian datos, documentos, usuarios, preguntas o modelos.

Programar evaluaciones periódicas sobre muestras de producción para revisar calidad real.

Configurar alertas ante degradaciones de seguridad, groundedness, latencia o coste.

Revisar diferencias entre agentes internos, customer-facing, analíticos y RAG en métricas de seguimiento.

Documentar owners de monitorización, umbrales, procedimientos de respuesta y frecuencia de revisión.

Evitar que monitorización sea responsabilidad exclusiva del equipo IA sin participación de negocio y operación.

Crear un ciclo de mejora continua basado en evidencias de producción.

Identificar riesgos de seguridad propios de agentes: acceso indebido a datos, tool misuse, prompt injection, data leakage y respuestas no autorizadas.

Aplicar permisos Unity Catalog para limitar datos, funciones, modelos, volúmenes y herramientas disponibles.

Diseñar filtros por usuario, grupo, departamento o tenant antes de recuperar documentos o ejecutar consultas.

Proteger secrets, tokens y credenciales de herramientas externas mediante mecanismos seguros del workspace.

Crear pruebas adversariales con instrucciones maliciosas, documentos contaminados y preguntas diseñadas para extraer información sensible.

Validar que el agente no revela fuentes, prompts internos, credenciales, tablas restringidas o datos fuera de permisos.

Limitar herramientas de escritura, código dinámico y APIs externas con confirmaciones, allowlists y controles de entrada.

Definir políticas para datos personales, propiedad intelectual, información financiera y documentos regulados.

Registrar incidentes de seguridad del agente y convertirlos en mejoras de prompt, herramienta, permisos o datos.

Documentar una matriz de riesgos antes de publicar agentes con usuarios reales.

Medir coste por conversación, request, modelo, herramienta, retrieval, endpoint, usuario y caso de uso.

Separar latencia de retrieval, generación, tool calling, ejecución Python, consultas SQL y respuesta de frontend.

Optimizar prompts reduciendo contexto innecesario, instrucciones redundantes y respuestas excesivamente largas.

Ajustar modelos según tarea para no usar modelos caros en operaciones simples o repetitivas.

Mejorar retrieval para reducir documentos irrelevantes que aumentan coste y degradan respuesta.

Aplicar caching cuando el caso permite reutilizar contexto o respuestas sin comprometer exactitud ni permisos.

Controlar concurrencia, timeouts, max tokens, streaming y límites de endpoints.

Identificar herramientas lentas o fallidas que dominan el tiempo total del agente.

Crear dashboards de FinOps para agentes con presupuesto, tendencia, anomalías y coste por unidad de valor.

Documentar criterios de optimización para no sacrificar calidad o seguridad por reducir coste de forma indiscriminada.

Versionar código, prompts, herramientas, configuración, datasets de evaluación y recursos Databricks en Git.

Diseñar pipelines que ejecutan tests unitarios, evaluaciones GenAI, validaciones de permisos y despliegue a entornos.

Separar dev, staging y producción con catálogos, esquemas, endpoints, apps y service principals diferenciados.

Automatizar despliegue de Databricks Apps, Model Serving endpoints, jobs, recursos y configuración.

Bloquear despliegues cuando evaluaciones de calidad, seguridad, groundedness o coste caen por debajo de umbrales definidos.

Preparar rollback de app, endpoint, modelo, prompt, tools o índice vectorial cuando una versión falla.

Gestionar migraciones de datos, reindexaciones y cambios de esquema dentro del ciclo de release.

Integrar revisiones de código con revisiones funcionales y de seguridad del agente.

Documentar changelog de cada release con cambios, métricas de evaluación y riesgos conocidos.

Construir un proceso DevOps que trate agentes como software crítico y no como notebooks aislados.

Inventariar prototipos existentes creados en notebooks, LangChain, scripts locales, herramientas externas o apps aisladas.

Separar lógica reusable de código experimental, prompts hardcodeados, credenciales, datasets temporales y dependencias no documentadas.

Adaptar agentes existentes a patrones Databricks con Unity Catalog, MLflow tracing, evaluación y serving.

Migrar RAG hacia Vector Search y fuentes gobernadas cuando los documentos deben estar bajo control corporativo.

Reescribir tools para que respeten permisos, secrets, timeouts, validación y logs.

Preparar una estrategia de transición sin interrumpir usuarios que ya consumen el prototipo.

Comparar resultados antes y después de migrar mediante datasets de evaluación y feedback humano.

Documentar cambios de arquitectura, mejoras de seguridad y limitaciones que permanecen.

Evitar migraciones literales que trasladan malas prácticas de la prueba de concepto a producción.

Crear una guía para convertir demos GenAI en agentes Databricks productivos.

Diseñar agentes de datos que ayudan a consultar métricas, explicar tablas, generar SQL seguro y localizar fuentes certificadas.

Crear agentes financieros que resumen variaciones, consultan KPIs, explican desviaciones y preparan informes con datos gobernados.

Diseñar agentes operativos que revisan incidencias, logs, alertas, documentación y procedimientos internos.

Crear agentes de soporte que consultan knowledge bases, tickets históricos, runbooks y fuentes de producto.

Preparar agentes para desarrollo que explican pipelines, jobs, notebooks, errores y dependencias dentro del Lakehouse.

Diseñar agentes para compliance que localizan políticas, controles, evidencias y documentación regulatoria.

Evaluar riesgos, herramientas y permisos por área antes de permitir respuestas o acciones automáticas.

Medir valor por caso de uso: tiempo ahorrado, precisión, reducción de escalados, adopción y calidad de decisión.

Crear una cartera priorizada de agentes por valor, complejidad, riesgo y disponibilidad de datos.

Documentar plantillas reutilizables para repetir patrones entre departamentos sin empezar de cero.

Crear un centro de excelencia o modelo de gobierno para agentes dentro de la estrategia de datos e IA.

Definir roles: owner funcional, AI engineer, data owner, platform engineer, security reviewer, evaluator y operations owner.

Establecer estándares de naming, catálogos, permisos, prompts, tools, evaluaciones, endpoints, apps y monitorización.

Crear plantillas de diseño de agente con caso de uso, datos, riesgos, herramientas, métricas y criterios de salida.

Establecer proceso de aprobación para agentes que acceden a datos sensibles o ejecutan acciones sobre sistemas externos.

Revisar periódicamente agentes activos, costes, errores, feedback, permisos, datasets e índices vectoriales.

Crear documentación de usuario, runbooks de soporte y procedimientos de retirada de agentes obsoletos.

Definir políticas de retención de trazas, requests, respuestas, feedback y datasets de evaluación.

Medir madurez de agentes con indicadores de cobertura, calidad, seguridad, adopción, coste y mantenimiento.

Convertir Databricks Agents en una capacidad corporativa repetible y no en iniciativas aisladas de cada equipo.

Diseñar un agente Databricks empresarial para responder preguntas sobre documentación, datos gobernados y procesos internos.

Preparar workspace, Unity Catalog, catálogos, esquemas, tablas, volúmenes, permisos, secrets y estructura de proyecto.

Crear un pipeline RAG con documentos, chunking, embeddings, Vector Search, metadata, filtros y pruebas de recuperación.

Implementar el agente en Python usando estructura modular, configuración por entorno y patrón compatible con despliegue.

Incorporar herramientas MCP, Python o funciones gobernadas para consultar datos, ejecutar lógica o llamar APIs de laboratorio.

Registrar trazas con MLflow 3 incluyendo retrieval, modelo, herramientas, errores, latencia, metadata y versión.

Crear datasets de evaluación con preguntas, respuestas esperadas, casos negativos, prompt injection y escenarios sin respuesta.

Ejecutar evaluaciones con scorers de groundedness, relevancia, seguridad, correctness, coste y latencia.

Desplegar el agente en Databricks Apps o Model Serving justificando la elección arquitectónica.

Activar monitorización mediante inference tables, dashboards, feedback humano y queries de análisis operativo.

Configurar permisos de acceso, service principal, secretos, límites de herramientas y política de datos sensibles.

Crear un pipeline CI/CD básico con tests, evaluación, validación de configuración y despliegue controlado.

Preparar runbook de operación con errores frecuentes, rollback, actualización de índices, revisión de trazas y escalado.

Presentar la solución final defendiendo arquitectura, datos, seguridad, evaluación, despliegue, coste, monitorización y gobierno.