Multi-Agent-System mit dem ADK erstellen, in Agent Engine bereitstellen und mit dem A2A-Protokoll beginnen

1. Ziel dieses Labs

In diesem praxisorientierten Lab erstellen Sie mit dem ADK (Agent Development Kit) eine Multi-Agent-Anwendung, die auf Grundlage Ihres Prompts ein Bild generiert und es anhand Ihres Prompts bewertet. Wenn das Bild die im Prompt beschriebenen Anforderungen nicht zufriedenstellend erfüllt, generiert der Agent so lange Bilder, bis das Bild generiert wird, das Ihren Anforderungen entspricht. Jeder der Agents in dieser Übung hat einen einzigen Zweck. Die Agents arbeiten zusammen, um das Gesamtziel zu erreichen. Sie erfahren, wie Sie die Anwendung lokal testen und in Vertex AI Agent Engine bereitstellen.

Lerninhalte

• Sie lernen die Grundlagen des ADK (Agent Development Kit) kennen und erfahren, wie Sie ein Multi-Agent-System erstellen.
• Hier erfahren Sie, wie Sie die KI-Agenten in Vertex AI Agent Engine bereitstellen und verwenden.
• Grundlagen des A2A-Protokolls
• Hier erfahren Sie, wie Sie das A2A-Protokoll und das ADK (Agent Development Kit) zusammen verwenden, um offene Agenten zu erstellen.

2. Projekt einrichten

Sie können Google Cloud-Guthaben erhalten, um dieses Lab durchzuführen. Klicken Sie hier, um die Gutschriften zu erhalten. Hier erfahren Sie, wie Sie Google Cloud-Guthaben einlösen.

• Wenn Sie noch kein Projekt haben, das Sie verwenden können, müssen Sie ein neues Projekt in der GCP Console erstellen.
• In diesem Lab verwenden wir GCP Cloud Shell, um unsere Aufgaben auszuführen. Öffnen Sie Cloud Shell und legen Sie das Projekt mit Cloud Shell fest.
• Öffnen Sie die GCP Cloud Shell, indem Sie hier klicken: Cloud Shell . Wenn das Pop-up-Fenster „Shell autorisieren“ angezeigt wird, klicken Sie darauf, um den Cloud Shell Editor zu autorisieren.
• Mit dem folgenden Befehl im Cloud Shell-Terminal können Sie prüfen, ob das Projekt bereits authentifiziert ist.

gcloud auth list

• Führen Sie den folgenden Befehl in Cloud Shell aus, um Ihr Projekt zu bestätigen.

gcloud config list project

• Kopieren Sie die Projekt-ID und legen Sie sie mit dem folgenden Befehl fest.

gcloud config set project <YOUR_PROJECT_ID>

• Damit wir dieses Lab ausführen können, müssen wir einige Dienste aktivieren. Führen Sie in Cloud Shell den folgenden Befehl aus.

gcloud services enable aiplatform.googleapis.com
gcloud services enable cloudresourcemanager.googleapis.com

3. Einführung in das Agent Development Kit

Das Agent Development Kit bietet mehrere entscheidende Vorteile für Entwicklerinnen und Entwickler, die agentische Anwendungen erstellen:

1. Multi-Agenten-Systeme: Erstellen Sie modulare und skalierbare Anwendungen, indem Sie mehrere spezialisierte Agenten in einer Hierarchie zusammenstellen. Ermöglichen Sie komplexe Koordination und Delegation.
2. Umfangreiches Tool-Ökosystem: Statten Sie Agenten mit verschiedenen Kompetenzen aus. Verwenden Sie vorgefertigte Tools (Suche, Code-Ausführung usw.), erstellen Sie benutzerdefinierte Funktionen, integrieren Sie Tools aus Agenten-Frameworks von Drittanbietern (LangChain, CrewAI) oder nutzen Sie sogar andere Agenten als Tools.
3. Flexible Orchestrierung: Definieren Sie Workflows mit Workflow-Agents (SequentialAgent, ParallelAgent und LoopAgent) für vorhersagbare Pipelines oder nutzen Sie LLM-basiertes dynamisches Routing (LlmAgent-Transfer) für adaptives Verhalten.
4. Integrierte Entwicklungsumgebung: Entwickeln, testen und debuggen Sie lokal mit einer leistungsstarken Befehlszeile und einer interaktiven Entwicklungs-UI. Prüfen Sie Ereignisse, Status und Agentenausführung Schritt für Schritt.
5. Integrierte Bewertung: Bewerten Sie die Leistung des Agenten systematisch, indem Sie sowohl die Qualität der endgültigen Antwort als auch den schrittweisen Ausführungsablauf anhand vordefinierter Testläufe bewerten.
6. Schnelle Bereitstellung: Sie können Ihre Agenten überall containerisieren und bereitstellen. Führen Sie sie lokal aus, skalieren Sie sie mit der Vertex AI Agent Engine oder integrieren Sie sie mit Cloud Run oder Docker in Ihre eigene Infrastruktur.

