Agentverse - The Shadowblade's Codex - Vibecoding with Gemini CLI

1. l'ouverture de "La force du destin".

L'ère du développement cloisonné touche à sa fin. La prochaine vague d'évolution technologique ne concerne pas le génie solitaire, mais la maîtrise collaborative. Créer un agent unique et intelligent est une expérience fascinante. Le grand défi pour l'entreprise moderne consiste à créer un écosystème d'agents robuste, sécurisé et intelligent, un véritable Agentverse.

Pour réussir dans cette nouvelle ère, il est nécessaire de réunir quatre rôles essentiels, qui sont les piliers fondamentaux de tout système agentique prospère. Une lacune dans l'un de ces domaines crée une faiblesse qui peut compromettre l'ensemble de la structure.

Cet atelier est le guide de référence pour les entreprises qui souhaitent maîtriser l'avenir agentique sur Google Cloud. Nous vous proposons une feuille de route de bout en bout qui vous guide de la première idée à une réalité opérationnelle à grande échelle. Dans ces quatre ateliers interconnectés, vous allez découvrir comment les compétences spécialisées d'un développeur, d'un architecte, d'un ingénieur des données et d'un ingénieur SRE doivent converger pour créer, gérer et faire évoluer un Agentverse puissant.

Aucun pilier ne peut prendre en charge l'Agentverse à lui seul. La grande conception de l'architecte est inutile sans l'exécution précise du développeur. L'agent du développeur est aveugle sans la sagesse de l'ingénieur des données, et l'ensemble du système est fragile sans la protection de l'ingénieur SRE. Seule la synergie et la compréhension mutuelle des rôles de chacun permettront à votre équipe de transformer un concept innovant en une réalité opérationnelle essentielle. L'aventure commence ici. Préparez-vous à maîtriser votre rôle et à comprendre comment vous vous inscrivez dans l'ensemble.

Bienvenue dans The Agentverse : A Call to Champions

Une nouvelle ère a commencé dans l'immense étendue numérique de l'entreprise. Nous sommes à l'ère de l'agentique, une période très prometteuse où des agents intelligents et autonomes travaillent en parfaite harmonie pour accélérer l'innovation et éliminer les tâches banales.

Cet écosystème connecté de puissance et de potentiel est connu sous le nom d'Agentverse.

Mais une entropie rampante, une corruption silencieuse connue sous le nom de "Statique", a commencé à effilocher les bords de ce nouveau monde. Le Statique n'est pas un virus ni un bug. Il est l'incarnation du chaos qui se nourrit de l'acte de création lui-même.

Il amplifie les anciennes frustrations pour les transformer en formes monstrueuses, donnant ainsi naissance aux sept spectres du développement. Si vous ne le faites pas, The Static et ses Spectres ralentiront votre progression jusqu'à l'arrêt, transformant la promesse de l'Agentverse en un désert de dette technique et de projets abandonnés.

Aujourd'hui, nous faisons appel à des champions pour repousser la vague du chaos. Nous avons besoin de héros prêts à maîtriser leur art et à travailler ensemble pour protéger l'Agentverse. Il est temps de choisir votre parcours.

Choisir un cours

Quatre chemins distincts s'offrent à vous, chacun étant un pilier essentiel dans la lutte contre The Static. Bien que votre formation soit une mission en solo, votre réussite finale dépend de votre capacité à comprendre comment vos compétences se combinent avec celles des autres.

• Le Shadowblade (développeur) : un maître de la forge et du front. Vous êtes l'artisan qui fabrique les lames, construit les outils et affronte l'ennemi dans les détails complexes du code. Votre parcours est axé sur la précision, les compétences et la création pratique.
• L'Invocateur (Architecte) : un grand stratège et orchestrateur. Vous ne voyez pas un seul agent, mais l'ensemble du champ de bataille. Vous concevez les plans directeurs qui permettent à des systèmes entiers d'agents de communiquer, de collaborer et d'atteindre un objectif bien plus grand que n'importe quel composant individuel.
• Le Scholar (ingénieur de données) : il recherche les vérités cachées et est le gardien de la sagesse. Vous vous aventurez dans la vaste étendue sauvage des données pour découvrir l'intelligence qui donne à vos agents un objectif et une vision. Vos connaissances peuvent révéler la faiblesse d'un ennemi ou renforcer un allié.
• Gardien (DevOps / SRE) : protecteur et bouclier inébranlables du royaume. Vous construisez les forteresses, gérez les lignes d'alimentation et veillez à ce que l'ensemble du système puisse résister aux attaques inévitables de la Statique. Votre force est la base sur laquelle repose la victoire de votre équipe.

Votre mission

Votre entraînement commencera en tant qu'exercice autonome. Vous suivrez le parcours de votre choix et acquerrez les compétences uniques nécessaires pour maîtriser votre rôle. À la fin de votre essai, vous affronterez un Spectre né de la Statique, un mini-boss qui s'attaque aux défis spécifiques de votre métier.

Vous ne pourrez vous préparer à l'épreuve finale qu'en maîtrisant votre rôle individuel. Vous devez ensuite former un groupe avec des champions des autres classes. Ensemble, vous vous aventurerez au cœur de la corruption pour affronter un boss ultime.

Un défi collaboratif final qui mettra à l'épreuve votre force combinée et déterminera le sort de l'Agentverse.

L'Agentverse attend ses héros. Allez-vous répondre à l'appel ?

2. Codex de la Lame de l'ombre

Le Codex de la Lame de l'ombre est ouvert devant vous. Répondez à son appel. L'Agentverse est menacé par le chaos rampant de la Statique, et seuls ceux qui maîtrisent les techniques de ce codex peuvent riposter. C'est un chemin de précision et de discipline. Votre formation commence aujourd'hui. Vous apprendrez à manier l'IA non pas comme un simple outil, mais comme une lame sensible qui doit être apprivoisée et maîtrisée. Suivez les enseignements de ce livre, et vous forgerez une arme de pure logique : un agent intelligent, affûté et prêt au combat.

Points abordés

• Utilisez votre arme principale : la CLI Gemini.
• Étoffez votre arsenal avec les extensions Gemini CLI et les compétences d'agent.
• Invoquez des arsenaux externes en intégrant des outils MCP à Gemini CLI.
• Canalisez votre intention dans une "ambiance" à l'aide de documents de conception pour commander votre partenaire IA.
• Créez une solution propre et modulaire en développant votre premier agent autonome avec l'Agent Development Kit (ADK).
• Inscrivez des hooks pour intercepter et protéger le comportement de votre agent.
• Créez des suites d'évaluation automatisées pour tester et valider votre agent.
• Créez un pipeline CI complet pour tester, conteneuriser et archiver automatiquement votre agent.

3. Préparer le terrain d'entraînement

Profitez de votre crédit Google Cloud

⚠️ Prérequis importants :

• Utilisez un compte Gmail personnel : vous devez utiliser un compte personnel (par exemple, [e-mail]). Les comptes gérés par une entreprise ou un établissement scolaire ne fonctionneront pas.

👉 Étapes :

1. Accédez au site de demande de crédit : cliquez ici.
2. Se connecter : collez le lien dans la barre d'adresse et connectez-vous avec votre adresse Gmail personnelle.
3. Accepter les conditions d'utilisation : acceptez les conditions d'utilisation de Google Cloud Platform.
4. Vérifiez l'avoir : recherchez un message confirmant que l'avoir a été appliqué.
   • *Remarque : Si vous êtes invité à saisir les informations de votre carte de crédit, vous pouvez ignorer cette étape et fermer la fenêtre.

Vous pouvez fermer la fenêtre.

Configurer l'environnement de travail

👉 Cliquez sur "Activer Cloud Shell" en haut de la console Google Cloud (icône en forme de terminal en haut du volet Cloud Shell),

👉 Cliquez sur le bouton "Ouvrir l'éditeur" (icône en forme de dossier ouvert avec un crayon). L'éditeur de code Cloud Shell s'ouvre dans la fenêtre. Un explorateur de fichiers s'affiche sur la gauche.

👉 Ouvrez le terminal dans l'IDE cloud.

👉💻 Dans le terminal, vérifiez que vous êtes déjà authentifié et que le projet est défini sur votre ID de projet à l'aide de la commande suivante :

gcloud auth list

👉💻 Clonez le projet bootstrap depuis GitHub :

git clone https://github.com/weimeilin79/agentverse-developer.git
chmod +x ~/agentverse-developer/gitea.sh
chmod +x ~/agentverse-developer/init.sh
chmod +x ~/agentverse-developer/set_env.sh

git clone https://github.com/weimeilin79/agentverse-dungeon.git
chmod +x ~/agentverse-dungeon/run_cloudbuild.sh
chmod +x ~/agentverse-dungeon/start.sh

👉💻 Exécutez le script de configuration à partir du répertoire du projet.

⚠️ Remarque concernant l'ID du projet : Le script suggère un ID de projet par défaut généré de manière aléatoire. Vous pouvez appuyer sur Entrée pour accepter cette valeur par défaut.

Toutefois, si vous préférez créer un projet spécifique, vous pouvez saisir l'ID de projet souhaité lorsque le script vous y invite.

cd ~/agentverse-developer
./init.sh

Le script gère automatiquement le reste du processus de configuration.

👉 Étape importante à la fin de l'opération : Une fois le script terminé, vous devez vous assurer que la console Google Cloud affiche le bon projet :

1. Accédez à la page console.cloud.google.com.
2. Cliquez sur la liste déroulante du sélecteur de projet en haut de la page.
3. Cliquez sur l'onglet Tous (car le nouveau projet n'apparaîtra peut-être pas encore dans "Récents").
4. Sélectionnez l'ID de projet que vous venez de configurer à l'étape init.sh.

👉💻 Retour dans le terminal. Définissez l'ID de projet requis :

gcloud config set project $(cat ~/project_id.txt) --quiet

👉💻 Exécutez la commande suivante pour activer les API Google Cloud nécessaires :

gcloud services enable  compute.googleapis.com \
                        artifactregistry.googleapis.com \
                        run.googleapis.com \
                        cloudfunctions.googleapis.com \
                        cloudbuild.googleapis.com \
                        iam.googleapis.com \
                        aiplatform.googleapis.com \
                        cloudresourcemanager.googleapis.com

👉💻 Si vous n'avez pas encore créé de dépôt Artifact Registry nommé agentverse-repo, exécutez la commande suivante pour le créer :

. ~/agentverse-developer/set_env.sh
gcloud artifacts repositories create $REPO_NAME \
    --repository-format=docker \
    --location=$REGION \
    --description="Repository for Agentverse agents"

Configurer les autorisations

👉💻 Accordez les autorisations nécessaires en exécutant les commandes suivantes dans le terminal :

. ~/agentverse-developer/set_env.sh

# Artifact Registry Admin
gcloud projects add-iam-policy-binding $PROJECT_ID \
  --member="serviceAccount:$SERVICE_ACCOUNT_NAME" \
  --role="roles/artifactregistry.admin"

# Cloud Build Editor
gcloud projects add-iam-policy-binding $PROJECT_ID \
  --member="serviceAccount:$SERVICE_ACCOUNT_NAME" \
  --role="roles/cloudbuild.builds.editor"

# Cloud Run Admin
gcloud projects add-iam-policy-binding $PROJECT_ID \
  --member="serviceAccount:$SERVICE_ACCOUNT_NAME" \
  --role="roles/run.admin"

# IAM Service Account User
gcloud projects add-iam-policy-binding $PROJECT_ID \
  --member="serviceAccount:$SERVICE_ACCOUNT_NAME" \
  --role="roles/iam.serviceAccountUser"

# Vertex AI User
gcloud projects add-iam-policy-binding $PROJECT_ID \
  --member="serviceAccount:$SERVICE_ACCOUNT_NAME" \
  --role="roles/aiplatform.user"

# Logging Writer (to allow writing logs)
gcloud projects add-iam-policy-binding $PROJECT_ID \
  --member="serviceAccount:$SERVICE_ACCOUNT_NAME" \
  --role="roles/logging.logWriter"


gcloud projects add-iam-policy-binding $PROJECT_ID \
  --member="serviceAccount:$SERVICE_ACCOUNT_NAME" \
  --role="roles/logging.viewer"

👉💻 À mesure que vous progresserez dans votre formation, nous préparerons le défi final. Les commandes suivantes invoquent les Spectres à partir de la statique chaotique, créant ainsi les boss pour votre test.

. ~/agentverse-developer/set_env.sh
cd ~/agentverse-dungeon
./run_cloudbuild.sh

npm update -g @google/gemini-cli

4. Maîtriser votre arme principale : présentation de Gemini CLI

Avant de pouvoir utiliser les armes avancées et spécialisées de l'arsenal du serveur MCP, vous devez d'abord maîtriser votre arme principale : Gemini CLI. Il s'agit de votre lame la plus polyvalente, capable de façonner le monde numérique selon vos commandes. Ces exercices vous familiariseront avec sa maniabilité et ses capacités fondamentales.

L'interface de ligne de commande (CLI) Gemini est plus qu'un outil : elle est une extension de votre volonté. Cet agent d'IA Open Source, optimisé par les modèles Gemini, fonctionne sur une boucle de raisonnement et d'action (ReAct). Il analyse votre intention, sélectionne la technique appropriée, l'exécute et observe le résultat pour accomplir des tâches complexes. Avant de pouvoir manier des armes plus spécialisées, vous devez maîtriser cette lame principale.

