Cómo generar Anotaciones de Columnas en Copilot en Fabric: paso a paso

João Barros 11 de November de 2026 6 min de lectura

Este tutorial muestra cómo usar Copilot en Fabric para generar anotaciones (column annotations) automáticas en una tabla del Lakehouse. Documentar columnas con descripciones y tipos es útil para el descubrimiento, la gobernanza y para que los equipos sepan el significado de los datos. Anotaciones consistentes ayudan a reducir el tiempo de onboarding de nuevos usuarios (p. ej. 30-50% menos tiempo hasta comprender un dataset) y facilitan la integración con herramientas como Power BI y procesos ETL.

Prerequisitos

Cuenta con acceso a Microsoft Fabric y permisos para editar un Lakehouse (al menos rol de Owner o Data Curator).
Tabla de datos cargada en el Lakehouse (por ejemplo CSV importado como tabla). Ejemplos típicos: tabla "Sales" con columnas order_id, price, currency, customer_email, order_date.
Copilot activado en su instancia de Fabric y con permisos para acceder al contexto del Lakehouse.
Noociones básicas de SQL (SELECT, ALTER) y de los conceptos de metadatos (semantic types, comentarios de columna).
Sugerencia: muestre a Copilot una muestra de 100–1000 registros para mejores ejemplos y detección de patrones.

Paso 1: Identificar la tabla y el objetivo de las anotaciones

Elija la tabla en el Lakehouse cuya documentación quiere mejorar. Decida el nivel de detalle: descripción corta (1–2 frases), semantic_type (p. ej.: currency, email, iso-country), ejemplo de valor y reglas de validación (regex o validaciones simples). Por ejemplo, para 10 columnas críticas (p. ej. order_id, price, customer_email) puede pedir descripciones detalladas; para 50 columnas menos críticas, descripciones cortas pueden ser suficientes. Anote también el público objetivo: analistas, ingenieros o usuarios de negocio — eso condiciona el lenguaje empleado en las descripciones.

Paso 2: Abrir Copilot en el contexto de la tabla

Navegue a la lista de archivos del Lakehouse, seleccione la tabla y abra el panel de Copilot (icono Copilot en la esquina superior derecha del UI del Lakehouse). Abrir Copilot en el contexto de la tabla le permite referenciar columnas y muestras automáticamente — el modelo puede leer los primeros N registros e inferir formatos. Si no puede abrir en el contexto, copie manualmente un esquema o muestra para el prompt.

Paso 3: Crear un prompt orientado a anotaciones

Escriba un prompt claro que pida descripciones, semantic_type y ejemplos para cada columna. Prefiera un formato estructurado (JSON) para facilitar la aplicación posterior. Explique la longitud deseada de las descripciones y el inventario de semantic_type aceptables (p. ej. currency, email, iso-country, datetime, id, postcode, phone, person-name). Incluya también que se generen rule_suggestion como regex o checks SQL simples.

{
  "prompt": "Analiza las columnas de la tabla 'Sales' y genera metadatos en JSON. Para cada columna, devuelve: name, description (1-2 frases), semantic_type (ex: currency, email, iso-country), example_value y rule_suggestion (regex o validación SQL). Usa muestras de los primeros 100 registros si es necesario.",
  "output_format": "json"
}

Ejemplos de rule_suggestion: email -> "^[^@\s]+@[^@\s]+\.[^@\s]+$"; price -> "^\\d+(\\.\\d{2})?$" (valor con dos decimales). Estas reglas ayudan a automatizar checks de calidad.

Paso 4: Ejecutar Copilot y revisar el resultado

Envíe el prompt y espere la respuesta de Copilot (normalmente segundos a 1-2 minutos, dependiendo del tamaño de la muestra). El output deberá ser un JSON con una entrada por columna. Revise cada campo: las descripciones deben ser concisas y correctas; los semantic_type útiles para el descubrimiento; los example_value representativos (no valores vacíos) y las rule_suggestion concretas y comprobables. Si encuentra un semantic_type incorrecto, anótelo para corregirlo en el siguiente prompt.

Ejemplo de snippet generado (conceptual):

{
  "columns": [
    {"name": "price", "description": "Precio unitario de la venta en euros.", "semantic_type": "currency", "example_value": "19.99", "rule_suggestion": "^\\d+(\\.\\d{1,2})?$"},
    {"name": "customer_email", "description": "Email del cliente usado para contacto.", "semantic_type": "email", "example_value": "cliente@example.com", "rule_suggestion": "^[^@\\s]+@[^@\\s]+\\.[^@\\s]+$"}
  ]
}

Paso 5: Ajustar e iterar el prompt en caso de errores comunes

Errores comunes: descripciones demasiado vagas, semantic_type genéricos (p. ej.: string) o ejemplos irrelevantes. Refine el prompt pidiendo mayor detalle o limitando el alcance a columnas específicas. Por ejemplo, si Copilot no detectó correctamente formatos de fecha, pida explícitamente "date format ISO 8601 o DD/MM/YYYY". Iterate hasta obtener una calidad aceptable — normalmente 2–3 iteraciones para conjuntos de 10–20 columnas.

{
  "prompt": "Céntrate en las columnas 'price', 'currency', 'customer_email'. Para cada una, devuelve: name, description (2 frases), semantic_type (currency/email), example_value (del dataset) y rule_suggestion. Si no hay ejemplos, devuelve null."
}

Paso 6: Convertir el JSON generado en cambios en la tabla

Después de validar el JSON, aplique las anotaciones usando la API de Fabric (si está disponible) o a través del UI del Lakehouse. Un enfoque sencillo es generar un script SQL que actualice comentarios de columna. Si tiene 20 columnas, genere 20 comandos ALTER automáticamente a partir del JSON.

-- Ejemplo conceptual: aplicar descripción vía SQL
ALTER TABLE Sales ALTER COLUMN price SET COMMENT 'Precio unitario en euros, sin IVA';
-- Para múltiples columnas, generar dinámicamente con base en el JSON de Copilot

Si prefiere validar las rule_suggestion antes de aplicar, ejecute checks SQL como:

SELECT COUNT(*) AS invalid_emails FROM Sales WHERE NOT (customer_email REGEXP '^[^@\s]+@[^@\s]+\.[^@\s]+$');

Verificar el resultado

Confirme que las descripciones aparecen en el catálogo del Lakehouse y que herramientas como Power BI o Data Insights muestran las anotaciones. Pruebe también las sugerencias de validación ejecutando los checks (p. ej. contar registros que fallan la regex). Registre métricas antes/después (p. ej. número de registros inválidos) para medir el impacto. Si lo implementa en un pipeline ETL, añada estas validaciones como pasos automáticos y registre alertas cuando el porcentaje de errores supere un umbral (p. ej. 1%).

Conclusión

Al usar Copilot en Fabric para generar anotaciones de columnas gana tiempo y uniformidad en la documentación de los datos; el siguiente paso es automatizar este flujo (p. ej.: programar revisiones mensuales) e integrar las rule_suggestion en pipelines ETL. Consejo práctico: empiece por un subconjunto crítico de 5–10 columnas, valide resultados y después escale al catálogo completo. Mantenga siempre un ciclo de revisión humana para garantizar calidad semántica — ¿quiere probar a generar anotaciones para un subconjunto crítico primero?