Während andere SDKs oder Agenten-Frameworks auf Basis generativer KI Ihnen ebenfalls ermöglichen, Modelle abzufragen und sie sogar mit Tools auszustatten, erfordert die dynamische Koordination zwischen mehreren Modellen einen erheblichen Arbeitsaufwand Ihrerseits.

Das Agent Development Kit bietet ein übergeordnetes Framework, mit dem Sie problemlos mehrere Agenten miteinander verbinden können, um komplexe, aber einfach zu wartende Workflows zu erstellen.

Abbildung 1: Positionierung des ADK (Agent Development Kit)

4. Einführung in Vertex AI Agent Engine

Die Vertex AI Agent Engine ist ein vollständig verwalteter Dienst zum Bereitstellen von Agenten in Google Cloud. Mit der Vertex AI Agent Engine können Entwickler OSS-KI-Agents( ADK (Agent Development Kit) , LangChain, LangGraph, CrewAI, AutoGen und mehr) in Vertex AI entwickeln, anpassen, bereitstellen, bereitstellen und verwalten.

Agent Engine bietet auch Dienste zur Verarbeitung der Nutzerdaten, die auch als Agent-Speicher bezeichnet werden. Derzeit sind zwei Arten von Memory-Diensten verfügbar.

• Kurzzeitgedächtnis: Mit Agent Engine-Sitzungen können Sie den laufenden Unterhaltungsverlauf (Status) innerhalb einer einzelnen Sitzung als Kurzzeitgedächtnis speichern, verwalten und abrufen.
• Langzeitgedächtnis: Mit der Memory Bank der Agent Engine können Sie Erinnerungen (Status) speichern, transformieren und abrufen, insbesondere über mehrere Sitzungen hinweg als Langzeitgedächtnis.

Sie können Agents auch in anderen Google Cloud-Diensten wie Cloud Run oder GKE bereitstellen. Für die folgenden Anwendungsfälle sollten Sie jedoch Vertex AI Agent Engine verwenden.

• Statusbehaftete verwaltete Laufzeit: Wenn Sie eine statusbehaftete, vollständig verwaltete Laufzeit für die Bereitstellung Ihres Agents benötigen, ist Vertex AI Agent Engine eine gute Wahl, da sie allgemeine Aufgaben wie die Sitzungsverwaltung und die Persistenz für KI-Agents abstrahiert.
• Codeausführung: Wenn Ihr Agent Code ausführen muss, der während der Nutzersitzung dynamisch generiert wird, bietet Agent Engine eine sichere Sandbox, in der Sie den Code ausführen können.
• Flexibler Langzeitspeicher: Wenn Sie einen flexiblen Langzeitspeicher für Ihre Agenten benötigen, kann die Vertex AI Memory Bank, die mit der Vertex AI Agent Engine verwendet werden kann, eine flexible Möglichkeit bieten, sich die Informationen zu Ihrem Nutzer zu merken, die sitzungsübergreifend verwendet werden können.

Sie können die Vertex AI Agent Engine auch mit anderen Runtimes wie Cloud Run kombinieren, um eine flexible Anwendungsarchitektur zu erstellen. Nachfolgend finden Sie ein Beispiel für eine Referenzarchitektur, in der verschiedene Dienste zum Erstellen eines Agents verwendet werden.