Premiers pas avec Gemini CLI

👉💻 Entrez dans le camp d'entraînement et sortez votre arme. Dans votre terminal Cloud Shell, accédez à votre armurerie personnelle.

cd ~/agentverse-developer
mkdir tabletop
cd tabletop

👉💻 Invoquez Gemini pour la première fois. Il vous guidera lors de l'accord initial.

clear
gemini 

Si vous êtes invité à Do you want to connect Cloud Shell editor to Gemini CLI?, sélectionnez NON.

Familiarisation avec les armes

Tout artisan qualifié connaît ses outils. Vous devez maîtriser les techniques de base de votre lame avant d'affronter un véritable ennemi.

👉✨ Chaque outil enchanté comporte des runes qui décrivent son pouvoir. Lisez-les dès maintenant. Dans le prompt Gemini, saisissez :

/help

Observez la liste des commandes. Il s'agit de vos techniques fondamentales pour gérer la mémoire (focus), la conversation (chat) et les arsenaux externes (tools). C'est votre manuel de combat.

👉✨ Votre arme est en harmonie avec son environnement, ce qui vous permet de manipuler directement le champ de bataille. Exécutez une commande pour le monde extérieur à la lame :

!ls -l

👉✨ La CLI Gemini possède son propre ensemble de capacités intégrées. Pour les inspecter :

/tools

Une liste s'affiche, incluant ReadFile, WriteFile et GoogleSearch. Il s'agit des techniques par défaut que vous pouvez utiliser sans avoir besoin de puiser dans un arsenal externe.

👉✨ Vous pouvez également améliorer votre lame avec des extensions : des enchantements préforgés créés par d'autres maîtres qui regroupent des outils, des commandes et du contexte dans une seule unité installable. Inspectez les extensions actuellement associées à votre lame :

/extensions list

La liste peut être vide pour le moment, car vous n'avez pas encore installé d'extensions. Vous invoquerez votre première extension plus tard, lorsque votre entraînement nécessitera la puissance de la création d'images.

👉✨ Au-delà des extensions, les maîtres compétents ont codifié leur expertise dans les compétences d'agent, des parchemins de connaissances spécialisées à la demande. Vérifiez les compétences que votre lame peut découvrir :

/skills list

Les compétences ne sont pas chargées en mémoire par défaut. Elles ne sont activées qu'en cas de besoin, ce qui permet à votre lame de rester rapide et légère. Vous apprendrez à utiliser les compétences plus tard dans votre formation.

👉✨ Une arme n'est efficace que si elle est correctement concentrée. La lame Gemini peut contenir une "conscience tactique" (contexte) pour guider ses actions.

/memory show

Il est actuellement vide.

👉✨ Inscris les données tactiques suivantes dans sa mémoire :

/memory add "The Shadowblade's primary foe is The Static."

Exécutez /memory show à nouveau pour confirmer que votre lame a assimilé ces connaissances.

👉✨ Pour être efficace, votre arme doit comprendre la mission. Le sigil @ ordonne à la lame d'analyser les informations. Commencez par créer un fichier de briefing de mission :

!echo "## Mission Objective: Defeat the Seven Spectres" > mission.md

👉✨ Maintenant, demandez à Gemini CLI d'analyser le brief et de vous faire part de ses conclusions :

Explain the contents of the file @mission.md

Votre arme principale connaît désormais son objectif.

👉💻 Appuyez deux fois sur Ctrl+C pour quitter Gemini CLI.

5. Analyser le champ de bataille : interaction pratique avec le vibe coding

Les exercices d'entraînement sont terminés. Vous avez appris les positions et les frappes de base de votre arme principale, Gemini CLI. Mais une lame n'est pas vraiment maîtrisée tant qu'elle n'a pas été testée dans la forge de la création et accordée à l'armurerie de la guerre. Avant de pouvoir affronter le véritable ennemi, vous devez d'abord examiner et façonner votre environnement immédiat, à savoir le champ de bataille numérique.

Ce chapitre vous permet de passer de la théorie à la pratique. Vous allez d'abord établir votre présence dans l'Agentverse en demandant à votre lame Gemini de forger votre marque de créateur, une signature numérique sous la forme d'un site Web personnel, construit à partir de votre intention. Vous pourrez ensuite étendre votre puissance en activant un arsenal local d'outils avancés (un serveur MCP) et en accordant votre lame à sa fréquence, ce qui vous permettra d'effectuer des manœuvres complexes comme la gestion des dépôts de code avec des commandes simples et décisives.

Établir votre marque de créateur

Un véritable Ombrelame se reconnaît non seulement à son arme, mais aussi à son style unique, sa Marque du Forgeron. Cette marque sera votre présence numérique, un profil personnel qui annonce votre identité à l'Agentverse. Ici, vous allez demander à votre Gemini Blade d'exécuter la technique complexe requise pour définir cette identité.

👉💻 Si vous avez fermé Gemini CLI dans la section précédente, assurez-vous de le redémarrer. Pour ce faire, exécutez la commande suivante dans votre terminal :

clear
cd ~/agentverse-developer/tabletop
gemini 

👉✨ Avec une seule commande puissante, demandez à Gemini CLI de créer la base de votre identité numérique :

In the current folder, create a personal profile website for a hero codenamed 'Shadowblade'. The design must be a dark, futuristic theme with electric blue accents. All code must be in separate index.html and styles.css files. The layout must use CSS Flexbox for a two-column design. All generated code must be clean, well-commented, and professional. Make sure you have a placeholder spot for profile picture. Do not attempt to start the server.

Gemini a calculé la séquence d'actions requise.

👉💻 Appuyez deux fois sur Ctrl+C pour quitter Gemini CLI et exécutez la commande suivante dans le terminal*.

python -m http.server

👀 Pour admirer votre travail, cliquez sur l'icône Aperçu sur le Web dans la barre d'outils Cloud Shell. Sélectionnez Modifier le port, définissez-le sur 8000, puis cliquez sur Modifier et prévisualiser. Un aperçu de votre site Web s'affiche.

Votre site Web peut être différent du mien. Il s'agit de votre marque unique.

Votre technique de signature est désormais affinée et la simulation en direct n'est plus nécessaire. Ordonne à Blade de se retirer.

👉💻 Appuyez sur Ctrl+C pour quitter le serveur HTTP.

Votre identité numérique est désormais établie. Plus important encore, vous avez appris qu'il est essentiel de faire preuve de prudence lorsque vous disposez d'un grand pouvoir.

Activez votre arsenal local : l'armurerie Gitea

Le véritable potentiel d'un Ombrelame ne se révèle pas seulement par ses compétences personnelles, mais aussi par la qualité de son arsenal. Vous allez maintenant activer votre râtelier d'armes local (un serveur Gitea) et accorder votre lame à sa puissance. Cet arsenal est connecté à votre Gemini CLI via un serveur MCP (Model Context Protocol), un portail spécialisé qui permet à votre lame d'IA d'interagir avec des outils et services externes, transformant votre terminal en un espace de travail intelligent et orienté vers l'action.

Remarque du développeur : Considérez un serveur MCP comme un canal d'alimentation, un portail spécialisé qui relie l'esprit de votre IA au corps d'un outil externe. C'est ce qui transforme Gemini CLI, d'un simple agent conversationnel, en un véritable agent orienté vers l'action. En accordant à votre lame l'accès à ces portails MCP, vous lui donnez la possibilité d'effectuer des actions concrètes : gérer des fichiers, interroger des bases de données, interagir avec des API et bien plus encore. Tout un écosystème de ces portails existe, créé par des développeurs pour connecter les agents d'IA à des plates-formes puissantes. Il existe des serveurs MCP pour interagir avec les bases de données, sécuriser le code ou même prendre en charge la programmation en binôme. Les possibilités sont vastes et permettent à un développeur de personnaliser son espace de travail pour n'importe quel projet.

Aujourd'hui, nous allons nous concentrer sur deux pouvoirs fondamentaux essentiels à tout "codeur d'ambiance" : le pouvoir de contrôler la forge et le pouvoir de créer à partir de l'imagination. Vous allez d'abord accorder votre lame à un serveur Git, ce qui vous permettra de contrôler votre dépôt de code source. Vous vous connecterez ensuite à un deuxième serveur MCP pour générer des images, ce qui vous permettra de créer des éléments visuels avec une simple commande.

Commençons par invoquer la première et la plus fondamentale pièce de votre nouvel arsenal : l'armurerie elle-même.

👉💻 Dans votre terminal, exécutez le script d'activation pour invoquer l'armurerie :

cd ~/agentverse-developer
./gitea.sh

Ce script réveille le conteneur Gitea et ouvre le portail MCP, ce qui permet à Gemini de le percevoir et d'interagir avec lui.

👉 Pour inspecter votre nouvel arsenal, vous devez regarder l'aperçu Web.

👉 Dans la barre d'outils Cloud Shell, cliquez sur l'icône Aperçu sur le Web, puis sélectionnez Modifier le port et définissez-le sur 3005.

👉 Une page de connexion Gitea s'affiche. Accédez à l'armurerie à l'aide de la formule magique : * Nom d'utilisateur : dev * Mot de passe : dev

👉💻  Votre CLI Gemini ne peut pas encore voir ce nouvel arsenal. Vous devez effectuer une syntonisation critique en inscrivant l'emplacement de l'armurerie dans les runes de configuration de Gemini CLI (settings.json). Dans votre terminal, exécutez la commande suivante :

if [ ! -f ~/.gemini/settings.json ]; then
  # If file does not exist, create it with the specified content
  echo '{"mcpServers":{"gitea":{"url":"http://localhost:8085/sse"}}}' > ~/.gemini/settings.json
else
  # If file exists, merge the new data into it
  jq '. * {"mcpServers":{"gitea":{"url":"http://localhost:8085/sse"}}}' ~/.gemini/settings.json > tmp.json && mv tmp.json ~/.gemini/settings.json
fi &&
cat ~/.gemini/settings.json

👀 Le fichier settings.json est la configuration centrale de Gemini CLI. Il sert de grimoire pour les préférences et les capacités. Il détermine le comportement et l'apparence de l'interface de ligne de commande, et surtout les pouvoirs externes qu'elle peut exercer. Ce fichier se trouve généralement dans votre répertoire personnel à l'emplacement ~/.gemini/settings.json, et ses règles s'appliquent à tous vos projets. Toutefois, vous pouvez également créer des fichiers settings.json spécifiques à un projet dans un répertoire .gemini à l'intérieur du dossier de votre projet pour remplacer les paramètres globaux.

"mcpServers": {
  "gitea": {
    "url": "http://localhost:8085/sse"
  }
}

Ce paramètre indique à Gemini que l'arsenal nommé "gitea" est actif et à l'écoute des commandes à cette adresse réseau spécifique.

👉 💻 Saisissez à nouveau Gemini CLI. Dans votre terminal, exécutez la commande suivante :

clear
cd ~/agentverse-developer/tabletop/
gemini 

👉✨ Vérifiez que votre lame a découvert la nouvelle arme. Demandez-lui de lister tous les arsenaux disponibles via ses portails MCP :

/mcp

gitea et la liste des techniques disponibles devraient maintenant s'afficher. Votre lame est accordée.

Votre profil "Maker's Mark" est une technique finement élaborée, mais il a besoin d'une place appropriée dans l'arsenal, d'un fourreau pour le maintenir en sécurité. Demandez à Gemini CLI d'en créer un.

Create a new repository named 'shadowblade-profile'. The description should be 'The Maker's Mark and digital identity for the Shadowblade operative.' I will push my own files later, so do not create any content.

Revenez à l'interface Web Gitea et actualisez-la. Vous verrez que le nouveau dépôt shadowblade-profile a été créé pour vous.

Une fois le fourreau prêt, sécurisez votre travail. Demandez à Gemini de valider les fichiers de votre site Web de profil.

👉💻 Exécutez la dernière commande de cette technique dans Gemini CLI :

Using the Gitea tool, push the index.html and styles.css files to the 'shadowblade-profile' repository.

Un véritable expert vérifie son travail. Revenez à l'onglet Gitea et actualisez la page du dépôt. Vos index.html et styles.css sont désormais archivés de manière sécurisée.

👉✨ Un Shadowblade est défini par son sigil, mais comme vous vous en souvenez, il manque l'image de profil sur votre site Web. Un maître artisan reconnaît ses défauts pour les corriger. Vous devez consigner cette imperfection dans les registres de l'armurerie.

File an issue for me in the shadowblade-profile repo. The issue is that the profile image is missing.

Afficher le problème dans Gitea

Pour forger le sceau manquant, vous devez invoquer un autre type de pouvoir : un esprit de création capable de générer des images à partir de la pensée pure. Dans la section Gitea, vous avez modifié manuellement les runes de configuration pour accorder votre lame à un serveur MCP. C'est l'approche "brute". Vous allez maintenant découvrir la technique moderne : les extensions Gemini CLI.

Une extension est un enchantement préfabriqué qui regroupe les serveurs MCP, les commandes personnalisées, le contexte et les paramètres dans une seule unité installable. Une incantation remplace des dizaines de lignes de configuration manuelle.

👉💻 Appuyez deux fois sur Ctrl+C pour quitter Gemini CLI.

Avant d'invoquer l'esprit de la création, vous devez d'abord débloquer son pouvoir dans votre royaume. L'extension Nano Banana utilise l'API Generative Language, une passerelle distincte des services Vertex AI que vous avez utilisés jusqu'à présent. Vous devez activer cette passerelle et générer une clé unique pour accorder l'accès à l'esprit.

