Curso de Microsoft Agent Framework (MAF) para equipos de desarrollo

Visión del ecosistema: dónde vive el agente, dónde vive el modelo, dónde vive el dato.

Azure AI Foundry como “hub” para construir/operar experiencias agentic (dashboards, controles enterprise).

Azure OpenAI como proveedor de modelos (deployment, cuotas, políticas, content safety).

GitHub Models como catálogo y experimentación rápida (probar modelos y prompts en el ciclo dev).

Modelos locales: motivos (latencia, coste, privacidad, offline) y limitaciones (capacidad, contexto, mantenimiento).

Patrón “bring your own gateway” / control de red y acceso a modelos vía pasarelas empresariales.

Selección de modelo por tarea (razonamiento vs velocidad; routing; fallback).

Gestión de credenciales: Identity, secret stores, managed identity, rotación.

Observabilidad y telemetría end-to-end entre app, tools y proveedor de modelo.

Estrategias de costes: caching, batching, límites de tokens, compresión de contexto, evaluación de ROI.

Entornos: local dev → staging → prod (paridad, configuración por entorno, feature flags).

Gobierno: catálogos, aprobaciones de modelos, políticas de uso, auditoría.

Definición de “agente” en MAF: entidad que decide + actúa mediante tools y modelo.

Tools: qué son, para qué sirven, contratos de entrada/salida, validación y timeouts.

Contexto: system/role instructions, memoria conversacional, estado de ejecución, “working set”.

Ciclo de vida: inicialización → planificación → ejecución de tools → síntesis → persistencia.

Tipos de tools: funciones puras, I/O externo (REST/DB), tools “lentas”, tools humanas (aprobación).

Gestión de errores: retries, circuit breakers, degradación elegante, respuestas parciales.

Observabilidad por defecto: trazas de cada step, tool call, latencias y tokens.

Control de comportamiento: políticas (allow/deny tools), reglas de negocio, “guardrails”.

Seguridad de tools: least privilege, scopes, sanitización, auditoría.

Packaging en .NET: DI, configuración, logging, options pattern.

Idempotencia y consistencia: evitar dobles ejecuciones en reintentos.

Diseño “testable”: separar lógica de orquestación de acceso a infraestructura.

Estructura mínima de un proyecto .NET con MAF (organización de carpetas y DI).

Configuración de proveedor de modelo (Azure OpenAI / Foundry / gateway / local) por appsettings.

Selección de modelo para el primer caso: chat general vs tool-use.

Definición del agente: instrucciones base (system prompt), objetivos, límites.

Añadir 1–2 tools iniciales (ej: “GetTime”, “SearchDocs”) para ver tool-use real.

Manejo de configuración segura: user-secrets, Key Vault, managed identity.

Activación de observabilidad: OpenTelemetry + exporters + correlación.

Uso de DevUI para inspeccionar trazas, steps, tool invocations y latencias.

Debugging práctico: prompts, tool schemas, errores de serialización, timeouts.

Buenas prácticas “hello agent”: límites de tokens, mensajes de error, fallback sin tools.

Registro de costes: tokens/requests por conversación y por tool.

Checklist de “listo para demo”: reproducibilidad, logs útiles, configuración clara.

Jerarquía de instrucciones: system > developer > user; conflictos y resolución.

Prompts orientados a tareas: objetivo, criterios de éxito, restricciones y “definition of done”.

“Tool-first thinking”: cuándo usar tool vs responder directo.

Diseño de tools con contratos claros (nombres, descripciones, tipos, ejemplos).

Manejo de ambigüedad: preguntar antes de actuar; confirmaciones “baratas”.

Guardrails: límites de acción (no borrar, no enviar emails, no transferir dinero sin aprobación).

Formatos de salida: JSON estructurado, markdown, plantillas empresariales.

Inyección de contexto: políticas, catálogos, “datos oficiales” vs “opinión del modelo”.

Prompting para robustez: self-checks, verificación de precondiciones, detección de falta de datos.

Tool chaining: composición de tools sin “looping” infinito.

Manejo de errores en tool-use: qué decir, cuándo reintentar, cuándo escalar a humano.

