Diese Seite wurde von der Cloud Translation API übersetzt.

Multi-Agent-Systeme mit dem ADK erstellen

1. Einführung

Übersicht

In diesem Lab erfahren Sie, wie Sie komplexe Multi-Agenten-Systeme mit dem Google Agent Development Kit (Google ADK) orchestrieren. Sie gehen von einfachen Agentenhierarchien zu automatisierten, kollaborativen Workflows über.

Aufgaben

Sie erstellen zwei verschiedene Multi-Agenten-Systeme:

Ein einfacher Reiseplanungs-Agent, der lernt, Unterhaltungen zwischen einem „Brainstorming“-Agenten und einem „Attraktionsplanungs“-Agenten zu übertragen.
Ein fortschrittlicherer Generator für Filmkonzepte, der einen „Writer’s Room“ mit automatisierten Agents (z. B. Rechercheur, Drehbuchautor und Kritiker) verwendet, die in einem Loop zusammenarbeiten, um eine vollständige Filmhandlung zu erstellen.

Lerninhalte

So erstellen Sie Beziehungen zwischen über- und untergeordneten Agenten.
So schreiben Sie Daten aus einem Tool in die Sitzung state.
So lesen Sie Daten aus state mithilfe von Schlüsselvorlagen (z.B. {my_key?}).
SequentialAgent für Schritt-für-Schritt-Workflows verwenden
LoopAgent verwenden, um iterative Optimierungszyklen zu erstellen.
So verwenden Sie einen ParallelAgent, um unabhängige Aufgaben gleichzeitig auszuführen.

2. Multi-Agenten-Systeme

Mit dem Agent Development Kit (ADK) können Entwickler generative Modelle mit zuverlässigeren, anspruchsvolleren und mehrstufigen Verhaltensweisen ausstatten. Anstelle eines komplexen Prompts können Sie mit dem ADK einen Flow aus mehreren einfacheren Agenten erstellen, die zusammenarbeiten, um ein Problem zu lösen, indem sie die Arbeit aufteilen.

Dieser Ansatz bietet mehrere Vorteile gegenüber der Verwendung eines einzelnen, monolithischen Prompts:

Einfacheres Design:Es ist einfacher, einen Ablauf mit kleinen, spezialisierten Agents zu entwerfen und zu organisieren, als einen großen, komplexen Prompt zu erstellen.
Zuverlässigkeit:Spezialisierte Agenten sind bei ihren spezifischen Aufgaben zuverlässiger als ein großer, komplexer Agent.
Wartungsfreundlichkeit:Es ist einfacher, einen kleinen, spezialisierten Agenten zu korrigieren oder zu verbessern, ohne andere Teile des Systems zu beschädigen.
Modularität:Agenten, die für einen Workflow erstellt wurden, lassen sich problemlos in anderen Workflows wiederverwenden.

Der hierarchische KI-Agenten-Baum

Baumstruktur mit hierarchischen KI-Agenten

Im ADK organisieren Sie Agenten in einer Baumstruktur. Diese Hierarchie ist entscheidend für die Steuerung des Gesprächsablaufs, da sie einschränkt, welcher Agent das Gespräch an welchen anderen Agenten „übergeben“ kann. Dadurch ist das Verhalten des Systems besser vorhersagbar und die Fehlerbehebung wird einfacher. Die wichtigsten Vorteile:

Intuitives Design:Die Struktur ist an realen Teams orientiert, was die Analyse erleichtert.
Kontrollierter Ablauf:Die Hierarchie ermöglicht eine präzise Steuerung der Aufgabenübertragung, was beim Debuggen hilfreich ist. Die Baumstruktur sorgt beispielsweise dafür, dass der richtige Agent zum Verfassen von Berichten aufgerufen wird, auch wenn Sie zwei mit ähnlichen Beschreibungen haben.

Die gesamte Struktur beginnt mit dem root_agent. Dieser Agent fungiert als übergeordnetes Element und kann einen oder mehrere Sub-Agenten haben, die wiederum auch übergeordnete Elemente für ihre eigenen Sub-Agenten sein können. So entsteht der Baum.

3. Projekt einrichten

Google-Konto

Wenn Sie noch kein privates Google-Konto haben, müssen Sie ein Google-Konto erstellen.

Verwenden Sie stattdessen ein privates Konto.

Melden Sie sich mit einem privaten Google-Konto in der Google Cloud Console an.

Abrechnung aktivieren

Google Cloud-Guthaben im Wert von 5 $einlösen (optional)

Für diesen Workshop benötigen Sie ein Rechnungskonto mit Guthaben. Wenn Sie Ihre eigene Abrechnung verwenden möchten, können Sie diesen Schritt überspringen.

Klicken Sie auf diesen Link und melden Sie sich mit einem privaten Google-Konto an.Sie sehen dann Folgendes:
Klicken Sie auf die Schaltfläche HIER KLICKEN, UM AUF IHR GUTHABEN ZUZUGREIFEN. Sie werden dann auf eine Seite weitergeleitet, auf der Sie Ihr Abrechnungsprofil einrichten können.
Klicken Sie auf Bestätigen.