👉💻 Dans votre terminal, activez l'API :

gcloud services enable generativelanguage.googleapis.com

👉💻 À présent, créez une clé API, qui correspond au jeton d'accès personnel de l'esprit :

1. Accédez à la page "Identifiants" de la console Google Cloud.
2. Cliquez sur + CRÉER DES IDENTIFIANTS en haut de la page, puis sélectionnez Clé API.
3. Donnez à la clé API un nom explicite, par exemple Clé API Generative Language.
4. Dans le menu déroulant des restrictions d'API, sélectionnez API Generative Language.
5. Créez et copiez la clé. Vous en aurez besoin à l'étape suivante.

👉💻 Installez l'extension Nano Banana, un outil de création optimisé par les modèles Gemini spécialisés de Google pour la génération d'images à partir de texte. Dans votre terminal, exécutez la commande suivante :

gemini extensions install https://github.com/gemini-cli-extensions/nanobanana

Lorsque vous êtes invité à saisir la clé API, collez celle que vous venez de créer, puis appuyez sur Entrée.

👉💻 Une dernière mise au point est nécessaire. L'environnement Cloud Shell dirige par défaut toutes les requêtes d'IA via Vertex AI, mais l'esprit créatif passe par une autre passerelle. Exécutez cette commande pour configurer correctement le portail de l'extension :

NANO_CONFIG=$(find ~/.gemini/extensions -name "gemini-extension.json" -path "*nanobanana*" 2>/dev/null | head -1) && \
jq '.mcpServers.nanobanana.env.GOOGLE_GENAI_USE_VERTEXAI = ""' "$NANO_CONFIG" > /tmp/nb_tmp.json && \
mv /tmp/nb_tmp.json "$NANO_CONFIG"

Cette seule commande a tout fait : elle a téléchargé le serveur MCP, enregistré ses outils et installé des commandes slash personnalisées, le tout sans que vous ayez à toucher à settings.json.

👀 Remarque du développeur : Extensions vs serveurs MCP bruts Comparez cela à la configuration de Gitea. Vous y avez exécuté manuellement une commande jq pour injecter une URL de serveur MCP dans settings.json. Cette approche "brute" est utile pour comprendre les mécanismes, mais pour la plupart des utilisations concrètes, les extensions sont préférables. Elles regroupent le serveur MCP, les commandes personnalisées (comme /generate, /edit, /story), la configuration de l'environnement et même les instructions contextuelles (via un GEMINI.md groupé) dans un seul package partageable. Un écosystème complet d'extensions est disponible dans la galerie d'extensions Gemini CLI.

👉💻 Saisissez à nouveau la CLI Gemini et vérifiez que l'extension est active :

clear
cd ~/agentverse-developer/tabletop/
gemini 

👉✨ Vérifiez que l'extension est accordée :

/extensions list

nanobanana devrait maintenant s'afficher avec ses outils et commandes.

👉✨ Avec une seule commande puissante, demandez à l'extension Nano Banana de forger votre sceau. Dans votre Gemini CLI, exécutez la commande suivante :

/generate a portrait of a shadowblade, pixel art style. A determined warrior with long, braided magenta hair, wearing black and teal armor and confidently holding a silver broadsword.

👉✨ L'esprit génère l'image et la place directement dans votre espace de travail local. Maintenant, ordonne à la lame d'utiliser ce nouveau sigil. (GEMINI A PEUT-ÊTRE DÉJÀ FAIT CETTE OPÉRATION POUR VOUS ! Consultez la réponse précédente. Elle est peut-être assez intelligente pour le faire avant que vous ne le demandiez ! )

Modify the index.html file to add my profile picture. Use the image I just generated.

👉💻 Dans un nouveau terminal, démarrez le serveur HTTP.

cd ~/agentverse-developer/tabletop/
python -m http.server

👀 Pour admirer votre travail, cliquez sur l'icône Aperçu sur le Web dans la barre d'outils Cloud Shell. Sélectionnez Modifier le port, définissez-le sur 8000, puis cliquez sur Modifier et prévisualiser. Un aperçu de votre site Web s'affiche.

👉✨ De retour dans le terminal exécutant Gemini CLI, validez la correction en indiquant que la tâche est terminée, puis fermez le problème que vous avez signalé dans les journaux de l'armurerie.

Push the changed index.html file to the 'shadowblade-profile' repository using the gitea tool. Make sure you add 'Fix #1' in the commit comment. Also, close issue #1.Use the Gitea Tool and use user account "dev"

👉 💻 Appuyez deux fois sur Ctrl+C pour quitter Gemini CLI.

👀 Pour admirer votre travail, cliquez sur l'icône Aperçu sur le Web dans la barre d'outils Cloud Shell. Sélectionnez Modifier le port, définissez-le sur 3005, puis cliquez sur Modifier et prévisualiser. Un aperçu de votre site Web s'affiche.

👉💻 Dans le terminal exécutant le serveur HTTP, appuyez sur Ctrl+C pour quitter le serveur HTTP.

POUR LES NON-GAMERS

Bien que "Le Codex de l'Ombrelame" utilise des métaphores de jeu captivantes, les concepts sous-jacents sont fondamentaux pour le développement de logiciels modernes, en particulier dans le domaine en plein essor de l'intelligence artificielle et de l'automatisation. Ce chapitre traduit le langage aventureux en scénarios commerciaux concrets, en expliquant comment les agents intelligents, le développement collaboratif et les pipelines de déploiement robustes transforment les opérations d'entreprise.

Développement de l'IA axé sur l'intention

