Créer des produits de données avec des compétences agentiques

Présentation

Ce guide explique comment utiliser des compétences agentiques spécialisées de Cortex Framework, fournies directement par Cortex Framework dans le dépôt GitHub, avec un assistant de codage IA (tel que Gemini associé au framework de développement agentique Antigravity) pour créer des produits de données personnalisés qui suivent les bonnes pratiques de Cortex Framework.

Cortex Framework fournit des compétences agentiques spécialisées pour étendre ses capacités, ce qui permet à votre assistant IA de vous guider tout au long du processus de création de produits de données qui suivent les bonnes pratiques de Cortex Framework. Grâce à ces fonctionnalités, vous pouvez utiliser le langage naturel pour demander un nouveau produit de données en fonction des exigences spécifiques de votre entreprise. Par exemple, vous pouvez demander un produit de données de consommation des comptes fournisseurs pour obtenir des insights sur le total dû, les montants en retard et le chiffre d'affaires. Le résultat est un produit de données Cortex Framework entièrement intégré, basé sur les exigences et les données spécifiques de votre client, et prêt à être exécuté.

Compétences de l'agent

Les compétences agentiques sont un format ouvert et léger permettant d'étendre les capacités des agents IA avec des connaissances et des workflows spécialisés. Une compétence est un dossier contenant un fichier SKILL.md (qui inclut des métadonnées et des instructions), ainsi que des scripts, des références et des composants facultatifs qui indiquent à un agent comment effectuer une tâche spécifique. Les compétences regroupent les connaissances procédurales et le contexte dans des dossiers portables que les agents chargent à la demande, ce qui leur permet de fournir une expertise dans un domaine et des workflows reproductibles. Les compétences de Cortex Framework sont stockées dans le répertoire .agent.

Compétences agentiques de Cortex Framework

Le créateur de produits de données agentiques automatise le cycle de vie de développement de bout en bout des produits de données dans Cortex Framework. En demandant à votre assistant IA d'exécuter des workflows de développement structurés, vous n'avez plus besoin de créer manuellement des structures de fichiers, de parcourir des schémas SAP complexes, de configurer des couches de base, de gérer des espaces de noms personnalisés ni d'écrire du code SQLX Dataform standard.

L'assistant IA gère les tâches principales suivantes :

  • Planification et mappage des exigences : traduit les exigences concrètes de l'entreprise en un plan de modélisation et de développement de données exploitable.
  • Recherche de schéma en direct : exécute des scripts qui interrogent les tables répliquées du dictionnaire de données SAP (DDIC) pour fournir des informations contextuelles spécifiques au client, telles que des champs Z personnalisés.
  • Création de code standard : génère automatiquement tous les fichiers de configuration, métadonnées et artefacts de code SQLX ou JavaScript requis.
  • Portes de qualité des données : valide les produits de données en exécutant des builds locaux, en compilant du code SQL, en exécutant des tests unitaires et d’intégration, et en vérifiant la conformité aux normes de nommage.
  • Création de documentation : crée automatiquement des composants de documentation, y compris la visualisation des diagrammes d'entité-relation et des clés primaires de votre module de produit de données.

Le développement de produits de données avec ces compétences agentiques est un processus itératif. Vous pouvez commencer par vos objectifs initiaux, examiner le plan d'implémentation proposé par l'agent, y compris les diagrammes et schémas d'entité-relation, et demander à l'assistant IA d'affiner la logique de manière conversationnelle au fur et à mesure. L'agent accélère le développement, mais vous gardez le contrôle total pour examiner et approuver tout le code généré avant de le valider dans votre dépôt. De plus, comme ces scripts agentiques s'exécutent localement à l'aide de vos identifiants authentifiés, ils respectent intrinsèquement vos limites d'accès Google Cloud et BigQuery existantes.

Prérequis

