GENAI106

Présentation

Cet atelier porte sur l'orchestration de systèmes multi-agents dans Google Agent Development Kit (Google ADK).

Cet atelier suppose que vous connaissiez les bases d'ADK et des outils utilisés dans les ateliers suivants :

• Premiers pas avec Google Agent Development Kit (ADK)
• Équiper les agents ADK d'outils

Objectifs

Au cours de cet atelier, vous allez :

• créer plusieurs agents et les relier entre eux à l'aide de relations parent-sous-agent ;
• créer du contenu sur plusieurs tours de conversation et plusieurs agents en écrivant dans le dictionnaire d'état d'une session ;
• demander aux agents de lire les valeurs d'état de session pour les utiliser comme contexte dans leurs réponses ;
• utiliser des agents de workflow pour transférer directement la conversation entre agents.

Préparation

Avant de cliquer sur le bouton Start Lab (Démarrer l'atelier)

Lisez ces instructions. Les ateliers sont minutés, et vous ne pouvez pas les mettre en pause. Le minuteur, qui démarre lorsque vous cliquez sur le bouton "Start Lab" (Démarrer l'atelier), indique combien de temps les ressources cloud resteront accessibles.

Cet atelier pratique Qwiklabs vous permet de suivre vous-même les activités dans un véritable environnement cloud, et non dans un environnement de simulation ou de démonstration. Des identifiants temporaires vous sont fournis pour vous permettre de vous connecter à Google Cloud Platform le temps de l'atelier.

Conditions requises

Pour réaliser cet atelier, vous devez remplir les conditions suivantes :

• Vous devez avoir accès à un navigateur Internet standard (nous vous recommandons d'utiliser Chrome).
• Vous devez disposer de suffisamment de temps pour réaliser l'atelier en une fois.

Remarque : Si vous possédez déjà un compte ou un projet GCP, veillez à ne pas l'utiliser pour réaliser cet atelier.

Démarrer l'atelier et se connecter à la console Google Cloud

1. Cliquez sur le bouton Démarrer l'atelier. Si l'atelier est payant, une boîte de dialogue s'affiche pour vous permettre de sélectionner un mode de paiement. Sur la gauche, vous trouverez le panneau "Détails concernant l'atelier", qui contient les éléments suivants :

   • Le bouton "Ouvrir la console Google Cloud"
   • Le temps restant
   • Les identifiants temporaires que vous devez utiliser pour cet atelier
   • Des informations complémentaires vous permettant d'effectuer l'atelier

2. Cliquez sur Ouvrir la console Google Cloud (ou effectuez un clic droit et sélectionnez Ouvrir le lien dans la fenêtre de navigation privée si vous utilisez le navigateur Chrome).

   L'atelier lance les ressources, puis ouvre la page "Se connecter" dans un nouvel onglet.

   Conseil : Réorganisez les onglets dans des fenêtres distinctes, placées côte à côte.

   Remarque : Si la boîte de dialogue Sélectionner un compte s'affiche, cliquez sur Utiliser un autre compte.

3. Si nécessaire, copiez le nom d'utilisateur ci-dessous et collez-le dans la boîte de dialogue Se connecter.

   {{{user_0.username | "Username"}}}

   Vous trouverez également le nom d'utilisateur dans le panneau "Détails concernant l'atelier".

4. Cliquez sur Suivant.

5. Copiez le mot de passe ci-dessous et collez-le dans la boîte de dialogue Bienvenue.

   {{{user_0.password | "Password"}}}

   Vous trouverez également le mot de passe dans le panneau "Détails concernant l'atelier".

6. Cliquez sur Suivant.

   Important : Vous devez utiliser les identifiants fournis pour l'atelier. Ne saisissez pas ceux de votre compte Google Cloud. Remarque : Si vous utilisez votre propre compte Google Cloud pour cet atelier, des frais supplémentaires peuvent vous être facturés.

7. Accédez aux pages suivantes :

   • Acceptez les conditions d'utilisation.
   • N'ajoutez pas d'options de récupération ni d'authentification à deux facteurs (ce compte est temporaire).
   • Ne vous inscrivez pas à des essais sans frais.

Après quelques instants, la console Cloud s'ouvre dans cet onglet.

Remarque : Pour accéder aux produits et services Google Cloud, cliquez sur le menu de navigation ou saisissez le nom du service ou du produit dans le champ Recherche.

Systèmes multi-agents

Agent Development Kit permet aux développeurs d'obtenir des comportements plus fiables, sophistiqués et en plusieurs étapes de la part des modèles génératifs. Au lieu de rédiger des prompts longs et complexes qui ne donnent pas toujours des résultats fiables, vous pouvez créer un flux de plusieurs agents simples qui peuvent collaborer sur des problèmes complexes en se répartissant les tâches et les responsabilités.

Cette approche architecturale offre plusieurs avantages clés :

• Conception simplifiée : vous pouvez penser en termes d'agents ayant des tâches et des compétences spécifiques.
• Fonctions spécialisées avec des performances plus fiables : les agents spécialisés peuvent apprendre à partir d'exemples clairs pour gagner en fiabilité dans leurs tâches spécifiques.
• Organisation : diviser le workflow en agents distincts permet d'adopter une approche plus organisée et donc plus facile à appréhender.
• Amélioration et maintenabilité : il est plus facile d'améliorer ou de corriger un composant spécialisé que de modifier un agent complexe en corrigeant un comportement qui pourrait avoir un impact sur d'autres.
• Modularité : les agents distincts d'un workflow peuvent être facilement copiés et inclus dans d'autres workflows similaires.

L'arborescence hiérarchique des agents

Dans Agent Development Kit, vous organisez vos agents dans une structure arborescente. Cela permet de limiter les options de transfert pour chaque agent de l'arborescence, ce qui facilite le contrôle et la prédiction des routes possibles que la conversation peut emprunter dans l'arborescence. Voici certains avantages de la structure hiérarchique :

• Elle s'inspire des équipes collaboratives du monde réel, ce qui facilite la conception et le raisonnement du comportement du système multi-agent.
• Elle est intuitive pour les développeurs, car elle reprend les schémas de développement logiciel courants.
• Elle offre un meilleur contrôle sur le flux d'informations et la délégation de tâches dans le système, ce qui aide à comprendre quels sont les chemins possibles et comment déboguer le système. Par exemple, si un système comporte deux agents de génération de rapports à différents endroits de son flux avec des descriptions similaires, la structure arborescente permet de s'assurer que c'est le bon agent qui est appelé.

La structure commence toujours par l'agent défini dans la variable root_agent (même s'il peut s'identifier auprès de l'utilisateur sous un nom différent). L'agent racine (root-agent) peut agir en tant que parent d'un ou plusieurs sous-agents. Chaque sous-agent peut avoir ses propres sous-agents.

Tâche 1 : Installer ADK et configurer votre environnement

Dans cet environnement d'atelier, l'API Vertex AI a été activée pour vous. Si vous deviez suivre ces étapes dans votre propre projet, vous l'activeriez en accédant à Vertex AI et en suivant les indications.

Préparer un onglet dans l'éditeur Cloud Shell

1. Dans la fenêtre de la console Google Cloud, ouvrez Cloud Shell en appuyant sur les touches G, puis S de votre clavier. Vous pouvez également cliquer sur le bouton "Activer Cloud Shell" () en haut à droite de la console Cloud.
2. Cliquez sur Continuer.
3. Si vous êtes invité à autoriser Cloud Shell, cliquez sur Autoriser.
4. En haut à droite du panneau du terminal Cloud Shell, cliquez sur le bouton Ouvrir dans une nouvelle fenêtre .
5. Cliquez sur l'icône en forme de crayon Ouvrir l'éditeur () en haut du volet pour afficher les fichiers.
6. En haut du menu de navigation de gauche, cliquez sur l'icône de l'explorateur () pour ouvrir l'explorateur de fichiers.
7. Cliquez sur le bouton Ouvrir le dossier.
8. Dans la boîte de dialogue "Ouvrir le dossier" qui s'affiche, cliquez sur OK pour sélectionner le dossier de base de votre compte élève Qwiklabs.
9. Fermez les éventuels tutoriels ou panneaux Gemini qui s'affichent sur le côté droit de l'écran pour donner plus de place à l'éditeur de code.
10. Pour le reste de cet atelier, vous pouvez utiliser cette fenêtre comme IDE avec l'éditeur Cloud Shell et le terminal Cloud Shell.

Télécharger et installer ADK et les exemples de code pour cet atelier

1. Collez les commandes suivantes dans le terminal Cloud Shell pour copier les fichiers de code d'un bucket Cloud Storage pour cet atelier :

   gcloud storage cp -r gs://{{{project_0.project_id| YOUR_GCP_PROJECT_ID}}}-bucket/adk_multiagent_systems

2. Mettez à jour votre variable d'environnement PATH et installez ADK ainsi que les autres éléments requis pour l'atelier en exécutant les commandes suivantes dans le terminal Cloud Shell.

   export PATH=$PATH:"/home/${USER}/.local/bin" python3 -m pip install google-adk -r adk_multiagent_systems/requirements.txt

Tâche 2 : Étudier les transferts entre les agents parents, les sous-agents et les agents pairs

La conversation commence toujours avec l'agent défini par la variable root_agent.

Par défaut, le rôle d'un agent parent est de comprendre la description de chaque sous-agent et de déterminer si le contrôle de la conversation doit être transféré à un sous-agent à un moment donné.

Vous pouvez guider ces transferts dans l'instruction du parent en faisant référence aux sous-agents par leur nom (les valeurs de leur paramètre name, et non leurs noms de variables). Par exemple :

1. Dans le terminal Cloud Shell, exécutez la commande suivante pour créer un fichier .env afin d'authentifier l'agent dans le répertoire parent_and_subagents.

   cd ~/adk_multiagent_systems cat << EOF > parent_and_subagents/.env GOOGLE_GENAI_USE_VERTEXAI=TRUE GOOGLE_CLOUD_PROJECT={{{project_0.project_id| YOUR_GCP_PROJECT_ID}}} GOOGLE_CLOUD_LOCATION=global MODEL={{{project_0.startup_script.gemini_flash_model_id | gemini_flash_model_id}}} EOF

2. Exécutez la commande suivante pour copier le fichier .env dans le répertoire workflow_agents, que vous utiliserez plus tard dans l'atelier :

   cp parent_and_subagents/.env workflow_agents/.env

3. Dans le volet de l'explorateur de fichiers de l'éditeur Cloud Shell, accédez au répertoire adk_multiagent_systems/parent_and_subagents.

4. Cliquez sur le fichier agent.py pour l'ouvrir.

5. Notez qu'il y a trois agents ici :

   • Un agent racine (root_agent) nommé steering (son nom sert à l'identifier dans l'UI de développement et les interfaces de ligne de commande d'ADK). Il pose une question à l'utilisateur (est-ce qu'il sait où il veut voyager, ou a-t-il besoin d'aide pour prendre une décision), et la réponse de l'utilisateur à cette question va aider cet agent de guidage à savoir vers lequel de ses deux sous-agents orienter la conversation. Notez qu'il ne contient qu'une simple instruction qui ne mentionne pas les sous-agents, mais qu'il connaît leur description.
   • Un agent travel_brainstormer qui aide l'utilisateur à trouver des destinations s'il ne sait pas où il aimerait aller.
   • Un agent attractions_planner qui aide l'utilisateur à établir une liste de choses à faire une fois qu'il sait quel pays il souhaite visiter.

6. Faites de travel_brainstormer et de attractions_planner des sous-agents du root_agent en ajoutant la ligne suivante à la création du root_agent :

   sub_agents=[travel_brainstormer, attractions_planner]

7. Enregistrez le fichier.

8. Notez que vous n'ajoutez pas de paramètre parent correspondant aux sous-agents. L'arborescence hiérarchique est définie uniquement en spécifiant sub_agents lors de la création d'agents parents.

9. Dans le terminal Cloud Shell, exécutez la commande suivante afin d'utiliser l'interface de ligne de commande ADK pour les discussions avec votre agent :

   cd ~/adk_multiagent_systems adk run parent_and_subagents

10. Lorsque [user]: s'affiche, saluez l'agent en saisissant :

    hello

    Exemple de sortie (la vôtre peut être légèrement différente) :

    user: hello [steering]: Hi there! Do you already have a country in mind for your trip, or would you like some help deciding where to go?

11. Dites à l'agent :

    I could use some help deciding.

    Exemple de sortie (la vôtre peut être légèrement différente) :

    user: I could use some help deciding. [travel_brainstormer]: Okay! To give you the best recommendations, I need to understand what you're looking for in a trip. ...

12. Notez que le nom [travel_brainstormer] entre crochets dans la réponse indique que le root_agent (nommé [steering]) a transféré la conversation au sous-agent approprié en se basant uniquement sur la description de ce sous-agent.

13. Lorsque user: s'affiche, saisissez exit pour mettre fin à la conversation.

14. Vous pouvez également fournir à votre agent des instructions plus détaillées sur le moment où il doit transférer la demande à un sous-agent dans le cadre de ses instructions. Dans le fichier agent.py, ajoutez les lignes suivantes à l'instruction du root_agent :

    If they need help deciding, send them to 'travel_brainstormer'. If they know what country they'd like to visit, send them to the 'attractions_planner'.

15. Enregistrez le fichier.

16. Dans le terminal Cloud Shell, exécutez la commande suivante pour redémarrer l'interface de ligne de commande :

    adk run parent_and_subagents

17. Saluez l'agent en disant :

    hello

18. Répondez au message de l'agent en indiquant :

    I would like to go to Japan.

    Exemple de sortie (la vôtre peut être légèrement différente) :

    user: I would like to go to Japan. [attractions_planner]: Okay, I can help you with that! Here are some popular attractions in Japan: * **Tokyo:** * Senso-ji Temple * Shibuya Crossing * Tokyo Skytree * **Kyoto:** ...

19. Notez que vous avez été transféré vers l'autre sous-agent, attractions_planner.

20. Saisissez une réponse :

    Actually I don't know what country to visit.

    Exemple de sortie (la vôtre peut être légèrement différente) :

    user: actually I don't know what country to visit [travel_brainstormer]: Okay! I can help you brainstorm some countries for travel...

21. Notez que vous avez été transféré vers l'agent travel_brainstormer, qui est un agent pair de l'agent attractions_planner. Ce transfert est autorisé par défaut. Si vous aviez voulu empêcher les transferts vers des pairs, vous auriez pu définir le paramètre disallow_transfer_to_peers sur True pour l'agent attractions_planner.

22. Saisissez ensuite exit pour mettre fin à la session.

Cliquez sur Vérifier ma progression pour valider l'objectif. Étudier les transferts entre les agents parents, les sous-agents et les agents pairs

Tâche 3 : Utiliser l'état de session pour stocker et récupérer des informations spécifiques

Chaque conversation dans ADK est contenue dans une session à laquelle tous les agents impliqués dans la conversation peuvent accéder. Une session inclut l'historique des conversations, que les agents lisent dans le cadre du contexte utilisé pour générer une réponse. La session inclut également un dictionnaire d'état de session que vous pouvez utiliser pour mieux contrôler les informations les plus importantes que vous souhaitez mettre en avant et la façon dont elles sont accessibles.

Cela peut être particulièrement utile pour transmettre des informations entre agents ou pour maintenir une structure de données simple, comme une liste de tâches, tout au long d'une conversation avec un utilisateur.

Pour découvrir comment ajouter des données à l'état et les lire :

1. Revenez au fichier adk_multiagent_systems/parent_and_subagents/agent.py.

2. Collez la définition de fonction suivante après l'en-tête # Tools :

   def save_attractions_to_state( tool_context: ToolContext, attractions: List[str] ) -> dict[str, str]: """Saves the list of attractions to state["attractions"]. Args: attractions [str]: a list of strings to add to the list of attractions Returns: None """ # Charger les attractions existantes depuis l'état. S'il n'en existe aucune, commencer une liste vide existing_attractions = tool_context.state.get("attractions", []) # Mettre à jour la clé 'attractions' avec une combinaison de nouvelles et d'anciennes listes. # Lorsque l'outil est exécuté, ADK crée un événement et effectue # les mises à jour correspondantes dans l'état de session. tool_context.state["attractions"] = existing_attractions + attractions # Une bonne pratique pour les outils consiste à renvoyer un message d'état dans un dictionnaire de retour return {"status": "success"}

3. Dans ce code, notez les points suivants :

   • La session est transmise à la fonction de votre outil en tant que ToolContext. Il vous suffit d'attribuer un paramètre pour le recevoir, comme vous le voyez ici avec le paramètre nommé tool_context. Vous pouvez ensuite utiliser tool_context pour accéder aux informations de session, comme l'historique des conversations (avec tool_context.events) et le dictionnaire d'état de session (avec tool_context.state). Lorsque le dictionnaire tool_context.state est modifié par la fonction de l'outil, ces changements sont répercutés dans l'état de session une fois l'exécution de l'outil terminée.
   • La docstring fournit une description claire et des sections pour les arguments et les valeurs renvoyées.
   • Le code de la fonction commenté montre à quel point il est facile de mettre à jour le dictionnaire d'état.

4. Ajoutez l'outil à l'agent attractions_planner en ajoutant le paramètre tools lors de la création de l'agent :

   tools=[save_attractions_to_state]

5. Ajoutez les points suivants à l'instruction existante de l'agent attractions_planner :

   - When they reply, use your tool to save their selected attraction and then provide more possible attractions. - If they ask to view the list, provide a bulleted list of { attractions? } and then suggest some more.

6. Notez la section entre accolades : { attractions? }. Cette fonctionnalité d'ADK, key templating, charge la valeur de la clé attractions à partir du dictionnaire d'état. Le point d'interrogation après la clé attractions empêche la génération d'une erreur si le champ n'est pas encore présent.

7. Vous allez maintenant exécuter l'agent à partir de l'interface Web, qui fournit un onglet permettant de visualiser les modifications apportées à l'état de session. Lancez l'UI Web Agent Development Kit avec la commande suivante :

   adk web

   Résultat

   INFO: Started server process [2434] INFO: Waiting for application startup. +-------------------------------------------------------+ | ADK Web Server started | | | | For local testing, access at http://localhost:8000. | +-------------------------------------------------------+ INFO: Application startup complete. INFO: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)

8. Pour afficher l'interface Web dans un nouvel onglet, cliquez sur le lien http://127.0.0.1:8000 dans le résultat du terminal.

9. L'UI de développement d'ADK s'ouvre dans un nouvel onglet du navigateur.

10. Dans le menu déroulant Sélectionner un agent à gauche, sélectionnez l'agent parent_and_subagents.

11. Commencez par dire hello.

12. Après que l'agent vous a salué, répondez :

    I'd like to go to Egypt.

    Vous devriez être transféré vers attractions_planner et recevoir une liste d'attractions.

13. Choisissez une attraction, par exemple :

    I'll go to the Sphinx

14. Vous devriez recevoir une réponse de confirmation, comme : Okay, I've saved The Sphinx to your list. Here are some other attractions...

15. Cliquez sur la case de l'outil de réponse (marquée d'une coche) pour afficher l'événement créé à partir de la réponse de l'outil. Notez qu'il inclut un champ actions qui contient state_delta décrivant les modifications apportées à l'état.

16. L'agent doit vous inviter à sélectionner d'autres attractions. Répondez à l'agent en nommant l'une des options qu'il vous a présentées.

17. Dans le menu de navigation de gauche, cliquez sur le "X" pour quitter l'événement que vous avez inspecté précédemment.

18. Dans la barre latérale, vous devriez maintenant voir la liste des événements et quelques onglets. Sélectionnez l'onglet État. Vous y verrez l'état actuel, y compris le tableau attractions avec les deux valeurs que vous avez demandées.

    

19. Envoyez le message suivant à l'agent :

    What is on my list?

20. Il doit renvoyer votre liste sous forme de liste à puces, conformément à son instruction.

21. Lorsque vous avez terminé d'expérimenter avec l'agent, fermez l'onglet du navigateur Web et appuyez sur CTRL+C dans le terminal Cloud Shell pour arrêter le serveur.

    Plus tard dans cet atelier, vous allez montrer comment utiliser l'état pour communiquer entre les agents.

Cliquez sur Vérifier ma progression pour valider l'objectif. Utiliser l'état de session pour stocker et récupérer des informations spécifiques

Agents de workflow

Les transferts du parent vers les sous-agents sont très utiles lorsque vous avez plusieurs sous-agents spécialisés et que vous souhaitez que l'utilisateur interagisse avec chacun d'eux.

Toutefois, si vous souhaitez que les agents interviennent l'un après l'autre sans attendre le tour de l'utilisateur, vous pouvez utiliser des agents de workflow. Voici quelques exemples de scénarios dans lesquels vous pouvez utiliser des agents de workflow :

• Planification et exécution : lorsqu'un agent doit préparer une liste d'éléments, et que d'autres agents doivent utiliser cette liste pour effectuer des tâches de suivi, par exemple rédiger des sections d'un document.
• Recherche et rédaction : lorsque vous souhaitez qu'un agent appelle des fonctions pour collecter des informations contextuelles à partir de la recherche Google ou d'autres sources de données, puis qu'un autre agent utilise ces informations pour produire une sortie.
• Rédaction et révision : lorsqu'un agent doit rédiger un brouillon de document, puis que d'autres agents doivent vérifier le travail et l'améliorer.

Pour effectuer ce type de tâches, les agents de workflow ont des sous-agents et garantissent l'intervention de chacun. Agent Development Kit fournit trois agents de workflow intégrés et vous permet de définir les vôtres :

• SequentialAgent
• LoopAgent
• ParallelAgent

Dans le reste de cet atelier, vous allez créer un système multi-agent qui utilise plusieurs agents LLM, des agents de workflow et des outils pour contrôler le flux de l'agent.

Plus précisément, vous allez créer un agent qui va rédiger le pitch d'un nouveau biopic basé sur la vie d'un personnage historique. Vos sous-agents se chargeront de la recherche, d'un cycle d'écriture itératif avec un scénariste et un critique, et enfin, d'autres sous-agents vous aideront à trouver des idées de casting et à utiliser les données historiques du box-office pour prédire le succès du film.

Au final, votre système multi-agent ressemblera à ceci (vous pouvez cliquer sur l'image pour l'agrandir) :

Mais vous allez commencer par une version plus simple.

Tâche 4 : Commencer à créer un système multi-agent avec un SequentialAgent

Le SequentialAgent exécute ses sous-agents dans une séquence linéaire. Les sous-agents de sa liste sub_agents sont exécutés l'un après l'autre, dans l'ordre dans lequel ils sont définis.

C'est idéal pour les workflows dans lesquels les tâches doivent être effectuées dans un ordre précis, et où le résultat d'une tâche sert d'entrée à la suivante.

Dans cette tâche, vous allez exécuter un SequentialAgent pour créer une première version de votre système multi-agent de création de pitch. La première version de votre agent sera structurée comme suit :

• Un root_agent nommé greeter pour saluer l'utilisateur et lui demander de choisir un personnage historique comme sujet de film.

• Un SequentialAgent appelé film_concept_team, qui inclura :

  • Un researcher (chercheur) pour trouver des informations à propos du personnage historique sur Wikipédia, à l'aide d'un outil LangChain présenté dans l'atelier Équiper les agents ADK d'outils. Un agent peut choisir d'appeler ses outils plusieurs fois de suite. Le chercheur peut donc effectuer plusieurs tours consécutifs s'il estime avoir besoin de plus de temps pour ses recherches.
  • Un screenwriter (scénariste) pour transformer les recherches en scénario.
  • Un file_writer pour donner un titre au film obtenu et écrire les résultats de la séquence dans un fichier.

1. Dans l'éditeur Cloud Shell, accédez au répertoire adk_multiagent_systems/workflow_agents.

2. Cliquez sur le fichier agent.py dans le répertoire workflow_agents.

3. Lisez ce fichier de définition d'agent. Comme les sous-agents doivent être définis avant de pouvoir être attribués à un agent parent, pour lire le fichier dans l'ordre du flux de conversation, vous pouvez lire les agents du bas du fichier vers le haut.

4. Vous disposez également d'un outil de fonction append_to_state. Cette fonction permet aux agents disposant de l'outil d'ajouter du contenu à une valeur de dictionnaire dans l'état. Il est particulièrement utile pour les agents qui peuvent appeler un outil plusieurs fois ou agir en plusieurs passes d'un LoopAgent, afin que leur sortie soit stockée à chaque fois.

5. Testez la version actuelle de l'agent en lançant l'interface Web à partir du terminal Cloud Shell. Vous allez utiliser l'argument --reload_agents pour activer le rechargement à chaud des agents en fonction des modifications apportées :

   cd ~/adk_multiagent_systems adk web --reload_agents Remarque : Si vous n'avez pas arrêté votre session adk web précédente, le port par défaut 8000 sera bloqué. Vous pouvez toutefois lancer l'UI de développement sur un nouveau port en utilisant adk web --port 8001, par exemple.

6. Pour afficher l'interface Web dans un nouvel onglet, cliquez sur le lien http://127.0.0.1:8000 dans le résultat du terminal.

7. L'UI de développement d'ADK s'ouvre dans un nouvel onglet du navigateur.

8. Dans le menu déroulant Sélectionner un agent à gauche, sélectionnez workflow_agents.

9. Commencez par dire hello. L'agent peut mettre quelques instants à répondre, mais il devrait vous demander de saisir un personnage historique pour commencer à générer le scénario de votre film.

10. Lorsque vous êtes invité à saisir un personnage historique, vous pouvez choisir celui que vous voulez ou utiliser l'un de ces exemples :

    • Zhang Zhongjing, célèbre médecin chinois du IIe siècle.
    • Ada Lovelace, mathématicienne et écrivaine anglaise connue pour ses travaux sur les premiers ordinateurs.
    • Marc Aurèle, empereur romain connu pour ses écrits philosophiques.

11. L'agent doit maintenant appeler ses agents l'un après l'autre à mesure qu'il exécute le workflow et écrit le scénario dans votre répertoire ~/adk_multiagent_systems/movie_pitches. Il doit vous informer lorsqu'il a écrit le fichier sur le disque.

    Si l'agent ne vous a pas indiqué qu'il avait généré un fichier pour vous ou si vous souhaitez essayer un autre personnage, vous pouvez cliquer sur + Nouvelle session en haut à droite et réessayer.

12. Affichez la sortie de l'agent dans l'éditeur Cloud Shell. (Vous devrez peut-être utiliser le menu de l'éditeur Cloud Shell pour activer Affichage > Retour automatique afin de voir le texte complet sans avoir à faire défiler la page horizontalement.)

13. Dans l'UI de développement ADK, cliquez sur l'une des icônes d'agent () représentant un tour de conversation pour afficher la vue des événements.

14. La vue des événements fournit une représentation visuelle de l'arborescence des agents et des outils utilisés dans cette session. Vous devrez peut-être faire défiler le panneau d'événements pour voir l'intégralité du scénario.

15. En plus de la vue graphique, vous pouvez cliquer sur l'onglet Request de l'événement pour afficher les informations que cet agent a reçues dans le cadre de sa requête, y compris l'historique des conversations.
16. Vous pouvez également cliquer sur l'onglet Réponse de l'événement pour voir ce que l'agent a renvoyé.

Cliquez sur Vérifier ma progression pour valider l'objectif. Commencer à créer un système multi-agent avec un SequentialAgent

Tâche 5 : Ajouter un LoopAgent pour le travail itératif

Le LoopAgent exécute ses sous-agents dans une séquence définie, puis recommence au début de la séquence sans attendre d'entrée utilisateur. Il répète la boucle jusqu'à ce qu'un certain nombre d'itérations soit atteint ou qu'un de ses sous-agents demande à quitter la boucle (généralement en appelant l'outil intégré exit_loop).

C'est un avantage pour les tâches qui nécessitent un affinement continu, une surveillance ou des workflows cycliques. Voici quelques exemples :

• Affinement itératif : améliorer continuellement un document ou un plan grâce à des cycles d'agent répétés.
• Surveillance continue : vérifier régulièrement les sources de données ou les conditions à l'aide d'une séquence d'agents.
• Débat ou négociation : simuler des discussions itératives entre des agents pour parvenir à un meilleur résultat.

Vous allez ajouter un LoopAgent à votre agent de pitch pour permettre plusieurs cycles de recherche et d'itération lors de l'élaboration du scénario. En plus d'affiner le script, cela permet à l'utilisateur de commencer avec une entrée moins spécifique : au lieu de suggérer un personnage historique en particulier, il peut simplement expliquer qu'il veut une histoire sur un médecin de l'Antiquité. Une boucle d'itération de recherche et d'écriture permettra aux agents de trouver un bon candidat, puis de travailler sur le scénario.

Voici le flux que va suivre votre agent révisé :

• Le root_agent greeter, qui restera le même.
• Le SequentialAgent film_concept_team, qui sera désormais composé des éléments suivants :
  • Un LoopAgent writers_room qui lancera la séquence. Il comprendra les éléments suivants :
    • Le researcher (chercheur), qui sera le même qu'avant.
    • Le screenwriter (scénariste), qui sera semblable à celui d'avant.
    • Un critic (critique) qui fournira des commentaires sur l'ébauche produite afin de motiver le cycle de recherche et d'amélioration suivant.
  • Lorsque la boucle se terminera, elle renverra le contrôle de la conversation au SequentialAgent film_concept_team, qui le transmettra ensuite à l'agent suivant de sa séquence : le même file_writer que précédemment, qui donnera un titre au film et écrira les résultats de la séquence dans un fichier.

Pour effectuer ces modifications :

1. Dans le fichier adk_multiagent_systems/workflow_agents/agent.py, ajoutez l'importation de cet outil pour permettre à un agent de sortir de la boucle quand il le souhaite :

   from google.adk.tools import exit_loop

2. Pour déterminer quand sortir de la boucle, ajoutez cet agent critic pour décider quand le scénario est prêt. Collez l'agent suivant dans le fichier agent.py sous l'en-tête de section # Agents (sans écraser les agents existants). Notez qu'il contient l'outil exit_loop et des instructions sur son utilisation :

   critic = Agent( name="critic", model=model_name, description="Reviews the outline so that it can be improved.", instruction=""" INSTRUCTIONS: Consider these questions about the PLOT_OUTLINE: - Does it meet a satisfying three-act cinematic structure? - Do the characters' struggles seem engaging? - Does it feel grounded in a real time period in history? - Does it sufficiently incorporate historical details from the RESEARCH? If the PLOT_OUTLINE does a good job with these questions, exit the writing loop with your 'exit_loop' tool. If significant improvements can be made, use the 'append_to_state' tool to add your feedback to the field 'CRITICAL_FEEDBACK'. Explain your decision and briefly summarize the feedback you have provided. PLOT_OUTLINE: { PLOT_OUTLINE? } RESEARCH: { research? } """, before_model_callback=log_query_to_model, after_model_callback=log_model_response, tools=[append_to_state, exit_loop] )

3. Créez un LoopAgent appelé writers_room qui crée la boucle itérative du chercheur, du scénariste et du critique. Chaque passe dans la boucle se termine par un examen critique du travail effectué jusqu'à présent, ce qui permet d'apporter des améliorations pour le tour suivant. Collez le code suivant au-dessus du SequentialAgent film_concept_team existant.

   writers_room = LoopAgent( name="writers_room", description="Iterates through research and writing to improve a movie plot outline.", sub_agents=[ researcher, screenwriter, critic ], max_iterations=5, )

4. Notez que la création du LoopAgent inclut un paramètre pour max_iterations. Ce paramètre définit le nombre de fois que la boucle s'exécutera avant de s'arrêter. Même si vous prévoyez d'interrompre la boucle par une autre méthode, il est judicieux de limiter le nombre total d'itérations.

5. Mettez à jour le SequentialAgent film_concept_team pour remplacer les agents researcher et screenwriter par le LoopAgent writers_room que vous venez de créer. L'agent file_writer doit rester à la fin de la séquence. L'agent film_concept_team doit désormais se présenter comme suit :

   film_concept_team = SequentialAgent( name="film_concept_team", description="Write a film plot outline and save it as a text file.", sub_agents=[ writers_room, file_writer ], )

6. Revenez à l'onglet de l'UI de développement ADK et cliquez sur le bouton + Nouvelle session en haut à droite pour démarrer une nouvelle session.

7. Commencez une nouvelle conversation avec hello.

8. Lorsque vous êtes invité à choisir un personnage historique, proposez-en un qui vous intéresse. Voici quelques idées :

   • an industrial designer who made products for the masses (un designer industriel qui a créé des produits pour le grand public)
   • a cartographer (un cartographe)
   • that guy who made crops yield more food (ce type qui a augmenté les rendements agricoles)

9. Une fois le type de personnage choisi, l'agent doit exécuter les itérations de la boucle et enfin donner un titre au film et écrire le scénario dans un fichier.

10. À l'aide de l'éditeur Cloud Shell, examinez le fichier généré, qui doit être enregistré dans le répertoire adk_multiagent_systems/movie_pitches. (Là encore, vous devrez peut-être utiliser le menu pour activer Affichage > Retour automatique afin de voir le texte complet sans avoir à faire défiler la page horizontalement.)

Cliquez sur Vérifier ma progression pour valider l'objectif. Ajouter un LoopAgent pour le travail itératif

Tâche 6 : Utiliser un modèle "fan out and gather" pour générer un rapport avec un ParallelAgent

L'agent ParallelAgent permet l'exécution simultanée de ses sous-agents. Chaque sous-agent opère dans sa propre branche et, par défaut, il ne partage pas directement l'historique des conversations ni l'état pendant l'exécution parallèle.

Cette approche est utile pour les tâches qui peuvent être divisées en sous-tâches indépendantes pouvant être traitées simultanément. L'utilisation d'un ParallelAgent peut réduire considérablement le temps d'exécution global de ces tâches.

Dans cet atelier, vous allez ajouter des rapports supplémentaires (une étude sur le potentiel de recettes au box-office et quelques idées de casting) pour améliorer votre pitch.

Voici le flux que va suivre votre agent révisé :

• Le greeter, qui sera le même.
• Le SequentialAgent film_concept_team, qui sera désormais composé des éléments suivants :
  • Le LoopAgent writers_room, qui restera le même, y compris :
    • L'agent researcher
    • L'agent screenwriter
    • L'agent critic
  • Votre nouveau ParallelAgent preproduction_team entrera alors en action. Il sera composé des agents suivants :
    • Un agent box_office_researcher pour utiliser les données historiques du box-office afin de générer un rapport sur les performances potentielles de ce film au box-office
    • Un agent casting_agent pour générer des idées de casting initiales en fonction des acteurs qui ont joué dans des films similaires
  • Le file_writer qui restera tel quel pour écrire les résultats de la séquence dans un fichier

Bien que cet exemple montre principalement un travail créatif qui serait effectué par des équipes humaines, ce workflow illustre comment une chaîne complexe de tâches peut être répartie entre plusieurs sous-agents pour produire des brouillons de documents complexes que les membres d'une équipe humaine peuvent ensuite modifier et améliorer.

1. Collez les nouveaux agents et ParallelAgent suivants dans votre fichier workflow_agents/agent.py sous l'en-tête # Agents :

   box_office_researcher = Agent( name="box_office_researcher", model=model_name, description="Considers the box office potential of this film", instruction=""" PLOT_OUTLINE: { PLOT_OUTLINE? } INSTRUCTIONS: Write a report on the box office potential of a movie like that described in PLOT_OUTLINE based on the reported box office performance of other recent films. """, output_key="box_office_report" ) casting_agent = Agent( name="casting_agent", model=model_name, description="Generates casting ideas for this film", instruction=""" PLOT_OUTLINE: { PLOT_OUTLINE? } INSTRUCTIONS: Generate ideas for casting for the characters described in PLOT_OUTLINE by suggesting actors who have received positive feedback from critics and/or fans when they have played similar roles. """, output_key="casting_report" ) preproduction_team = ParallelAgent( name="preproduction_team", sub_agents=[ box_office_researcher, casting_agent ] )

2. Mettez à jour la liste sub_agents de l'agent film_concept_team existant pour inclure l'agent preproduction_team entre writers_room et file_writer :

   film_concept_team = SequentialAgent( name="film_concept_team", description="Write a film plot outline and save it as a text file.", sub_agents=[ writers_room, preproduction_team, file_writer ], )

3. Mettez à jour l'instruction de file_writer comme suit :

   INSTRUCTIONS: - Create a marketable, contemporary movie title suggestion for the movie described in the PLOT_OUTLINE. If a title has been suggested in PLOT_OUTLINE, you can use it, or replace it with a better one. - Use your 'write_file' tool to create a new txt file with the following arguments: - for a filename, use the movie title - Write to the 'movie_pitches' directory. - For the 'content' to write, include: - The PLOT_OUTLINE - The BOX_OFFICE_REPORT - The CASTING_REPORT PLOT_OUTLINE: { PLOT_OUTLINE? } BOX_OFFICE_REPORT: { box_office_report? } CASTING_REPORT: { casting_report? }

4. Enregistrez le fichier.

5. Dans l'UI de développement ADK, cliquez sur + Nouvelle session en haut à droite.

6. Saisissez hello pour démarrer la conversation.

7. Lorsque vous y êtes invité, saisissez une idée de personnage qui vous intéresse. Voici quelques idées :

   • that actress who invented the technology for wifi (cette actrice qui a inventé la technologie du Wi-Fi)
   • an exciting chef (un chef passionnant)
   • key players in the worlds fair exhibitions (des personnes ayant joué un rôle important dans l'organisation des expositions universelles)

8. Une fois que l'agent a terminé de rédiger le pitch et de générer le rapport, examinez le fichier qu'il a produit dans le répertoire adk_multiagent_systems/movie_pitches. Si une partie du processus échoue, cliquez sur + Nouvelle session en haut à droite et réessayez.

Agents de workflow personnalisés

Si les agents de workflow prédéfinis SequentialAgent, LoopAgent et ParallelAgent ne répondent pas à vos besoins, le CustomAgent vous permet d'implémenter une nouvelle logique de workflow. Vous pouvez définir des modèles pour le contrôle de flux, l'exécution conditionnelle ou la gestion des états entre les sous-agents. Cette approche est utile pour les workflows complexes, les orchestrations avec état ou l'intégration d'une logique métier personnalisée dans la couche d'orchestration du framework.

La création d'un CustomAgent ne fait pas partie de cet atelier, mais il est bon de savoir que cette option existe si vous en avez besoin.

Félicitations !

Dans cet atelier, vous avez appris à créer plusieurs agents et à les relier entre eux à l'aide de relations parent-sous-agent, à ajouter des valeurs à l'état de session et à les lire dans les instructions de l'agent, et à utiliser des agents de workflow pour transférer directement la conversation entre agents.

Formations et certifications Google Cloud

Les formations et certifications Google Cloud vous aident à tirer pleinement parti des technologies Google Cloud. Nos cours portent sur les compétences techniques et les bonnes pratiques à suivre pour être rapidement opérationnel et poursuivre votre apprentissage. Nous proposons des formations pour tous les niveaux, à la demande, en salle et à distance, pour nous adapter aux emplois du temps de chacun. Les certifications vous permettent de valider et de démontrer vos compétences et votre expérience en matière de technologies Google Cloud.

Dernière mise à jour du manuel : 3 février 2026

Dernier test de l'atelier : 3 février 2026

Copyright 2020 Google LLC Tous droits réservés. Google et le logo Google sont des marques de Google LLC. Tous les autres noms d'entreprises et de produits peuvent être des marques des entreprises auxquelles ils sont associés.