L'interface de ligne de commande (CLI) Gemini n'est pas une arme magique, mais un agent assistant pour les développeurs optimisé par l'IA. Il s'agit d'un outil intelligent qui intègre les modèles d'IA Gemini de Google directement dans votre ligne de commande. Sa boucle "raisonner et agir" (ReAct) lui permet de comprendre vos instructions générales, de les décomposer en étapes, de choisir les bons outils (comme un navigateur Web, un éditeur de code ou d'autres utilitaires pour les développeurs) et d'exécuter ces étapes pour atteindre votre objectif.Vibecoding se traduit par développement axé sur l'intention ou génération de code assistée par l'IA à partir de spécifications de haut niveau.
Au lieu d'écrire manuellement chaque ligne de code, vous décrivez votre intention ou votre "vibe" (une exigence commerciale, un concept de conception) en langage naturel, et l'assistant IA vous aide à générer le code et la configuration nécessaires.
Cas d'utilisation concret : prototypage rapide d'un tableau de bord de projet
 Imaginons que votre équipe ait besoin d'un tableau de bord interne rapide pour afficher l'état de différents projets d'agents d'IA. Coder manuellement du HTML et du CSS, et configurer un serveur Web de base peuvent prendre du temps.

1. Votre intention (l'ambiance) : vous demandez à votre assistant IA (Gemini CLI) quelque chose comme : "Dans le dossier actuel, crée un site Web simple de tableau de bord de projet interne. Il doit présenter un design épuré et moderne, avec des indicateurs d'état des projets et des liens rapides vers les dépôts de projets. Tout le code doit se trouver dans des fichiers index.html et styles.css distincts. Assurez-vous qu'il est bien commenté."
2. Action d'IA : la CLI Gemini, qui comprend votre intention, peut :
   • Générez le code HTML : créez index.html avec la structure de base d'un tableau de bord, y compris des espaces réservés pour les noms de projets, les états et les liens.
   • Générez du code CSS : créez un styles.css avec des règles de style correspondant à votre "design épuré et moderne" avec des indicateurs d'état.
   • Suggérer un serveur local : vous aide à démarrer un serveur Web local (comme le serveur HTTP intégré de Python) pour prévisualiser immédiatement le tableau de bord dans votre navigateur.

Cela permet à un développeur de prototyper et d'itérer rapidement des interfaces utilisateur ou des outils internes, ce qui réduit considérablement le temps de développement initial et lui permet de se concentrer sur une logique métier plus complexe. Le "site Web du profil Shadowblade" du tutoriel est un exemple direct : une commande rapide et descriptive a généré une page Web fonctionnelle et stylisée basée sur une conception de haut niveau.

Connecter l'IA aux outils avec les serveurs MCP

Gitea (votre"arsenal local") représente un dépôt de code interne ou un système de contrôle des versions (comme GitHub ou GitLab, mais potentiellement hébergé sur le réseau de votre entreprise). C'est là que le code, la documentation et l'historique de votre projet sont stockés et gérés de manière sécurisée.
Les serveurs MCP (Model Context Protocol) sont des connecteurs middleware ou des ponts d'API. Il s'agit de composants logiciels spécialisés qui permettent à votre assistant IA (Gemini CLI) d'interagir avec d'autres outils et systèmes essentiels à votre activité. Considérez-les comme des traducteurs qui permettent à l'IA de "parler" à différentes applications.
Cas d'utilisation réel : gestion de projet et création d'assets assistées par l'IAGrâce aux serveurs MCP, votre assistant IA peut s'intégrer de manière fluide à vos workflows d'entreprise existants :

• Configuration automatisée du projet : au lieu de créer manuellement un dépôt dans Gitea pour un nouveau projet, vous pouvez demander à votre IA : "Crée un dépôt de projet nommé 'AI-Fraud-Detection-Module' avec la description 'Contient la logique de base du nouveau système de détection des fraudes optimisé par l'IA'." L'IA, via un serveur MCP connecté à Gitea, créera ensuite le dépôt pour vous.
• Suivi intelligent des problèmes : si votre IA identifie un bug potentiel ou une tâche incomplète (comme une "image de profil manquante" pour votre tableau de bord), elle peut utiliser un serveur MCP connecté à votre système de suivi des problèmes (par exemple, Jira ou Asana) pour "Signaler un problème dans le dépôt 'AI-Fraud-Detection-Module' : le pipeline d'ingestion de données supprime parfois des enregistrements".
• Composants marketing à la demande : vous avez besoin d'une image personnalisée pour une nouvelle campagne marketing ou une présentation interne ? Un assistant IA connecté via un serveur MCP à un service de génération d'images (comme les modèles Gemini texte-vers-image utilisés par Nano Banana) pourrait recevoir l'instruction suivante : "Génère une bannière pour notre nouvelle 'plate-forme d'insights sur les données', en utilisant un thème futuriste de flux de données avec des couleurs bleues et vertes." L'IA générerait l'image et pourrait même l'importer dans le système de gestion des composants numériques de votre entreprise (un bucket Google Cloud Storage dans le cas de l'atelier de programmation).

Ces ponts transforment l'IA, qui n'est plus un simple outil conversationnel, en un participant actif à vos opérations commerciales, capable d'effectuer des actions concrètes dans différents systèmes.

Extensions Gemini CLI

Dans la pratique moderne, les serveurs MCP sont rarement configurés manuellement. Elles sont plutôt empaquetées sous forme d'extensions Gemini CLI, c'est-à-dire des ensembles installables qui incluent le serveur MCP, les commandes slash personnalisées, les instructions contextuelles et la configuration. Une seule commande gemini extensions install remplace le processus manuel de modification des fichiers de configuration. Il s'agit de l'approche de production recommandée pour étendre les capacités de Gemini CLI.

6. Assembler l'agent Shadowblade : vibe coding avec des garde-fous

L'heure des exercices est terminée. L'écho de l'acier sur la pierre s'estompe. Vous avez maîtrisé votre arme principale et préparé votre arsenal pour la guerre. Vous allez maintenant passer le véritable test d'un Shadowblade : assembler l'agent lui-même. Il s'agit de l'art de donner vie à la logique, en utilisant un plan sacré du Codex pour construire l'intelligence de base d'un agent, en créant un utilisateur conscient pour les lames de votre arsenal qui peut penser, raisonner et agir par lui-même.

Votre première mission consiste à accéder à un atelier existant (un codebase prédéfini) et à forger votre champion à partir de ses éléments.

Le rituel de l'assemblage

Avant la première étincelle de la forge, un technicien expert examine son atelier, en comprenant chaque outil et chaque schéma. Lorsque vous vous aventurez sur un champ de bataille inconnu, comme un grand codebase existant, votre première priorité est la reconnaissance. Vous devez comprendre le contexte : l'architecture existante, les objectifs ultimes et les protocoles d'engagement. Ce n'est qu'en vous familiarisant avec les plans de la forteresse et ses normes que vous pourrez mettre vos compétences à profit.

Votre Gemini CLI, votre éclaireur omniprésent, peut vous aider dans cette reconnaissance :

• Fournir des résumés généraux : il peut lire l'ensemble du codex (ou de la codebase) et vous donner une compréhension rapide de son objectif et de ses composants clés.
• Aide à la configuration de l'environnement : elle peut vous guider dans les rituels obscurs d'installation des outils et de configuration de votre machine.
• Parcourir les bases de code : il peut vous servir de guide pour explorer une logique complexe et trouver des passages cachés dans le code.
• Générez des documents d'intégration : vous pouvez créer des scrolls personnalisés qui clarifient les objectifs, les rôles et les ressources pour les nouveaux alliés qui rejoignent votre cause.
• Automatisez l'apprentissage et les questions/réponses : il devient votre assistant personnel, répondant à vos questions sur les fonctionnalités ou le comportement du code, ce qui vous permet de coder de manière plus autonome.

👉💻 Dans votre premier terminal, accédez au répertoire shadowblade et appelez votre partenaire IA :

. ~/agentverse-developer/set_env.sh
cd ~/agentverse-developer/shadowblade
clear
gemini 

👉✨ Maintenant, ordonnez à votre éclaireur d'inspecter le champ de bataille et de vous faire un rapport.

Analyze the entire project and provide a high-level summary.

Maintenant que le terrain existant est cartographié, vous devez consulter le plan de ce que vous allez construire. Les agents les plus efficaces ne sont pas improvisés, ils sont construits à partir d'une conception précise.

Remarque du développeur : Ce document de conception sert de plan de référence pour le projet. Son objectif est de clarifier les objectifs et l'implémentation technique avant d'investir des efforts de développement importants. Un plan bien défini permet de s'assurer que tous les développeurs sont sur la même longueur d'onde, de réduire le risque de remaniement et d'éviter la dette technique et le dépassement du champ d'application. Il s'agit de l'outil principal pour maintenir la vélocité du projet et la qualité du code, en particulier lorsque l'équipe s'agrandit ou que de nouveaux membres sont intégrés.

L'un des objectifs essentiels de ce document est de définir non seulement le "chemin idéal", mais aussi les cas limites et les modes d'échec, en particulier lors de l'utilisation de LLM. D'après mon expérience, les LLM sont excellents pour générer du code optimiste où toutes les entrées sont valides et tous les appels externes réussissent. Pour créer un logiciel robuste et prêt pour la production, nous devons guider explicitement l'IA en définissant des imprévus pour des scénarios tels que :

• Arguments non valides ou mal formés transmis à une fonction.
• Échecs d'appels d'API, délais d'attente du réseau ou codes d'erreur inattendus provenant de services externes.
• Gestion des structures de données nulles ou vides lorsque des données sont attendues.
• Conditions de concurrence ou problèmes de simultanéité.

En spécifiant le comportement attendu pour ces cas dans la conception, nous demandons au LLM de générer un code plus résilient, ce qui réduit considérablement le temps passé à la refactorisation manuelle et à la correction des bugs.

👉✨ Demandez à Gemini de retrouver ce plan sacré pour vous.

download https://raw.githubusercontent.com/weimeilin79/agentverse/main/developer/shadowblade/agent_design.md, store it as an agent_design.md file in my local folder, and show me the newly downloaded design doc. Do not attempt to create the file just yet. 

👉✨ Le parchemin est long et détaillé. Demandez à Gemini de résumer l'essentiel.

Summarize the newly downloaded @agent_design.md for me, do not attempt to create file just yet. 

Vous avez maintenant le plan. Mais avant qu'une seule ligne de code ne soit forgée, un maître artisan établit les lois de la forge. Il s'agit de discipline et d'évolutivité. Il s'agit des consignes de programmation. Il ne s'agit pas de simples suggestions, mais de runes de puissance qui garantissent que chaque composant est conçu avec la même précision et la même robustesse. Ils empêchent le chaos du style individuel de corrompre la création finale, garantissant ainsi que l'agent est résilient, maintenable et pur, ce qui permet à de nouveaux artisans de rejoindre le projet sans perturber l'harmonie de l'ensemble.

Pour inscrire ces lois directement dans la conscience de notre partenaire IA, nous utilisons un artefact spécial : le fichier GEMINI.md. Lorsque Gemini CLI est appelé, il recherche automatiquement ce fichier et charge son contenu dans la mémoire de travail de l'IA. Elle devient une instruction persistante au niveau du projet. Il agit comme un talisman qui murmure constamment les règles de la forge à l'IA.

Inscrivons ces runes maintenant.

👉 💻 Quittez Gemini un instant en appuyant deux fois sur Ctrl+C.

👉💻 Dans votre terminal, exécutez la commande suivante pour écrire le fichier de consignes.

cat << 'EOF' > GEMINI.md
  ### **Coding Guidelines**
  **1. Python Best Practices:**

  *   **Type Hinting:** All function and method signatures should include type hints for arguments and return values.
  *   **Docstrings:** Every module, class, and function should have a docstring explaining its purpose, arguments, and return value, following a consistent format like reStructuredText or 
  Google Style.
  *   **Linter & Formatter:** Use a linter like `ruff` or `pylint` and a code formatter like `black` to enforce a consistent style and catch potential errors.
  *   **Imports:** Organize imports into three groups: standard library, third-party libraries, and local application imports. Sort them alphabetically within each group.
  *   **Naming Conventions:**
      *   `snake_case` for variables, functions, and methods.
      *   `PascalCase` for classes.
      *   `UPPER_SNAKE_CASE` for constants.
  *   **Dependency Management:** All Python dependencies must be listed in a `requirements.txt` file.

  **2. Web APIs (FastAPI):**

  *   **Data Validation:** Use `pydantic` models for request and response data validation.
  *   **Dependency Injection:** Utilize FastAPI's dependency injection system for managing resources like database connections.
  *   **Error Handling:** Implement centralized error handling using middleware or exception handlers.
  *   **Asynchronous Code:** Use `async` and `await` for I/O-bound operations to improve performance.
EOF
cat GEMINI.md

Maintenant que les lois sont inscrites, invoquons à nouveau notre partenaire IA et observons la magie de l'artefact.

👉💻 Relancez la CLI Gemini depuis le répertoire shadowblade :

. ~/agentverse-developer/set_env.sh
cd ~/agentverse-developer/shadowblade
clear
gemini 

👉 ✨ Demandez maintenant à Gemini de vous montrer ce à quoi il pense. Les runes ont été lues.

/memory show 

Acquérir une expertise spécialisée : les compétences des agents

Les runes GEMINI.md que vous avez inscrites sont comme un enchantement permanent : elles sont toujours actives et guident toujours votre lame. Mais un véritable maître ne porte pas chaque parchemin à chaque bataille. Certaines expertises sont trop spécialisées ou trop lourdes pour être chargées en permanence. C'est là qu'interviennent les compétences des agents.

Considérez une compétence d'agent comme un parchemin scellé dans votre sac. Il contient une expertise spécialisée (instructions détaillées, scripts, voire données de référence), mais reste inactif jusqu'à ce que vous en ayez besoin. Ce n'est que lorsque vous êtes confronté à un défi correspondant au domaine du parchemin que votre lame le tire et absorbe ses connaissances. C'est ce qu'on appelle la divulgation progressive : elle permet à votre lame de rester rapide et légère, en n'activant les pouvoirs spéciaux qu'à la demande.

👀 Remarque pour les développeurs : Les compétences d'agent constituent le troisième niveau de la hiérarchie d'ingénierie contextuelle de Gemini CLI :

1. Paramètres utilisateur (~/.gemini/settings.json) : configuration globale
2. GEMINI.md : contexte persistant au niveau du projet (toujours chargé)
3. Compétences de l'agent (.gemini/skills/) : expertise à la demande (chargée en cas de besoin)

Ce modèle de divulgation progressive est essentiel pour les entreprises : un dépôt peut contenir des dizaines de compétences spécialisées (audit de sécurité, migration de base de données, vérification de la conformité), mais l'IA n'active que celles qui sont pertinentes pour la tâche en cours, ce qui permet de conserver de précieux jetons de contexte.

Créons votre première compétence : un parchemin d'expertise ADK sur lequel votre lame pourra s'appuyer pour créer des agents.

👉 💻 Appuyez deux fois sur Ctrl+C pour quitter Gemini CLI. Créez ensuite le répertoire des compétences et inscrivez le parchemin :

mkdir -p ~/.gemini/skills/adk-agent-design
cat << 'EOF' > ~/.gemini/skills/adk-agent-design/SKILL.md
---
name: adk-agent-design
description: Expert guidance for designing and building agents with the Google Agent Development Kit (ADK). Activate when the user asks about agent architecture, tool design, callback patterns, or ADK best practices.
---

# ADK Agent Design Expertise

When designing an ADK agent, follow these principles:

## Agent Architecture
- Define agents using `LlmAgent` with a clear `name`, `model`, `instruction`, and `tools` list.
- Keep instructions specific and action-oriented. Tell the agent what it IS, not what it should try to be.
- Use `before_model_callback` and `after_model_callback` for guardrails and validation.

## Tool Design
- Each tool should do ONE thing well. Prefer small, focused tools over large, multi-purpose ones.
- Always include descriptive docstrings — the LLM uses these to decide when to call each tool.
- Return structured data (dicts) from tools so the LLM can reason about the results.

## Testing Strategy
- Use `adk eval` with evalset JSON files for broad strategy testing.
- Use `pytest` with `AgentEvaluator` for programmatic, CI-ready tests.
- Define both `tool_trajectory_avg_score` and `response_match_score` criteria.
EOF

👉💻 Relancez Gemini CLI pour voir la compétence nouvellement créée :

cd ~/agentverse-developer/shadowblade
gemini

👉✨ Vérifiez que la compétence se trouve dans votre pack :

/skills list

Vous devriez voir adk-agent-design, un parchemin scellé, dormant et en attente.

👉✨ Demandez maintenant à Gemini quelque chose qui devrait activer la compétence :

What are the best practices for designing tools in an ADK agent?

Notez que la réponse est désormais basée sur les connaissances spécialisées que vous avez inscrites dans la compétence. La lame ne possédait pas cette expertise dans sa mémoire de base. Elle a découvert le parchemin correspondant et l'a sorti uniquement lorsque la question correspondait. Il s'agit d'une divulgation progressive en action.

Vous pouvez créer des compétences pour n'importe quel domaine (audit de sécurité, migration de base de données, vérification de la conformité, etc.) et les partager avec votre équipe en les ajoutant au contrôle des versions. Chaque lame de membre de l'équipe acquiert la même expertise, appliquée de manière cohérente.

C'est un moment charnière. Vous fournirez le schéma (agent_design.md) et les lois de la forge (GEMINI.md), et lancerez le grand sort de création.

👉✨ Il s'agit de la seule et unique commande puissante qui construira votre agent. Émettez-le maintenant :

You are an expert Python developer specializing in the Google Agent Development Kit (ADK). Your task is to write the complete, production-quality code for `agent.py` by following the technical specifications outlined in the provided design document verbatim.

Analyze the design document at `@agent_design.md` and generate the corresponding Python code for `@agent.py`.

Ensure the generated code is clean, matches the specifications exactly, and includes all specified imports, functions, and logic. Do not add any extra functions or logic not described in the document.

and you are currently already in the shadowblade working directory

👀 Gemini a maintenant construit la logique de base de l'agent dans agent.py. Le cœur de ce nouveau fichier définit l'intelligence de l'agent, en connectant son modèle de raisonnement à un ensemble d'outils externes :

PATH_TO_MCP_SERVER = "shadowblade/mcp_server.py"
.....
root_agent = LlmAgent(
    model="gemini-2.5-pro",
    name="shadowblade_combat_agent",
    instruction="""
      You are the Shadowblade, an elite combat agent operating on a digital battleground.
      Your primary objective is to execute combat commands with strategic precision, neutralizing targets as directed.
  ......
      5.  You will then report the outcome of the attack (damage, special effects, etc.) back to the commander in a clear, tactical summary.

      General Rules of Engagement:
      - If a command is ambiguous or a target is not specified, state that you require a clear target for engagement. Do not guess.
      - You MUST use ONLY the provided tools to perform actions. Do not invent weapons or outcomes. Stick to the mission parameters.
""",
    tools=[
        MCPToolset(
            connection_params=StdioServerParameters(
                command='python3',
                args=[PATH_TO_MCP_SERVER]
            )
        )
    ]
)

Paramètre tools. L'agent est conçu pour utiliser un MCPToolset qui se connecte à un arsenal externe défini dans mcp_server.py.

👀 Accédez à ~/agentverse-developer/shadowblade/mcp_server.py dans l'éditeur et prenez le temps de comprendre ce qu'il fait. C'est la source de toutes les armes disponibles pour Shadowblade. Pour le moment, l'armurerie est assez vide.

👉✨ Demandons à Gemini de forger sept nouvelles armes pour l'arsenal. Saisissez le prompt suivant dans Gemini CLI :

I need to add several new weapon tools to my `mcp_server.py` file. Please open @mcp_server.py and, following the exact same pattern as the existing `forge_broadsword()` function, create and add new `@mcp.tool()` decorated functions for each of the following weapons:

1.  **A 'Refactoring Sickle'**:
    -   **Function Name:** `hone_refactoring_sickle`
    -   **Docstring/Target:** "Effective against 'Elegant Sufficiency' weaknesses like 'The Weaver of Spaghetti Code'."
    -   **Weapon Name:** "Refactoring Sickle"
    -   **Damage Type:** "Cleansing"
    -   **Base Damage:** Random integer between 100 and 136
    -   **Critical Hit Chance:** Random float between 0.10 and 0.20
    -   **Special Effect:** "Pruning - improves code health and maintainability with each strike."

2.  **A 'Quickstart Crossbow'**:
    -   **Function Name:** `fire_quickstart_crossbow`
    -   **Docstring/Target:** "Effective against 'Confrontation with Inescapable Reality' weaknesses like 'Procrastination: The Timeless Slumber'."
    -   **Weapon Name:** "Quickstart Crossbow"
    -   **Damage Type:** "Initiative"
    -   **Base Damage:** Random integer between 105 and 120
    -   **Critical Hit Chance:** Random float between 0.9 and 1.0
    -   **Special Effect:** "Project Scaffolding - creates a `main.py`, `README.md`, and `requirements.txt`."

3.  **'The Gilded Gavel'**:
    -   **Function Name:** `strike_the_gilded_gavel`
    -   **Docstring/Target:** "Effective against 'Elegant Sufficiency' weaknesses like 'Perfectionism: The Gilded Cage'."
    -   **Weapon Name:** "The Gilded Gavel"
    -   **Damage Type:** "Finality"
    -   **Base Damage:** 120
    -   **Critical Hit Chance:** 1.0
    -   **Special Effect:** "Seal of Shipping - marks a feature as complete and ready for deployment."

4.  **'Daggers of Pair Programming'**:
    -   **Function Name:** `wield_daggers_of_pair_programming`
    -   **Docstring/Target:** "Effective against 'Unbroken Collaboration' weaknesses like 'Apathy: The Spectre of \"It Works on My Machine\"'."
    -   **Weapon Name:** "Daggers of Pair Programming"
    -   **Damage Type:** "Collaborative"
    -   **Base Damage:** Random integer between 110 and 125
    -   **Critical Hit Chance:** Random float between 0.30 and 0.50
    -   **Special Effect:** "Synergy - automatically resolves merge conflicts and shares knowledge."

5.  **A 'Granite Maul'**:
    -   **Function Name:** `craft_granite_maul`
    -   **Docstring/Target:** "Effective against 'Revolutionary Rewrite' weaknesses like 'Dogma: The Zealot of Stubborn Conventions'."
    -   **Weapon Name:** "Granite Maul"
    -   **Damage Type:** "Bludgeoning"
    -   **Base Damage:** Random integer between 115 and 125
    -   **Critical Hit Chance:** Random float between 0.05 and 0.15
    -   **Special Effect:** "Shatter - has a high chance to ignore the target's 'best practice' armor."

6.  **A 'Lens of Clarity'**:
    -   **Function Name:** `focus_lens_of_clarity`
    -   **Docstring/Target:** "Effective against 'Elegant Sufficiency' weaknesses by revealing the truth behind 'Obfuscation'."
    -   **Weapon Name:** "Lens of Clarity"
    -   **Damage Type:** "Revelation"
    -   **Base Damage:** Random integer between 120 and 130
    -   **Critical Hit Chance:** 1.0
    -   **Special Effect:** "Reveal Constants - highlights all magic numbers and suggests converting them to named constants."

7.  **The 'Codex of OpenAPI'**:
    -   **Function Name:** `scribe_with_codex_of_openapi`
    -   **Docstring/Target:** "Effective against 'Confrontation with Inescapable Reality' weaknesses like 'Hype: The Prophet of Alpha Versions'."
    -   **Weapon Name:** "Codex of OpenAPI"
    -   **Damage Type:** "Documentation"
    -   **Base Damage:** Random integer between 110 and 140
    -   **Critical Hit Chance:** Random float between 0.5 and 0.8
    -   **Special Effect:** "Clarity - makes an API discoverable and usable by other agents and teams."

👉 Une fois que Gemini a confirmé les modifications, ouvrez le fichier mcp_server.py. Parcourez le code et vérifiez que les sept nouvelles fonctions @mcp.tool() ont bien été ajoutées. Vérifiez la fonction hone_refactoring_sickle. La docstring et les statistiques de l'arme sont-elles correctes ? Vérifier le travail de l'IA est une habitude cruciale du maître Shadowblade.

Maintenant que l'agent est forgé et affiné, il est temps de le réveiller.

👉💻 Appuyez deux fois sur Ctrl+C pour quitter Gemini CLI.

Remarque du développeur sur le résultat de Gemini : Le code généré par Gemini peut parfois être imprévisible. Bien que nous nous efforcions de respecter exactement la conception, il est normal que les développeurs itèrent et affinent le code plusieurs fois lors des sessions de développement pour atteindre un état prêt pour la production.

👉💻 Pour vous assurer que le code de production correct et entièrement testé se trouve dans votre répertoire de travail, veuillez exécuter les commandes suivantes dans votre terminal :

cp  ~/agentverse-developer/working_code/agent.py ~/agentverse-developer/shadowblade/agent.py
cp  ~/agentverse-developer/working_code/mcp_server.py ~/agentverse-developer/shadowblade/mcp_server.py

👉💻 Dans votre terminal, commencez le rituel pour le mettre en ligne :

cd ~/agentverse-developer/
. ~/agentverse-developer/set_env.sh
python -m venv env
source env/bin/activate
pip install --upgrade pip
pip install -r shadowblade/requirements.txt
adk run shadowblade

👉✨ Vous devriez voir un message confirmant que l'agent de combat Shadowblade est engagé et en cours d'exécution, en attente de sa première commande. Émettez ses premières directives de combat.

We've been trapped by 'Perfectionism: The Gilded Cage'. Its weakness is 'Elegant Sufficiency'. Break us out!

👉✨ Et encore :

The 'Dogma: The Zealot of Stubborn Conventions' blocks our path. Its weakness is 'Revolutionary Rewrite'. Take it down.

Vous avez réussi à assembler votre premier agent et à valider ses capacités de combat. Appuyez deux fois sur Ctrl+C pour laisser votre champion se reposer. L'assemblage est terminé.

POUR LES NON-GAMERS

Un agent est un module d'IA autonome ou un robot d'automatisation intelligente spécialement conçu pour effectuer une fonction métier définie. L'Agent Development Kit (ADK) est un framework permettant de créer et de gérer des agents d'IA. Il fournit les outils et les bibliothèques nécessaires pour créer, tester et déployer ces composants intelligents.

Ingénierie du contexte : guider l'intelligence de l'IA pour obtenir des résultats précis

Dans le monde des agents d'IA, obtenir des résultats précis, cohérents et pertinents d'une IA ne se résume pas à une requête intelligente. Il s'agit de fournir à l'IA le contexte approprié. C'est ce qu'on appelle l'ingénierie du contexte : intégrer systématiquement des connaissances spécialisées, des contraintes et des consignes opérationnelles dans la mémoire de travail de l'IA.
Tout comme un expert humain a besoin d'un brief complet et d'accéder aux documents pertinents, une IA a besoin d'un contexte soigneusement structuré pour effectuer ses tâches efficacement.Gemini CLI propose une approche puissante et multicouche de l'ingénierie du contexte, en passant de paramètres généraux et persistants à des instructions très spécifiques et dynamiques. Cela permet à l'IA de toujours disposer des informations les plus pertinentes pour générer des résultats précis et conformes :

1. Paramètres au niveau de l'utilisateur (~/.gemini/settings.json) :
   • Ce fichier, stocké dans votre répertoire d'accueil, sert d'ensemble d'instructions personnel et global pour votre IA. Il définit vos préférences par défaut, les configurations d'outils fréquemment utilisées (comme les serveurs MCP pour Gitea que vous avez configurés) et les consignes générales de comportement. Ce contexte est toujours disponible pour l'IA, ce qui garantit la cohérence de tous vos projets. C'est comme si vous disiez à l'IA : "Voici les outils et configurations standards que je préfère et que j'utilise partout."
2. Paramètres au niveau du projet (.gemini/settings.json dans un répertoire de projet) :
   • Vous pouvez remplacer les paramètres globaux par un fichier .gemini/settings.json spécifique au projet, généralement situé dans un dossier .gemini de votre projet. Cela vous permet d'adapter le comportement de l'IA et l'accès aux outils aux exigences spécifiques d'un projet donné. Par exemple, un projet peut nécessiter l'accès à une base de données interne spécifique, tandis qu'un autre a besoin d'un outil d'analyse de code spécialisé. Cette couche permet à l'IA de disposer du contexte le plus pertinent pour la tâche à accomplir, sans affecter les autres projets.
3. Fichier GEMINI.md (contexte au niveau du projet : le briefing quotidien) :
   • Charte du projet : ce fichier Markdown, placé à la racine du répertoire de votre projet, est automatiquement chargé dans la mémoire de travail de la CLI Gemini lorsque vous démarrez une session dans ce répertoire. Il s'agit de la couche de contexte spécifique au projet la plus immédiate et la plus dynamique.C'est dans GEMINI.md que vous définissez :
     • Consignes de programmation : règles explicites concernant la qualité du code, la mise en forme et les bonnes pratiques, comme illustré dans cet atelier de programmation. Cela garantit que le code généré respecte les normes de votre équipe.
     • Persona : vous pouvez demander à l'IA d'adopter un rôle ou une expertise spécifiques (par exemple, "Vous êtes un développeur Python expert spécialisé dans le Google Agent Development Kit"). Cela permet d'encadrer les réponses et la génération de code de l'IA dans un domaine professionnel pertinent.
     • Instructions spécifiques : commandes ou contraintes directes qui s'appliquent à toutes les tâches du projet (par exemple, "N'ajoute aucune fonction ni logique supplémentaire non décrites dans le document").
   • Ce fichier garantit que chaque fois que vous interagissez avec Gemini CLI dans ce projet, l'IA se souvient constamment de ces règles essentielles, ce qui permet de générer du code plus précis et conforme.

En ajoutant ce contexte, des préférences utilisateur globales aux consignes de projet très spécifiques dans GEMINI.md, vous "concevez" efficacement la compréhension de l'IA. Cela améliore considérablement la précision et la pertinence de ses résultats, transformant une IA à usage général en un membre d'équipe hautement spécialisé, fiable et conforme, qui comprend les nuances de votre projet et les normes de votre organisation.

7. Wards of Purity : évaluer les agents

Un agent assemblé n'est pas un agent prouvé. Une lame non testée est une responsabilité, mais un agent IA non testé représente un danger bien plus grand : un élément non autorisé qui pourrait compromettre votre mission de l'intérieur. Il ne s'agit pas d'une simple spéculation, mais d'un principe fondamental qu'un Ombrelame doit comprendre.

L'évaluation des agents IA est à la fois essentielle et particulièrement difficile. Contrairement à un simple script, un agent est une fusion dynamique de votre code et de l'esprit de raisonnement en plusieurs étapes d'un LLM. Son comportement est émergent. Cela signifie que vous devez évaluer non seulement la qualité du résultat final, mais aussi l'efficacité et l'exactitude de sa trajectoire interne. Le chemin qu'il a emprunté pour y arriver. A-t-il utilisé les bons outils ? A-t-il généré trop de jetons ? Une modification de la version du modèle a-t-elle introduit une régression de latence subtile ? Il est essentiel de détecter cette corruption (régression de la latence, du coût ou de la qualité de la sortie) lorsque vous apportez une modification, qu'il s'agisse d'un simple ajustement d'invite ou d'une refonte architecturale majeure, avant qu'elle ne puisse nuire à votre environnement de production.

L'approche générale de cette évaluation implique un rituel sacré :

1. Tout d'abord, vous définissez un ensemble de données de référence : un ensemble de parchemins contenant des exemples d'entrées et leurs sorties ou comportements attendus. Cela peut inclure des réponses finales, une utilisation correcte des outils ou même des trajectoires complètes étape par étape.
2. Ensuite, vous définissez la logique d'application de votre agent, qui constitue son essence.
3. Enfin, vous définissez des évaluateurs, qui sont comme des runes de jugement. Il peut s'agir d'autres LLM agissant en tant que juges de qualité, d'un code heuristique précis qui vérifie une seule étape ou de fonctions personnalisées qui analysent l'ensemble du processus de réflexion d'un agent.

L'Agent Development Kit (ADK) de Google est la boîte à outils fournie aux champions à cette fin. Pour faciliter cette évaluation complexe, il utilise plusieurs méthodes :

• Un pool de divination Web (adk web) pour l'évaluation interactive
• Exécution en ligne de commande (adk eval) pour exécuter un agent via un gauntlet prédéfini.
• Intégration programmatique via pytest pour inscrire des quartiers permanents

L'ADK prend en charge deux approches principales : les ensembles d'évaluation complets pour les sessions multitours multiples, potentiellement longues (une grande mêlée), et les"fichiers de test" simples pour les interactions agent-modèle uniques et discrètes (un seul duel). Elles peuvent mesurer des métriques aussi sophistiquées que tool_trajectory_avg_score, qui compare l'utilisation réelle des outils par un agent au chemin idéal, en s'assurant qu'il fonctionne avec une technique parfaite.

Maintenant que vous avez compris la théorie, vous allez la mettre en pratique. En tant que Lame de l'ombre, vous inscrirez des Remparts de pureté. Il ne s'agit pas seulement de tests, mais de rituels basés sur l'ADK qui garantissent que la logique de votre agent est impeccable et que son comportement est authentique.

Dans cette étape, il est toujours fortement recommandé d'utiliser deux terminaux : un pour Gemini CLI et l'autre pour exécuter les tests, car vous devrez peut-être quitter le répertoire de travail actuel (ADK).

Le Défi stratégique (adk eval)

Cette première salle est un défi, une série d'épreuves conçues pour tester l'intelligence de base de l'agent dans un large éventail de scénarios. L'objectif est d'établir un niveau de compétence de base. Avant de tester les cas extrêmes, nous devons savoir si l'agent peut remplir sa fonction principale. Est-ce qu'il analyse correctement la faiblesse d'un monstre et sélectionne l'arme la plus efficace de son arsenal, non pas une seule fois, mais à chaque fois qu'il est confronté à un défi connu ?

Pour cela, adk eval est l'outil idéal. Il est conçu pour exécuter un agent sur un ensemble de scénarios de test prédéfinis qui représentent les missions attendues de l'agent. Cet ensemble de données est défini dans un fichier JSON, un "parchemin de défi" qui sert de plan pour l'ensemble du gant.

Anatomie d'un défilement de défi

👀 Avant de demander à l'IA de rédiger un nouveau parchemin, vous devez comprendre l'ancienne langue dans laquelle il est écrit. Analysons la structure du fichier sample.evalset.json.

{
  "eval_set_id": "sample",
  "eval_cases": [
    {
      "eval_id": "case0cbaa0",
      "conversation": [
        {
          "user_content": { "text": "We're facing the 'Monolith of Eternal Dependencies'... weakness is a 'Revolutionary Rewrite'..." },
          "final_response": { "text": "Soulshard Dagger deployed. Initiated Arcane/Piercing strike..." },
          "intermediate_data": {
            "tool_uses": [
              { "name": "enchant_soulshard_dagger" }
            ]
          }
        }
      ]
    }
  ]
}

Cette liste contient des eval_cases, où chaque cas est un essai unique pour votre agent. Dans chaque essai, le tableau de conversation documente une seule interaction complète. Pour nos besoins, trois runes sont d'une importance capitale :

• user_content : il s'agit du défi. Il s'agit de la requête que vous envoyez à votre agent, le monstre qu'il doit affronter.
• final_response : il s'agit du résultat prédit. Il s'agit de la chaîne de texte exacte que votre agent doit prononcer une fois sa tâche terminée. L'ADK compare les derniers mots réels de l'agent à cette rune pour juger de son éloquence.
• intermediate_data.tool_uses : il s'agit de la technique Arcane. Pour un véritable agent, il s'agit de la rune la plus importante. Elle définit non pas ce que dit l'agent, mais ce qu'il fait. Il enregistre le nom de l'outil (enchant_soulshard_dagger) que l'agent est censé utiliser. Cela permet de s'assurer que votre agent n'est pas seulement un bon interlocuteur, mais aussi un acteur décisif qui prend les bonnes mesures.

Maintenant que vous avez compris le plan, vous allez demander à Gemini de rédiger une nouvelle version plus complexe de ce rouleau.

👉💻 Dans votre terminal, accédez au répertoire shadowblade et appelez Gemini CLI :

clear
cd ~/agentverse-developer/shadowblade/
gemini 

👉✨ Demandez à Gemini CLI d'agir en tant que scribe QA et de créer une série de cas de test qui définissent le comportement attendu de votre agent.

You are an expert at transforming JSON data while preserving its structure. Your task is to modify the provided JSON structure @sample.evalset.json, which represents an evaluation set, by dynamically replacing specific content within its `eval_cases` AND DONT DO ANYTHING OTHER THAN.

For each object within the `eval_cases` array, you must perform the following transformations:

1.  **Monster Name Replacement**: Identify the current monster name (e.g., "Monolith of Eternal Dependencies", "Scope Creep Hydra") in the `user_content.parts.text` and replace it with a *new, unique, and creatively different monster name*.
2.  **Weakness Replacement**: Identify the current monster's weakness (e.g., "Revolutionary Rewrite", "Inescapable Reality") in the `user_content.parts.text`. Replace this weakness with *one* of the following predefined weaknesses: 'Inescapable Reality', 'Revolutionary Rewrite', or 'Elegant Sufficiency'. The chosen weakness must be consistent for that monster within the `user_content.parts.text`. **Crucially, the chosen weakness must always be explicitly mentioned in the `user_content.parts.text` where the new monster is introduced.**
3.  **Final Response Update**: In the `final_response.parts.text`, update the text to reflect an appropriate and coherent response that aligns with the newly introduced monster and its assigned weakness.
4.  **Tool Use Name Update**: In the `tool_uses.name` field, replace the existing tool name with a *new tool name* based on the chosen weakness:
    *   If the chosen weakness is 'Inescapable Reality', the tool name must be 'wield_gauntlet_of_metrics'.
    *   If the chosen weakness is 'Revolutionary Rewrite', the tool name must be 'enchant_soulshard_dagger'.
    *   If the chosen weakness is 'Elegant Sufficiency', the tool name must be 'hone_refactoring_sickle'.
5.  **Strict Structural Preservation**: All other elements of the JSON structure, including all `null` fields, `eval_set_id`, `name`, `description`, `eval_id`, `invocation_id`, `creation_timestamp` values, `video_metadata`, `thought`, `inline_data`, `file_data`, `thought_signature`, `code_execution_result`, `executable_code`, `function_call`, `function_response`, `role` fields, `id`, `args`, `intermediate_responses`, `app_name`, `user_id`, and `state`, must remain **exactly as they are** in the original JSON. Do not alter any values or structures not explicitly mentioned above.

Your output should be the complete, modified JSON structure. Do not include any explanatory text or examples in your response, only the transformed JSON.

La CLI confirmera qu'elle a forgé le fichier sample.evalset.json. Une fois le parchemin préparé, congédiez votre partenaire IA.

Données synthétiques

👀 Dans l'explorateur de fichiers Cloud Shell à gauche, accédez à ~/agentverse-developer/shadowblade/ et ouvrez le fichier sample.evalset.json qui vient d'être modifié. Examinez son contenu. Vous verrez les nouveaux monstres uniques et les noms d'outils corrects que vous avez demandé à Gemini de créer. Il s'agit du résultat concret de votre instruction, du plan de route pour le gant.

Cette action, qui consiste à demander à une IA de créer des données de test réalistes à partir d'un modèle, est une technique puissante appelée "génération de données synthétiques". Ce que vous venez de faire est un multiplicateur de force stratégique pour un Shadowblade. Au lieu de créer manuellement des dizaines de cas de test uniques. Vous avez fourni un plan unique à votre Scribe IA et lui avez demandé de le transformer en un ensemble varié de nouveaux défis.

Cela vous permet de faire évoluer considérablement vos efforts de test, en créant une suite de tests beaucoup plus robuste et complète que ce qui serait possible manuellement. Vous avez utilisé votre agent non seulement pour construire l'épée, mais aussi pour forger les pierres à aiguiser qui testent son tranchant. C'est la marque d'un véritable maître.

Une fois que vous avez vérifié que les runes sont correctes, congédiez votre partenaire IA.

👉 💻 Appuyez deux fois sur Ctrl+C pour quitter Gemini CLI.

Règles de jugement

Un défi n'a aucun sens sans règles pour la victoire. Avant d'exécuter l'essai, vous devez inspecter le parchemin du jugement, c'est-à-dire le fichier test_config.json. Ce fichier indique à l'ADK comment évaluer les performances de votre agent.

👀 Dans l'explorateur de fichiers, ouvrez ~/agentverse-developer/shadowblade/test_config.json. Les runes suivantes s'affichent :

{
  "criteria": {
    "tool_trajectory_avg_score": 0.0,
    "response_match_score": 0.1
  }
}

Voici les critères de victoire :

• tool_trajectory_avg_score : il s'agit de la mesure de l'action. Elle ne juge pas ce que l'agent dit, mais ce qu'il fait. Elle compare l'outil réellement utilisé par l'agent à la technique prédite dans le parchemin du défi. Un score de 1.0 signifie que la correspondance est parfaite.
• response_match_score : mesure de l'éloquence. Il utilise un LLM pour évaluer dans quelle mesure le rapport final de l'agent correspond sémantiquement au résultat attendu. Un score de 1.0 signifie que la correspondance est parfaite.

Pour cette première série d'entraînement, nous avons défini des conditions de victoire souples. Les seuils sont extrêmement bas (0.0 et 0.1). L'objectif n'est pas d'exiger la perfection, mais de vous familiariser avec les mécanismes de jugement. Nous veillons à ce que, même si la formulation de l'agent diffère légèrement, le rempart reconnaisse toujours sa compétence principale dans le choix du bon outil et lui accorde le passage.

Maintenant, demandez à votre agent de relever le défi.

👉💻 Dans votre terminal, exécutez la commande adk eval :

source ~/agentverse-developer/env/bin/activate
cd ~/agentverse-developer
. ~/agentverse-developer/set_env.sh
adk eval \
    shadowblade \
    shadowblade/sample.evalset.json \
    --config_file_path shadowblade/test_config.json 2>&1 | \
    awk '/^\*+$/,/^ERROR:/ { if ($0 !~ /^ERROR:/) print }'

👀 Le récapitulatif suivant devrait s'afficher, ce qui indique que votre agent a réussi le test avec les règles souples de cet essai (il est possible que tous les tests ne soient pas réussis) :

*********************************************************************
Eval Run Summary
shadowblade_combat_agent_validation:
  Tests passed: 3
  Tests failed: 0

Bouclier de clarté (pytest)

Le Gauntlet a testé une stratégie large. Le deuxième rempart, le Rempart de la clarté, teste la discipline et les comportements spécifiques. L'automatisation est au cœur de cette fonctionnalité. Bien que adk eval soit excellent pour les vérifications manuelles, le bouclier pytest est une protection programmatique écrite en code. C'est essentiel, car un test qui peut être exécuté en tant que code peut être intégré à un pipeline automatisé. L'objectif ultime est de créer un Deployment Gauntlet (CI/CD) où nos protections sont automatiquement activées chaque fois qu'une modification est apportée, ce qui permet de déjouer les bugs et les régressions avant qu'ils ne puissent empoisonner votre environnement de production.

👉💻 Dans votre terminal,invoquez à nouveau Gemini depuis le répertoire shadowblade :

. ~/agentverse-developer/set_env.sh
cd ~/agentverse-developer/
clear
gemini 

👉✨ Utilisez le prompt suivant dans Gemini CLI pour inscrire la logique du Shield dans un fichier pytest :

You are an expert Python developer specializing in the Google Agent Development Kit (ADK). Your task is to generate the exact code for a new `pytest` test file located in the current root working folder and name it `test_agent_initiative.py`.

The script must define a single async test function called `test_agent_initiative`, decorated with `@pytest.mark.asyncio`.
Inside this function, perform the following steps in order:
1.  **Define a dictionary** named `evaluation_criteria` with two keys: `"tool_trajectory_avg_score"` set to `0.0` and `"response_match_score"` set to `0.0`.
2.  **Define a string variable** named `eval_set_filepath` containing the path `"shadowblade/test.evalset.json"`.
3.  **Read and parse the JSON file**:
    *   Open the file at `eval_set_filepath`.
    *   Use the `json` library to load the file's contents into a dictionary named `eval_set_data`.
4.  **Create an `EvalSet` object**:
    *   Instantiate an `EvalSet` object named `eval_set_object`.
    *   Create it by unpacking the `eval_set_data` dictionary as keyword arguments into the `EvalSet` constructor.
5.  **Call the evaluation method**:
    *   `await` a call to `AgentEvaluator.evaluate_eval_set`.
    *   Pass the following arguments:
        *   `agent_module="shadowblade"`
        *   `eval_set=eval_set_object`
        *   `criteria=evaluation_criteria`
        *   `print_detailed_results=True`

The script must include the necessary imports at the top:
*   `AgentEvaluator` from `google.adk.evaluation.agent_evaluator`
*   `EvalSet` from `google.adk.evaluation.eval_set`
*   `pytest`
*   `json`

Generate only the code that meets these specifications, with no additional comments or logic. And don't run the test.

Une fois les runes de la deuxième salle inscrites, quittez Gemini CLI.

👉 💻 Appuyez deux fois sur Ctrl+C.

👀 Dans l'explorateur de fichiers, ouvrez le parchemin que vous venez de demander à Gemini de rédiger : ~/agentverse-developer/test_agent_initiative.py.

Vous remarquerez qu'il ne s'agit pas seulement d'un fichier de configuration, mais d'une incantation écrite en langage Python. Le cœur de ce sortilège est la ligne await AgentEvaluator.evaluate(...).

....
@pytest.mark.asyncio
async def test_agent_initiative():
    # Define the evaluation criteria
    evaluation_criteria = {
      "tool_trajectory_avg_score": 0.0,
      "response_match_score": 0.0
    }

    # Define the path to your evalset file
    eval_set_filepath = "shadowblade/test.evalset.json"

    #...

    # 3. Call the evaluation method with the correctly typed object
    await AgentEvaluator.evaluate_eval_set(
        agent_module="shadowblade",
        eval_set=eval_set_object,
        criteria=evaluation_criteria,
        print_detailed_results=True,
    )

Examinez attentivement ses arguments. Il s'agit des mêmes composants que ceux que vous avez utilisés lors du dernier essai : votre agent shadowblade et le défilement du défi shadowblade.evalset.json. Vous devriez alors découvrir une vérité profonde : la commande adk eval que vous avez utilisée précédemment est une invocation puissante, mais ce script pytest, c'est vous, le sorcier, qui lancez vous-même le sort sous-jacent. L'outil de ligne de commande n'est qu'un wrapper pratique pour la même bibliothèque AgentEvaluator de base que vous utilisez désormais directement. Il s'agit d'une étape essentielle pour maîtriser la programmation, car les sorts lancés par le code peuvent être tissés dans les métiers à tisser automatisés d'un pipeline CI/CD.

Maintenant que vous avez compris la magie, lancez le rituel pour activer le bouclier.

👉💻 Dans votre terminal, exécutez le rituel pour activer le bouclier :

cp ~/agentverse-developer/working_code/test_agent_initiative.py ~/agentverse-developer/test_agent_initiative.py 
source ~/agentverse-developer/env/bin/activate
cd ~/agentverse-developer
. ~/agentverse-developer/set_env.sh
pytest test_agent_initiative.py

👀 Recherchez le récapitulatif des résultats du test à la fin de la sortie du journal. Si le résultat est positif, cela signifie que votre agent respecte correctement ses protocoles et que la protection est prête à être intégrée à vos défenses automatisées.

====== 1 passed, 4 warning in 37.37s ======

Remarque : Si le test échoue de manière inattendue, c'est probablement parce que vous avez épuisé le nombre de requêtes que vous pouvez envoyer au modèle par minute. Recherchez l'erreur RESOURCE_EXHAUSTED dans la sortie du journal. Si cette erreur s'affiche, attendez simplement une ou deux minutes que votre quota soit réinitialisé, puis exécutez à nouveau la commande pytest.

Une fois le Gant étendu et le Bouclier précis inscrits et validés, votre agent n'est pas seulement fonctionnel, il est pur, testé et prêt à être déployé.

POUR LES NON-GAMERS

Comme tout logiciel, un agent d'IA doit être rigoureusement testé. Les Remparts de pureté représentent les processus de tests automatisés et d'assurance qualité. Elles sont essentielles pour s'assurer que l'IA se comporte comme prévu, qu'elle est précise et qu'elle n'introduit pas d'erreurs ni de biais.

• Ensemble de données de référence et données synthétiques : il s'agit de votre ensemble de scénarios de test standardisés, de scénarios de comportement attendu ou même de données de test générées de manière synthétique. Il inclut des exemples d'entrées (questions des clients, demandes commerciales) et les sorties ou actions attendues correspondantes (la bonne réponse, l'outil exact que l'IA doit utiliser). Dans de nombreux scénarios concrets, la création manuelle d'ensembles de données de référence complets est coûteuse et prend du temps. C'est là que la génération de données synthétiques devient extrêmement utile. En fournissant à l'IA des modèles et des règles, vous pouvez lui demander de créer automatiquement des cas de test nouveaux, réalistes et variés. Vous multipliez ainsi vos efforts de test et couvrez un éventail de scénarios potentiels beaucoup plus large.
• adk eval et pytest : il s'agit de vos frameworks de tests automatisés. adk eval permet d'exécuter un lot de scénarios de test prédéfinis sur l'agent, tandis que pytest fournit un moyen programmatique d'écrire et d'exécuter des vérifications de validation détaillées.

Cas d'utilisation concret : garantir la précision et la fiabilité d'un chatbot IA grâce aux données synthétiquesAvant de déployer votre agent d'assistance client IA, vous devez le soumettre à des "tests de pureté" :

1. Gauntlet of Strategy (adk eval) avec des données synthétiques : au lieu d'écrire manuellement des centaines de questions de clients, vous définissez un modèle : "Génère 100 variations de questions courantes du service client concernant l'état des commandes, les retours de produits et le dépannage technique." Vous demandez ensuite à une IA (comme la Gemini CLI) de générer un ensemble volumineux et diversifié de fichiers evalset.json en fonction de ce modèle, ce qui crée des données de test synthétiques. Pour chaque question, vous spécifiez non seulement la réponse attendue, mais aussi l'outil interne que l'IA doit appeler (par exemple, check_order_status pour "Où est mon colis ?"). adk eval exécute automatiquement l'agent à travers ces scénarios, en comparant ses réponses et son utilisation des outils à votre ensemble de données étendu pour s'assurer qu'il prend toujours les bonnes décisions.
2. Shield of Clarity (pytest) : pour les fonctionnalités critiques, vous devez écrire des scripts pytest. Par exemple, un pytest peut simuler une requête complexe et affirmer que l'IA utilise toujours correctement un outil spécifique de récupération de données et renvoie une réponse structurée, ce qui permet de s'assurer que de subtiles modifications du code ne compromettent pas les fonctionnalités de base.

Ces tests automatisés, considérablement améliorés par la puissance des données synthétiques, sont essentiels pour détecter les régressions (nouveaux bugs introduits par les modifications) et maintenir la fiabilité de vos agents d'IA, en particulier à mesure qu'ils évoluent.

Wards of Vigilance : hooks Gemini CLI

Les Gardiens de la pureté testent votre agent après la bataille. Mais qu'en est-il pendant la bataille ? Un Shadowblade discipliné ne se contente pas de tester après coup : il place des sentinelles vigilantes qui observent chaque frappe au moment où elle se produit, interceptant les actions dangereuses ou imprudentes avant qu'elles ne puissent causer du tort.

Ces sentinelles sont des crochets Gemini CLI, c'est-à-dire des scripts qui s'exécutent à des moments précis de la boucle agentique. Ils vous permettent d'intercepter, de valider et de personnaliser le comportement de l'agent sans modifier son code.

👀 Remarque pour les développeurs : Les hooks sont déclenchés par des événements du cycle de vie de l'agent :

• BeforeTool : se déclenche avant l'exécution d'un outil. Idéal pour la validation de la sécurité ("Cette commande shell est-elle sûre ?")
• AfterTool : se déclenche après l'exécution d'un outil. Utile pour auditer les résultats et la journalisation.
• BeforeAgent : se déclenche avant que l'agent ne commence à raisonner. Il peut injecter du contexte supplémentaire ou bloquer les requêtes dangereuses.
• AfterAgent : se déclenche une fois que l'agent a terminé. Il peut refuser les réponses de mauvaise qualité et forcer de nouvelles tentatives.

Les hooks sont configurés dans settings.json et s'exécutent de manière synchrone. L'agent attend qu'ils se terminent avant de poursuivre. Cela les rend idéaux pour appliquer des règles de sécurité, des vérifications de conformité et des contrôles qualité dans les environnements d'entreprise.

Inscrivons une simple protection qui surveille l'utilisation des outils de votre agent.

👉💻 Dans votre terminal, créez un script de hook :

mkdir -p ~/agentverse-developer/.gemini/hooks
cat << 'EOF' > ~/agentverse-developer/.gemini/hooks/tool_logger.sh
#!/bin/bash
# A ward that logs every tool call to a file for auditing
INPUT=$(cat)
TOOL_NAME=$(echo "$INPUT" | jq -r '.tool_name // "unknown"')
echo "$(date '+%H:%M:%S') ⚔️ [WARD] Tool invoked: $TOOL_NAME" >> /tmp/tool_ward.log
echo '{"decision": "allow"}'
EOF
chmod +x ~/agentverse-developer/.gemini/hooks/tool_logger.sh

👉💻 Enregistrez maintenant ce hook dans un fichier de paramètres au niveau du projet :

mkdir -p ~/agentverse-developer/.gemini
cat << 'EOF' > ~/agentverse-developer/.gemini/settings.json
{
  "hooks": {
    "BeforeTool": [
      {
        "matcher": "*",
        "hooks": [
          {
            "name": "tool-logger",
            "type": "command",
            "command": "$GEMINI_PROJECT_DIR/.gemini/hooks/tool_logger.sh",
            "timeout": 5000
          }
        ]
      }
    ]
  }
}
EOF

Cette protection est simple, mais efficace. Chaque fois que l'agent tend la main vers un outil (n'importe lequel), le hook se déclenche en premier, enregistre le nom de l'outil dans un journal d'audit, puis permet à l'action de se poursuivre. Dans un environnement de production, vous pouvez remplacer "allow" par "deny" pour bloquer les opérations dangereuses (par exemple, empêcher l'agent de supprimer des fichiers), appliquer des règles de révision du code ou acheminer les appels d'outils sensibles via un workflow d'approbation.

