Cette page a été traduite par l'API Cloud Translation.

Créer des systèmes multi-agents avec ADK

1. Introduction

Présentation

Cet atelier vous apprend à orchestrer des systèmes multi-agents complexes à l'aide de Google Agent Development Kit (Google ADK). Vous passerez de hiérarchies d'agents simples à la création de workflows automatisés et collaboratifs.

Ce que vous allez faire

Vous allez créer deux systèmes multi-agents distincts :

Un simple agent de planification de voyages qui apprend à transférer des conversations entre un agent de brainstorming et un agent de planification d'attractions.
Un générateur de pitchs de films plus avancé qui utilise une "salle des auteurs" d'agents automatisés (comme un chercheur, un scénariste et un critique) pour travailler ensemble en boucle afin de créer un scénario de film complet.

Points abordés

Découvrez comment créer des relations parent-sous-agent.
Comment écrire des données dans la session state à partir d'un outil.
Comment lire à partir de state à l'aide de modèles de clés (par exemple, {my_key?}).
Utiliser un SequentialAgent pour les workflows détaillés.
Découvrez comment utiliser un LoopAgent pour créer des cycles d'affinage itératifs.
Découvrez comment utiliser un ParallelAgent pour exécuter des tâches indépendantes simultanément.

2. Systèmes multi-agent

L'Agent Development Kit (ADK) 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 d'un prompt complexe, ADK vous permet de créer un flux de plusieurs agents plus simples qui collaborent sur un problème en se répartissant le travail.

Cette approche présente plusieurs avantages par rapport à l'utilisation d'une seule requête monolithique :

Conception plus simple : il est plus simple de concevoir et d'organiser un flux d'agents spécialisés de petite taille que de concevoir une requête volumineuse et complexe.
Fiabilité : les agents spécialisés sont plus fiables dans leurs tâches spécifiques qu'un agent volumineux et complexe.
Maintenabilité : il est plus facile de corriger ou d'améliorer un petit agent spécialisé sans casser d'autres parties du système.
Modularité : les agents conçus pour un workflow peuvent être facilement réutilisés dans d'autres.

L'arborescence hiérarchique des agents

Arborescence montrant des agents hiérarchiques

Dans ADK, vous organisez les agents dans une structure arborescente. Cette hiérarchie est essentielle pour contrôler le flux de la conversation, car elle limite les agents auxquels un agent peut "transférer" la conversation. Cela rend le comportement du système plus prévisible et plus facile à déboguer. Voici quelques-uns de ses avantages :

Conception intuitive : la structure s'inspire des équipes du monde réel, ce qui facilite le raisonnement.
Flux contrôlé : la hiérarchie vous permet de contrôler précisément la délégation des tâches, ce qui facilite le débogage. Par exemple, la structure arborescente permet de s'assurer que l'agent de rédaction de rapports approprié est appelé, même si vous en avez deux avec des descriptions similaires.

L'ensemble de la structure commence par root_agent. Cet agent agit en tant que parent et peut avoir un ou plusieurs sous-agents, qui à leur tour peuvent également être parents de leurs propres sous-agents, formant ainsi l'arborescence.

3. Configuration du projet

Compte Google

Si vous ne possédez pas encore de compte Google personnel, vous devez en créer un.

Utilisez un compte personnel au lieu d'un compte professionnel ou scolaire.

Connectez-vous à la console Google Cloud à l'aide d'un compte Google personnel.

Activer la facturation

Utiliser 5 $de crédits Google Cloud (facultatif)

Pour suivre cet atelier, vous avez besoin d'un compte de facturation avec un certain crédit. Si vous prévoyez d'utiliser votre propre facturation, vous pouvez ignorer cette étape.

Cliquez sur ce lien et connectez-vous avec un compte Google personnel.Vous verrez quelque chose comme ceci :
Cliquez sur le bouton CLIQUEZ ICI POUR ACCÉDER À VOS CRÉDITS. Vous serez redirigé vers une page permettant de configurer votre profil de facturation.
Cliquez sur Confirmer.

Vous êtes désormais connecté à un compte de facturation d'essai Google Cloud Platform.