Evaluación iterativa: A/B de prompts + métricas + regresiones.

Diferencia entre “historial de chat” y “memoria útil” (resumen, hechos, preferencias).

Estado persistente: qué guardar (y qué no), TTL, versionado.

Estrategias de compresión de contexto: summarization, key facts, “rolling window”.

Memoria por usuario vs por sesión vs por caso (ticket/work item).

Consistencia: cómo evitar contradicciones cuando el usuario corrige información.

Privacidad: minimización de datos, PII, borrado bajo petición, cifrado.

Recuperación selectiva: traer solo lo relevante a la ventana del modelo.

Persistencia en stores (SQL/NoSQL/Redis) y patrones de acceso.

Sincronización con sistemas externos (CRM/ERP) como “memoria de verdad”.

Long-running agents: reanudación, checkpoints, idempotencia, reintentos.

Human-in-the-loop en conversaciones largas (aprobaciones y handoffs).

Métricas de calidad en conversaciones largas (coherencia, seguimiento de objetivos, fatiga).

Qué es un workflow tipo grafo y por qué aporta control explícito.

Nodos típicos: decisión, acción (tool), validación, resumen, handoff a humano.

Branching: reglas deterministas vs decisiones asistidas por modelo.

Estados del workflow: iniciado, en progreso, bloqueado, completado, fallido.

Human-in-the-loop: aprobación, edición, rechazo con feedback, SLAs.

Gestión de dependencias: tareas paralelas, joins, timeouts.

Retry policies por nodo: reintentos controlados y escalado.

Observabilidad del grafo: trazas por transición y métricas por nodo.

Diseño para auditabilidad: “por qué se tomó esta rama”.

Plantillas de workflow: intake → análisis → acción → verificación → reporte.

Integración con colas/eventos: disparar workflows por eventos.

Testing de workflows: casos felices, bordes, fallos de tools, fallos humanos.

Roles: coordinador (planner), especialistas (dominio), ejecutor de tools, verificador.

Patrones: hub-and-spoke, debate/critique, supervisor-revisor, panel de expertos.

Contratos de comunicación: mensajes estructurados, handoffs, turn-taking.

Evitar “cacofonía”: límites de turnos, presupuesto de tokens, objetivos compartidos.

Delegación: cómo partir una tarea compleja en subtareas accionables.

Consenso: votación, scorecards, verificación cruzada.

Seguridad: qué agente puede usar qué tool (scopes por rol).

Observabilidad multiagente: correlación de trazas entre agentes y tools.

Gestión de estado compartido: workspace común vs memorias separadas.

Manejo de errores: especialista falla → fallback a otro → escalado a humano.

Coste y rendimiento: paralelismo vs coordinación; cuándo merece la pena.

Casos reales: soporte TI (triage + ejecución), ventas (research + propuesta), finanzas (reconciliación + reporte).

Qué es RAG en contexto agentic: recuperar → razonar → actuar (y citar).

Fuentes: ficheros (PDF/Word), wikis, SharePoint, bases internas, KB de soporte.

Ingesta: chunking, limpieza, normalización, metadatos.

Índices: embeddings, búsqueda semántica + keyword (híbrida).

Recuperación: top-k, filtros por permisos/metadata, frescura.

Grounding: cómo forzar respuestas basadas en fuentes y evitar alucinaciones.

Citado y trazabilidad: qué documento y qué fragmento sustentan cada afirmación.

RAG + tools: “si falta info, busca”; “si hay conflicto, pide aclaración”.

Control de permisos: security trimming, ACLs, multi-tenant.

Evaluación de RAG: relevancia, exactitud factual, cobertura, consistencia.

Actualización: reindex incremental, invalidación de cache, versionado.

Anti-patrones: indexar basura, chunks gigantes, falta de metadatos, prompts sin grounding.

Diseñar tools REST: endpoints, métodos, esquemas, paginación.

Autenticación: OAuth2, managed identity, client credentials, on-behalf-of.

Rate limits: backoff, colas, cache, “request shaping”.

Integración con bases de datos: lectura vs escritura, transacciones, parámetros seguros.