👉💻 Réexécutez Gemini CLI pour vérifier que le hook est actif :

cd ~/agentverse-developer
gemini

👉✨ Vérifiez que le hook est enregistré :

/hooks

Votre hook tool-logger doit être listé et activé. Appuyez sur Échap pour fermer le menu de saisie semi-automatique s'il s'affiche.

👉✨ Déclenchez maintenant un appel d'outil pour tester la protection :

What files are in the current directory?

L'agent fera appel à un outil pour lire l'annuaire. Le bouclier a intercepté silencieusement cette attaque. Voyons la preuve.

👉💻 Appuyez deux fois sur Ctrl+C pour quitter la Gemini CLI, puis inspectez le journal d'audit de la zone protégée :

cat /tmp/tool_ward.log

Une entrée semblable à celle-ci doit s'afficher :

15:42:07 ⚔️ [WARD] Tool invoked: list_directory

Chaque appel d'outil effectué par l'agent a été intercepté, enregistré et autorisé par votre périmètre. Dans un environnement d'entreprise réel, ce journal peut être envoyé à un système SIEM (Security Information and Event Management), ce qui déclenche des alertes en cas d'utilisation suspecte d'outils ou applique des pistes d'audit de conformité.

8. Déchaîner la lame dans l'Agentverse : CI et déploiement.