Capture d'écran de la vue d'ensemble de la facturation

Configurer un compte de facturation personnel

Si vous avez configuré la facturation à l'aide de crédits Google Cloud, vous pouvez ignorer cette étape.

Pour configurer un compte de facturation personnel, cliquez ici pour activer la facturation dans la console Cloud.

Remarques :

Cet atelier devrait vous coûter moins de 1 USD en ressources Cloud.
Vous pouvez suivre les étapes à la fin de cet atelier pour supprimer les ressources et éviter ainsi que des frais supplémentaires ne vous soient facturés.
Les nouveaux utilisateurs peuvent bénéficier d'un essai sans frais pour un crédit de 300$.

Créer un projet (facultatif)

Si vous n'avez pas de projet que vous souhaitez utiliser pour cet atelier, créez-en un.

4. Ouvrir l'éditeur Cloud Shell

Cliquez sur ce lien pour accéder directement à l'éditeur Cloud Shell.
Si vous êtes invité à autoriser l'accès à un moment donné, cliquez sur Autoriser pour continuer.
Si le terminal ne s'affiche pas en bas de l'écran, ouvrez-le :
- Cliquez sur Afficher.
- Cliquez sur Terminal.
Dans le terminal, définissez votre projet à l'aide de la commande suivante :
```
gcloud config set project [PROJECT_ID]
```
- Exemple :
```
gcloud config set project lab-project-id-example
```
- Si vous ne vous souvenez pas de l'ID de votre projet, vous pouvez lister tous vos ID de projet avec la commande suivante :
```
gcloud projects list
```
Le message suivant doit s'afficher :
```
Updated property [core/project].
```
Si le message WARNING s'affiche et que vous êtes invité à Do you want to continue (Y/n)?, cela signifie probablement que vous avez saisi l'ID du projet de manière incorrecte. Appuyez sur n, puis sur Enter, et réessayez d'exécuter la commande gcloud config set project.

5. Activer les API

Pour utiliser l'API Vertex AI et interagir avec le modèle Gemini, vous devez activer l'API Vertex AI dans votre projet Google Cloud.

Dans le terminal, activez l'API :

gcloud services enable aiplatform.googleapis.com

Voici les sections mises à jour, qui remplacent la création manuelle de fichiers par des instructions permettant de cloner le dépôt GitHub et d'installer les dépendances.

Présentation du SDK Vertex AI pour Python

Pour interagir avec les modèles hébergés sur Vertex AI depuis votre application Python, vous devez utiliser le SDK Vertex AI pour Python. Ce SDK simplifie le processus d'envoi de requêtes, de spécification des paramètres du modèle et de réception des réponses, sans avoir à gérer directement la complexité des appels d'API sous-jacents.

Vous trouverez une documentation complète sur le SDK Vertex AI pour Python ici : Présentation du SDK Vertex AI pour Python | Google Cloud.

6. Configurer l'environnement du projet

Cloner le dépôt

Dans le terminal, clonez le dépôt contenant les fichiers de démarrage.
```
git clone --depth 1 https://github.com/GoogleCloudPlatform/devrel-demos.git
```
L'indicateur --depth 1 ne clone que la dernière version, ce qui est plus rapide.

Dans le terminal, accédez au répertoire de travail approprié pour cet atelier.

cd devrel-demos/ai-ml/build-multiagent-systems-with-adk/adk_multiagent_systems

Activer un environnement virtuel

Dans le terminal, créez et activez un environnement virtuel à l'aide de uv :
```
uv venv
source .venv/bin/activate
```
Dans le terminal, installez google-adk et les autres dépendances à partir du fichier requirements.txt :
```
uv pip install -r requirements.txt
```

Vérifier la structure de vos fichiers

Maintenant que tous vos fichiers sont créés, ouvrez le dossier adk_multiagent_systems dans l'explorateur pour afficher la structure complète.