Abbildung 2: Beispiel einer Referenzarchitektur zum Erstellen von Agents mit mehreren Diensten.

5. Einführung in A2A

Das Agent2Agent-Protokoll (A2A) ist ein offener Standard, der eine nahtlose und sichere Kommunikation und Zusammenarbeit zwischen autonomen KI-Agenten aus verschiedenen Frameworks, von verschiedenen Anbietern und aus verschiedenen Bereichen ermöglicht.

1. Universelle Interoperabilität:Mit A2A können Agents unabhängig von den zugrunde liegenden Technologien zusammenarbeiten, was ein echtes Multi-Agent-Ökosystem ermöglicht. So können von verschiedenen Unternehmen auf unterschiedlichen Plattformen entwickelte Agents miteinander kommunizieren und sich abstimmen.
2. Funktionserkennung:Agenten können ihre Funktionen mithilfe von „Agentenkarten“ (JSON-Dokumenten) bewerben, die ihre Identität, unterstützten A2A-Funktionen, Fähigkeiten und Authentifizierungsanforderungen beschreiben. So können andere Agents den am besten geeigneten Agent für eine bestimmte Aufgabe finden und auswählen.
3. Standardmäßig sicher:Sicherheit ist ein zentrales Prinzip. A2A umfasst Authentifizierungs- und Autorisierungsmechanismen auf Unternehmensniveau, die Standards wie HTTPS/TLS, JWT, OIDC und API-Schlüssel verwenden, um sichere Interaktionen zu gewährleisten und sensible Daten zu schützen.
4. Modalitätsunabhängig:Das Protokoll unterstützt verschiedene Kommunikationsmodalitäten, darunter Text-, Audio- und Videostreaming sowie interaktive Formulare und eingebettete iFrames. Diese Flexibilität ermöglicht es Agenten, Informationen im für die Aufgabe und den Nutzer am besten geeigneten Format auszutauschen.
5. Strukturierte Aufgabenverwaltung:A2A definiert klare Protokolle für die Aufgabenübertragung, ‑überwachung und ‑erledigung. Es unterstützt das Gruppieren ähnlicher Aufgaben und die Verwaltung über verschiedene Agents hinweg mithilfe eindeutiger Aufgaben-IDs. Aufgaben können definierte Lebenszyklen durchlaufen (z.B. „Eingereicht“, „Wird bearbeitet“, „Abgeschlossen“).
6. Undurchsichtige Ausführung:Eine wichtige Funktion ist, dass KI-Agenten anderen KI-Agenten gegenüber ihre internen Denkprozesse, ihren Speicher oder bestimmte Tools nicht offenlegen müssen. Sie stellen nur ihre aufrufbaren Dienste zur Verfügung, was die Modularität und den Datenschutz fördert.
7. Basierend auf bestehenden Standards:A2A nutzt etablierte Webtechnologien wie HTTP, Server-Sent Events (SSE) für Echtzeit-Streaming und JSON-RPC für den strukturierten Datenaustausch. Dadurch lässt sich die Lösung einfacher in bestehende IT-Infrastrukturen integrieren.
8. Asynchrone Kommunikation:Das Protokoll ist in erster Linie für die asynchrone Kommunikation konzipiert. Das ermöglicht einen flexiblen Aufgabenfortschritt und Push-Benachrichtigungen für Updates, auch wenn keine dauerhafte Verbindung besteht.

6. Agentenarchitektur

In diesem Lab erstellen Sie eine Multi-Agenten-Anwendung, die ein Bild entsprechend Ihren Angaben generiert und es bewertet, bevor es Ihnen präsentiert wird.

Das System ist mit einem Haupt-Agenten namens image_scoring strukturiert, der den gesamten Prozess orchestriert. Dieser Haupt-Agent hat einen Sub-Agenten namens image_generation_scoring_agent, der wiederum eigene Sub-Agenten für spezifischere Aufgaben hat. Dadurch wird eine hierarchische Beziehung erstellt, in der der Haupt-Agent Aufgaben an seine untergeordneten Agenten delegiert.