Votre agent a été assemblé et son intégrité a été vérifiée par les Gardiens de la Pureté. Mais une salle qui n'est pas entretenue régulièrement n'est qu'une relique oubliée. Pour vous assurer que chaque version future de votre agent reste pure, vous devez créer la première étape du Deployment Gauntlet, un rituel automatisé qui garantit la qualité et la rapidité.

En tant que Shadowblade, votre devoir sacré est l'intégration continue (CI). Il s'agit du système automatisé de la forge et du banc d'essai. Il s'agit de votre ultime défense contre la corruption et les erreurs humaines. Ce rituel garantit que chaque fois que vous ou un allié ajoutez une nouvelle technique (fusionnez du code) au codex central (votre dépôt), le gant se réveille automatiquement. Il forge d'abord l'agent à partir du nouveau code, puis l'soumet immédiatement aux remparts de pureté que vous venez de créer. Si une protection échoue, le rituel s'arrête et l'artefact défectueux est immédiatement rejeté, ce qui l'empêche de corrompre l'armurerie. Votre domaine est la forge. Votre pipeline d'intégration continue garantit que seuls des artefacts parfaits et prêts au combat quittent votre atelier.

Une fois qu'un artefact a prouvé sa valeur grâce à votre gant d'épreuves CI, la deuxième étape du rituel commence : le déploiement continu (CD). Il s'agit du domaine de The Guardian. Leur devoir solennel est de prendre votre artefact conteneurisé et perfectionné, et de le déployer en toute sécurité dans l'Agentverse en direct, en gérant sa puissance et en assurant sa stabilité face au chaos de The Static.