Dans le menu de l'éditeur Cloud Shell, sélectionnez Fichier > Ouvrir le dossier….
Dans la boîte qui s'affiche, ajoutez les informations de dossier suivantes après votre nom d'utilisateur : devrel-demos/ai-ml/build-multiagent-systems-with-adk/adk_multiagent_systems/. Cliquez sur OK.
Voici un exemple :
Le panneau de l'explorateur à gauche s'actualise. Vous devriez maintenant voir la structure complète de votre projet, avec les sous-répertoires parent_and_subagents et workflow_agents, prêts pour les prochaines étapes.

Configurer des variables d'environnement

Vous êtes déjà dans le répertoire adk_multiagent_systems. Dans le terminal, créez un fichier .env pour stocker vos variables d'environnement :
```
cloudshell edit .env
```

Collez ce qui suit dans le fichier .env qui s'ouvre dans l'éditeur :

GOOGLE_GENAI_USE_VERTEXAI=TRUE
GOOGLE_CLOUD_PROJECT="[YOUR-PROJECT-ID]"
GOOGLE_CLOUD_LOCATION=global
MODEL="gemini-2.5-flash"

Remplacez [YOUR-PROJECT-ID] par l'ID de votre projet Google Cloud. (par exemple, PROJECT_ID = "google-cloud-labs")
Si vous ne vous souvenez pas de votre ID de projet, exécutez la commande suivante dans votre terminal. La liste de tous vos projets et de leurs ID s'affiche.
```
gcloud projects list
```
Dans le terminal, copiez le fichier .env dans les répertoires des sous-agents afin qu'ils puissent également accéder aux variables :
```
cp .env parent_and_subagents/.env
cp .env workflow_agents/.env
```
La structure du fichier devrait maintenant se présenter comme suit :

7. Étudier les transferts entre les agents parents, les sous-agents et les agents pairs

La conversation commence toujours par root_agent. Par défaut, un agent parent utilise le description de ses sous-agents pour décider quand transférer la conversation. Vous pouvez également guider explicitement ces transferts dans le instruction du parent en utilisant le name des sous-agents.

Faisons le test.

Dans l'éditeur Cloud Shell, ouvrez adk_multiagent_systems/parent_and_subagents/agent.py. Notez les trois agents dans le fichier agent.py :
- root_agent (nommé steering) : pose une question à l'utilisateur pour déterminer à quel sous-agent le transférer. Au départ, il ne s'appuie que sur les description de ses sous-agents.
- travel_brainstormer : aide l'utilisateur à trouver des destinations.
- attractions_planner : aide l'utilisateur à lister les choses à faire dans un pays spécifique.
Conseil : Pour lire un fichier agent.py dans l'ordre du flux de conversation, il est souvent plus facile de commencer par le root_agent en bas et de remonter. En effet, le code Python exige que nous définissions nos sous-agents avant de pouvoir les ajouter à un agent.
Faites de travel_brainstormer et attractions_planner des sous-agents de root_agent en ajoutant la ligne suivante à la création de root_agent :
```
    sub_agents=[travel_brainstormer, attractions_planner]
```
Remarque : La hiérarchie des agents n'est définie que par la liste sub_agents du parent. Les sous-agents n'ont pas besoin de paramètre parent.

Dans le terminal, discutez avec votre agent :

cd ~/devrel-demos/ai-ml/build-multiagent-systems-with-adk/adk_multiagent_systems
adk run parent_and_subagents

À l'invite [user]: dans le terminal, saisissez :

hello

Exemple de résultat (le vôtre peut être légèrement différent) :

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

Dites maintenant à l'agent dans le terminal :
```
I could use some help deciding.
```
Exemple de résultat (le vôtre peut être légèrement différent) :
```
[travel_brainstormer]: Okay! To give you the best recommendations, I need to understand what you're looking for in a trip.
...
```
Notez la balise [travel_brainstormer]. Le contrôle transféré root_agent est basé uniquement sur le description du sous-agent.
À l'invite user: dans le terminal, saisissez exit et appuyez sur ENTRÉE pour mettre fin à la conversation.

Soyons maintenant plus explicites. Dans agent.py, ajoutez les éléments suivants à instruction de 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'.