Abbildung 3: Gesamtablauf des Agent.

Liste aller Agents

Gemini Agent	Purpose	Untergeordnete Vertreter
image_scoring (Main Agent)	Dies ist der Stamm-Agent, der den gesamten Workflow verwaltet. Er führt den image_generation_scoring_agent und den checker_agent wiederholt in einer Schleife aus, bis eine Abbruchbedingung erfüllt ist.	image_generation_scoring_agent checker_agent_instance
image_generation_scoring_agent (Untergeordneter Agent von image_scoring)	Dieser Agent ist für die Kernlogik der Bildgenerierung und ‑bewertung verantwortlich. Dazu wird eine Sequenz von drei Sub-Agents ausgeführt.	image_generation_prompt_agent image_generation_agent scoring_images_prompt
checker_agent_instance (Unter-Agent von image_scoring)	Dieser Agent prüft, ob der Prozess zur Bewertung von Bildern fortgesetzt oder beendet werden soll. Dazu wird das Tool check_tool_condition verwendet.	–
checker_agent_instance (Unter-Agent von image_scoring)	Dieser KI-Agent ist ein Experte für die Erstellung von Prompts zur Bildgenerierung. Es nimmt einen Eingabetext entgegen und generiert einen detaillierten Prompt, der für das Bildgenerierungsmodell geeignet ist.	–
image_generation_prompt_agent (Unter-Agent von image_generation_scoring_agent)	Dieser KI-Agent ist ein Experte für die Erstellung von Prompts zur Bildgenerierung. Es nimmt einen Eingabetext entgegen und generiert einen detaillierten Prompt, der für das Bildgenerierungsmodell geeignet ist.	–
scoring_images_prompt (Unteragent von „image_generation_scoring_agent“):	Dieser Agent ist ein Experte für die Bewertung und Einstufung von Bildern anhand verschiedener Kriterien. Es nimmt das generierte Bild entgegen und weist ihm eine Punktzahl zu.	–

Liste aller verwendeten Tools

Tool	Beschreibung	User-Agent
check_tool_condition	Mit diesem Tool wird geprüft, ob die Schleifenbeendigungsbedingung erfüllt ist oder die maximale Anzahl von Iterationen erreicht wurde. Wenn eine dieser Bedingungen erfüllt ist, wird die Schleife beendet.	checker_agent_instance
generate_images	Mit diesem Tool werden Bilder mit dem Imagen 3-Modell generiert. Die generierten Bilder können auch in einem Google Cloud Storage-Bucket gespeichert werden.	image_generation_agent
get_policy	Mit diesem Tool wird eine Richtlinie aus einer JSON-Datei abgerufen. Die Richtlinie wird vom image_generation_prompt_agent verwendet, um den Prompt zur Bildgenerierung zu erstellen, und vom scoring_images_prompt, um die Bilder zu bewerten.	image_generation_agent
get_image	Mit diesem Tool wird das generierte Bildartefakt geladen, damit es bewertet werden kann.	scoring_images_prompt
set_score	Mit diesem Tool wird die Gesamtbewertung des generierten Bildes im Sitzungsstatus festgelegt.	scoring_images_prompt

7. ADK installieren und Umgebung einrichten

In dieser Anleitung verwenden wir Cloud Shell, um die Aufgaben auszuführen.

Cloud Shell-Editor-Tab vorbereiten

1. Klicken Sie auf diesen Link, um direkt zum Cloud Shell-Editor zu gelangen.
2. Klicken Sie auf Weiter.
3. Wenn Sie zur Autorisierung der Cloud Shell aufgefordert werden, klicken Sie auf Autorisieren.
4. Im weiteren Verlauf dieses Labs dient dieses Fenster als IDE für das Arbeiten im Cloud Shell-Editor und Cloud Shell-Terminal.
5. Öffnen Sie im Cloud Shell-Editor ein neues Terminal über Terminal> Neues Terminal. Alle Befehle unten werden in diesem Terminal ausgeführt.

ADK und Codebeispiele für dieses Lab herunterladen und installieren