Avant d'utiliser les compétences agentiques, vérifiez que votre environnement de développement répond aux exigences suivantes pour activer les requêtes de schéma en direct, la compilation de données et la validation automatisée :

  1. Google Cloud SDK (gcloud) : installez et authentifiez l'CLI (gcloud) avec votre compte utilisateur. Pour en savoir plus, consultez la documentation sur le déploiement.

  2. Identifiants par défaut de l'application (ADC): Configurez vos ADC locaux et vos cibles de projet afin que les outils de compilation locaux et les suites pytest puissent communiquer avec BigQuery. Pour en savoir plus, consultez la section Préparer votre projet par défaut Google Cloud .

  3. Tables répliquées du dictionnaire de données SAP (DDIC): pour permettre à l'agent d'effectuer des vérifications de schéma non sensibles à la casse et de vérifier avec précision la longueur des champs, répliquez les tables de métadonnées SAP suivantes dans votre ensemble de données BigQuery cible brut :

    • DD03L (champs de table)
    • DD04T (textes des éléments de données)
    • DD08L (relations entre les tables)
    • DD01L (domaines)
    • DD07L (valeurs de domaine – facultatif)
    • DD07T (textes des valeurs de domaine – facultatif)

  4. Environnement Python local : installez les dépendances locales et exécutez l’outil de synchronisation à l’aide de uv pour vous assurer que les bibliothèques de validation et les tests unitaires fonctionnent correctement. Pour en savoir plus, consultez la documentation.

Configuration de l'IDE

Avant de commencer, consultez la documentation de l'assistant de codage IA de votre choix pour obtenir des instructions d'installation et de configuration (par exemple, Antigravity).

  1. Collectez les artefacts d'installation requis et clonez le dépôt. Pour en savoir plus, consultez la section Artefacts d'installation.

  2. Ouvrez l'empreinte du code source cloné de Google Cloud Cortex Framework dans l'assistant de codage IA de votre choix.

Google Cloud Cortex Framework expose ses capacités agentiques via un ensemble de compétences spécialisées situées dans le répertoire .agents/skills/ du dépôt. Vous pouvez utiliser ces compétences dans plusieurs environnements de développement :

  • Framework Antigravity: Antigravity détecte, indexe et active automatiquement toutes les compétences de l'espace de travail au démarrage. Aucune configuration supplémentaire n'est requise. Pour vérifier, posez la question suivante à l'assistant :

    Quelles compétences sont disponibles ?

  • VSCode avec Gemini Code Assist :

    1. Installez l'extension Gemini Code Assist à partir de VS Code Marketplace.
    2. Ouvrez le dossier cortex-framework-core en tant qu'espace de travail. L'assistant analyse et charge automatiquement les compétences à partir du répertoire .agents/skills/.

  • Autres outils CLI d'IA: faites référence au répertoire de compétences de manière native dans vos invites d'instructions. Exemple :

    Lisez la compétence create-data-product dans le répertoire .agents/skills/ et créez le code standard...

Créer un produit de données personnalisé

Les étapes suivantes décrivent le workflow de développement structuré pour utiliser des compétences agentiques afin de créer un produit de données personnalisé.

Étape 1 : Fournir les exigences et le contexte

À l'aide de l'interface de chat de votre assistant de codage IA, fournissez une invite qui décrit vos exigences spécifiques en matière de données. Exemple :

Créez un produit de données Cortex Framework pour les insights sur les comptes fournisseurs ciblant SAP S/4HANA et ECC. Utilisez l'espace de noms : custom_finance. L'exigence métier principale consiste à suivre le total dû et les montants en retard pour nos fournisseurs, et à calculer notre taux de rotation des comptes fournisseurs par code de société.