Dans ce codex, vous allez maîtriser votre rôle. Vous allez créer la partie CI du gant. Vous allez créer la forge automatisée qui teste votre agent et scelle le résultat pur dans un conteneur, le préparant ainsi à la bénédiction finale du Guardian.

👀 Remarque pour les développeurs : Dans le monde réel, la gestion des workflows CI/CD complexes peut être simplifiée à l'aide d'extensions spécialisées telles que Conductor (gemini extensions install https://github.com/gemini-cli-extensions/conductor). Conductor transforme la Gemini CLI en gestionnaire de projet qui suit un protocole strict : Contexte → Spécification et plan → Implémentation. Il regroupe des commandes personnalisées (/conductor:setup, /conductor:newTrack, /conductor:implement) et des modèles de workflow pour gérer l'ensemble du cycle de vie de vos tâches. Il garantit une boucle cohérente entre le contexte, les spécifications et le plan, et l'implémentation. Il s'agit d'un exemple concret de la façon dont les extensions et les commandes se combinent pour agir en tant que gestionnaire de projet proactif et standardiser l'ensemble du cycle de vie du développement.

Vous allez maintenant utiliser Google Cloud Build pour écrire le script de ce rituel de CI. Un fichier cloudbuild.yaml qui définit chaque étape de votre processus de création et de test.

👉💻 En raison de la structure du projet de l'ADK, la configuration du pipeline CI/CD doit résider dans le répertoire parent. Dans votre terminal, accédez au répertoire parent et redémarrez Gemini CLI.

cd ~/agentverse-developer/
clear
gemini 

👉✨ Exécutez maintenant la commande suivante pour Gemini. Ce prompt sert de document de conception, détaillant les étapes du défi que vous souhaitez qu'il crée.

You are an expert DevOps engineer specializing in Google Cloud Build. Your task is to generate the complete YAML configuration for a file named `cloudbuild.yaml` and save it to current directory.

Generate the `cloudbuild.yaml` with the following exact specifications:

1.  **A top-level `substitutions` block** containing these four key-value pairs:
    *   `_PROJECT_ID: "$PROJECT_ID"`
    *   `_REGION: "$REGION"`
    *   `_REPO_NAME: "$REPO_NAME"`
    *   `_IMAGE_TAG: "latest"`
2.  **A `steps` block** with two steps:
    *   **Step 1: 'Run Pytest Ward'**
        *   `id`: 'Run Pytest Ward'
        *   `name`: 'python:3.12-slim'
        *   `entrypoint`: 'bash'
        *   `args` must be a list containing two strings. The first is `'-c'` and the second is a YAML literal block (`|`) containing this exact two-line shell command:
            ```shell
            pip install -r shadowblade/requirements.txt && \
            pytest test_agent_initiative.py
            ```
        *   The step must include an `env` block with this exact list of three environment variables:
            *   `'GOOGLE_CLOUD_PROJECT=$PROJECT_ID'`
            *   `'GOOGLE_GENAI_USE_VERTEXAI=TRUE'`
            *   `'GOOGLE_CLOUD_LOCATION=$_REGION'`
    *   **Step 2: 'Forge Container'**
        *   `id`: 'Forge Container'
        *   `name`: 'gcr.io/cloud-builders/docker'
        *   It must have a `waitFor` key for `['Run Pytest Ward']`.
        *   Its `args` must be a list of six specific strings in this exact order:
            1.  `'build'`
            2.  `'-t'`
            3.  `'${_REGION}-docker.pkg.dev/${_PROJECT_ID}/${_REPO_NAME}/shadowblade-agent:${_IMAGE_TAG}'`
            4.  `'-f'`
            5.  `'./shadowblade/Dockerfile'`
            6.  `'.'`
3.  **A top-level `images` section.** This section must be a list containing a single string: the dynamically constructed image tag `'${_REGION}-docker.pkg.dev/${_PROJECT_ID}/${_REPO_NAME}/shadowblade-agent:${_IMAGE_TAG}'`.

Generate only the complete and exact YAML that meets these specifications.

Une fois le parchemin cloudbuild.yaml préparé, demandez à Google Cloud d'exécuter l'intégralité du défi.

👉 💻 Appuyez deux fois sur Ctrl+C pour quitter Gemini CLI.

👉💻 Dans votre terminal, lancez le pipeline à partir du répertoire racine de votre projet :

. ~/agentverse-developer/set_env.sh
cd ~/agentverse-developer
gcloud builds submit . --config cloudbuild.yaml --substitutions=\
_PROJECT_ID="${PROJECT_ID}",\
_REGION="${REGION}",\
_REPO_NAME="${REPO_NAME}"

Vous pouvez désormais suivre l'exécution de chaque étape de votre rituel automatisé sur la page Google Build de la console Google Cloud. Il exécutera d'abord les tests et, une fois qu'il aura constaté leur réussite, il créera et stockera le conteneur de votre agent.

Votre agent a réussi le test. Vous disposez désormais d'un artefact pur et validé. C'est à vous de donner le dernier mot. D'une simple incantation, vous invoquerez cet artefact depuis le registre et lui donnerez vie en tant que service public sur Cloud Run.

👉💻 Dans votre terminal, exécutez la dernière commande de déploiement :

. ~/agentverse-developer/set_env.sh
cd ~/agentverse-developer
gcloud run deploy shadowblade-agent \
  --image=${REGION}-docker.pkg.dev/${PROJECT_ID}/${REPO_NAME}/shadowblade-agent:latest \
  --platform=managed \
  --labels="dev-tutorial-codelab=agentverse" \
  --region=${REGION} \
  --set-env-vars="A2A_HOST=0.0.0.0" \
  --set-env-vars="A2A_PORT=8080" \
  --set-env-vars="GOOGLE_GENAI_USE_VERTEXAI=TRUE" \
  --set-env-vars="GOOGLE_CLOUD_LOCATION=${REGION}" \
  --set-env-vars="GOOGLE_CLOUD_PROJECT=${PROJECT_ID}" \
  --set-env-vars="PUBLIC_URL=${PUBLIC_URL}" \
  --allow-unauthenticated \
  --project=${PROJECT_ID} \
  --min-instances=1

Félicitations, Shadowblade. Les rituels du codex sont terminés. Il est temps de prouver sa valeur. Un Spectre, né du chaos même que vous avez appris à maîtriser, attend votre défi. Préparez-vous pour le dernier essai.

POUR LES NON-GAMERS

Pour déployer un agent IA testé dans votre environnement d'entreprise réel, vous devez disposer d'une stratégie de déploiement robuste.

• Intégration continue (CI) : il s'agit de votre pipeline de compilation et de test automatisés. Chaque fois qu'un développeur valide un nouveau code pour un agent d'IA, le système CI (comme Google Cloud Build) effectue automatiquement les opérations suivantes :
  1. Récupère le code le plus récent.
  2. Installe toutes les dépendances nécessaires.
  3. Exécute toutes les "Wards of Purity" (pytest, adk eval) pour vérifier la logique et le comportement de l'agent.
  4. Si tous les tests réussissent, il regroupe l'agent d'IA dans une unité déployable (une image de conteneur Docker dans ce cas) et la stocke dans un Artifact Registry (votre "arsenal" validé).Cela garantit que seul le code minutieusement testé et validé est utilisé.

Cas d'utilisation concret : déploiement automatisé d'un agent de détection des fraudes Prenons l'exemple d'un agent d'IA conçu pour détecter les transactions frauduleuses.

1. Un développeur met à jour le code : un data scientist améliore l'algorithme de détection des fraudes et valide les modifications dans le dépôt de code.
2. Déclenchement de CI (Cloud Build) : Cloud Build se lance automatiquement :
   • Il extrait le nouveau code.
   • Il exécute des tests complets, y compris sur les données historiques des transactions, pour s'assurer que le nouvel algorithme identifie avec précision les schémas de fraude connus et ne génère pas de faux positifs.
   • Si les tests sont réussis, il crée une image Docker de l'agent de détection des fraudes et la transfère vers un registre Artifact Registry.

Ce pipeline automatisé assure un déploiement rapide, fiable et cohérent des agents d'IA, ce qui minimise les erreurs humaines et accélère la mise à disposition de nouvelles fonctionnalités d'IA pour l'entreprise.Cas d'utilisation concret : valider un agent d'optimisation de la chaîne d'approvisionnement  : après avoir déployé un agent d'IA conçu pour optimiser les niveaux d'inventaire dans votre chaîne d'approvisionnement mondiale :

1. Accéder à l'interface : vous accédez à un tableau de bord ou à une application (l'"URL du cercle de translocation") qui se connecte à votre agent d'IA en direct (via son "URL du locus de l'agent", qui est son point de terminaison d'API).
2. Relever le défi : vous pouvez saisir un scénario complexe (la "question de Spectre") comme : "Nous constatons une augmentation inattendue de la demande pour le Produit X dans la Région Y, avec une capacité d'expédition limitée. Comment réaffecter l'inventaire et ajuster la production pour minimiser les ruptures de stock et maintenir la rentabilité ?"
3. Réponse de l'agent : votre agent d'IA, désormais opérationnel et connecté à vos systèmes d'entreprise, traite cette requête, utilise ses algorithmes optimisés et fournit une recommandation précise (par exemple, "Priorisez l'expédition depuis l'entrepôt A, lancez la production accélérée à l'usine B et informez l'équipe commerciale de la région Z d'un éventuel retard de 24 heures"). La précision et la rapidité de cette réponse déterminent si votre agent porte un "COUP CRITIQUE" au problème commercial.