1. Führen Sie die folgenden Befehle aus, um die erforderliche Quelle von GitHub zu klonen und die erforderlichen Bibliotheken zu installieren. Führen Sie die Befehle im Terminal aus, das im Cloud Shell-Editor geöffnet ist.

#create the project directory
mkdir ~/imagescoring
cd ~/imagescoring
#clone the code in the local directory
git clone https://github.com/haren-bh/multiagenthandson.git

2. Wir verwenden uv, um eine Python-Umgebung zu erstellen (im Cloud Shell-Editor-Terminal ausführen):

#Install uv if you do not have installed yet
pip install uv

#Create the virtual environment
uv venv .adkvenv

source .adkvenv/bin/activate

#go to the project directory
cd ~/imagescoring/multiagenthandson

#install dependencies
uv pip install -r pyproject.toml

3. Wenn Sie keinen Cloud Storage-Bucket haben, erstellen Sie einen neuen in Google Cloud Storage. Sie können den Bucket auch mit dem gsutil-Befehl erstellen. Agent Engine Zugriff auf Google Cloud Storage gewähren (im Cloud Shell Editor-Terminal ausführen).

# First, make sure your PROJECT_ID variable is set
PROJECT_ID=$(gcloud config get-value project)

# Now, create the bucket with a unique name
# We'll use the project ID to help ensure uniqueness
gsutil mb gs://${PROJECT_ID}-imagescoring-bucket

#Now lets give Agent Engine the permission to access Cloud Storage
# 1. Get the current Project ID (text) and Project Number (numeric)
PROJECT_ID=$(gcloud config get-value project)
PROJECT_NUMBER=$(gcloud projects describe $PROJECT_ID --format="value(projectNumber)")

# 2. Construct the Reasoning Engine Service Account email
SA_EMAIL="service-${PROJECT_NUMBER}@gcp-sa-aiplatform-re.iam.gserviceaccount.com"
# 3. Create Agent Engine Service account if not already created
gcloud beta services identity create --service=aiplatform.googleapis.com --project=${PROJECT_NUMBER}

# 3. Grant GCS Access
gcloud projects add-iam-policy-binding $PROJECT_ID --member="serviceAccount:$SA_EMAIL" --role="roles/storage.objectUser" --condition=None

4. Klicken Sie im Editor auf „Ansicht“ > „Versteckte Dateien einblenden“. Erstellen Sie im Ordner image_scoring eine .env-Datei mit folgendem Inhalt. Fügen Sie die erforderlichen Details wie Projektname und Cloud Storage-Bucket hinzu (Run in Cloud Shell Editor Terminal).

#go to image_scoring folder
cd ~/imagescoring/multiagenthandson/image_scoring

cat <<EOF>> .env
GOOGLE_GENAI_USE_VERTEXAI=1
GOOGLE_CLOUD_PROJECT=$(gcloud config get-value project)
GOOGLE_CLOUD_LOCATION=us-central1
GOOGLE_CLOUD_STORAGE_BUCKET=$(gcloud config get-value project)-imagescoring-bucket
GCS_BUCKET_NAME=$(gcloud config get-value project)-imagescoring-bucket
SCORE_THRESHOLD=40
IMAGEN_MODEL="imagen-3.0-generate-002"
GENAI_MODEL="gemini-2.5-flash"
EOF

5. Sehen Sie sich die Agentenstruktur im Quellcode an. Beginnen Sie mit agent.py. Dieser Agent enthält den Stamm-Agent, der eine Verbindung zu den anderen Agents herstellt.
6. Kehren Sie im Terminal zum obersten Verzeichnis multiagenthandson zurück und führen Sie den folgenden Befehl aus, um den Agenten lokal auszuführen (im Cloud Shell-Editor-Terminal ausführen).

#go to the directory multiagenthandson
cd ~/imagescoring/multiagenthandson
# Run the following command to run agents locally
adk web

Abbildung 4

Klicken Sie bei gedrückter Strg-Taste (Befehlstaste + Klick unter macOS) auf die im Terminal angezeigte http://-URL, um den browserbasierten GUI-Client des ADK zu öffnen. Das sollte so aussehen wie in Abbildung 2.