Sie sind jetzt mit einem Google Cloud Platform-Testrechnungskonto verbunden.

Screenshot der Abrechnungsübersicht

Privates Rechnungskonto einrichten

Wenn Sie die Abrechnung mit Google Cloud-Guthaben eingerichtet haben, können Sie diesen Schritt überspringen.

Klicken Sie hier, um die Abrechnung in der Cloud Console zu aktivieren und ein privates Rechnungskonto einzurichten.

Hinweise:

Die Kosten für Cloud-Ressourcen für dieses Lab sollten weniger als 1 $betragen.
Sie können die Schritte am Ende dieses Labs ausführen, um Ressourcen zu löschen und so weitere Kosten zu vermeiden.
Neuen Nutzern steht die kostenlose Testversion mit einem Guthaben von 300$ zur Verfügung.

Projekt erstellen (optional)

Wenn Sie kein aktuelles Projekt haben, das Sie für dieses Lab verwenden möchten, erstellen Sie hier ein neues Projekt.

4. Cloud Shell-Editor öffnen

Klicken Sie auf diesen Link, um direkt zum Cloud Shell-Editor zu gelangen.
Wenn Sie heute an irgendeinem Punkt zur Autorisierung aufgefordert werden, klicken Sie auf Autorisieren, um fortzufahren.
Wenn das Terminal nicht unten auf dem Bildschirm angezeigt wird, öffnen Sie es:
- Klicken Sie auf Ansehen.
- Klicken Sie auf Terminal.
Legen Sie im Terminal Ihr Projekt mit diesem Befehl fest:
```
gcloud config set project [PROJECT_ID]
```
- Beispiel:
```
gcloud config set project lab-project-id-example
```
- Wenn Sie sich nicht mehr an Ihre Projekt-ID erinnern, können Sie alle Ihre Projekt-IDs mit folgendem Befehl auflisten:
```
gcloud projects list
```
Es sollte folgende Meldung angezeigt werden:
```
Updated property [core/project].
```
Wenn Sie WARNING sehen und gefragt werden, ob Sie Do you want to continue (Y/n)?, haben Sie die Projekt-ID wahrscheinlich falsch eingegeben. Drücken Sie n, dann Enter und versuchen Sie, den Befehl gcloud config set project noch einmal auszuführen.

5. APIs aktivieren

Wenn Sie die Vertex AI API verwenden und mit dem Gemini-Modell interagieren möchten, müssen Sie die Vertex AI API in Ihrem Google Cloud-Projekt aktivieren.

Aktivieren Sie die API im Terminal:

gcloud services enable aiplatform.googleapis.com

Hier finden Sie die aktualisierten Abschnitte, in denen das manuelle Erstellen von Dateien durch Anleitungen zum Klonen des GitHub-Repositorys und Installieren der Abhängigkeiten ersetzt wird.

Einführung in das Vertex AI SDK für Python

Wenn Sie in Ihrer Python-Anwendung mit Modellen interagieren möchten, die auf Vertex AI gehostet werden, verwenden Sie das Vertex AI SDK für Python. Dieses SDK vereinfacht das Senden von Prompts, das Festlegen von Modellparametern und das Empfangen von Antworten, ohne dass die Komplexität der zugrunde liegenden API-Aufrufe direkt berücksichtigt werden muss.

Eine umfassende Dokumentation zum Vertex AI SDK für Python finden Sie unter Einführung in das Vertex AI SDK für Python | Google Cloud.

6. Projektumgebung einrichten

Repository klonen

Klonen Sie im Terminal das Repository mit den Startdateien.
```
git clone --depth 1 https://github.com/GoogleCloudPlatform/devrel-demos.git devrel-demos-multiagent-lab
```
Das Flag --depth 1 klont nur die neueste Version, was schneller geht.
Verschieben Sie im Terminal den labspezifischen Ordner in Ihr Basisverzeichnis und benennen Sie ihn so um, dass er der erwarteten Struktur des Labs entspricht.
```
mv devrel-demos-multiagent-lab/ai-ml/build-multiagent-systems-with-adk/adk_multiagent_systems ~
```
Wechseln Sie im Terminal zum richtigen Arbeitsverzeichnis für dieses Lab (adk_multiagent_systems).
```
cd ~/adk_multiagent_systems
```

Dateistruktur überprüfen

Nachdem alle Dateien erstellt wurden, öffnen Sie den Ordner adk_multiagent_systems im Explorer, um die vollständige Struktur zu sehen.

Wählen Sie im Menü des Cloud Shell-Editors Datei > Ordner öffnen… aus.
Fügen Sie im Pop-up-Fenster nach Ihrem Nutzernamen die folgenden Ordnerinformationen hinzu: adk_multiagent_systems/. Klicken Sie auf OK.
Das sollte ungefähr so aussehen:
Der Explorer-Bereich auf der linken Seite wird aktualisiert. Sie sollten nun die vollständige Projektstruktur mit den Unterverzeichnissen parent_and_subagents und workflow_agents sehen.
Wenn das Terminal verschwindet, können Sie es wieder öffnen, indem Sie im oberen Menü auf Ansicht und dann auf Terminal klicken.