Microsoft 365 + Graph: correo, calendario, archivos, Teams, usuarios y grupos (casos típicos).

Validación de entrada: sanitización, prevención de inyección, listas blancas.

Patrón “read → propose → approve → write” para acciones sensibles.

Diseño idempotente: claves de idempotencia y detección de duplicados.

Observabilidad de integraciones: latencias por dependencia, errores por API.

Resiliencia: circuit breakers, fallback, modo degradado “solo lectura”.

Trazabilidad/auditoría: quién pidió qué, qué tool ejecutó qué, cuándo.

Testing: mocks de APIs, entornos sandbox, contratos (contract testing).

Por qué eventos: sistemas reactivos, desacoplo, escalabilidad.

Fuentes: Service Bus, Event Hubs, Kafka, colas internas, webhooks.

Patrones: event-driven workflow (un evento dispara un nodo del grafo).

Procesamiento: consumer groups, concurrencia, orden, exactly-once vs at-least-once.

Idempotencia: deduplicación, watermarking, claves.

Ventanas de tiempo: streaming analytics, agregaciones, alertas.

Tools asincrónicas: “emitir comando” y “esperar resultado” con correlación.

Tiempo real en UI: notificaciones, status updates, progreso del workflow.

Manejo de fallos: DLQ, reintentos, poison messages.

Observabilidad: trazas distribuidas con correlation IDs.

Seguridad: firmas de eventos, scopes, control de topics/queues.

Casos: monitorización (alert→diagnóstico→remediación), pedidos (order→validación→factura), IT ops.

Por qué evaluar: calidad, seguridad, estabilidad y “no romper” en cambios.

Tipos de evaluación: offline (datasets) vs online (telemetría).

Métricas de calidad: relevancia, completitud, coherencia, veracidad (según librerías).

Métricas de seguridad: hate/violence/sexual content, instrucciones peligrosas, etc.

Evaluadores “in-the-box” y evaluadores personalizados (reglas del dominio).

Evaluación de tool-use: ¿eligió la tool correcta?, ¿parámetros correctos?, ¿se detuvo a tiempo?

Regresiones: golden tests, snapshots, tolerancias y “drift” de modelos.

Conjuntos de pruebas: casos felices, bordes, adversariales, PII, prompt injection.

Integración CI/CD: ejecutar evaluaciones en pipeline y bloquear despliegues si baja el score.

Observabilidad + evaluación: usar trazas para explicar fallos y ajustar prompts/tools.

Benchmarks internos por caso de uso (SLA de calidad, coste por tarea).

Reporting: scorecards para negocio + métricas técnicas para ingeniería.

Threat model agentic: tool abuse, prompt injection, data exfiltration, lateral movement.

Identidad y acceso: RBAC, managed identity, scopes por tool y por usuario.

Data governance: clasificación, etiquetado, retención, minimización.

Cumplimiento: auditoría, registros inmutables, evidencias para compliance.

Aislamiento de red: VNET, private endpoints, egress control (cuando aplique).

Seguridad de prompts: no incluir secretos, redacción de PII, plantillas seguras.

Seguridad de memoria/estado: cifrado, TTL, borrado, multi-tenant isolation.

Content safety: filtros, políticas, respuesta segura ante solicitudes no permitidas.

Revisión humana para acciones críticas (human approval gates).

Principio de menor privilegio en integraciones (Graph/DB/REST).

Logging responsable: logs útiles sin filtrar datos sensibles.

Políticas operativas: revisiones de cambios, approvals de modelos, controles de despliegue.

Opciones de hosting: App Service, contenedores, AKS; criterios de elección.

Containerización: imágenes, configuración externa, health checks, readiness/liveness.

Escalado horizontal: stateless front + estado en store; sticky sessions cuando sea necesario.

Gestión de estado: Redis/SQL/NoSQL; particionado por tenant/usuario.

Colas para trabajos largos: desacoplar request/response de ejecución.

Observabilidad en prod: logs, métricas, trazas (OpenTelemetry) y dashboards.

Resiliencia: timeouts, retries, circuit breakers, bulkheads.