7. Wählen Sie im Drop-down-Menü oben links „image_scoring“ aus (siehe Abbildung 5). Lassen Sie uns jetzt einige Bilder generieren. Die Bilder sollten sich auch im Google Cloud Storage-Bucket befinden. Probieren Sie die folgenden Prompts oder eigene Prompts aus.
8. Eine friedliche Berglandschaft bei Sonnenuntergang
9. Eine Katze fährt Fahrrad

Abbildung 5: Beispielausgabe

8. In Agent Engine bereitstellen

Jetzt stellen wir den Agent in der Agent Engine bereit. Agent Engine ist ein vollständig verwalteter Dienst zum Bereitstellen von Agenten in der GCP. Agent Engine ist mit dem ADK (Agent Development Kit) kompatibel, sodass mit dem ADK (Agent Development Kit) erstellte Agenten in Agent Engine bereitgestellt werden können.

1. Erstellen Sie die Datei requirements.txt mit Poetry. Poetry verwendet pyproject.toml, um die Datei requirements.txt zu erstellen. Prüfen Sie nach dem Ausführen des Befehls, ob die Datei requirements.txt erstellt wurde (im Cloud Shell-Editor-Terminal ausführen).

# Go to the parent folder containing pyproject.toml file
cd ~/imagescoring/multiagenthandson

# install poetry-plugin-export
uv pip install poetry-plugin-export

#Create requirements.txt file
python3 -m poetry export -f requirements.txt --output requirements.txt --without-hashes

2. Erstellen Sie das Paket. Wir müssen unsere App in ein Python-Paket vom Typ .whl packen. Dazu verwenden wir Gedichte. Nachdem Sie den Befehl ausgeführt haben, prüfen Sie, ob ein „dist“-Ordner erstellt wurde, der die Datei .whl enthält (im Cloud Shell-Editor-Terminal ausführen).

# Go to the parent folder containing pyproject.toml file
cd ~/imagescoring/multiagenthandson

#Create python package, to create whl file
python3 -m poetry build

3. Jetzt bereiten wir das Bereitstellungsskript vor. Mit dem Bereitstellungsskript wird unser Agent zum Bewerten von Bildern oder der Agent Engine-Dienst bereitgestellt. Prüfen Sie den Inhalt von deploy.py im Ordner deploy wie unten beschrieben. Verwenden Sie die Seitenleiste des Cloud Shell-Editors, um die Datei zu finden.

import vertexai
from image_scoring.agent import root_agent
import os
import glob # To easily find the wheel file
from dotenv import load_dotenv

# Load environment variables from image_scoring/.env
env_path = os.path.join(os.path.dirname(__file__), "..", "image_scoring", ".env")
load_dotenv(env_path)

PROJECT_ID = os.getenv("GOOGLE_CLOUD_PROJECT")
LOCATION = os.getenv("GOOGLE_CLOUD_LOCATION", "us-central1")
STAGING_BUCKET = f"gs://{os.getenv('GOOGLE_CLOUD_STORAGE_BUCKET')}"

from vertexai import agent_engines

client=vertexai.Client(
    project=PROJECT_ID,
    location=LOCATION,
)
remote_app = client.agent_engines.create(
    agent=root_agent,
    config={
        "display_name": "image-scoring",
        "staging_bucket": STAGING_BUCKET,
        "requirements": open(os.path.join(os.getcwd(), "requirements.txt")).readlines() + ["./dist/image_scoring-0.1.0-py3-none-any.whl"],
        "extra_packages": [
            "./dist/image_scoring-0.1.0-py3-none-any.whl",
        ],     "env_vars":{"GCS_BUCKET_NAME":os.getenv('GOOGLE_CLOUD_STORAGE_BUCKET')}
    }
)
print(f"DEBUG: AgentEngine attributes: {dir(remote_app)}")
try:
    print(remote_app.api_resource.name)
except AttributeError:
    print("Could not find resource_name, check DEBUG output above.")

4. Wir können jetzt das Bereitstellungsskript ausführen. Wechseln Sie zuerst zum obersten Ordner multiagenthandson (Run in Cloud Shell Editor Terminal).