Virtuelle Umgebung aktivieren

Erstellen und aktivieren Sie im Terminal eine virtuelle Umgebung mit uv. So wird sichergestellt, dass die Projektabhängigkeiten nicht mit dem System-Python oder anderen Projekten in Konflikt stehen.
```
uv venv
source .venv/bin/activate
```
Wenn Ihre Cloud Shell-Sitzung aktualisiert wird oder Sie einen neuen Terminaltab öffnen, müssen Sie die virtuelle Umgebung möglicherweise reaktivieren, indem Sie source .venv/bin/activate im Verzeichnis adk_multiagent_systems ausführen.
Installieren Sie im Terminal google-adk und die anderen Abhängigkeiten aus der Datei requirements.txt:
```
uv pip install -r requirements.txt
```

Umgebungsvariablen einrichten

Sie befinden sich bereits im Verzeichnis adk_multiagent_systems. Erstellen Sie im Terminal eine .env-Datei zum Speichern Ihrer Umgebungsvariablen:
```
cloudshell edit .env
```

Fügen Sie Folgendes in die Datei .env ein, die im Editor geöffnet wird:

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

Ersetzen Sie [YOUR-PROJECT-ID] durch Ihre tatsächliche Google Cloud-Projekt-ID. (z.B. PROJECT_ID = "google-cloud-labs")
Wenn Sie sich nicht an Ihre Projekt-ID erinnern können, führen Sie den folgenden Befehl in Ihrem Terminal aus. Sie sehen dann eine Liste aller Ihrer Projekte und deren IDs.
```
gcloud projects list
```
Kopieren Sie im Terminal die Datei .env in die Unter-Agent-Verzeichnisse, damit auch sie auf die Variablen zugreifen können:
```
cp .env parent_and_subagents/.env
cp .env workflow_agents/.env
```
Die Dateistruktur sollte jetzt so aussehen:

7. Übertragungen zwischen übergeordneten, Sub- und gleichrangigen Agenten

Die Unterhaltung beginnt immer mit dem root_agent. Standardmäßig verwendet ein übergeordneter Agent die description seiner untergeordneten Agents, um zu entscheiden, wann die Unterhaltung weitergeleitet werden soll. Sie können diese Übertragungen auch explizit in der instruction des übergeordneten Kontos mithilfe der name der untergeordneten Konten steuern.

Probieren wir es aus.

Öffnen Sie im Cloud Shell-Editor die Datei adk_multiagent_systems/parent_and_subagents/agent.py. Beachten Sie die drei Agenten in der Datei agent.py:
- root_agent (mit dem Namen steering): Stellt dem Nutzer eine Frage, um zu entscheiden, an welchen untergeordneten Agenten die Anfrage weitergeleitet werden soll. Zuerst stützt er sich nur auf die description seiner untergeordneten Agenten.
- travel_brainstormer: Hilft dem Nutzer, Reiseziele zu finden.
- attractions_planner: Hilft dem Nutzer, eine Liste mit Aktivitäten in einem bestimmten Land zu erstellen.
Tipp:Wenn Sie eine agent.py-Datei in der Reihenfolge des Konversationsablaufs lesen möchten, ist es oft am einfachsten, mit der root_agent unten zu beginnen und sich nach oben vorzuarbeiten. Das liegt daran, dass in Python unsere untergeordneten Agenten definiert werden müssen, bevor wir sie einem Agenten hinzufügen können.
Machen Sie travel_brainstormer und attractions_planner zu untergeordneten Agenten von root_agent, indem Sie beim Erstellen von root_agent die folgende Zeile hinzufügen:
```
    sub_agents=[travel_brainstormer, attractions_planner]
```
Hinweis: Die Agentenhierarchie wird nur durch die sub_agents-Liste des übergeordneten Agenten definiert. Untergeordnete Agenten benötigen keinen parent-Parameter.

Chatten Sie im Terminal mit Ihrem Agent:

cd ~/adk_multiagent_systems
adk run parent_and_subagents

Geben Sie bei der Eingabeaufforderung [user]: im Terminal Folgendes ein:

hello

Beispielausgabe (Ihre Ausgabe kann abweichen):

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

Teilen Sie dem Agenten jetzt im Terminal Folgendes mit:
```
I could use some help deciding.
```
Beispielausgabe (Ihre Ausgabe kann abweichen):
```
[travel_brainstormer]: Okay! To give you the best recommendations, I need to understand what you're looking for in a trip.
...
```
Beachten Sie das Tag [travel_brainstormer]. Die übertragene Kontrolle von root_agent basiert nur auf dem description des untergeordneten Kundenservicemitarbeiters.
Geben Sie im Terminal beim Prompt user: exit ein und drücken Sie die Eingabetaste, um die Unterhaltung zu beenden.

Sehen wir uns das genauer an. Fügen Sie in agent.py Folgendes zum instruction des root_agent hinzu:

        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'.