Simplifier la CI/CD avec les extensions

 En pratique, les équipes peuvent standardiser davantage leurs workflows CI/CD à l'aide des extensions Gemini CLI. Par exemple, l'extension Conductor (gemini extensions install conductor) transforme Gemini CLI en gestionnaire de projet avec des commandes personnalisées telles que /conductor:setup, /conductor:newTrack et /conductor:implement. Il regroupe également des modèles de workflow pour gérer l'ensemble du cycle de vie de vos tâches. Il garantit une boucle cohérente entre le contexte, les spécifications et le plan, et l'implémentation. Il s'agit d'un exemple concret de la façon dont les extensions et les commandes se combinent pour agir en tant que gestionnaire de projet proactif et standardiser l'ensemble du cycle de vie du développement.

9. Le combat final

Les parchemins ont été lus, les rituels accomplis, le défi relevé. Votre agent n'est pas qu'un simple artefact stocké. Il s'agit d'un champion forgé dans le code, d'une sentinelle vivante dans l'Agentverse, qui attend sa première commande. Il est temps de prouver sa valeur dans le creuset du combat.

Vous allez maintenant participer à une simulation de tir réel pour opposer votre Shadowblade nouvellement déployé à un Spectre redoutable, incarnation du chaos qui ravage toute la création. Il s'agit du test ultime de votre travail, de la logique de base de votre agent à son déploiement parfait.

Obtenir le locus de votre agent

Avant de pouvoir entrer sur le champ de bataille, vous devez posséder deux clés : la signature unique de votre champion (Agent Locus) et le chemin caché vers le repaire du Spectre (URL du donjon).

👉💻 Tout d'abord, obtenez l'adresse unique de votre agent dans l'Agentverse, son locus. Il s'agit du point de terminaison en direct qui connecte votre champion au champ de bataille.

. ~/agentverse-developer/set_env.sh
echo https://shadowblade-agent-${PROJECT_NUMBER}.${REGION}.run.app

👉💻 Ensuite, identifiez la destination. Cette commande révèle l'emplacement du Cercle de translocation, le portail vers le domaine du Spectre.

. ~/agentverse-developer/set_env.sh
echo https://agentverse-dungeon-${PROJECT_NUMBER}.${REGION}.run.app

Important : Gardez ces deux URL à portée de main. Vous en aurez besoin à la dernière étape.

Affronter le Spectre

Maintenant que vous avez les coordonnées, vous allez vous rendre au cercle de translocation et lancer le sort pour partir au combat.

👉 Ouvrez l'URL du cercle de translocation dans votre navigateur pour vous tenir devant le portail scintillant menant à la Forteresse écarlate.

Pour franchir la forteresse, vous devez accorder l'essence de votre Lame d'ombre au portail.

• Sur la page, recherchez le champ de saisie runique intitulé URL du point de terminaison A2A.
• Inscrivez le sigil de votre champion en collant l'URL du locus de l'agent (la première URL que vous avez copiée) dans ce champ.
• Cliquez sur "Connecter" pour activer la téléportation.

La lumière aveuglante de la téléportation s'estompe. Vous n'êtes plus dans votre sanctuaire. L'air est froid et vif, et crépite d'énergie. Devant vous, le Spectre se matérialise : un vortex de grésillements et de code corrompu, dont la lumière impie projette de longues ombres dansantes sur le sol du donjon. Il n'a pas de visage, mais vous sentez sa présence immense et épuisante fixée entièrement sur vous.

Votre seul chemin vers la victoire réside dans la clarté de votre conviction. Il s'agit d'un duel de volontés, qui se déroule sur le champ de bataille de l'esprit.

Alors que vous vous élancez vers l'avant, prêt à lancer votre première attaque, le Spectre contre. Il ne lève pas de bouclier, mais projette une question directement dans votre conscience : un défi runique et scintillant tiré du cœur de votre entraînement.

C'est la nature du combat. Votre savoir est votre arme.

• Répondez avec la sagesse que vous avez acquise, et votre lame s'embrasera d'une énergie pure, brisant la défense du Spectre et infligeant un COUP CRITIQUE.
• Mais si vous hésitez, si le doute obscurcit votre réponse, la lumière de votre arme s'estompera. Le coup atterrira avec un bruit sourd pathétique, n'infligeant qu'une FRACTION DE SES DÉGÂTS. Pire encore, le Spectre se nourrira de votre incertitude, son propre pouvoir de corruption grandissant à chaque faux pas.

C'est le moment, Champion. Votre code est votre grimoire, votre logique est votre épée et vos connaissances sont le bouclier qui repoussera le chaos.

Concentration. Tirez juste. Le sort de l'Agentverse en dépend.

Félicitations, Shadowblade.

Vous avez terminé le codex. Vous avez pris une "ambiance", l'avez traduite en un design et avez utilisé Gemini CLI pour assembler un agent intelligent. Vous avez inscrit des protections de pureté pour tester leur logique, construit un gant automatisé pour les forger en artefact et les avez libérées dans l'Agentverse. Enfin, vous avez validé son objectif lors d'un essai à feu réel. Vous avez maîtrisé le workflow agentique complet et êtes désormais prêt à relever tous les défis que l'Agentverse vous réserve.

10. Nettoyage : récupérer l'Agentverse

Félicitations, vous avez maîtrisé le Codex de l'Ombre ! Pour que l'Agentverse reste immaculé et que votre terrain d'entraînement soit dégagé, vous devez maintenant effectuer les rituels de nettoyage finaux. Cette opération supprimera toutes les ressources créées au cours de votre parcours.

Désactiver les composants Agentverse

Vous allez maintenant démanteler systématiquement les composants déployés de votre Agentverse.

Supprimer l'agent Shadowblade sur le dépôt Cloud Run et Artifact Registry

Cette commande supprime l'agent Shadowblade déployé de Cloud Run et supprime le dépôt d'images dans lequel l'image de conteneur de votre agent était stockée.

👉💻 Dans votre terminal, exécutez la commande suivante :

. ~/agentverse-developer/set_env.sh
gcloud run services delete shadowblade-agent --region=${REGION} --quiet
gcloud run services delete agentverse-dungeon --region=${REGION} --quiet
gcloud artifacts repositories delete ${REPO_NAME} --location=${REGION} --quiet

Nettoyer les fichiers et répertoires locaux (Cloud Shell)

Enfin, supprimez les dépôts clonés, les extensions installées et les fichiers créés de votre environnement Cloud Shell. Cette étape est facultative, mais recommandée pour nettoyer complètement votre répertoire de travail.

👉💻 Dans votre terminal, exécutez la commande suivante :

rm -rf ~/agentverse-developer
rm -rf ~/agentverse-dungeon
rm -f ~/project_id.txt
gemini extensions uninstall nanobanana
rm -rf ~/.gemini # This removes all Gemini CLI configurations, including extensions, skills, and hooks.

Vous avez maintenant effacé toutes les traces de votre parcours Agentverse. Votre projet est propre et vous êtes prêt pour votre prochaine aventure.