#go to multiagenthandson folder
cd ~/imagescoring/multiagenthandson

#run deploy script from the parent folder containing deploy.py
python3 -m deploy.deploy

Nach der Bereitstellung sollte etwa Folgendes angezeigt werden:

Abbildung 6: Beispielausgabe

5. Jetzt testen wir den bereitgestellten Agent. Wenn Sie die remote bereitgestellte Agent-Engine testen möchten, kopieren Sie zuerst den Agent-Speicherort aus der Bereitstellungsausgabe im Terminal. Sie sollte in etwa so aussehen: projects/85469421903/locations/us-central1/reasoningEngines/7369674597261639680 .
    Rufen Sie den Ordner testclient auf,öffnen Sie die Datei remote_test.py im Cloud Shell-Editor und bearbeiten Sie die folgenden Zeilen.

REASONING_ENGINE_ID = "projects/xxx/locations/us-central1/reasoningEngines/xxx"  # TODO: Change this

6. Führen Sie im obersten Ordner multiagenthandson den folgenden Befehl aus. Die Ausgabe sollte in etwa so aussehen wie in Abbildung 4. Nach Abschluss der Ausführung sollte „(Run in Cloud Shell Editor Terminal)“ angezeigt werden.

#go to multiagenthandson folder
cd ~/imagescoring/multiagenthandson

#execute remote_test.py
python3 -m testclient.remote_test

Abbildung 7: Beispielausgabe

9. A2A-Agent erstellen

In diesem Schritt erstellen wir einen einfachen A2A-Agenten auf Grundlage des Agenten, den wir in den vorherigen Schritten erstellt haben. Bestehende ADK-Agents (Agent Development Kit) können unter dem A2A-Protokoll veröffentlicht werden. In diesem Schritt lernen Sie Folgendes:

• Grundlagen des A2A-Protokolls
• Informationen zum Zusammenspiel von ADK- und A2A-Protokollen
• Informationen zur Interaktion mit dem A2A-Protokoll

In diesem Praktikum verwenden wir den Code im Ordner image_scoring_adk_a2a_server. Bevor Sie mit der Aufgabe beginnen, wechseln Sie in dieses Verzeichnis (führen Sie den Befehl im Cloud Shell Editor-Terminal aus).

#change directory to image_scoring_adk_a2a_server
cd ~/imagescoring/multiagenthandson/image_scoring_adk_a2a_server

#copy the env file
cp ~/imagescoring/multiagenthandson/image_scoring/.env remote_a2a/image_scoring

1. A2A-Agentenkarte erstellen

Das A2A-Protokoll erfordert eine Agentenkarte, die alle Informationen zum Agenten enthält, z. B. Agentenfunktionen und eine Anleitung zur Verwendung des Agenten. Sobald ein A2A-Agent bereitgestellt wurde, kann die Agentenkarte über den Link .well-known/agent-card.json aufgerufen werden. Clients können sich auf diese Informationen beziehen, um die Anfrage an Kundenservicemitarbeiter zu senden.

Prüfen Sie im Ordner remote_a2a/image_scoring mit dem Cloud Shell-Editor, ob die Datei agents.json mit folgendem Inhalt vorhanden ist.

{
 "name": "image_scoring",
 "description": "Agent that generates images based on user prompts and scores their adherence to the prompt.",
 "url": "http://localhost:8001/a2a/image_scoring",
 "version": "1.0.0",
 "defaultInputModes": ["text/plain"],
 "defaultOutputModes": ["image/png", "text/plain"],
 "capabilities": {
   "streaming": true,
   "functions": true
 },
 "skills": [
   {
     "id": "generate_and_score_image",
     "name": "Generate and Score Image",
     "description": "Generates an image from a given text prompt and then evaluates how well the generated image adheres to the original prompt, providing a score.",
     "tags": ["image generation", "image scoring", "evaluation", "AI art"],
     "examples": [
       "Generate an image of a futuristic city at sunset",
       "Create an image of a cat playing a piano",
       "Show me an image of a serene forest with a hidden waterfall"
     ]
   }
 ]
}

2. A2A-Agenten erstellen

