View a markdown version of this page

Pilotage SQL d'Aurora : compétences et pouvoirs - Amazon Aurora DSQL
Présentation de Compétences CLIKiro PowerClaude SkillCompétence GémeauxCompétence Codex

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.

Choisissez le chemin de configuration qui correspond à votre environnement de développement :

La compétence DSQL 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 peut être installée à l'aide de la CLI Skills. 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

  2. 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 duCompétences 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'autreuser.

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.