Führen Sie den Agent im Terminal noch einmal aus:
```
adk run parent_and_subagents
```
Geben Sie bei der Eingabeaufforderung [user]: im Terminal Folgendes ein:
```
hello
```
Das solltest du sagen:
```
I would like to go to Japan.
```
Beispielausgabe (Ihre Ausgabe kann abweichen):
```
[attractions_planner]: Okay, I can help you with that! Here are some popular attractions in Japan:
...
```
Beachten Sie die Übertragung zu attractions_planner gemäß Ihrer neuen Anleitung.
Antworte jetzt mit:
```
Actually I don't know what country to visit.
```
Beispielausgabe (Ihre Ausgabe kann abweichen):
```
[travel_brainstormer]: Okay! I can help you brainstorm some countries for travel...
```
Sie wurden an travel_brainstormer weitergeleitet, einen gleichrangigen Agenten von attractions_planner. Das ist standardmäßig zulässig.
Wenn Sie Übertragungen verhindern möchten, können Sie disallow_transfer_to_peers=True für den attractions_planner-Agenten festlegen.
Geben Sie mit der Eingabeaufforderung exit ein, um die Sitzung zu beenden.

Zusammenfassung

In diesem Abschnitt haben Sie die Grundlagen der Agent-Hierarchie und des Unterhaltungsablaufs kennengelernt:

Die Unterhaltung beginnt immer mit dem root_agent.
Ein übergeordneter Agent kann automatisch an einen untergeordneten Agenten übertragen werden, wenn er die description erfüllt.
Sie können diesen Ablauf explizit steuern, indem Sie dem übergeordneten Agenten instruction geben, um über seine name an einen untergeordneten Agenten zu übertragen.
Standardmäßig können Agenten an ihre peer-Agents (Geschwister in der Hierarchie) weiterleiten.

8. Verwendung des Sitzungsstatus zum Speichern und Abrufen von Informationen

Jede ADK-Unterhaltung hat einen Session, der ein Sitzungsstatus-Dictionary enthält. Auf diesen Status kann von allen Agenten zugegriffen werden. Er ist also ideal, um Informationen zwischen ihnen weiterzugeben oder Daten (z. B. eine Liste) während der gesamten Unterhaltung beizubehalten.

So fügen Sie dem Status etwas hinzu und lesen daraus:

Zur Datei adk_multiagent_systems/parent_and_subagents/agent.py zurückkehren

Fügen Sie nach dem Header # Tools die folgende Funktionsdefinition ein:

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"}

In diesem Code ist Folgendes von Interesse:

Die Funktion empfängt tool_context: ToolContext. Dieses Objekt ist Ihr Gateway zur Sitzung.
In der Zeile tool_context.state["attractions"] = ... wird direkt aus dem Zustands-Dictionary der Sitzung gelesen und in dieses geschrieben. Das ADK erledigt den Rest.

Fügen Sie das Tool dem Agenten attractions_planner hinzu, indem Sie den Parameter tools ergänzen:
```
    tools=[save_attractions_to_state]
```
Fügen Sie der vorhandenen instruction des Agenten attractions_planner die folgenden Aufzählungspunkte hinzu:
```
        - 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.
```
Beachten Sie den Abschnitt in geschweiften Klammern: { attractions? }. Mit dieser ADK-Funktion, key templating, wird der Wert des Schlüssels attractions aus dem Status in den Prompt des Kundenservicemitarbeiters eingefügt. Das ? macht es optional und verhindert Fehler, wenn der Schlüssel noch nicht vorhanden ist.

Starten Sie die Web-Benutzeroberfläche des Agent Development Kit mit dem folgenden Befehl im Terminal:

adk web

Ausgabe

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)

Klicken Sie im Cloud Shell-Terminal auf die Schaltfläche Webvorschau und wählen Sie Port ändern aus, um die Weboberfläche in einem neuen Tab aufzurufen.
Geben Sie die Portnummer 8000 ein und klicken Sie auf Ändern und Vorschau. Ein neuer Browsertab mit der ADK-Entwicklungsoberfläche wird geöffnet.
Wählen Sie links im Drop-down-Menü KI-Agent auswählen die Option parent_and_subagents aus.
Beginnen Sie die Unterhaltung mit: hello
Nachdem der Agent Sie begrüßt hat, antworten Sie mit:
```
I'd like to go to Egypt.
```
Sie sollten an den attractions_planner weitergeleitet werden und eine Liste mit Sehenswürdigkeiten erhalten.
Wählen Sie eine Sehenswürdigkeit aus, z. B.:
```
I'll go to the Sphinx
```
Sie sollten eine Antwort wie Okay, ich habe die Sphinx in deiner Liste gespeichert… erhalten.
Klicken Sie auf die Antwort-Toolbox (mit einem Häkchen markiert), um das Ereignis aufzurufen, der aus der Antwort des Tools erstellt wurde.
Wie Sie sehen, enthält es das Feld actions mit stateDelta, das die Änderungen am Status beschreibt.
Antworten Sie mit einer anderen Attraktion aus der Liste des Kundenservicemitarbeiters.
Klicken Sie im Navigationsmenü auf der linken Seite auf das „X“, um den Fokus auf das zuvor untersuchte Ereignis zu beenden.
Klicken Sie in der linken Seitenleiste auf den Tab Status. Sie können das attractions-Array jetzt im Status der Sitzung sehen. Es sollte beide ausgewählten Elemente enthalten.
Senden Sie dem Agenten die folgende Nachricht:
```
What is on my list?
```
Der Agent sollte jetzt den Status lesen und Ihre Liste zurückgeben.
Wenn Sie mit dem Testen des Agenten fertig sind, schließen Sie den Browser-Tab und drücken Sie im Cloud Shell-Terminal STRG + C, um den Server zu beenden.