Dans le terminal, exécutez à nouveau l'agent :
```
adk run parent_and_subagents
```
À l'invite [user]: dans le terminal, saisissez :
```
hello
```
Réponse :
```
I would like to go to Japan.
```
Exemple de résultat (le vôtre peut être légèrement différent) :
```
[attractions_planner]: Okay, I can help you with that! Here are some popular attractions in Japan:
...
```
Remarquez le transfert vers attractions_planner, comme indiqué dans vos nouvelles instructions.
Maintenant, réponds avec :
```
Actually I don't know what country to visit.
```
Exemple de résultat (le vôtre peut être légèrement différent) :
```
[travel_brainstormer]: Okay! I can help you brainstorm some countries for travel...
```
Notez que vous avez été transféré vers travel_brainstormer, un pair de attractions_planner. Ce transfert est autorisé par défaut.
Si vous souhaitez empêcher le transfert, vous pouvez définir disallow_transfer_to_peers=True sur l'agent attractions_planner.
À l'invite utilisateur, saisissez exit pour mettre fin à la session.

Récapitulatif

Dans cette section, vous avez découvert les principes de base de la hiérarchie des agents et du flux de conversation :

La conversation commence toujours par root_agent.
Un agent parent peut transférer automatiquement une conversation à un sous-agent en fonction de son description.
Vous pouvez contrôler explicitement ce flux en donnant au parent instruction pour transférer vers un sous-agent par son name.
Par défaut, les agents peuvent transférer les conversations à leurs agents peer (frères et sœurs dans la hiérarchie).

8. Utiliser l'état de session pour stocker et récupérer des informations

Chaque conversation ADK possède un Session, qui inclut un dictionnaire d'état de session. Cet état est accessible à tous les agents, ce qui en fait le moyen idéal de transmettre des informations entre eux ou de conserver des données (comme une liste) tout au long de la conversation.

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