Notez que vous pouvez également faire référence à des exigences ou des documents de spécification existants directement dans votre invite. Ces documents (qui peuvent être au format Markdown ou dans d'autres formats structurés) fournissent à l'agent un contexte essentiel, tel que :

  • Contexte et domaine métier : objectifs détaillés, récits utilisateur et consommateurs cibles.
  • Spécifications des données d'entrée : liste des tables sources (par exemple, LFA1, BSIK, BSEG ,Z...), détails de la gestion des versions (ECC ou S/4HANA), règles d'exclusion, champs personnalisés, etc.
  • Logique de transformation et règles métier : contraintes de mappage de base, filtrage des clients (mandt), suppressions logiques (loekz), gestion des mappages d'indicateurs de blocage des paiements (zlspr) et règles de rapprochement (par exemple, exclusion des transactions interentreprises des fournisseurs pour éviter des taux de rotation faussés).
  • Intégrité des données et assertions de test : scénarios de validation (par exemple, vérification de l'unicité des grains et vérification que la somme des montants des factures ouvertes dans la sortie finale correspond exactement aux tables sources brutes).

Étape 2 : Examiner le plan d'implémentation

Une fois que vous avez défini les exigences, l'agent utilise plusieurs compétences, telles que la compétence query-sap-ddic, pour interroger vos tables de métadonnées DDIC BigQuery brutes. Cela permet à l'agent d'identifier et de valider les tables sources requises, en s'assurant que les types de champs et les relations sont exacts. L'agent peut également appeler d'autres compétences pour s'assurer que vos exigences sont parfaitement conformes aux bonnes pratiques de Cortex Framework.

Avant de commencer l'implémentation, l'agent fournit un bref plan d'implémentation pour examen. Ce plan inclut les tables sources, les mappages et la structure architecturale proposée du produit de données. Examinez ce plan et demandez les ajustements nécessaires avant de confirmer.

Étape 3 : Générer le produit de données

Une fois que vous avez confirmé le plan d'implémentation, l'agent utilise la compétence create-data-product pour créer la structure de répertoire. Cela isole vos nouveaux développements personnalisés des mises à jour de la plate-forme de base sous l'espace de noms personnalisé que vous avez désigné :

src/data_modules/<custom_namespace>/products/<dataproductname>/
├── manifest.yaml
├── table_settings.default.yaml
├── README.md
├── definitions/
│   └── [ecc|s4]/
│       └── <product_name>.js
└── annotations/
    └── [ecc|s4]/
        └── <product_name>.yaml

Pour en savoir plus sur la structure des dossiers et les fichiers individuels, consultez la documentation du guide d'extensibilité.

Au cours de cette phase, vous pouvez également demander à l'agent de visualiser automatiquement les relations à l'aide de la compétence generate-er-diagram ou de créer des assertions à l'aide de la compétence create-python-tests.

Étape 4 : Exécuter les portes de qualité et valider les données

En fonction des autorisations accordées, l'agent exécute automatiquement les portes de validation obligatoires suivantes ou vous invite à les exécuter. Tout au long de ce processus, l'agent génère des rapports d'état précis afin que vous puissiez examiner les résultats :

  1. Validation du build : exécute uv run cortex-build --config config/config.yaml pour s'assurer que tous les modèles SQL générés sont compilés correctement, ce qui génère un résumé du build.
  2. Exécution de Pytest : exécute la suite complète de tests unitaires Python, ce qui génère un rapport d’exécution des tests qui valide votre logique métier et vos assertions de base.
  3. Linter et audits : utilise la compétence validate-data-product pour effectuer des vérifications strictes de la parité des champs et vérifier la conformité aux conventions de nommage, ce qui se termine par un rapport de préparation détaillé.

Étape 5 : Déployer et exécuter

Une fois que vous avez examiné les rapports de validation et approuvé le code généré, vous êtes prêt à déployer les composants de votre produit de données.

  • Déployer des composants : transmettez les définitions compilées du produit de données à l'espace de travail Dataform que vous avez configuré en exécutant le script de déploiement localement (par exemple, uv run cortex-deploy --config config/config.yaml).
  • Matérialiser les données : effectuez le workflow final post-déploiement pour exécuter les pipelines Dataform générés, en matérialisant vos nouvelles tables et vues directement dans BigQuery.
  • Fournir des insights : une fois matérialisé, votre produit de données personnalisé est entièrement prêt à être connecté à des applications analytiques en aval, telles que Gemini Enterprise, pour fournir des réponses intelligentes et exploitables à vos questions métier d'origine.

Modifier un produit de données existant

Une fois votre produit de données personnalisé créé, vous n'avez pas besoin de repartir de zéro pour le modifier. Vous pouvez utiliser la compétence update-data-product pour ajouter de nouveaux champs de manière itérative, ajuster la logique métier ou intégrer des tables sources entièrement nouvelles. Exemple :

Mettez à jour mon produit de données AP custom_finance. Ajoutez le champ des conditions de paiement (ZTERM) à partir de la table source LFA1 et assurez-vous qu'il est correctement mappé à la vue de sortie finale. Exécutez la validation du build lorsque vous avez terminé.

L'agent localise la configuration, interroge le DDIC BigQuery pour connaître les exigences exactes des champs, met à jour votre code Dataform et exécute les vérifications de build nécessaires pour valider la modification.

Bonnes pratiques et limites

  • Échecs des requêtes de schéma : si l'agent ne parvient pas à récupérer les schémas de métadonnées SAP, vérifiez que vos identifiants par défaut de l'application (ADC) locaux sont actifs et qu'ils disposent du rôle IAM Lecteur de données BigQuery pour l'ensemble de données brut cible.
  • Limites de contexte : si vous créez un produit de données exceptionnellement volumineux impliquant des dizaines de tables, l'agent risque de perdre le contexte. Augmentez votre taux de réussite en fournissant des instructions plus petites et atomiques (par exemple, demandez à l'agent de créer d'abord les dimensions au niveau de l'en-tête, puis d'ajouter des faits au niveau de l'élément dans une invite de suivi distincte).