Zusammenfassung des Abschnitts

In diesem Abschnitt haben Sie gelernt, wie Sie den Status Session verwenden, um Daten freizugeben:

Status schreiben: Sie schreiben aus einem Tool in das Status-Dictionary und verwenden dazu das tool_context.state-Objekt (z.B. tool_context.state["my_list"] = [...]) verwenden.
Status lesen: Sie fügen Statusdaten direkt in die instruction eines Agenten ein, indem Sie Schlüsselvorlagen verwenden (z.B. Here is your list: {my_list?}) verwenden.
Status prüfen: Sie können den Sitzungsstatus live in der ADK-Entwicklungsoberfläche auf dem Tab „Status“ überwachen.

9. Workflow-Agenten

Bisher haben Sie gesehen, wie ein übergeordneter Agent an einen untergeordneten Agenten übergeben wird und dann auf den Nutzer wartet. Workflow-Agenten funktionieren anders: Sie führen ihre untergeordneten Agenten nacheinander in einem automatisierten Ablauf aus, ohne auf Nutzereingaben zu warten.

Das ist ideal für automatisierte, mehrstufige Aufgaben wie eine „Planen und Ausführen“- oder „Entwurf erstellen und überarbeiten“-Pipeline. Das ADK bietet drei integrierte Workflow-Agenten, um dies zu verwalten:

SequentialAgent
LoopAgent
ParallelAgent

Im restlichen Teil dieses Labs wird beschrieben, wie Sie mit diesen drei Workflow-Agenten ein Multi-Agent-System erstellen.

Sie erstellen einen Agenten, der ein Konzept für einen neuen Film über eine historische Figur entwickelt. Ihre Agenten übernehmen die Recherche, das iterative Schreiben und die Berichterstellung.

Am Ende sieht Ihr System so aus:

Diagramm des Multi-Agenten-Systems film_concept_team

Sie erstellen dieses System Schritt für Schritt und beginnen mit dem einfachsten Workflow.

10. Multi-Agenten-System mit einem SequentialAgent erstellen

Ein SequentialAgent ist ein Workflow-Agent, der seine Sub-Agents in einer einfachen, linearen Abfolge ausführt. Jeder Agent in der Liste sub_agents wird nacheinander in der Reihenfolge ausgeführt. Das ist ideal für Pipelines, in denen Aufgaben in einer bestimmten Reihenfolge ausgeführt werden müssen, wie bei dem Agenten für Filmvorschläge, den Sie jetzt erstellen.

Die erste Version ist so strukturiert:

Schritt 1 für das Multi-Agenten-System film_concept_team

Ein root_agent (greeter) begrüßt den Nutzer und ermittelt das Filmthema.
Die Daten werden dann in ein SequentialAgent mit dem Namen film_concept_team übertragen. Dieses SequentialAgent hat folgende Eigenschaften:
1. Führen Sie einen researcher-Agent aus, um Fakten aus Wikipedia abzurufen.
2. Führen Sie einen screenwriter-Agenten aus, um diese Fakten zum Schreiben einer Handlung zu verwenden.
3. Führen Sie einen file_writer-Agent aus, um das endgültige Diagramm in einer Datei zu speichern.

Führen wir sie aus.