Prüfen Sie im Stammordner image_scoring_adk_a2a_server über die Seitenleiste des Cloud Shell-Editors, ob die Datei a2a_agent.py vorhanden ist. Sie ist der Einstiegspunkt für den A2A-Agenten. Sie sollte Folgendes enthalten:

from google.adk.agents.remote_a2a_agent import RemoteA2aAgent

root_agent = RemoteA2aAgent(
   name="image_scoring",
   description="Agent to give interesting facts.",
   agent_card="http://localhost:8001/a2a/image_scoring/.well-known/agent.json",
  
   # Optional configurations
   timeout=300.0,          # HTTP timeout (seconds)
   httpx_client=None,      # Custom HTTP client
)

3. A2A-Agenten ausführen

Jetzt können wir den Agent ausführen. image_scoring_adk_a2a_server

#following command runs the ADK agent as a2a agent
adk api_server --a2a --port 8001 remote_a2a

4. A2A-Agent testen

Sobald der Agent ausgeführt wird, können wir ihn testen. Sehen wir uns zuerst die Agent-Karte an. Öffnen Sie ein neues Terminal über „Terminal“ > „Neues Terminal“ und führen Sie den folgenden Befehl aus (im neu geöffneten Cloud Shell-Editor-Terminal).

#Execute the following 
curl http://localhost:8001/a2a/image_scoring/.well-known/agent.json

Wenn Sie den obigen Befehl ausführen, sollte die Agentenkarte für unseren A2A-Agenten angezeigt werden. Sie enthält hauptsächlich den Inhalt der Datei agent.json, die wir im vorherigen Schritt erstellt haben.

Senden wir nun eine Anfrage an den Agenten. Wir können „curl“ verwenden, um eine Anfrage an den Agent zu senden (im neu geöffneten Cloud Shell Editor-Terminal ausführen):

curl -X POST   http://localhost:8001/a2a/image_scoring   -H 'Content-Type: application/json'   -d '{
    "id": "uuid-123",
    "params": {
      "message": {
        "messageId": "msg-456",
        "parts": [{"text": "Create an image of a cat"}],
        "role": "user"
      }
    }
  }'

Im obigen Beispiel können Sie den Prompt ändern, indem Sie die Zeile Create an image of a cat (Erstelle ein Bild einer Katze) ändern. Nachdem Sie den Befehl ausgeführt haben, können Sie das Ausgabebild im angegebenen Google Cloud Storage suchen.

10. Bereinigen

Räumen wir jetzt auf.

1. Löschen Sie den Server für Vertex AI Agent Engine, den wir gerade erstellt haben. Rufen Sie Vertex AI auf, indem Sie in der Suchleiste der Google Cloud Console „Vertex AI“ eingeben. Klicken Sie links auf Agent Engine.Sie können den Agenten löschen, indem Sie auf „Löschen“ klicken.

Abbildung 8

2. Dateien in Cloud Shell löschen

#Execute the following to delete the files
cd ~
rm -R ~/imagescoring

3. Löschen Sie den Bucket. Sie können in der GCP Console unter „Cloud Storage“ Ihren Bucket auswählen und löschen.

Abbildung 9: Bucket löschen

11. Fazit

Glückwunsch! Sie haben eine Multi-Agent-Anwendung mit dem ADK (Agent Development Kit) in der Vertex AI Agent Engine bereitgestellt. Dies ist ein wichtiger Schritt, der den Kernlebenszyklus einer modernen cloudnativen Anwendung abdeckt und Ihnen eine solide Grundlage für die Bereitstellung Ihrer eigenen komplexen agentenbasierten Systeme bietet.

Zusammenfassung

In diesem Lab haben Sie Folgendes gelernt:

• Multi-Agent-Anwendung mit dem ADK (Agent Development Kit) erstellen
• Anwendung in Vertex AI Agent Engine bereitstellen
• Erstellen Sie einen Agenten, der über das A2A-Protokoll kommunizieren kann.

Nützliche Ressourcen

• Offizielle ADK-Dokumentation
• Vertex AI Agent Engine
• A2A-Protokoll
• Cloud Run