Revenir au fichier adk_multiagent_systems/parent_and_subagents/agent.py

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
    """
    # Load existing attractions from state. If none exist, start an empty list
    existing_attractions = tool_context.state.get("attractions", [])

    # Update the 'attractions' key with a combo of old and new lists.
    # When the tool is run, ADK will create an event and make
    # corresponding updates in the session's state.
    tool_context.state["attractions"] = existing_attractions + attractions

    # A best practice for tools is to return a status message in a return dict
    return {"status": "success"}

Dans ce code, notez les points suivants :

La fonction reçoit tool_context: ToolContext. Cet objet est votre passerelle vers la session.
La ligne tool_context.state["attractions"] = ... lit et écrit directement dans le dictionnaire d'état de la session. L'ADK s'occupe du reste.

Ajoutez l'outil à l'agent attractions_planner en ajoutant le paramètre tools :
```
    tools=[save_attractions_to_state]
```
Ajoutez les points suivants aux instruction existantes 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.
```
Notez la section entre accolades : { attractions? }. Cette fonctionnalité de l'ADK, key templating, injecte la valeur de la clé attractions de l'état dans l'invite de l'agent. Le ? le rend facultatif, ce qui évite les erreurs si la clé n'existe pas encore.

Lancez l'UI Web Agent Development Kit avec la commande suivante dans le terminal :

adk web

Sortie

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)

Dans le terminal Cloud Shell, cliquez sur le bouton Aperçu sur le Web, puis sélectionnez Modifier le port.
Saisissez le numéro de port 8000, puis cliquez sur Modifier et prévisualiser. L'UI de développement d'ADK s'ouvre dans un nouvel onglet du navigateur.
Dans le menu déroulant Sélectionner un agent à gauche, sélectionnez parent_and_subagents.
Commencez la conversation avec hello.
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.
Choisissez une attraction, par exemple :
```
I'll go to the Sphinx
```
Vous devriez obtenir une réponse semblable à celle-ci : D'accord, j'ai ajouté le Sphinx à votre liste…
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 stateDelta décrivant les modifications apportées à l'état.
Répondez en proposant une autre attraction de la liste de l'agent.
Dans le menu de navigation de gauche, cliquez sur le "X" pour quitter l'événement que vous avez inspecté précédemment.
Dans la barre latérale de gauche, cliquez sur l'onglet État. Vous pouvez désormais voir le tableau attractions dans l'état de la session, qui devrait contenir les deux éléments que vous avez sélectionnés.
Envoyez le message suivant à l'agent :
```
What is on my list?
```
L'agent devrait maintenant lire l'état et renvoyer votre liste.
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.

Récapitulatif de la section

Dans cette section, vous avez appris à utiliser l'état Session pour partager des données :

Écrire l'état : vous écrivez dans le dictionnaire d'état à partir d'un outil, à l'aide de l'objet tool_context.state (par exemple, tool_context.state["my_list"] = [...]).
Pour lire l'état : vous injectez des données d'état directement dans le instruction d'un agent à l'aide de modèles de clés (par exemple, Here is your list: {my_list?}).
Pour inspecter l'état : vous pouvez surveiller l'état de la session en direct dans l'UI de développement ADK à l'aide de l'onglet "État".

9. Agents de workflow

Jusqu'à présent, vous avez vu comment un agent parent transférait une requête à un sous-agent, puis attendait l'utilisateur. Les agents de workflow sont différents : ils exécutent leurs sous-agents les uns après les autres dans un flux automatisé, sans attendre l'intervention de l'utilisateur.

C'est idéal pour les tâches automatisées en plusieurs étapes, comme un pipeline "Planifier et exécuter" ou "Rédiger et réviser". ADK fournit trois agents de workflow intégrés pour gérer cela :

SequentialAgent
LoopAgent
ParallelAgent

Le reste de cet atelier sera consacré à la création d'un système multi-agent à l'aide de ces trois agents de workflow.

Vous allez créer un agent qui va rédiger le pitch d'un nouveau film sur un personnage historique. Vos agents se chargeront de la recherche, de l'écriture itérative et de la génération de rapports.

Au final, votre système ressemblera à ceci :

Diagramme d'un système multi-agent film_concept_team

Vous allez créer ce système étape par étape, en commençant par le workflow le plus simple.

10. Créer un système multi-agent avec un SequentialAgent

Un SequentialAgent est un agent de workflow qui exécute ses sous-agents dans une séquence linéaire simple. Chaque agent de sa liste sub_agents est exécuté l'un après l'autre, dans l'ordre. C'est idéal pour les pipelines dans lesquels les tâches doivent être effectuées dans un ordre précis, comme l'agent de présentation de films que vous allez créer maintenant.

Cette première version sera structurée comme suit :

Système multi-agent Film_concept_team étape 1

Un root_agent (greeter) accueillera l'utilisateur et obtiendra le sujet du film.
Il sera ensuite transféré vers un SequentialAgent nommé film_concept_team, qui :
1. Exécutez un agent researcher pour obtenir des informations sur Wikipédia.
2. Exécutez un agent screenwriter pour utiliser ces faits et écrire une intrigue.
3. Exécutez un agent file_writer pour enregistrer le graphique final dans un fichier.

Exécutons-le.

Dans l'éditeur Cloud Shell, ouvrez adk_multiagent_systems/workflow_agents/agent.py.
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.
Notez l'outil append_to_state. Cette fonction d'assistance permet aux agents d'ajouter des données à une liste dans l'état de la session, ce qui permet à researcher et screenwriter de transmettre leur travail.
Essayez l'agent. Dans le terminal, lancez l'interface Web avec le rechargement en direct activé :
```
cd ~/devrel-demos/ai-ml/build-multiagent-systems-with-adk/adk_multiagent_systems
adk web --reload_agents
```
Remarque : Si le port 8000 est utilisé, vous pouvez exécuter le serveur sur un autre port, par exemple : adk web --reload_agents --port 8001.
Dans le terminal Cloud Shell, cliquez sur le bouton Aperçu sur le Web, puis sélectionnez Modifier le port.
Saisissez le numéro de port 8000, puis cliquez sur Modifier et prévisualiser. L'UI de développement d'ADK s'ouvre dans un nouvel onglet du navigateur.
Dans le menu déroulant Sélectionner un agent, sélectionnez workflow_agents.
Commencez la conversation par hello. L'agent greeter répondra.
Lorsque vous y êtes invité, saisissez un personnage historique. Vous pouvez utiliser l'une de ces options ou la vôtre :
- Zhang Zhongjing
- Ada Lovelace
- Marc Aurèle
Le SequentialAgent va maintenant prendre le relais. Vous ne verrez aucun message intermédiaire. researcher, screenwriter et file_writer s'exécuteront les uns après les autres. L'agent ne répondra que lorsque la séquence complète sera terminée.
Si l'opération échoue, vous pouvez cliquer sur + Nouvelle session en haut à droite et réessayer.
Une fois que l'agent a confirmé que le fichier est écrit, recherchez et ouvrez le nouveau fichier .txt dans le répertoire movie_pitches de votre éditeur Cloud Shell pour afficher le résultat.
Dans l'UI de développement ADK, cliquez sur la dernière icône d'agent de l'historique des discussions pour ouvrir la vue des événements.
La vue des événements affiche un graphique visuel de l'arborescence des agents. Vous pouvez voir comment greeter a appelé film_concept_team, qui a ensuite appelé chacun de ses sous-agents dans l'ordre.
Vous pouvez cliquer sur les onglets Request (Requête) et Response (Réponse) pour n'importe quel agent du graphique afin d'inspecter les données exactes qui ont été transmises, y compris l'état de la session.

Récapitulatif de la section

Dans cette section, vous avez appris à utiliser un agent de workflow :

Un SequentialAgent exécute ses sous-agents un par un, dans l'ordre, sans attendre l'intervention de l'utilisateur entre les étapes.
Il s'agit d'un "workflow" (flux de travail) car l'utilisateur parle à root_agent, qui transmet ensuite le travail à SequentialAgent pour qu'il le termine.
Les sous-agents de la séquence utilisent l'état de la session (par exemple, { PLOT_OUTLINE? }) pour accéder au travail des agents précédents.
Vous pouvez utiliser le graphique d'événements dans l'interface utilisateur pour les développeurs afin de visualiser et de déboguer l'intégralité du workflow d'agent à agent.

11. Ajouter un LoopAgent pour le travail itératif

LoopAgent est un agent de workflow qui exécute ses sous-agents dans une séquence, puis recommence au début. Cette "boucle" se poursuit jusqu'à ce qu'une condition soit remplie, par exemple lorsqu'un nombre max_iterations est atteint ou qu'un sous-agent appelle l'outil intégré exit_loop.

Cela s'avère utile pour les tâches qui nécessitent un affinement itératif. Vous allez ajouter ce LoopAgent pour créer une "salle des auteurs" pour votre agent de pitch de film. Cela permet à un agent researcher, screenwriter et critic de travailler en boucle, en améliorant l'intrigue à chaque passage jusqu'à ce que l'agent critic décide que c'est prêt. Cela aide également l'agent à gérer les entrées utilisateur plus vagues (comme "un ancien médecin") en lui permettant de faire des recherches et d'affiner une idée.

Système multi-agent Film_concept_team étape 2

Pour effectuer ces modifications :

Dans adk_multiagent_systems/workflow_agents/agent.py, ajoutez l'importation pour exit_loop (à côté des autres importations google.adk) :
```
from google.adk.tools import exit_loop
```

Ajoutez le nouvel agent critic. Cet agent examinera l'intrigue. Si elle est bonne, elle appelle exit_loop. Sinon, il ajoute des commentaires à l'état pour la boucle suivante.
Collez la définition d'agent suivante sous la section # Agents :

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]
)

Créez le writers_room LoopAgent. Il contiendra les trois agents qui travailleront en boucle.
Collez le code suivant au-dessus de la définition de l'agent film_concept_team :
```
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,
)
```
Notez le paramètre max_iterations=5. Il s'agit d'un garde-fou essentiel pour éviter les boucles infinies, même lorsque vous avez une condition de sortie.

Mettez à jour le SequentialAgent film_concept_team pour utiliser la nouvelle boucle writers_room. Remplacez researcher et screenwriter par l'agent writers_room unique.Remplacez votre définition film_concept_team existante par celle-ci :

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
    ],
)

Revenez à l'onglet de l'UI de développement ADK et cliquez sur + Nouvelle session en haut à droite.
Commencez une nouvelle conversation avec hello.
Lorsque vous y êtes invité, donnez à l'agent un sujet plus général cette fois-ci. Voici quelques idées :
- un designer industriel qui a créé des produits pour le grand public
- un cartographe (un créateur de cartes)
- ce type qui a augmenté les rendements agricoles
L'agent va maintenant parcourir la boucle. Dans l'UI de développement ADK, vous verrez les journaux à mesure que les agents s'exécutent plusieurs fois (par exemple, "[chercheur]", "[scénariste]", "[critique]", "[chercheur]", "[scénariste]", "[critique]"…
Une fois la boucle terminée, l'agent écrit le fichier. Examinez le fichier généré dans le répertoire adk_multiagent_systems/movie_pitches.
Inspectez le graphique des événements dans l'UI de développement pour voir la structure de la boucle.

Récapitulatif de la section

Dans cette section, vous avez appris à utiliser LoopAgent :

Un LoopAgent est un agent de workflow qui répète sa séquence de sous-agents, créant ainsi une "boucle interne" pour les tâches itératives.
Les agents de la boucle utilisent l'état de la session pour transmettre le travail (par exemple, PLOT_OUTLINE) et les commentaires (par exemple, CRITICAL_FEEDBACK) les uns aux autres lors des passages suivants.
La boucle peut être arrêtée en atteignant une limite de max_iterations ou par un agent appelant l'outil exit_loop.

12. Utiliser un ParallelAgent pour "fan out and gather"

ParallelAgent est un agent de workflow qui exécute tous ses sous-agents en même temps (simultanément). Cette approche est utile pour les tâches qui peuvent être divisées en sous-tâches indépendantes, comme l'exécution de deux tâches de recherche différentes.

Vous allez utiliser un ParallelAgent pour créer une "équipe de préproduction" qui travaille en parallèle. Un agent étudiera le potentiel au box-office, tandis qu'un autre réfléchira simultanément à des idées de casting. Il s'agit souvent d'un modèle de type "fan out and gather" : l'ParallelAgent "déploie" le travail, et un agent ultérieur (notre file_writer) "rassemble" les résultats.

Système multi-agent Film_concept_team étape 3

Le flux de votre agent final sera le suivant :

greeter (racine) lance le chat.
Il est transféré à film_concept_team (SequentialAgent), qui exécute :
- writers_room (LoopAgent) pour créer le graphique.
- La nouvelle preproduction_team (ParallelAgent) pour rechercher le box-office et le casting en même temps.
- Le file_writer pour collecter tous les résultats et enregistrer le fichier.

Pour effectuer ces modifications :

Dans adk_multiagent_systems/workflow_agents/agent.py, collez le nouveau ParallelAgent et ses sous-agents 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
    ]
)

Mettez à jour la liste sub_agents de SequentialAgent film_concept_team pour inclure le nouveau preproduction_team (entre writers_room et file_writer).Remplacez votre définition film_concept_team existante par celle-ci :

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
    ],
)

Mettez à jour les instruction de l'agent file_writer afin qu'il "rassemble" les nouveaux rapports de l'état et les ajoute au fichier.
Remplacez la chaîne instruction pour file_writer par le code suivant :

    instruction="""
    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? }
    """,

Revenez à l'onglet de l'UI de développement ADK et cliquez sur + Nouvelle session.
Saisissez hello pour démarrer la conversation.
Lorsque vous y êtes invité, saisissez une idée de personnage. Voici quelques idées :
- cette actrice qui a inventé la technologie du Wi-Fi
- un chef passionnant
- acteurs clés des expositions universelles.
Une fois que l'agent a terminé son travail, examinez le fichier final dans le répertoire adk_multiagent_systems/movie_pitches. Il devrait maintenant contenir le résumé, le rapport sur les recettes et le rapport sur le casting dans un seul document.

Récapitulatif de la section

Dans cette section, vous avez appris à utiliser ParallelAgent :

Un ParallelAgent "se déploie" en exécutant tous ses sous-agents en même temps, plutôt que dans une séquence.
Cette méthode est très efficace pour les tâches qui ne dépendent pas les unes des autres (comme la recherche sur deux sujets différents).
Les résultats des agents parallèles sont "rassemblés" par un agent ultérieur. Pour ce faire, les agents parallèles doivent enregistrer leur travail dans l'état de la session (à l'aide de output_key), et un agent final (comme file_writer) doit lire ces clés.

13. Agents de workflow personnalisés

Si les agents de workflow prédéfinis de SequentialAgent, LoopAgent et ParallelAgent ne répondent pas à vos besoins, 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.

14. Félicitations !

Vous avez réussi à créer un système multi-agents sophistiqué à l'aide de Google Agent Development Kit (ADK). Vous êtes passé d'une simple relation parent-enfant entre agents à l'orchestration de workflows automatisés complexes capables de rechercher, d'écrire et d'affiner un projet créatif.

Récapitulatif

Dans cet atelier, vous avez :

Organiser les agents dans une arborescence hiérarchique avec des relations parent-sous-agent
Transferts d'agent à agent contrôlés, à la fois automatiquement (à l'aide de description) et explicitement (à l'aide de instruction).
Utilisez un outil pour écrire des données dans le dictionnaire tool_context.state.
Utilisation de modèles de clés (par exemple, { PLOT_OUTLINE? }) pour lire l'état de la session et guider la requête d'un agent.
Implémentation d'un SequentialAgent pour créer un workflow simple et détaillé (recherche > écriture > enregistrement).
Utilisé un LoopAgent avec un agent critic et l'outil exit_loop pour créer un cycle d'affinage itératif.
Utilisé un ParallelAgent pour "étendre" les tâches indépendantes (comme le casting et les recherches sur le box-office) afin de les exécuter simultanément.

Continuer à expérimenter

Il existe de nombreuses façons de mettre en pratique ce que vous avez appris. Voici quelques idées :

Ajouter des agents : essayez d'ajouter un agent à votre preproduction_team ParallelAgent. Par exemple, vous pouvez créer un marketing_agent qui rédige un slogan pour le film en fonction du PLOT_OUTLINE.
Ajouter des outils : fournissez d'autres outils à votre agent researcher. Vous pouvez créer un outil qui utilise une API Recherche Google pour trouver des informations qui ne figurent pas sur Wikipédia.
Explorer CustomAgent : l'atelier mentionne CustomAgent pour les workflows qui ne correspondent pas aux modèles standards. Essayez d'en créer un qui, par exemple, exécute un agent de manière conditionnelle uniquement si une clé spécifique existe dans l'état de la session.

Créer des systèmes multi-agents avec ADK

1. Introduction

Présentation

Ce que vous allez faire

Points abordés

2. Systèmes multi-agent

L'arborescence hiérarchique des agents

3. Configuration du projet

Compte Google

Se connecter à la console Google Cloud

Activer la facturation

Utiliser 5 $de crédits Google Cloud (facultatif)

Configurer un compte de facturation personnel

Créer un projet (facultatif)

4. Ouvrir l'éditeur Cloud Shell

5. Activer les API

Présentation du SDK Vertex AI pour Python

6. Configurer l'environnement du projet

Cloner le dépôt

Activer un environnement virtuel

Vérifier la structure de vos fichiers

Configurer des variables d'environnement

7. Étudier les transferts entre les agents parents, les sous-agents et les agents pairs

Récapitulatif

8. Utiliser l'état de session pour stocker et récupérer des informations

Récapitulatif de la section

9. Agents de workflow

10. Créer un système multi-agent avec un SequentialAgent

Récapitulatif de la section

11. Ajouter un LoopAgent pour le travail itératif

Récapitulatif de la section

12. Utiliser un ParallelAgent pour "fan out and gather"

Récapitulatif de la section

13. Agents de workflow personnalisés

14. Félicitations !

Récapitulatif

Continuer à expérimenter