Öffnen Sie im Cloud Shell-Editor die Datei adk_multiagent_systems/workflow_agents/agent.py.
Lesen Sie diese Agenten-Definitionsdatei. Da untergeordnete Agenten definiert werden müssen, bevor sie einem übergeordneten Agenten zugewiesen werden können, können Sie die Agenten von unten nach oben lesen, um die Datei in der Reihenfolge des Unterhaltungsablaufs zu lesen.
Beachten Sie das Tool append_to_state. Mit dieser Hilfsfunktion können Kundenservicemitarbeiter Daten an eine Liste im Sitzungsstatus anhängen. So übergeben researcher und screenwriter ihre Arbeit.
Probieren Sie den Agenten aus. Starten Sie die Weboberfläche im Terminal mit aktivierter Live-Aktualisierung:
```
cd ~/adk_multiagent_systems
adk web --reload_agents
```
Hinweis: Wenn Port 8000 verwendet wird, können Sie einen anderen Port verwenden, z. B. adk web --reload_agents --port 8001.
Klicken Sie im Cloud Shell-Terminal auf die Schaltfläche Webvorschau und wählen Sie Port ändern aus, um die Weboberfläche in einem neuen Tab aufzurufen.
Geben Sie die Portnummer 8000 ein und klicken Sie auf Ändern und Vorschau. Ein neuer Browsertab mit der ADK-Entwicklungsoberfläche wird geöffnet.
Wählen Sie im Drop-down-Menü KI-Agent auswählen die Option workflow_agents aus.
Beginnen Sie die Unterhaltung mit hello. Der greeter-Agent antwortet.
Geben Sie bei Aufforderung eine historische Persönlichkeit ein. Sie können eine dieser Optionen oder eine eigene verwenden:
- Zhang Zhongjing
- Ada Lovelace
- Marcus Aurelius
Die SequentialAgent wird jetzt übernommen. Es werden keine Zwischennachrichten angezeigt. Die researcher, screenwriter und file_writer werden nacheinander ausgeführt. Der Agent antwortet erst, wenn die gesamte Sequenz abgeschlossen ist.
Wenn der Vorgang fehlschlägt, können Sie rechts oben auf + Neue Sitzung klicken und es noch einmal versuchen.
Sobald der Agent bestätigt, dass die Datei geschrieben wurde, suchen und öffnen Sie die neue .txt-Datei im Verzeichnis movie_pitches im Cloud Shell-Editor, um die Ausgabe zu sehen.
Klicken Sie in der ADK Dev-Benutzeroberfläche auf das letzte Agenten-Symbol im Chatverlauf, um die Ereignisansicht zu öffnen.
In der Ereignisansicht wird ein visuelles Diagramm des Agentenbaums angezeigt. Sie sehen, wie der greeter den film_concept_team aufgerufen hat, der dann seine einzelnen Sub-Agents der Reihe nach aufgerufen hat.
Sie können im Diagramm für jeden Agent auf die Tabs Anfrage und Antwort klicken, um die genauen Daten zu prüfen, die übergeben wurden, einschließlich des Sitzungsstatus.

Zusammenfassung des Abschnitts

In diesem Abschnitt haben Sie gelernt, wie Sie einen Workflow-Agenten verwenden:

Ein SequentialAgent führt seine untergeordneten Agenten nacheinander aus, ohne zwischen den Schritten auf eine Nutzereingabe zu warten.
Dies ist ein „Workflow“, da der Nutzer mit root_agent spricht, das dann die Arbeit an SequentialAgent übergibt, damit diese abgeschlossen werden kann.
Untergeordnete Agents in der Sequenz verwenden den Sitzungsstatus (z.B. { PLOT_OUTLINE? }) aufrufen, um auf die Arbeit vorheriger Kundenservicemitarbeiter zuzugreifen.
Mit dem Ereignisdiagramm in der Entwickler-Benutzeroberfläche können Sie den gesamten Agent-zu-Agent-Workflow visualisieren und debuggen.

11. Hinzufügen eines LoopAgent für iterative Arbeit

Der LoopAgent ist ein Workflow-Agent, der seine untergeordneten Agenten in einer Sequenz ausführt und dann wiederholt, beginnend am Anfang. Diese „Schleife“ wird fortgesetzt, bis eine Bedingung erfüllt ist, z. B. bis eine bestimmte Anzahl von max_iterations erreicht ist oder ein untergeordneter Agent das integrierte Tool exit_loop aufruft.

Das ist für Aufgaben nützlich, die eine iterative Optimierung erfordern. Sie fügen diesen LoopAgent hinzu, um einen „Writer’s Room“ für Ihren Agenten für Filmvorschläge zu erstellen. So können ein researcher-, ein screenwriter- und ein neuer critic-Agent in einer Schleife zusammenarbeiten und die Handlung mit jedem Durchlauf verbessern, bis der critic-Agent entscheidet, dass sie fertig ist. So kann der Agent auch vage Nutzereingaben wie „ein Arzt aus der Antike“ verarbeiten, indem er eine Idee recherchiert und verfeinert.

Schritt 2 für das Multi-Agenten-System film_concept_team

So nehmen Sie diese Änderungen vor:

Fügen Sie in adk_multiagent_systems/workflow_agents/agent.py den Import für exit_loop hinzu (in der Nähe der anderen google.adk-Importe):
```
from google.adk.tools import exit_loop
```

Fügen Sie den neuen critic-Agent hinzu. Dieser Agent überprüft die Handlung. Wenn es gut ist, wird exit_loop aufgerufen. Falls nicht, wird dem Status für den nächsten Schleifendurchlauf Feedback hinzugefügt.
Fügen Sie die folgende Agentendefinition in den Abschnitt # Agents ein:

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