Gestión de secretos: Key Vault, managed identity, rotación automática.

Cost management: límites por usuario, presupuestos por entorno, caching.

Blue/green o canary: despliegues seguros con evaluación post-deploy.

CI/CD: build, test, eval, deploy; versionado de prompts y tools.

SRE: SLIs/SLOs (latencia, éxito de tool-use, coste por tarea).

Clean architecture: dominio separado de infra (tools como adaptadores).

Microservicios: agente como “orquestador” vs lógica distribuida en servicios.

Event-driven: workflows disparados por eventos; saga/orquestación.

Bounded contexts: agentes por dominio (HR, IT, Finance) con herramientas propias.

Hexagonal: puertos y adaptadores para tools (REST/DB/Graph).

CQRS: lectura enriquecida (RAG) y comandos con aprobación.

Workflow engine + agent: decisiones del modelo encapsuladas en nodos controlados.

Anti-corruption layer: normalizar datos de sistemas legacy antes del agente.

Observabilidad como primera clase: correlación distribuida.

Seguridad transversal: policy enforcement point para tools.

Testing por capas: unit (dominio), contract (tools), end-to-end (workflow).

Evolución: versionar prompts, tools y workflows como artefactos.

Inventario: qué agentes existen, qué skills/tools, qué memorias y qué orquestación.

Mapeo conceptual: skills/plugins → tools; planners → workflows; chat history → state/memory.

Identificar “quick wins”: agentes simples que migran casi directo.

Migrar herramientas primero: encapsular acceso a APIs/DB en tools bien tipadas.

Migrar prompts: consolidar instrucciones, eliminar redundancias y añadir guardrails.

Introducir workflows: mover lógica procedural a grafos con ramas explícitas.

Estado persistente: diseñar stores y estrategias de compresión para conversaciones largas.

Multiagente: pasar de “chat entre agentes” a coordinación basada en patrones + control.

Observabilidad: instrumentar desde el día 1 (Otel) y comparar antes/después.

Evaluación/regresión: crear baseline con MEAI Evaluations antes de cambiar.

Plan de rollout: canary, feature flags, fallback al sistema anterior.

Documentación y formación interna (operación, troubleshooting, seguridad).

Copiloto interno de conocimiento (RAG + políticas + citations).

Triage IT: entender incidencia → pedir info → ejecutar remediación (tools) → reportar.

Automatización de RRHH: altas/bajas, FAQs, generación de documentos con aprobación.

Finanzas: conciliación, extracción de facturas, validación con reglas.

Ventas/Presales: research, propuesta, comparación, creación de contenidos.

Legal/Compliance: búsqueda, checklist, borradores con “no advice” y revisión humana.

Operaciones: procesamiento de pedidos, excepciones, comunicación proactiva.

Multiagente por departamentos: coordinador + especialistas (dominio, datos, verificación).

Workflows con humanos: aprobaciones, escalado, handoff a equipos.

Integración Microsoft 365/Graph: calendarios, emails, archivos, tareas (con permisos).

Tiempo real: alertas + acciones por eventos (cola/bus).

Medición de valor: reducción de tiempos, tasa de resolución, coste por caso, satisfacción.

Definición del caso: “copiloto de operaciones” (o similar) con objetivos medibles.

Arquitectura: front API + agent service + state store + RAG index + event bus.

Agentes: coordinador + 2–3 especialistas + verificador + tool-runner.

Tools: Graph/REST/DB + RAG search + “approval tool” humana.

Workflow grafo: intake → análisis → plan → ejecución → verificación → reporte.

Persistencia: memoria por usuario/caso con compresión y TTL.

Observabilidad: Otel + dashboards; trazas por step, tool-call y transición de grafo.

Seguridad: RBAC, secretos, límites de tools, auditoría de acciones.

RAG empresarial: ingesta, índices, filtros por permisos, citado en respuestas.

Evaluación: suite de regresión + métricas de tool-use + safety checks en CI.

Despliegue: contenedor + App Service o AKS + estrategia canary.

Entregables: repo, documentación, runbook, demo guiada, informe de métricas y costes.