Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra. # Pilotage SQL d'Aurora : compétences et pouvoirs Cette section décrit comment configurer le pilotage par IA pour Aurora DSQL à l'aide de compétences et de pouvoirs. Ces fichiers de configuration basés sur le markdown fournissent un contexte et des conseils que les assistants d'intelligence artificielle appliquent automatiquement lors de la génération de code afin d'améliorer la qualité du développement agentic. ## Présentation de Les compétences et les pouvoirs sont des fonctionnalités modulaires qui étendent les fonctionnalités de l'assistant AI pour Aurora DSQL. Ils contiennent des instructions, des métadonnées et des ressources que les assistants d'intelligence artificielle utilisent automatiquement lorsqu'ils travaillent avec des bases de données Aurora DSQL. ### Pourquoi utiliser les compétences et les pouvoirs Les compétences et les pouvoirs offrent plusieurs avantages clés pour le développement d'Aurora DSQL : + **Assistants spécialisés en intelligence artificielle** : fournissez une expertise spécifique à un domaine pour Aurora DSQL, notamment les meilleures pratiques, les modèles SQL compatibles avec Postgres et les optimisations de bases de données distribuées. + **Réduisez les répétitions** : créez une fois, utilisez automatiquement. Élimine le besoin de fournir à plusieurs reprises les mêmes conseils au cours de plusieurs conversations. + **Efficacité du contexte** : les compétences se chargent à la demande au lieu de consommer le contexte dès le départ. L'IA charge les informations par étapes selon les besoins. + **Apprentissage continu** - À mesure que les fonctionnalités d'Aurora DSQL évoluent, les assistants IA accèdent automatiquement aux modèles mis à jour lorsque les compétences sont mises à jour. ### Chemins de configuration recommandés Choisissez le chemin de configuration qui correspond à votre environnement de développement : + [Compétences CLI](#skills-cli)(Agnostique vis-à-vis des agents) + [Kiro Power](#kiro-power) + [Claude Skill](#claude-skill) + [Compétence Gémeaux](#gemini-skill) + [Compétence Codex](#codex-skill) La [compétence DSQL](https://github.com/awslabs/mcp/tree/main/src/aurora-dsql-mcp-server/skills/dsql-skill) peut également être utilisée avec d'autres agents de codage AI en copiant le dossier de compétences dans le `skills` répertoire `rules` ou l'outil. ## Compétences CLI La [compétence DSQL](https://skills.sh/awslabs/mcp/dsql) peut être installée à l'aide de la [CLI Skills](https://skills.sh/docs/cli). Cette méthode de configuration indépendante de l'agent fonctionne avec la plupart des assistants de codage basés sur l'IA et vous permet d'installer la compétence sur plusieurs agents à la fois. ### Configuration Exécutez la commande suivante pour installer la compétence Aurora DSQL : ``` npx skills add awslabs/mcp --skill dsql ``` La CLI vous guidera à travers : + **Sélection des agents** : choisissez les agents sur lesquels installer (Kiro, Claude Code, Cursor, Copilot, Gemini, Codex, Roo, Cline, Windsurf, etc.) OpenCode + **Champ d'installation** - Choisissez entre : + Projet : Installation dans le répertoire en cours (intégré à votre projet) + Global : Installation dans le répertoire de base (disponible dans tous les projets) + **Méthode d'installation** - Choisissez entre : + Symlink (recommandé) : source unique de vérité, mises à jour faciles + Copie destinée à tous les agents : copies indépendantes pour chaque agent ### Gestion des skills Vérifiez et mettez à jour vos compétences à tout moment en utilisant : ``` npx skills check npx skills update ``` ## Kiro Power Les Kiro Powers sont des packages unifiés qui associent des outils MCP à une expertise en matière de framework et à des instructions de pilotage. Chaque alimentation inclut un document d'entrée expliquant les outils MCP et les déclencheurs d'activation disponibles, la configuration du serveur MCP et des instructions supplémentaires spécifiques au flux de travail chargées à la demande. Les pouvoirs s'activent de manière dynamique en fonction du contexte utilisateur. Plutôt que de charger tous les outils dès le départ, les pouvoirs maintiennent une utilisation de base proche de zéro jusqu'à ce que les mots clés pertinents déclenchent l'activation. ### Configuration Pour configurer la puissance Kiro pour Aurora DSQL, procédez comme suit : 1. Installation directe depuis le registre [Kiro Powers](https://kiro.dev/launch/powers/amazon-aurora-dsql/) 1. Une fois redirigé vers Power in the IDE, vous pouvez soit : + Sélectionnez le bouton **Try Power**. Suggéré pour les utilisateurs qui souhaitent utiliser l'IA pour guider la configuration du serveur MCP ou bénéficier d'une expérience d'intégration interactive avec Aurora DSQL pour créer un nouveau cluster. + Ouvrez un nouveau chat Kiro et posez des questions concernant Aurora DSQL. Vous pouvez éventuellement mettre à jour la configuration MCP avec les détails de votre cluster existant pour tester la connexion au serveur MCP afin qu'elle puisse être utilisée prête à l'emploi avec l'alimentation. L'agent Kiro activera automatiquement le pouvoir s'il identifie le pouvoir comme précieux pour accomplir la tâche de l'utilisateur. ## Claude Skill Les compétences de Claude sont des capacités modulaires qui étendent les fonctionnalités de Claude. Chaque compétence regroupe des instructions, des métadonnées et des ressources facultatives que Claude utilise automatiquement le cas échéant. Les compétences sont basées sur le système de fichiers et se chargent à la demande afin de minimiser l'utilisation du contexte. ### Configuration simple avec la CLI Skills La compétence peut être installée sur Claude Code à l'aide du[Compétences CLI](#skills-cli). Pour spécifier uniquement Claude Code comme agent sur lequel effectuer l'installation, utilisez : ``` npx skills add awslabs/mcp --skill dsql --agent claude-code ``` ### Alternative : Configuration directe à l'aide d'un clone Git La configuration alternative utilise un clone fragmenté du répertoire dsql-skill et établit un lien symbolique entre ce clone et le dossier. `~/.claude/skills/` Cela permet d'apporter des modifications à la compétence chaque fois que la compétence doit être mise à jour. #### Conditions préalables + Git installé #### Étapes de configuration **1. Création d'un répertoire de dépôts de base** ``` mkdir -p .dsql_skill_repos ``` **2. Clonez la compétence dans Sparse depuis le référentiel MCP** Clonez uniquement le `dsql-skill` dossier (aucun autre fichier) : ``` cd .dsql_skill_repos git clone --filter=blob:none --no-checkout https://github.com/awslabs/mcp.git cd mcp git sparse-checkout init --cone git sparse-checkout set src/aurora-dsql-mcp-server/skills/dsql-skill git checkout cd ../.. ``` **3. Associez la compétence au répertoire des compétences** Ajoutez le répertoire des compétences (par défaut : global/scopé pour l'utilisateur) : ``` mkdir -p ~/.claude/skills ``` **Note** Si vous souhaitez en faire une compétence adaptée au projet, utilisez plutôt le répertoire racine de `.claude/skills/` votre projet. Ajoutez le lien symbolique : ``` ln -s "$(pwd)/.dsql_skill_repos/mcp/src/aurora-dsql-mcp-server/skills/dsql-skill" ~/.claude/skills/dsql-skill ``` **4. Vérifiez la configuration** ``` # Should show SKILL.md and other skill files ls -la ~/.claude/skills/dsql-skill/ ``` **5. Vérifier l'utilisation des compétences** Une fois la compétence configurée, vous devriez avoir une nouvelle commande de compétence :`/dsql`. Vous devrez peut-être redémarrer Claude Code après avoir ajouté la compétence pour qu'elle soit détectée. Vous pouvez utiliser cette commande à partir de la CLI ou du panneau Claude Code comme vous le souhaitez. #### Mettre à jour la compétence Pour extraire les dernières modifications du référentiel, procédez comme suit : ``` cd .dsql_skill_repos/mcp git pull ``` #### Structure des annuaires Après avoir configuré une compétence globale, vous devriez voir les répertoires suivants : ``` .dsql_skill_repos/ └── mcp/ # Sparse git checkout └── src/ └── aurora-dsql-mcp-server/ └── skills/ └── dsql-skill/ ├── SKILL.md └── ... ~/.claude/ └── skills/ └── dsql-skill -> /path/to/.dsql_skill_repos/mcp/src/aurora-dsql-mcp-server/skills/dsql-skill ``` **Note** Ajoutez-le `.dsql_skill_repos/` à votre `.gitignore` si vous ne souhaitez pas le suivre. Le checkout fragmenté ne conserve que le dossier des compétences, minimisant ainsi l'utilisation du disque. ## Compétence Gémeaux Pour ajouter la compétence Aurora DSQL directement dans Gemini, choisissez une portée : `workspace` (contenue dans le projet) ou `user` (par défaut, globale) et utilisez le programme d'installation des compétences. ### Configuration ``` gemini skills install https://github.com/awslabs/mcp.git --path src/aurora-dsql-mcp-server/skills/dsql-skill --scope $SCOPE ``` Remplacez `$SCOPE` par l'un `workspace` ou l'autre`user`. Vous pouvez ensuite utiliser la commande de `/dsql` compétence avec Gemini, et Gemini détectera automatiquement quand la compétence doit être utilisée. ## Compétence Codex Utilisez l'installateur de compétences de la CLI du Codex ou du TUI à l'aide de la `$skill-installer` compétence. ### Configuration ``` $skill-installer install dsql skill: https://github.com/awslabs/mcp/tree/main/src/aurora-dsql-mcp-server/skills/dsql-skill ``` Redémarrez Codex pour récupérer la compétence. La compétence peut ensuite être activée à l'aide de`$dsql`.