Erstellen Sie den writers_room LoopAgent. Sie enthält die drei Agents, die in der Schleife verwendet werden.
Fügen Sie den folgenden Code über der Agentendefinition film_concept_team ein:
```
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,
)
```
Beachten Sie den Parameter max_iterations=5. Dies ist eine wichtige Sicherheitsvorkehrung, um Endlosschleifen zu verhindern, auch wenn Sie eine Exit-Bedingung haben.
Aktualisieren Sie die film_concept_team SequentialAgent, um die neue writers_room-Schleife zu verwenden. Ersetzen Sie researcher und screenwriter durch den einzelnen writers_room-Agenten.Ersetzen Sie Ihre vorhandene film_concept_team-Definition durch Folgendes:
```
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
    ],
)
```
Kehren Sie zum Tab der ADK Dev-Benutzeroberfläche zurück und klicken Sie rechts oben auf + Neue Sitzung.
Beginnen Sie eine neue Unterhaltung mit: hello
Geben Sie dem Kundenservicemitarbeiter dieses Mal ein allgemeineres Thema an. Hier einige Ideen:
- ein Industriedesigner, der Produkte für die breite Masse entworfen hat
- ein Kartograf
- der Typ, der dafür gesorgt hat, dass Pflanzen mehr Nahrung liefern
Der Agent durchläuft jetzt die Schleife. In der ADK Dev-Benutzeroberfläche werden die Logs angezeigt, wenn die Agents mehrmals ausgeführt werden (z.B. „[researcher]“, „[screenwriter]“, „[critic]“, „[researcher]“, „[screenwriter]“, „[critic]“ …
Wenn die Schleife abgeschlossen ist, schreibt der Agent die Datei. Sehen Sie sich die generierte Datei im Verzeichnis adk_multiagent_systems/movie_pitches an.
Sehen Sie sich das Ereignisdiagramm in der Entwickler-UI an, um die Schleifenstruktur zu sehen.

Zusammenfassung des Abschnitts

In diesem Abschnitt haben Sie gelernt, wie Sie die LoopAgent verwenden:

Ein LoopAgent ist ein Workflow-Agent, der seine Sequenz von untergeordneten Agents wiederholt und so eine „innere Schleife“ für iterative Aufgaben erstellt.
Agents innerhalb der Schleife verwenden den Sitzungsstatus, um Aufgaben zu übergeben (z.B. PLOT_OUTLINE) und Feedback (z.B. CRITICAL_FEEDBACK) zueinander.
Die Schleife kann durch Erreichen eines max_iterations-Limits oder durch einen Agenten, der das exit_loop-Tool aufruft, beendet werden.

12. ParallelAgent für „Fan-Out- und Gather“-Muster verwenden

Der ParallelAgent ist ein Workflow-Agent, der alle seine Sub-Agents gleichzeitig (parallel) ausführt. Das ist nützlich für Aufgaben, die in unabhängige Unteraufgaben unterteilt werden können, z. B. für die Ausführung von zwei verschiedenen Forschungsjobs.

Sie verwenden ein ParallelAgent, um ein „Pre-Production-Team“ zu erstellen, das parallel arbeitet. Ein KI-Agent recherchiert das Einspielergebnis, während ein anderer gleichzeitig Ideen für die Besetzung sammelt. Dies wird oft als „Fan-out-and-Gather“-Muster bezeichnet: Der ParallelAgent „fächert“ die Arbeit auf und ein späterer Agent (unser file_writer) „sammelt“ die Ergebnisse.

Schritt 3 für das Multi-Agenten-System film_concept_team

Der endgültige Ablauf des Agents sieht so aus:

Der greeter (Stamm) startet den Chat.
Sie wird an film_concept_team (SequentialAgent) übertragen, die Folgendes ausführt:
- Die writers_room (LoopAgent), mit der das Diagramm erstellt werden soll.
- Mit dem neuen Feld preproduction_team (ParallelAgent) können Sie gleichzeitig Informationen zu Einspielergebnissen und Besetzung abrufen.
- Die file_writer, um alle Ergebnisse zu erfassen und die Datei zu speichern.

So nehmen Sie diese Änderungen vor:

Fügen Sie in adk_multiagent_systems/workflow_agents/agent.py die neue ParallelAgent und ihre untergeordneten Agenten unter der Überschrift # Agents ein.

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

Aktualisieren Sie die Liste sub_agents des SequentialAgent film_concept_team, um die neue preproduction_team (zwischen writers_room und file_writer) einzufügen. Ersetzen Sie die vorhandene film_concept_team-Definition durch Folgendes:

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

Aktualisieren Sie die instruction des file_writer-Agents, damit die neuen Berichte aus dem Status „erfasst“ und der Datei hinzugefügt werden.
Ersetzen Sie den String instruction für file_writer durch Folgendes:

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

Kehren Sie zum Tab der ADK Dev-Benutzeroberfläche zurück und klicken Sie auf + Neue Sitzung.
Geben Sie hello ein, um die Unterhaltung zu beginnen.
Geben Sie bei Aufforderung eine neue Idee für eine Figur ein. Hier einige Ideen:
- die Schauspielerin, die die Technologie für WLAN erfunden hat
- ein spannender Koch
- wichtige Akteure bei den Weltausstellungen
Wenn der Agent seine Arbeit abgeschlossen hat, sehen Sie sich die endgültige Datei im Verzeichnis adk_multiagent_systems/movie_pitches an. Es sollte nun die Handlung, den Bericht zum Einspielergebnis und den Bericht zur Besetzung in einem Dokument enthalten.

Zusammenfassung des Abschnitts

In diesem Abschnitt haben Sie gelernt, wie Sie die ParallelAgent verwenden:

Ein ParallelAgent-Arbeitsablauf wird „aufgefächert“, indem alle seine Sub-Agents gleichzeitig und nicht nacheinander ausgeführt werden.
Das ist sehr effizient für Aufgaben, die nicht voneinander abhängen, z. B. die Recherche zu zwei verschiedenen Themen.
Die Ergebnisse paralleler Agents werden von einem späteren Agent „gesammelt“. Dazu speichern die parallelen Agenten ihre Arbeit im Sitzungsstatus (mit output_key) und ein letzter Agent (z. B. file_writer) liest diese Schlüssel.

13. Benutzerdefinierte Workflow-Agenten

Wenn die vordefinierten Workflow-Agenten von SequentialAgent, LoopAgent und ParallelAgent nicht Ihren Anforderungen entsprechen, bietet CustomAgent die Flexibilität, neue Workflow-Logik zu implementieren.

Sie können Muster für die Ablaufsteuerung, die bedingte Ausführung oder die Statusverwaltung zwischen untergeordneten Agenten definieren. Das ist nützlich für komplexe Workflows, zustandsorientierte Orchestrierungen oder die Einbindung benutzerdefinierter Geschäftslogiken in die Orchestrierungsebene des Frameworks.

Die Erstellung eines CustomAgent wird in diesem Lab nicht behandelt, aber Sie sollten dennoch im Hinterkopf behalten, dass diese Funktion verfügbar ist, falls Sie sie benötigen.

14. Glückwunsch!

Sie haben mit dem Google Agent Development Kit (ADK) erfolgreich ein komplexes Multi-Agenten-System erstellt. Sie haben sich von einer einfachen über- und untergeordneten Agentenbeziehung zur Orchestrierung komplexer, automatisierter Workflows weiterentwickelt, die ein kreatives Projekt recherchieren, schreiben und optimieren können.

Zusammenfassung

In diesem Lab haben Sie Folgendes getan:

Agenten in einer hierarchischen Baumstruktur mit über- und untergeordneten Agenten organisiert.
Kontrollierte Agent-zu-Agent-Übertragungen, sowohl automatisch (mit description) als auch explizit (mit instruction).
Sie haben ein Tool verwendet, um Daten in das tool_context.state-Dictionary zu schreiben.
Schlüsselvorlagen verwendet (z.B. { PLOT_OUTLINE? }), um den Sitzungsstatus zu lesen und den Prompt eines Agenten zu steuern.
SequentialAgent implementiert, um einen einfachen, schrittweisen Workflow zu erstellen (Recherche –> Schreiben –> Speichern).
LoopAgent mit einem critic-Agenten und dem exit_loop-Tool verwendet, um einen iterativen Optimierungszyklus zu erstellen.
Es wurde ein ParallelAgent verwendet, um unabhängige Aufgaben (z. B. Casting und Recherche an der Kinokasse) parallel auszuführen.

Fortlaufende Tests

Es gibt viele Möglichkeiten, auf dem aufzubauen, was Sie gelernt haben. Hier einige Tipps:

Weitere Agenten hinzufügen:Fügen Sie Ihrem preproduction_team ParallelAgent einen neuen Agenten hinzu. Sie könnten beispielsweise einen marketing_agent erstellen, der basierend auf dem PLOT_OUTLINE einen Slogan für den Film schreibt.
Weitere Tools hinzufügen:Sie können Ihrem researcher-Agent weitere Tools zur Verfügung stellen. Sie könnten ein Tool erstellen, das eine Google Search API verwendet, um Informationen zu finden, die nicht auf Wikipedia verfügbar sind.
Erkunden CustomAgent :Im Lab wurde die CustomAgent für Workflows erwähnt, die nicht den Standardvorlagen entsprechen. Sie können beispielsweise einen Agent erstellen, der nur dann bedingt ausgeführt wird, wenn ein bestimmter Schlüssel im Sitzungsstatus vorhanden ist.

Multi-Agent-Systeme mit dem ADK erstellen

1. Einführung

Übersicht

Aufgaben

Lerninhalte

2. Multi-Agenten-Systeme

Der hierarchische KI-Agenten-Baum

3. Projekt einrichten

Google-Konto

In der Google Cloud Console anmelden

Abrechnung aktivieren

Google Cloud-Guthaben im Wert von 5 $einlösen (optional)

Privates Rechnungskonto einrichten

Projekt erstellen (optional)

4. Cloud Shell-Editor öffnen

5. APIs aktivieren

Einführung in das Vertex AI SDK für Python

6. Projektumgebung einrichten

Repository klonen

Dateistruktur überprüfen

Virtuelle Umgebung aktivieren

Umgebungsvariablen einrichten

7. Übertragungen zwischen übergeordneten, Sub- und gleichrangigen Agenten

Zusammenfassung

8. Verwendung des Sitzungsstatus zum Speichern und Abrufen von Informationen

Zusammenfassung des Abschnitts

9. Workflow-Agenten

10. Multi-Agenten-System mit einem SequentialAgent erstellen

Zusammenfassung des Abschnitts

11. Hinzufügen eines LoopAgent für iterative Arbeit

Zusammenfassung des Abschnitts

12. ParallelAgent für „Fan-Out- und Gather“-Muster verwenden

Zusammenfassung des Abschnitts

13. Benutzerdefinierte Workflow-Agenten

14. Glückwunsch!

Zusammenfassung

Fortlaufende Tests