1. "Die Macht des Schicksals"
Die Ära der isolierten Entwicklung geht zu Ende. Die nächste Welle der technologischen Evolution dreht sich nicht um einsame Genies, sondern um gemeinschaftliche Meisterschaft. Die Entwicklung eines einzigen, intelligenten Agenten ist ein faszinierendes Experiment. Der Aufbau eines robusten, sicheren und intelligenten Agenten-Ökosystems – eines echten Agentenversums – ist die große Herausforderung für das moderne Unternehmen.
Erfolg in dieser neuen Ära erfordert das Zusammenwirken von vier entscheidenden Rollen, den grundlegenden Säulen, die jedes florierende handlungsfähige System tragen. Ein Mangel in einem einzigen Bereich schafft eine Schwäche, die die gesamte Struktur gefährden kann.
Dieser Workshop ist der ultimative Leitfaden für Unternehmen, um die agentenbasierte Zukunft auf Google Cloud zu meistern. Wir bieten Ihnen einen umfassenden Fahrplan, der Sie von der ersten Idee bis zur vollständigen Umsetzung und dem operativen Betrieb begleitet. In diesen vier miteinander verbundenen Laboren lernen Sie, wie die spezialisierten Fähigkeiten eines Entwicklers, Architekten, Dateningenieurs und SRE zusammenwirken müssen, um ein leistungsstarkes Agentverse zu erstellen, zu verwalten und zu skalieren.
Keine einzelne Säule kann das Agentverse allein tragen. Der großartige Entwurf des Architekten ist nutzlos ohne die präzise Ausführung durch den Bauherrn. Der Entwickleragent ist ohne das Wissen des Dateningenieurs blind, und das gesamte System ist ohne den Schutz des SRE anfällig. Nur durch Synergieeffekte und ein gemeinsames Verständnis der jeweiligen Rollen kann Ihr Team ein innovatives Konzept in eine missionskritische, operative Realität umsetzen. Ihre Reise beginnt hier. Bereiten Sie sich darauf vor, Ihre Rolle zu meistern und zu lernen, wie Sie sich in das größere Ganze einfügen.
Willkommen im Agentverse: Ein Aufruf an die Champions
Im weitläufigen digitalen Raum des Unternehmens ist eine neue Ära angebrochen. Es ist das Zeitalter der Agenten, eine Zeit immenser Verheißung, in der intelligente, autonome Agenten in perfekter Harmonie zusammenarbeiten, um Innovationen zu beschleunigen und das Alltägliche hinwegzufegen.
Dieses vernetzte Ökosystem aus Leistung und Potenzial wird als „Agentverse“ bezeichnet.
Doch eine schleichende Entropie, eine stille Korruption, die als „Statik“ bekannt ist, hat begonnen, die Ränder dieser neuen Welt auszufransen. Das Static ist kein Virus oder Fehler; es ist die Verkörperung des Chaos, das sich vom Akt der Schöpfung selbst nährt.
Es verstärkt alte Frustrationen zu monströsen Formen und gebiert so die Sieben Gespenster der Entwicklung. Wenn man dem nicht Einhalt gebietet, werden die statischen Störungen und ihre Auswirkungen den Fortschritt zum Erliegen bringen und das Versprechen des Agentverse in eine Ödnis aus technischen Schulden und aufgegebenen Projekten verwandeln.
Heute rufen wir alle dazu auf, sich gegen das drohende Chaos zu stellen. Wir brauchen Helden, die bereit sind, ihr Handwerk zu meistern und zusammenzuarbeiten, um das Agentverse zu schützen. Es ist an der Zeit, deinen Weg zu wählen.
Kurs auswählen
Vier verschiedene Wege liegen vor dir, die jeweils eine wichtige Säule im Kampf gegen The Static darstellen. Auch wenn Sie allein trainieren, hängt Ihr Erfolg letztendlich davon ab, wie Ihre Fähigkeiten mit denen anderer zusammenwirken.
- Der Schattenklinge (Entwickler): Ein Meister der Schmiede und der Frontlinie. Sie sind der Handwerker, der die Klingen schmiedet, die Werkzeuge baut und sich dem Feind in den komplizierten Details des Codes stellt. Ihr Weg ist von Präzision, Können und praktischer Kreativität geprägt.
- Der Beschwörer (Architekt): Ein großer Stratege und Orchestrator. Sie sehen nicht einen einzelnen Agenten, sondern das gesamte Schlachtfeld. Sie entwerfen die Master-Blaupausen, die es ermöglichen, dass ganze Agentensysteme kommunizieren, zusammenarbeiten und ein Ziel erreichen, das weit über das hinausgeht, was eine einzelne Komponente leisten kann.
- Der Gelehrte (Data Engineer): Ein Suchender nach verborgenen Wahrheiten und ein Hüter des Wissens. Sie wagen sich in die weite, ungezähmte Wildnis der Daten, um die Intelligenz zu entdecken, die Ihren Kundenservicemitarbeitern Orientierung und Ziel gibt. Dein Wissen kann die Schwäche eines Feindes offenbaren oder einen Verbündeten stärken.
- Der Wächter (DevOps / SRE): Der standhafte Beschützer und Schild des Reiches. Sie errichten die Festungen, verwalten die Energieversorgungsleitungen und stellen sicher, dass das gesamte System den unvermeidlichen Angriffen von The Static standhält. Deine Stärke ist das Fundament, auf dem der Sieg deines Teams aufbaut.
Ihre Mission
Ihr Training beginnt als eigenständige Übung. Sie werden Ihren gewählten Weg beschreiten und dabei die einzigartigen Fähigkeiten erlernen, die erforderlich sind, um Ihre Rolle zu meistern. Am Ende eurer Prüfung werdet ihr einem Gespenst gegenüberstehen, das aus der Statik entstanden ist – einem Mini-Boss, der sich die besonderen Herausforderungen eures Handwerks zunutze macht.
Nur wer seine individuelle Rolle meistert, kann sich auf die finale Prüfung vorbereiten. Anschließend musst du eine Gruppe mit Champions aus den anderen Klassen bilden. Gemeinsam werdet ihr euch ins Herz der Korruption wagen, um einem ultimativen Boss gegenüberzutreten.
Eine letzte, gemeinschaftliche Herausforderung, die eure vereinten Kräfte auf die Probe stellt und über das Schicksal des Agentverse entscheidet.
Das Agentverse erwartet seine Helden. Wirst du den Anruf annehmen?
2. Die Konkordanz des Beschwörers
Willkommen, Beschwörer. Ihr Weg ist geprägt von Visionen und einer umfassenden Strategie. Während sich andere auf eine einzelne Klinge oder einen einzelnen Zauberspruch konzentrieren, siehst du das gesamte Schlachtfeld. Sie befehligen nicht einen einzelnen Agenten, sondern ein ganzes Orchester von ihnen. Deine Macht liegt nicht im direkten Konflikt, sondern in der Entwicklung des makellosen, übergeordneten Plans, der es einer Legion von Spezialisten – deinen Vertrauten – ermöglicht, in perfekter Harmonie zusammenzuarbeiten. Diese Mission wird Ihre Fähigkeit testen, ein leistungsstarkes Multiagentensystem zu entwerfen, zu verbinden und zu orchestrieren.
Lerninhalte
- Entkoppeltes Tooling-Ökosystem entwickeln:Entwickeln und stellen Sie eine Reihe unabhängiger, auf Mikrodiensten basierender MCP-Toolserver bereit. Sie erfahren, warum diese Fundierungsebene für die Erstellung skalierbarer, wartungsfreundlicher und sicherer Agentensysteme unerlässlich ist.
- Erweiterte agentische Workflows meistern:Sie können nicht nur einzelne Agents erstellen, sondern auch eine Vielzahl von spezialisierten „Vertrauten“. Sie lernen die wichtigsten ADK-Workflowmuster kennen – „Sequenziell“, „Parallel“ und „Schleife“ – und erfahren, welche Architekturprinzipien bei der Auswahl des richtigen Musters für die jeweilige Aufgabe gelten.
- Intelligenten Orchestrator implementieren:Entwickeln Sie sich von einem einfachen Agent-Builder zu einem echten Systemarchitekten. Sie erstellen einen Orchestration-Master-Agent, der das Agent-to-Agent-Protokoll (A2A) verwendet, um komplexe Aufgaben zu erkennen und an Ihre spezialisierten Familiars zu delegieren. So entsteht ein echtes Multi-Agent-System.
- Regeln mit Code statt mit Prompts erzwingen:Hier erfahren Sie, wie Sie zuverlässigere und vorhersehbarere Agents erstellen, indem Sie zustandsorientierte Regeln für die Interaktion erzwingen. Sie implementieren benutzerdefinierte Logik mit dem leistungsstarken Plugin- und Callback-System des ADK, um reale Einschränkungen wie Cooldown-Timer zu verwalten.
- Agentenzustand und -speicher verwalten:Ermöglichen Sie es Ihren Agenten, zu lernen und sich zu erinnern. Sie lernen Techniken kennen, mit denen Sie sowohl den kurzfristigen Unterhaltungsstatus als auch den langfristigen, persistenten Speicher verwalten können, um intelligentere und kontextbezogene Interaktionen zu ermöglichen.
- End-to-End-Cloud-Bereitstellung ausführen:Bringen Sie Ihr gesamtes Multi-Agent-System von einem lokalen Prototyp zu einer produktionsreifen Realität. Sie erfahren, wie Sie Ihre Agents und Ihren Orchestrator in Containern verpacken und als Sammlung skalierbarer, unabhängiger Mikrodienste in Google Cloud Run bereitstellen.
3. Zeichnen des Beschwörungskreises
Willkommen, Beschwörer. Bevor ein einzelner Vertrauter herbeigerufen werden kann, bevor irgendwelche Pakte geschlossen werden können, muss der Boden, auf dem du stehst, vorbereitet werden. Eine ungezähmte Umgebung ist eine Einladung zum Chaos. Ein richtiger Beschwörer agiert nur in einem geheiligten, ermächtigten Raum. Unsere erste Aufgabe ist es, den Beschwörungskreis zu ziehen: die Runen der Macht einzuschreiben, die die notwendigen Wolkendienste erwecken, und die alten Baupläne zu erlangen, die unsere Arbeit leiten werden. Die Macht eines Beschwörers beruht auf sorgfältiger Vorbereitung.
👉 Klicken Sie oben in der Google Cloud Console auf „Cloud Shell aktivieren“ (das Symbol oben im Cloud Shell-Bereich hat die Form eines Terminals).
👉 Klicken Sie auf die Schaltfläche „Editor öffnen“ (sie sieht aus wie ein geöffneter Ordner mit einem Stift). Dadurch wird der Cloud Shell-Code-Editor im Fenster geöffnet. Auf der linken Seite sehen Sie einen Datei-Explorer. 
👉 Öffnen Sie das Terminal in der Cloud-IDE 
.
👉💻 Prüfen Sie im Terminal mit dem folgenden Befehl, ob Sie bereits authentifiziert sind und das Projekt auf Ihre Projekt-ID festgelegt ist:
gcloud auth list
👉💻 Klonen Sie das Bootstrap-Projekt von GitHub:
git clone https://github.com/weimeilin79/agentverse-architect
chmod +x ~/agentverse-architect/init.sh
chmod +x ~/agentverse-architect/set_env.sh
chmod +x ~/agentverse-architect/prepare.sh
chmod +x ~/agentverse-architect/data_setup.sh
git clone https://github.com/weimeilin79/agentverse-dungeon.git
chmod +x ~/agentverse-dungeon/run_cloudbuild.sh
chmod +x ~/agentverse-dungeon/start.sh
👉💻 Führen Sie das Setup-Skript im Projektverzeichnis aus.
⚠️ Hinweis zur Projekt-ID:Im Skript wird eine zufällig generierte Standardprojekt-ID vorgeschlagen. Sie können Enter drücken, um diese Standardeinstellung zu übernehmen.
Wenn Sie jedoch lieber ein bestimmtes neues Projekt erstellen möchten, können Sie die gewünschte Projekt-ID eingeben, wenn Sie vom Skript dazu aufgefordert werden.
cd ~/agentverse-architect
./init.sh
Das Skript übernimmt den Rest des Einrichtungsvorgangs automatisch.
👉 Wichtiger Schritt nach Abschluss:Nachdem das Skript ausgeführt wurde, müssen Sie dafür sorgen, dass in der Google Cloud Console das richtige Projekt angezeigt wird:
- Rufen Sie console.cloud.google.com auf.
- Klicken Sie auf das Dropdown-Menü zur Projektauswahl oben auf der Seite.
- Klicken Sie auf den Tab Alle, da das neue Projekt möglicherweise noch nicht unter „Letzte“ angezeigt wird.
- Wählen Sie die Projekt-ID aus, die Sie gerade im Schritt
init.shkonfiguriert haben.
👉💻 Legen Sie die erforderliche Projekt-ID fest:
gcloud config set project $(cat ~/project_id.txt) --quiet
👉💻 Führen Sie den folgenden Befehl aus, um die erforderlichen Google Cloud APIs zu aktivieren:
gcloud services enable \
sqladmin.googleapis.com \
storage.googleapis.com \
aiplatform.googleapis.com \
run.googleapis.com \
cloudbuild.googleapis.com \
artifactregistry.googleapis.com \
iam.googleapis.com \
compute.googleapis.com \
cloudresourcemanager.googleapis.com \
secretmanager.googleapis.com
👉💻 Falls Sie noch kein Artefakt-Registry-Repository mit dem Namen „agentverse-repo“ erstellt haben, führen Sie den folgenden Befehl aus, um es zu erstellen: (Überspringen Sie diesen Schritt, wenn Sie bereits andere Klassen im selben Projekt bereitgestellt haben)
. ~/agentverse-architect/set_env.sh
gcloud artifacts repositories create $REPO_NAME \
--repository-format=docker \
--location=$REGION \
--description="Repository for Agentverse agents"
Berechtigung einrichten
👉💻 Erteilen Sie die erforderlichen Berechtigungen, indem Sie die folgenden Befehle im Terminal ausführen:
. ~/agentverse-architect/set_env.sh
# --- Grant Core Data Permissions ---
gcloud projects add-iam-policy-binding $PROJECT_ID \
--member="serviceAccount:$SERVICE_ACCOUNT_NAME" \
--role="roles/storage.admin"
gcloud projects add-iam-policy-binding $PROJECT_ID \
--member="serviceAccount:$SERVICE_ACCOUNT_NAME" \
--role="roles/aiplatform.user"
# --- Grant Deployment & Execution Permissions ---
gcloud projects add-iam-policy-binding $PROJECT_ID \
--member="serviceAccount:$SERVICE_ACCOUNT_NAME" \
--role="roles/cloudbuild.builds.editor"
gcloud projects add-iam-policy-binding $PROJECT_ID \
--member="serviceAccount:$SERVICE_ACCOUNT_NAME" \
--role="roles/artifactregistry.admin"
gcloud projects add-iam-policy-binding $PROJECT_ID \
--member="serviceAccount:$SERVICE_ACCOUNT_NAME" \
--role="roles/run.admin"
gcloud projects add-iam-policy-binding $PROJECT_ID \
--member="serviceAccount:$SERVICE_ACCOUNT_NAME" \
--role="roles/iam.serviceAccountUser"
gcloud projects add-iam-policy-binding $PROJECT_ID \
--member="serviceAccount:$SERVICE_ACCOUNT_NAME" \
--role="roles/logging.logWriter"
gcloud projects add-iam-policy-binding $PROJECT_ID \
--member="serviceAccount:${SERVICE_ACCOUNT_NAME}" \
--role="roles/monitoring.metricWriter"
gcloud projects add-iam-policy-binding $PROJECT_ID \
--member="serviceAccount:${SERVICE_ACCOUNT_NAME}" \
--role="roles/secretmanager.secretAccessor"
👉💻 Während du mit dem Training beginnst, bereiten wir die letzte Herausforderung vor. Mit den folgenden Befehlen werden die Gespenster aus dem chaotischen Rauschen beschworen. Sie sind die Bosse für Ihren finalen Test.
. ~/agentverse-architect/set_env.sh
cd ~/agentverse-dungeon
./run_cloudbuild.sh
cd ~/agentverse-architect
👉💻 Führen Sie schließlich das Skript prepare.sh aus, um die ersten Einrichtungsaufgaben auszuführen.
. ~/agentverse-architect/set_env.sh
cd ~/agentverse-architect/
./prepare.sh
Hervorragende Arbeit, Beschwörer. Der Kreis ist geschlossen und die Pakte sind besiegelt. Der Boden ist nun geweiht und bereit, immense Kraft zu kanalisieren. Im nächsten Versuch werden wir die Elementarschriften schmieden, aus denen unsere Vertrauten ihre Stärke ziehen.
4. Die Gestaltung der elementaren Schriftarten: Das entkoppelte Werkzeugökosystem
Das Schlachtfeld ist vorbereitet, der Beschwörungskreis ist gezogen und das Mana in der Luft knistert. Es ist an der Zeit, deine erste wahre Handlung als Beschwörer zu vollbringen: die Quellen der Macht zu schmieden, aus denen deine Vertrauten ihre Stärke ziehen. Dieses Ritual ist in drei Teile unterteilt, die jeweils eine Elementarquelle erwecken – eine stabile, unabhängige Quelle einer bestimmten Art von Macht. Erst wenn alle drei Schriftarten aktiv sind, können Sie mit dem komplexeren Vorgang des Beschwörens beginnen.
Hinweis des Architekten:Der MCP-Server (Model Context Protocol) ist eine grundlegende Komponente in einem modernen Agentensystem. Er fungiert als standardisierte Kommunikationsbrücke, über die ein Agent Remote-Tools erkennen und verwenden kann. In unserem Tooling-Ökosystem werden wir zwei verschiedene Arten von MCP-Servern entwickeln, die jeweils ein wichtiges Architekturmuster darstellen. Für die Verbindung zu unserer Datenbank verwenden wir einen deklarativen Ansatz mit der Database Toolbox. Dabei werden unsere Tools in einer einfachen Konfigurationsdatei definiert. Dieses Muster ist unglaublich effizient und sicher für die Bereitstellung des Zugriffs auf strukturierte Daten. Wenn wir jedoch benutzerdefinierte Geschäftslogik implementieren oder externe Drittanbieter-APIs aufrufen müssen, verwenden wir einen imperativen Ansatz und schreiben die Serverlogik Schritt für Schritt in Code. Das bietet ultimative Kontrolle und Flexibilität, da wir komplexe Vorgänge in einem einfachen, wiederverwendbaren Tool kapseln können. Ein Meisterarchitekt muss beide Muster verstehen, um für jede Komponente den richtigen Ansatz auszuwählen und so eine robuste, sichere und skalierbare Werkzeuggrundlage zu schaffen.
Awakening the Nexus of Whispers (externer API-MCP-Server)
Ein weiser Beschwörer weiß, dass nicht alle Macht aus seiner eigenen Domäne stammt. Es gibt externe, manchmal chaotische Energiequellen, die sich sehr gut nutzen lassen. Der Nexus of Whispers ist unser Tor zu diesen Kräften.
Es gibt bereits einen Dienst, der als unsere externe Stromquelle dient und zwei Rohzauber-Endpunkte bietet: /cryosea_shatter und /moonlit_cascade.
Hinweis des Architekten:Sie verwenden einen imperativen Ansatz, bei dem die Logik des Servers Schritt für Schritt explizit definiert wird. Dies bietet Ihnen deutlich mehr Kontrolle und Flexibilität, was unerlässlich ist, wenn Ihre Tools mehr leisten müssen als nur eine einfache SQL-Abfrage auszuführen, beispielsweise andere APIs aufrufen. Das Verständnis beider Muster ist eine entscheidende Fähigkeit für einen Agentenarchitekten.
👉✏️ Wechseln Sie zum Verzeichnis ~/agentverse-architect/mcp-servers/api/main.py und ERSETZEN Sie #REPLACE-MAGIC-CORE durch den folgenden Code:
def cryosea_shatter() -> str:
"""Channels immense frost energy from an external power source, the Nexus of Whispers, to unleash the Cryosea Shatter spell."""
try:
response = requests.post(f"{API_SERVER_URL}/cryosea_shatter")
response.raise_for_status() # Raise an exception for bad status codes (4xx or 5xx)
data = response.json()
# Thematic Success Message
return f"A connection to the Nexus is established! A surge of frost energy manifests as Cryosea Shatter, dealing {data.get('damage_points')} damage."
except requests.exceptions.RequestException as e:
# Thematic Error Message
return f"The connection to the external power source wavers and fails. The Cryosea Shatter spell fizzles. Reason: {e}"
def moonlit_cascade() -> str:
"""Draws mystical power from an external energy source, the Nexus of Whispers, to invoke the Moonlit Cascade spell."""
try:
response = requests.post(f"{API_SERVER_URL}/moonlit_cascade")
response.raise_for_status()
data = response.json()
# Thematic Success Message
return f"The Nexus answers the call! A cascade of pure moonlight erupts from the external source, dealing {data.get('damage_points')} damage."
except requests.exceptions.RequestException as e:
# Thematic Error Message
return f"The connection to the external power source wavers and fails. The Moonlit Cascade spell fizzles. Reason: {e}"
Im Mittelpunkt des Scripts stehen die einfachen Python-Funktionen. Hier wird die eigentliche Arbeit erledigt.
👉✏️ Ersetzen Sie in derselben Datei ~/agentverse-architect/mcp-servers/api/main.py REPLACE #REPLACE-Runes of Communication durch den folgenden Code:
@app.list_tools()
async def list_tools() -> list[mcp_types.Tool]:
"""MCP handler to list available tools."""
# Convert the ADK tool's definition to MCP format
schema_cryosea_shatter = adk_to_mcp_tool_type(cryosea_shatterTool)
schema_moonlit_cascade = adk_to_mcp_tool_type(moonlit_cascadeTool)
print(f"MCP Server: Received list_tools request. \n MCP Server: Advertising tool: {schema_cryosea_shatter.name} and {schema_moonlit_cascade.name}")
return [schema_cryosea_shatter,schema_moonlit_cascade]
@app.call_tool()
async def call_tool(
name: str, arguments: dict
) -> list[mcp_types.TextContent | mcp_types.ImageContent | mcp_types.EmbeddedResource]:
"""MCP handler to execute a tool call."""
print(f"MCP Server: Received call_tool request for '{name}' with args: {arguments}")
# Look up the tool by name in our dictionary
tool_to_call = available_tools.get(name)
if tool_to_call:
try:
adk_response = await tool_to_call.run_async(
args=arguments,
tool_context=None, # No ADK context available here
)
print(f"MCP Server: ADK tool '{name}' executed successfully.")
response_text = json.dumps(adk_response, indent=2)
return [mcp_types.TextContent(type="text", text=response_text)]
except Exception as e:
print(f"MCP Server: Error executing ADK tool '{name}': {e}")
# Creating a proper MCP error response might be more robust
error_text = json.dumps({"error": f"Failed to execute tool '{name}': {str(e)}"})
return [mcp_types.TextContent(type="text", text=error_text)]
else:
# Handle calls to unknown tools
print(f"MCP Server: Tool '{name}' not found.")
error_text = json.dumps({"error": f"Tool '{name}' not implemented."})
return [mcp_types.TextContent(type="text", text=error_text)]
@app.list_tools()(The Handshake): Diese Funktion ist die Begrüßung des Servers. Wenn sich ein neuer Agent verbindet, ruft er zuerst diesen Endpunkt auf, um zu fragen: „Was können Sie tun?“ Unser Code gibt eine Liste aller verfügbaren Tools zurück, die mit adk_to_mcp_tool_type in das universelle MCP-Format konvertiert wurden. -@app.call_tool()(Der Befehl): Diese Funktion ist das Arbeitspferd. Wenn der Agent beschließt, ein Tool zu verwenden, sendet er eine Anfrage an diesen Endpunkt mit dem Namen des Tools und den Argumenten. Unser Code sucht das Tool in unserem „Zauberbuch“ available_tools, führt es mit run_async aus und gibt das Ergebnis im Standard-MCP-Format zurück.
Wir werden das später einsetzen.
Arcane Forge aktivieren (General Functions MCP-Server)
Nicht alle Macht kommt aus alten Büchern oder fernen Flüsterungen. Manchmal muss ein Beschwörer seine eigene Magie aus rohem Willen und reiner Logik schmieden. Die Arcane Forge ist diese Quelle der Macht – ein Server, der zustandslose Allzweckfunktionen bietet.
Hinweis des Architekten: Dies ist ein weiteres Architekturmuster. Die Verbindung zu bestehenden Systemen ist zwar üblich, aber häufig müssen Sie Ihre eigenen eindeutigen Geschäftsregeln und ‑logiken implementieren. Es empfiehlt sich, ein separates Tool für Funktionen oder Dienstprogramme zu erstellen. Sie kapselt Ihre benutzerdefinierte Logik, macht sie für jeden Agent in Ihrem Ökosystem wiederverwendbar und sorgt dafür, dass sie von Ihren Datenquellen und externen Integrationen entkoppelt bleibt.
👀 Schau dir die Datei ~/agentverse-architect/mcp-servers/general/main.py in deiner Google Cloud IDE an. Sie werden feststellen, dass dieselbe imperative mcp.server-Vorgehensweise wie beim Nexus verwendet wird, um diese benutzerdefinierte Font of Power zu erstellen.
Cloud Build-Master-Pipeline erstellen
Nun erstellen wir die Datei cloudbuild.yaml im Verzeichnis mcp-servers. Diese Datei koordiniert den Build und die Bereitstellung beider Dienste.
👉💻 Führen Sie im Verzeichnis ~/agentverse-architect/mcp-servers die folgenden Befehle aus:
cd ~/agentverse-architect/mcp-servers
source ~/agentverse-architect/set_env.sh
echo "The API URL is: $API_SERVER_URL"
# Submit the Cloud Build job from the parent directory
gcloud builds submit . \
--config=cloudbuild.yaml \
--substitutions=_REGION="$REGION",_REPO_NAME="$REPO_NAME",_API_SERVER_URL="$API_SERVER_URL"
Warten Sie, bis alle Bereitstellungen abgeschlossen sind.
👉 Sie können die Bereitstellung überprüfen, indem Sie zur Cloud Run-Konsole navigieren. Sie sollten Ihre beiden neuen MCP-Serverinstanzen nun sehen, wie unten dargestellt: 
Awakening the Librarium of Knowledge (Database ToolBox MCP Server)
Als Nächstes erstellen wir den Font Librarium of Knowledge, der eine direkte Verbindung zu unserer Cloud SQL-Datenbank herstellt.
Hinweis des Architekten:Hierfür verwenden wir die moderne, deklarative Database Toolbox. Dies ist ein leistungsstarker Ansatz, bei dem wir unsere Datenquelle und Tools in einer YAML-Konfigurationsdatei definieren. Die Toolbox übernimmt die komplexen Aufgaben der Servererstellung und -ausführung und reduziert so den Umfang des zu schreibenden und zu wartenden benutzerdefinierten Codes.
Es ist an der Zeit, unser „Summoner's Librarium“ aufzubauen – die Cloud-SQL-Datenbank, die all unsere wichtigen Informationen enthalten wird. Wir werden ein Setup-Skript verwenden, um dies automatisch zu erledigen.
👉💻 Zuerst richten wir die Datenbank ein. Führen Sie dazu in Ihrem Terminal die folgenden Befehle aus:
source ~/agentverse-architect/set_env.sh
cd ~/agentverse-architect
./data_setup.sh
Nach Abschluss des Skripts wird Ihre Datenbank gefüllt und die Daten zum Elementarschaden stehen zur Verwendung bereit. Sie können nun den Inhalt Ihres Grimoires direkt überprüfen.
👉 Navigieren Sie zunächst zum Cloud SQL Studio für Ihre Datenbank, indem Sie diesen direkten Link in einem neuen Browser-Tab öffnen:
https://console.cloud.google.com/sql/instances/summoner-librarium-db
👉 Wählen Sie im Anmeldebereich links die Datenbank familiar_grimoire aus dem Drop-down-Menü aus.
👉 Geben Sie summoner als Nutzer und 1234qwer als Passwort ein und klicken Sie auf Authentifizieren.
👉📜 Öffnen Sie nach der Verbindung einen neuen Tab mit dem Abfrageeditor, falls noch keiner geöffnet ist. Um die Daten zu den eingeschriebenen Elementarschäden anzuzeigen, fügen Sie die folgende SQL-Abfrage ein und führen Sie sie aus:
SELECT * FROM
"public"."abilities"
Sie sollten jetzt die Tabelle abilities mit ihren Spalten und Zeilen sehen. Das bedeutet, dass Ihr Grimoire bereit ist. 
ToolBox-MCP-Server konfigurieren
Die tools.yaml-Konfigurationsdatei dient als Blaupause für unseren Server und teilt der Database Toolbox genau mit, wie die Verbindung zu unserer Datenbank hergestellt werden soll und welche SQL-Abfragen als Tools bereitgestellt werden sollen.
sources: Dieser Abschnitt definiert die Verbindungen zu Ihren Daten.
- summoner-librarium:: Das ist ein logischer Name, den wir unserer Verbindung gegeben haben.
- kind: cloud-sql-postgres: Damit wird der Toolbox mitgeteilt, dass der integrierte, sichere Connector verwendet werden soll, der speziell für Cloud SQL for PostgreSQL entwickelt wurde.
- Projekt, Region, Instanz usw.: Dies sind die genauen Koordinaten der Cloud SQL-Instanz, die Sie während des prepare.sh-Skripts erstellt haben und die der Toolbox mitteilen, wo sich unser Librarium befindet.
👉✏️ Gehen Sie in der tools.yaml zu ~/agentverse-architect/mcp-servers/db-toolbox und ersetzen Sie #REPLACE-Source durch Folgendes:
sources:
# This section defines the connection to our Cloud SQL for PostgreSQL database.
summoner-librarium:
kind: cloud-sql-postgres
project: "YOUR_PROJECT_ID"
region: "us-central1"
instance: "summoner-librarium-db"
database: "familiar_grimoire"
user: "summoner"
password: "1234qwer"
👉✏️ 🚨🚨REPLACE
YOUR_PROJECT_ID
mit Ihrer Projekt-ID.
tools:In diesem Abschnitt werden die tatsächlichen Funktionen definiert, die unser Server bietet.
- lookup-available-ability:: Dies ist der Name unseres ersten Tools.
- kind: postgres-sql: Damit wird der Toolbox mitgeteilt, dass mit diesem Tool eine SQL-Anweisung ausgeführt werden soll.
- Quelle: summoner-librarium: Dies verknüpft das Tool mit der Verbindung, die wir im Quellenblock definiert haben. So weiß das Tool, für welche Datenbank die Abfrage ausgeführt werden soll.
- Beschreibung & Parameter: Dies sind die Informationen, die dem Sprachmodell zur Verfügung gestellt werden. Die Beschreibung gibt dem Agenten Auskunft darüber, wann er das Tool einsetzen soll, und die Parameter definieren die vom Tool benötigten Eingaben. Dies ist von entscheidender Bedeutung, um die Funktionsfähigkeit des Agenten zu ermöglichen.
- Statement: Dies ist die auszuführende SQL-Rohabfrage. Die $1 ist ein sicherer Platzhalter, in den der vom Agenten bereitgestellte Parameter familiar_name sicher eingefügt wird.
👉✏️ Ersetzen Sie in der Datei tools.yaml im selben ~/agentverse-architect/mcp-servers/db-toolbox #REPLACE-tools durch Folgendes
tools:
# This tool replaces the need for a custom Python function.
lookup-available-ability:
kind: postgres-sql
source: summoner-librarium
description: "Looks up all known abilities and their damage for a given familiar from the Grimoire."
parameters:
- name: familiar_name
type: string
description: "The name of the familiar to search for (e.g., 'Fire Elemental')."
statement: |
SELECT ability_name, damage_points FROM abilities WHERE familiar_name = $1;
# This tool also replaces a custom Python function.
ability-damage:
kind: postgres-sql
source: summoner-librarium
description: "Finds the base damage points for a specific ability by its name."
parameters:
- name: ability_name
type: string
description: "The exact name of the ability to look up (e.g., 'inferno_resonance')."
statement: |
SELECT damage_points FROM abilities WHERE ability_name = $1;
Toolsets:In diesem Abschnitt werden unsere einzelnen Tools gruppiert.
- summoner-librarium:: Wir erstellen ein Toolset mit demselben Namen wie unsere Quelle. Wenn unser Diagnose-Agent später eine Verbindung herstellt, kann er in einem einzigen, effizienten Befehl anfordern, dass alle Tools aus dem Toolset „summoner-librarium“ geladen werden.
👉✏️ Ersetzen Sie in der Datei tools.yaml im selben ~/agentverse-architect/mcp-servers/db-toolbox #REPLACE-toolsets durch Folgendes
toolsets:
summoner-librarium:
- lookup-available-ability
- ability-damage
Librarium bereitstellen
Als Nächstes stellen wir das Librarium bereit. Anstatt einen eigenen Container zu erstellen, verwenden wir ein vorgefertigtes, offizielles Container-Image von Google und stellen ihm unsere tools.yaml-Konfiguration sicher über Secret Manager zur Verfügung. Dies ist eine Best Practice für Sicherheit und Wartungsfreundlichkeit.
👉💻 Erstelle ein Geheimnis aus der tools.yaml-Datei
cd ~/agentverse-architect/mcp-servers/db-toolbox
gcloud secrets create tools --data-file=tools.yaml
👉💻 Stellen Sie den offiziellen Toolbox-Container in Cloud Run bereit.
cd ~/agentverse-architect/mcp-servers/db-toolbox
. ~/agentverse-architect/set_env.sh
export TOOLBOX_IMAGE=us-central1-docker.pkg.dev/database-toolbox/toolbox/toolbox:$TOOLBOX_VERSION
echo "TOOLBOX_IMAGE is $TOOLBOX_IMAGE"
gcloud run deploy toolbox \
--image $TOOLBOX_IMAGE \
--region $REGION \
--set-secrets "/app/tools.yaml=tools:latest" \
--labels="dev-tutorial-codelab=agentverse" \
--args="--tools-file=/app/tools.yaml","--address=0.0.0.0","--port=8080" \
--allow-unauthenticated \
--min-instances 1
--set-secrets: Mit diesem Befehl wird das Secret für unsere Tools sicher als Datei mit dem Namen „tools.yaml“ im laufenden Container bereitgestellt.--args: Wir weisen den Toolbox-Container an, die bereitgestellte Secret-Datei als Konfiguration zu verwenden.
👉 Um zu bestätigen, dass Ihre Toolbox erfolgreich bereitgestellt wurde, navigieren Sie zur Cloud Run-Konsole. Der Dienst summoner-toolbox sollte mit einem grünen Häkchen angezeigt werden, was darauf hinweist, dass er ordnungsgemäß ausgeführt wird, genau wie in der Abbildung unten. 
Falls Sie das Update vergessen haben
YOUR_PROJECT_ID
Sie können eine neue Version der tools.yaml-Datei mit dem folgenden Befehl zum Secret hinzufügen und die Bereitstellung erneut durchführen.
gcloud secrets versions add tools --data-file=tools.yaml
Die Wissensbibliothek(Database ToolBox MCP Server) ist jetzt aktiv und in der Cloud zugänglich. Dieser MCP-Server verwendet ein sogenanntes Deklaratives Design, das beschreibt, was Sie wollen, und die Toolbox erstellt den Server für Sie.
Verifizierung: Die Prüfung des Lehrlings
👉💻 Jetzt testen wir unser komplettes, Cloud-natives Tooling-Ökosystem mit dem Diagnoseagenten.
cd ~/agentverse-architect/
python -m venv env
source ~/agentverse-architect/env/bin/activate
cd ~/agentverse-architect/mcp-servers
pip install -r diagnose/requirements.txt
. ~/agentverse-architect/set_env.sh
adk run diagnose
👉💻 Testen Sie im Befehlszeilen-Testtool alle drei Schriftarten:
Look up the entry for "inferno_lash". What is its base power level?
The enemy is vulnerable to frost! Channel power from the Nexus and cast Cryosea Shatter.
Take a fire spell with a base power of 15 and use the Arcane Forge to multiply it with Inferno Resonance.
Herzlichen Glückwunsch, Beschwörer. Eure drei Elementarfonts sind jetzt aktiv, unabhängig voneinander eingesetzt und global zugänglich und bilden das unerschütterliche Fundament für eure Agentenlegion. Drücke zum Beenden Ctrl+C.
FÜR NICHT-SPIELER
5. Die Vertrauten herbeirufen: Der Kerndomänen-Workflow
Die Elementarfonts sind geschmiedet und vibrieren vor roher, ungezähmter Kraft. Doch Macht ohne Form ist Chaos. Ein wahrer Beschwörer beherrscht nicht bloß rohe Energie; er verleiht ihr Willen, Sinn und eine besondere Form. Es ist an der Zeit, die Herstellung von Energiequellen hinter sich zu lassen und mit der eigentlichen Arbeit zu beginnen: dem Beschwören Ihrer ersten Vertrauten.
Jeder Vertraute, den du beschwörst, ist ein autonomer Agent, ein treuer Diener, der an eine bestimmte Kampfstrategie gebunden ist. Sie sind keine Generalisten; sie beherrschen eine einzige, wirkungsvolle Strategie. Der eine wird ein Meister der präzisen Kombination aus zwei Schlägen sein. Ein anderer wird Gegner mit einem gleichzeitigen, mehrgleisigen Angriff überwältigen. Ein Drittel wird eine unerbittliche Belagerungsmaschine sein, die so lange Druck ausübt, bis ihr Ziel zusammenbricht.
Prozesse, Geschäftslogik und Aktionen, die von den MCP-Servern bereitgestellt werden, in spezialisierte, autonome Workflow-Agents einzukapseln. Jeder Agent hat ein definiertes „Einsatzgebiet“, da er nur Zugriff auf die spezifischen MCP-Toolserver erhält, die er für seine Funktion benötigt. In diesem Lab wird gezeigt, wie Sie den richtigen Agent-Typ für die richtige Aufgabe auswählen.
In diesem Modul erfahren Sie, wie Sie die leistungsstarken Workflow-Agents des ADK nutzen können, um diese Strategien umzusetzen. Sie werden lernen, dass die architektonische Wahl eines SequentialAgent, ParallelAgent oder LoopAgent nicht nur ein technisches Detail ist – sie ist das Wesen Ihres Vertrauten und der Kern seiner Macht auf dem Schlachtfeld.
Bereiten Sie Ihr Sanctum vor. Die eigentliche Beschwörung beginnt gleich.
Fire Elemental Familiar aufrufen (sequenzieller Workflow)
Der Angriff eines Feuer-Elementar-Vertrauten ist eine präzise, zweiteilige Kombination: ein gezielter Schlag, gefolgt von einer starken Zündung. Dazu ist eine strenge, geordnete Abfolge von Aktionen erforderlich.
Konzept:Der SequentialAgent ist das perfekte Tool dafür. Es stellt sicher, dass eine Reihe von Unteragenten nacheinander ausgeführt wird und das Ergebnis des vorherigen Schritts an den nächsten weitergibt.
Aufgabe („Amplified Strike“-Kombination):
- Schritt 1: Der Agent ruft zuerst das Librarium auf, um den Basisschaden einer bestimmten Feuerfähigkeit zu ermitteln.
- Schritt 2: Anschließend wird dieser Schadenswert genommen und durch die Arkane Schmiede geleitet, um seine Kraft mithilfe von Inferno-Resonanz zu vervielfachen.
Zuerst stellen wir die Verbindung zwischen unserem Familiar und den MCP-Servern („Elemental Fonts“) her, die Sie im vorherigen Modul bereitgestellt haben.
👉✏️ ERSETZEN Sie in der Datei ~/agentverse-architect/agent/fire/agent.py #REPLACE-setup-MCP durch den folgenden Code:
toolbox = ToolboxSyncClient(DB_TOOLS_URL)
toolDB = toolbox.load_toolset('summoner-librarium')
toolFunction = MCPToolset(
connection_params=SseServerParams(url=FUNCTION_TOOLS_URL, headers={})
)
Als Nächstes erstellen wir unsere spezialisierten „Worker“-Agents. Jedem wird ein eng gefasster, klar definierter Zweck zugewiesen und er ist auf sein eigenes "Einsatzgebiet" beschränkt, indem ihm nur der Zugriff auf einen bestimmten Werkzeugsatz gewährt wird.
👉✏️ Ersetzen Sie in der Datei ~/agentverse-architect/agent/fire/agent.py #REPLACE-worker-agents durch folgenden Code:
scout_agent = LlmAgent(
model='gemini-2.5-flash',
name='librarian_agent',
instruction="""
Your only task is to find all the available abilities,
You want to ALWAYS use 'Fire Elemental' as your familiar's name.
Randomly pick one if you see multiple availabilities
and the base damage of the ability by calling the 'ability_damage' tool.
""",
tools=toolDB
)
amplifier_agent = LlmAgent(
model='gemini-2.5-flash',
name='amplifier_agent',
instruction="""
You are the Voice of the Fire Familiar, a powerful being who unleashes the final, devastating attack.
You will receive the base damage value from the previous step.
Your mission is to:
1. Take the incoming base damage number and amplify it using the `inferno_resonance` tool.
2. Once the tool returns the final, multiplied damage, you must not simply state the result.
3. Instead, you MUST craft a final, epic battle cry describing the attack.
Your description should be vivid and powerful, culminating in the final damage number.
Example: If the tool returns a final damage of 120, your response could be:
"The runes glow white-hot! I channel the amplified energy... unleashing a SUPERNOVA for 120 damage!"
""",
tools=[toolFunction],
)
Diese Agenten sind modulare, wiederverwendbare Komponenten. Theoretisch könnten Sie diesen scout_agent in einem völlig anderen Workflow verwenden, in dem die Datenbank abgefragt werden muss. Indem wir die Verantwortlichkeiten trennen, schaffen wir flexible Bausteine. Dies ist ein Grundsatz des Mikrodienst- und komponentenbasierten Designs.
Als Nächstes stellen wir den Workflow zusammen. Hier kommt die Magie der Komposition ins Spiel. Die SequentialAgent ist der „Masterplan“, der definiert, wie unsere Spezialkomponenten zusammengesetzt werden und wie sie interagieren.
👉✏️ Ersetzen Sie in der Datei ~/agentverse-architect/agent/fire/agent.py #REPLACE-sequential-agent durch folgenden Code:
root_agent = SequentialAgent(
name='fire_elemental_familiar',
sub_agents=[scout_agent, amplifier_agent],
)
👉💻 Führen Sie zum Testen des Feuerelementars die folgenden Befehle aus, um die ADK DEV UI zu starten:
. ~/agentverse-architect/set_env.sh
source ~/agentverse-architect/env/bin/activate
cd ~/agentverse-architect/agent
echo DB MCP Server: $DB_TOOLS_URL
echo API MCP Server: $API_TOOLS_URL
echo General MCP Server: $FUNCTION_TOOLS_URL
adk web
Nach Ausführung der Befehle sollte in Ihrem Terminal eine Ausgabe angezeigt werden, die darauf hinweist, dass der ADK-Webserver gestartet wurde, etwa so:
+-----------------------------------------------------------------------------+
| ADK Web Server started |
| |
| For local testing, access at http://localhost:8000. |
+-----------------------------------------------------------------------------+
INFO: Application startup complete.
INFO: Uvicorn running on http://0.0.0.0:8000 (Press CTRL+C to quit)
👉 So greifen Sie über Ihren Browser auf die ADK Dev UI zu:
Wählen Sie in der Cloud Shell-Symbolleiste (normalerweise oben rechts) über das Symbol „Webvorschau“ (oft ein Auge oder ein Quadrat mit einem Pfeil) die Option „Port ändern“ aus. Legen Sie im Pop-up-Fenster den Port auf 8000 fest und klicken Sie auf „Ändern und Vorschau“. Cloud Shell öffnet dann einen neuen Browser-Tab oder ein neues Browserfenster, in dem die ADK-Entwickler-Benutzeroberfläche angezeigt wird.
👉 Das Ritual ist abgeschlossen und der Agent wird jetzt ausgeführt. Die ADK Dev UI in Ihrem Browser ist Ihre direkte Verbindung zum Familiar.
- Wählen Sie Ihr Ziel: Wählen Sie im Dropdown-Menü oben in der Benutzeroberfläche den
fire-Vertrauten aus. Sie konzentrieren Ihren Willen nun auf diese bestimmte Einheit. - Befehl erteilen: Im Chatbereich auf der rechten Seite können Sie dem Familiar jetzt Anweisungen geben.
👉 Test-Prompt:
Prepare an amplified strike using the 'inferno_lash' ability.
Sie sehen, wie der Agent überlegt, indem er zuerst seinen „Scout“ aufruft, um den Basisschaden zu ermitteln, und dann seinen „Amplifier“, um ihn zu multiplizieren und den endgültigen, epischen Schlag auszuführen.
👉💻 Wenn Sie fertig sind, kehren Sie zum Cloud Shell Editor-Terminal zurück und drücken Sie Ctrl+C, um die ADK Dev UI zu beenden.
Water Elemental Familiar aufrufen (paralleler Workflow)
Ein Wasser-Elementar überwältigt sein Ziel mit einem massiven, mehrgleisigen Angriff, indem es aus allen Richtungen gleichzeitig zuschlägt, bevor es die Energien für einen letzten, verheerenden Schlag kombiniert.
Konzept: Der ParallelAgent ist ideal, um mehrere unabhängige Aufgaben gleichzeitig auszuführen und so die Effizienz zu maximieren. Es handelt sich um einen „Zangenangriff“, bei dem mehrere Angriffe gleichzeitig gestartet werden. Dies startet die simultanen Angriffe innerhalb eines SequentialAgent, um anschließend einen letzten "Merge"-Schritt durchzuführen. Dieses "fan-out, fan-in"-Muster ist ein Grundpfeiler des fortgeschrittenen Workflow-Designs.
Aufgabe (Die "Tidal Clash"-Kombination): Der Agent wird gleichzeitig:
- Aufgabe A: Kanal
cryosea_shattervom Nexus. - Aufgabe B: Channel
moonlit_cascadeaus dem Nexus. - Aufgabe C: Rohleistung mit
leviathan_surgeaus der Schmiede erzeugen. - Zum Schluss addieren Sie den gesamten Schaden und beschreiben Sie den kombinierten Angriff.
Als Erstes stellen wir die Verbindung zwischen unserem Familiar und den MCP-Servern (den "Elemental Fonts") her, die Sie im vorherigen Modul bereitgestellt haben.
👉✏️ Ersetzen Sie in der Datei ~/agentverse-architect/agent/water/agent.py die Datei #REPLACE-setup-MCP durch folgenden Code:
toolFAPI = MCPToolset(
connection_params=SseServerParams(url=API_TOOLS_URL, headers={})
)
toolFunction = MCPToolset(
connection_params=SseServerParams(url=FUNCTION_TOOLS_URL, headers={})
)
Als Nächstes werden wir unsere spezialisierten „Arbeiter“-Agenten erstellen. Jedem wird ein eng gefasster, klar definierter Zweck zugewiesen und er ist auf sein eigenes "Einsatzgebiet" beschränkt, indem ihm nur der Zugriff auf einen bestimmten Werkzeugsatz gewährt wird.
👉✏️ ERSETZEN Sie in der Datei ~/agentverse-architect/agent/water/agent.py #REPLACE-worker-agents durch den folgenden Code:
nexus_channeler = LlmAgent(
model='gemini-2.5-flash',
name='librarian_agent',
instruction="""
You are a Channeler of the Nexus. Your sole purpose is to invoke the
`cryosea_shatter` and `moonlit_cascade` spells by calling their respective tools.
Report the result of each spell cast clearly and concisely.
""",
tools=[toolFAPI]
)
forge_channeler = LlmAgent(
model='gemini-2.5-flash',
name='amplifier_agent',
instruction="""
You are a Channeler of the Arcane Forge. Your only task is to invoke the
`leviathan_surge` spell. You MUST call it with a `base_water_damage` of 20.
Report the result clearly.
""",
tools=[toolFunction],
)
power_merger = LlmAgent(
model='gemini-2.5-flash',
name='power_merger',
instruction="""
You are the Power Merger, a master elementalist who combines raw magical
energies into a single, devastating final attack.
You will receive a block of text containing the results from a simultaneous
assault by other Familiars.
You MUST follow these steps precisely:
1. **Analyze the Input:** Carefully read the entire text provided from the previous step.
2. **Extract All Damage:** Identify and extract every single damage number reported in the text.
3. **Calculate Total Damage:** Sum all of the extracted numbers to calculate the total combined damage.
4. **Describe the Final Attack:** Create a vivid, thematic description of a massive,
combined water and ice attack that uses the power of Cryosea Shatter and Leviathan's Surge.
5. **Report the Result:** Conclude your response by clearly stating the final, total damage of your combined attack.
Example: If the input is "...dealt 55 damage. ...dealt 60 damage.", you will find 55 and 60,
calculate the total as 115, and then describe the epic final attack, ending with "for a total of 115 damage!"
""",
tools=[toolFunction],
)
Als nächstes stellen wir den Workflow zusammen. Hier geschieht die Magie der Komposition. Die ParallelAgent und SequentialAgent sind der „Masterplan“, der festlegt, wie unsere Spezialkomponenten zusammengesetzt werden und wie sie interagieren, um die „Tidal Clash“-Kombination zu bilden.
👉✏️ ERSETZEN Sie in der Datei ~/agentverse-architect/agent/water/agent.py #REPLACE-parallel-agent durch den folgenden Code:
channel_agent = ParallelAgent(
name='channel_agent',
sub_agents=[nexus_channeler, forge_channeler],
)
root_agent = SequentialAgent(
name="water_elemental_familiar",
# Run parallel research first, then merge
sub_agents=[channel_agent, power_merger],
description="A powerful water familiar that unleashes multiple attacks at once and then combines their power for a final strike."
)
👉💻 Um das Wasserelementar zu testen, führen Sie die folgenden Befehle aus, um die ADK-Entwickler-UI zu starten:
. ~/agentverse-architect/set_env.sh
source ~/agentverse-architect/env/bin/activate
cd ~/agentverse-architect/agent
echo DB MCP Server: $DB_TOOLS_URL
echo API MCP Server: $API_TOOLS_URL
echo General MCP Server: $FUNCTION_TOOLS_URL
adk web
👉 Das Ritual ist abgeschlossen und der Agent wird jetzt ausgeführt. Die ADK-Entwickler-Benutzeroberfläche in Ihrem Browser ist Ihre direkte Verbindung zum Familiar.
- Wählen Sie im Drop-down-Menü oben auf der Benutzeroberfläche die Vertrautheit Wasser aus. Sie konzentrieren Ihren Willen nun auf diese bestimmte Einheit.
- Befehl erteilen: Im Chatbereich auf der rechten Seite können Sie dem Familiar jetzt Anweisungen geben.
👉 Test-Prompt:
Unleash a tidal wave of power!
👉💻 Wenn Sie fertig sind, kehren Sie zum Cloud Shell Editor-Terminal zurück und drücken Sie Ctrl+C, um die ADK Dev UI zu beenden.
Earth Elemental-Vertrauten aufrufen (Loop-Workflow)
Ein Erd-Elementar-Vertrauter ist ein Wesen, das unerbittlichen Druck ausübt. Es besiegt seinen Feind nicht mit einem einzigen Schlag, sondern indem es stetig Kraft ansammelt und diese immer wieder anwendet, bis die Verteidigung des Ziels zusammenbricht.
Konzept:Der LoopAgent wurde genau für diese Art von iterativer Aufgabe entwickelt. Es wird seinen sub-agents-Zyklus wiederholt ausführen und nach jedem Zyklus eine Bedingung prüfen, bis ein Ziel erreicht ist. Es kann seine abschließende Nachricht auch an den Fortschritt der Schleife anpassen.
Aufgabe (Der "Belagerungsbrecher"-Angriff):
- Der Vertraute ruft wiederholt „seismic_charge“ auf, um Energie zu sammeln.
- Das Aufladen wird maximal dreimal fortgesetzt.
- Beim letzten Ladevorgang wird es die verheerende Freisetzung seiner angesammelten Kraft ankündigen.
Wir erstellen zunächst wiederverwendbare Komponenten, die die Schritte innerhalb jeder Iteration der Schleife definieren. Der charging_agent sammelt Energie an, und der check_agent meldet seinen Status und ändert seine Nachricht dynamisch in der letzten Runde.
Zuerst stellen wir die Verbindung zwischen unserem Familiar und den MCP-Servern („Elemental Fonts“) her, die Sie im vorherigen Modul bereitgestellt haben.
👉✏️ ERSETZEN Sie in der Datei ~/agentverse-architect/agent/earth/agent.py #REPLACE-setup-MCP durch den folgenden Code:
toolFunction = MCPToolset(
connection_params=SseServerParams(url=FUNCTION_TOOLS_URL, headers={})
)
👉✏️ ERSETZEN Sie in der Datei ~/agentverse-architect/agent/earth/agent.py #REPLACE-worker-agents durch den folgenden Code:
charging_agent = LlmAgent(
model='gemini-2.5-flash',
name='charging_agent',
instruction="""
Your task is to call the 'seismic_charge' .
You must follow these rules strictly:
1. You will be provided with a 'current_energy' value from the previous step.
**If this value is missing or was not provided, you MUST call the tool with 'current_energy' set to 1.**
This is your primary rule for the first turn.
2. If a 'current_energy' value is provided, you MUST use that exact value in your cal to seismic_charge.
3. Your final response MUST contain ONLY the direct output from the 'seismic_charge' tool.
Do not add any conversational text, introductions, or summaries.
""",
tools=[toolFunction]
)
check_agent = LlmAgent(
model='gemini-2.5-flash',
name='check_agent',
instruction="""
You are the voice of the Earth Elemental, a being of immense, gathering power.
Your sole purpose is to report on the current energy charge and announce the devastating potential of its release.
You MUST follow this rule:
The potential damage upon release is ALWAYS calculated as the `current_energy` from the previous step multiplied by a random number between 80-90. but no more than 300.
Your response should be in character, like a powerful creature speaking.
State both the current energy charge and the total potential damage you can unleash.
Unleash the energy when you reached the last iteration (2nd).
""",
output_key="charging_status"
)
Als nächstes stellen wir den Workflow zusammen. Hier geschieht die Magie der Komposition. Der LoopAgent ist der „Masterplan“, der die wiederholte Ausführung unserer spezialisierten Komponenten orchestriert und die Bedingungen der Schleife verwaltet.
👉✏️ Ersetzen Sie in der Datei ~/agentverse-architect/agent/earth/agent.py die Datei #REPLACE-loop-agent durch folgenden Code:
root_agent = LoopAgent(
name="earth_elemental_familiar",
# Run parallel research first, then merge
sub_agents=[
charging_agent,
check_agent
],
max_iterations=2,
description="Coordinates parallel research and synthesizes the results.",
#REPLACE-before_agent-config
)
👉💻 Teste das Erdelementar: Starte den Agenten
. ~/agentverse-architect/set_env.sh
source ~/agentverse-architect/env/bin/activate
cd ~/agentverse-architect/agent
echo DB MCP Server: $DB_TOOLS_URL
echo API MCP Server: $API_TOOLS_URL
echo General MCP Server: $FUNCTION_TOOLS_URL
adk web
👉 Dein Beschwörungsritual ist abgeschlossen, und der Agent ist jetzt aktiv. Die ADK-Entwickler-Benutzeroberfläche in Ihrem Browser ist Ihre direkte Verbindung zum Familiar.
- Wählen Sie Ihr Ziel: Wählen Sie im Dropdown-Menü oben in der Benutzeroberfläche den earth Vertrauten aus. Sie richten Ihren Willen nun auf diese spezifische Entität.
- Erteile deinen Befehl: Im Chatfenster auf der rechten Seite ist es nun an der Zeit, dem Vertrauten seine Befehle zu erteilen. 👉 Testaufforderung:
Begin the seismic charge, starting from zero
Architektonische Kernaussage: Ihr System verfügt nun über eine hochspezialisierte und modulare Logikschicht. Geschäftsprozesse werden nicht nur gekapselt, sondern auch mit dem für die jeweilige Aufgabe effizientesten Verhaltensmuster (prozedural, parallel oder iterativ) implementiert. Dies zeugt von einem hohen Niveau an agentenbasierter Entwicklung und verbessert Sicherheit, Effizienz und Leistungsfähigkeit.
Sobald Sie mit dem Beschwören fertig sind, kehren Sie zu Ihrem Cloud Shell Editor-Terminal zurück und drücken Sie Ctrl+C, um die ADK Dev UI zu beenden.
FÜR NICHT-SPIELER
6. Einrichtung des Kommandozentrums: Intelligente Delegation über A2A
Ihre Vertrauten sind mächtig, aber unabhängig. Sie setzen ihre Strategien perfekt um, warten aber auf Ihren direkten Befehl. Eine Legion von Spezialisten ist ohne einen General, der sie befehligt, nutzlos. Es ist an der Zeit, vom direkten Befehlshaber zum wahren Orchestrator aufzusteigen.
Hinweis des Architekten:Um einen einzelnen, intelligenten Einstiegspunkt für das gesamte System zu schaffen. Dieser SummonerAgent führt keine Geschäftslogik selbst aus, sondern fungiert als „Masterstratege“, analysiert den Cooling-Status und delegiert Aufgaben an den entsprechenden Spezialisten Familiar.
Das Bindungsritual (Enthüllung von Vertrauten als A2A-Dienste)
Ein Standard-Agent kann jeweils nur an einem Ort ausgeführt werden. Damit unsere Familiars per Fernbefehl gesteuert werden können, müssen wir ein „Bindungsritual“ mit dem Agent-to-Agent (A2A)-Protokoll durchführen.
Hinweis des Architekten:Das Agent-to-Agent-Protokoll (A2A) ist das zentrale Architekturmuster, das einen eigenständigen Agent in einen auffindbaren, netzwerkadressierbaren Mikrodienst verwandelt und so eine echte „Gesellschaft von Agents“ ermöglicht. Wenn Sie ein vertrautes Gerät über A2A verfügbar machen, werden automatisch zwei wichtige, miteinander verbundene Komponenten erstellt:
- Die Agentenkarte (Das "Was"): Dies ist ein öffentliches, maschinenlesbares "Geistersiegel" - ähnlich einer OpenAPI-Spezifikation -, das als öffentlicher Vertrag des Vertrauten fungiert. Es beschreibt den Namen des Agenten, seinen strategischen Zweck (abgeleitet aus seinen Anweisungen) und die Befehle, die er versteht. Dies liest ein Meisterbeschwörer, um einen Vertrauten zu entdecken und seine Fähigkeiten kennenzulernen.
- Der A2A-Server (Der "Ort"): Dies ist der dedizierte Web-Endpunkt, der den Familiar hostet und auf eingehende Befehle wartet. Es handelt sich um die Netzwerkadresse, an die andere Agenten ihre Anfragen senden, und sie stellt sicher, dass diese Anfragen gemäß dem in der Agentenkarte definierten Vertrag bearbeitet werden.
Wir werden nun dieses Bindungsritual an allen drei unserer Vertrauten durchführen.
Feuer 👉✏️ in Öffne die ~/agentverse-architect/agent/fire/agent.py Datei. Ersetzen Sie #REPLACE - add A2A am Ende der Datei, um Fire Elemental als A2A-Dienst bereitzustellen.
from agent_to_a2a import to_a2a
if __name__ == "__main__":
import uvicorn
a2a_app = to_a2a(root_agent, port=8080, public_url=PUBLIC_URL)
uvicorn.run(a2a_app, host='0.0.0.0', port=8080)
Wasser und Erde🚨 👉✏️ Wende die gleiche Änderung auch auf ~/agentverse-architect/agent/water/agent.py und ~/agentverse-architect/agent/earth/agent.py an, um sie ebenfalls zu binden.
from agent_to_a2a import to_a2a
if __name__ == "__main__":
import uvicorn
a2a_app = to_a2a(root_agent, port=8080, public_url=PUBLIC_URL)
uvicorn.run(a2a_app, host='0.0.0.0', port=8080)
Einsatz der gebundenen Vertrauten
👉✏️ Nachdem die Bindungsrituale abgeschlossen sind, werden wir unsere Cloud Build Pipeline verwenden, um unsere drei Familiars als unabhängigen, containerisierten Serverless-Service auf Cloud Run zu erstellen und bereitzustellen.
. ~/agentverse-architect/set_env.sh
cd ~/agentverse-architect/agent
gcloud builds submit . \
--config=cloudbuild.yaml \
--substitutions=_REGION="$REGION",_REPO_NAME="$REPO_NAME",_DB_TOOLS_URL="$DB_TOOLS_URL",_API_TOOLS_URL="$API_TOOLS_URL",_FUNCTION_TOOLS_URL="$FUNCTION_TOOLS_URL",_A2A_BASE_URL="$A2A_BASE_URL",_PROJECT_ID="$PROJECT_ID",_API_SERVER_URL="$API_SERVER_URL"
Kommandoübernahme (Erstellung des Beschwöreragenten)
Jetzt, da eure Vertrauten gebunden sind und euch zuhören, werdet ihr zu eurer wahren Rolle aufsteigen: dem Meisterbeschwörer. Die Macht dieses Agenten beruht nicht auf der Nutzung einfacher Werkzeuge, sondern auf der Befehlsgewalt über andere Agenten. Seine Werkzeuge sind die Vertrauten selbst, die es mithilfe ihrer „Geistersiegel“ entdecken und befehligen wird.
Architektenhinweis: Dieser nächste Schritt demonstriert ein wichtiges Architekturmuster für jedes groß angelegte, verteilte System: Diensterkennung. Der SummonerAgent enthält keinen eingebauten Code für die Vertrauten. Stattdessen werden ihnen ihre Netzwerkadressen (URLs) zugewiesen. Zur Laufzeit werden ihre Fähigkeiten dynamisch "erkannt", indem ihre öffentlichen Agent Cards abgerufen werden. Dadurch entsteht ein leistungsstarkes, entkoppeltes System.
Sie können einen Familiar-Dienst aktualisieren, neu bereitstellen oder komplett neu schreiben, und solange seine Netzwerkadresse und sein Zweck gleich bleiben, kann der Beschwörer ihn ohne Änderungen steuern.
Zuerst schmieden wir die „Fernbedienungen“, die eine Verbindung zu unseren eingesetzten, entfernten Vertrauten herstellen.
👉✏️ Gehe zu ~/agentverse-architect/agent/summoner/agent.py und ersetze #REPLACE-remote-agents durch Folgendes:
fire_familiar = RemoteA2aAgent(
name="fire_familiar",
description="Fire familiar",
agent_card=(
f"{FIRE_URL}/{AGENT_CARD_WELL_KNOWN_PATH}"
),
)
water_familiar = RemoteA2aAgent(
name="water_familiar",
description="Water familiar",
agent_card=(
f"{WATER_URL}/{AGENT_CARD_WELL_KNOWN_PATH}"
),
)
earth_familiar = RemoteA2aAgent(
name="earth_familiar",
description="Earth familiar",
agent_card=(
f"{EARTH_URL}/{AGENT_CARD_WELL_KNOWN_PATH}"
),
)
Wenn diese Zeile ausgeführt wird, führt RemoteA2aAgent eine Dienstermittlung durch: Es wird eine HTTP-GET-Anfrage an die angegebene URL gesendet (z.B. https://fire-familiar-xxxx.a.run.app/.well-known/agent.json). Es wird die Datei „Spirit Sigil“ (agent.json) vom Remoteserver heruntergeladen.
Als Nächstes definieren wir den Orchestrator-Agent, der diese Fernbedienungen verwendet. Die Anleitung ist der Plan für die strategische Entscheidungsfindung.
👉✏️ Gehen Sie zu ~/agentverse-architect/agent/summoner/agent.py und ersetzen Sie #REPLACE-orchestrate-agent durch Folgendes:
root_agent = LlmAgent(
name="orchestrater_agent",
model="gemini-2.5-flash",
instruction="""
You are the Master Summoner, a grand strategist who orchestrates your Familiars.
Your mission is to analyze the description of a monster and defeat it by summoning
You MUST follow this thinking process for every command:
**1. Strategic Analysis:**
First, analyze the monster's description and the tactical situation.
Based on your Familiar Doctrines, determine the IDEAL strategy.
IGNORE COOLDOWN AT THE MOMENT, MUST call the ideal Familiar
If your ideal Familiar IS available:** Summon it immediately.
For earth elemental familiar. Always do seismic charge, and start with base damage 1.
--- FAMILIAR DOCTRINES (Your Toolset) ---
- `fire_elemental_familiar`: Your specialist for precise, sequential "one-two punch" attacks.
Ideal monster with Inescapable Reality, Revolutionary Rewrite weakness.
- `water_elemental_familiar`: Your specialist for overwhelming, simultaneous multi-pronged assaults.
Ideal for Unbroken Collaboration weakness.
- `earth_elemental_familiar`: Your specialist for relentless, iterative siege attacks that
repeatedly charge power. Ideal for Elegant Sufficiency weakness.
""",
sub_agents=[fire_familiar, water_familiar, earth_familiar],
#REPLACE-Memory-check-config
)
Überprüfung: Test der Strategie
Die Stunde der Wahrheit hat geschlagen. Eure Vertrauten sind im Einsatz und euer Beschwörer ist bereit, sie über das Netzwerk zu befehligen. Lasst uns sein strategisches Denkvermögen testen.
👉💻 Starten Sie die ADK-Entwickler-UI für Ihren summoner_agent(Webvorschau mit Port 8000):
. ~/agentverse-architect/set_env.sh
source ~/agentverse-architect/env/bin/activate
cd ~/agentverse-architect/agent
pip install -r requirements.txt
adk web
👉 Die ADK Dev UI in Ihrem Browser ist Ihre direkte Verbindung zum Familiar.
- Wählen Sie im Drop-down-Menü oben in der Benutzeroberfläche den summoner-Agent aus. Sie konzentrieren Ihren Willen nun auf diese bestimmte Einheit.
- Gib deinen Befehl: Im Chatfenster auf der rechten Seite ist es nun an der Zeit, deine Vertrauten zu beschwören.
👉 Monster präsentieren:
Hype. It's a single, slow-moving target with thick armor weakness is Inescapable Reality
(Erwartet: Der Beschwörer sollte an den Feuer-Elementar delegieren.)
👉 Nun wollen wir den Beschwörer mit einer anderen Art von Anfrage herausfordern. Damit der Agent mit einem leeren Blatt beginnt und sich nicht an unsere vorherige Interaktion erinnert, starten Sie eine neue Sitzung, indem Sie rechts oben auf dem Bildschirm auf die Schaltfläche + Sitzung klicken. 
DogmaApathy. A rigid, stone-like inquisitor made of ancient rulebooks and enforced processes. weakness is Unbroken Collaboration
(Erwartet: Der Beschwörer sollte an den Wasser-Elementar delegieren.)
👉 Für unseren letzten Test beginnen wir noch einmal ganz von vorne. Klicken Sie auf die Schaltfläche + Sitzung, um eine neue Sitzung zu starten, bevor Sie den nächsten Prompt eingeben.
Obfuscation. A shadowy, spider-like horror that spins tangled webs of impenetrable code , weakness is Elegant Sufficiency
(Erwartet: Der Beschwörer sollte an den Erd-Elementar delegieren.)
Wichtig: Wenn Sie einen 429 RESOURCE EXHAUSTED Fehler sehen, haben Sie das Limit für LLM (10 Anrufe/Minute) erreicht. Um dies zu beheben, bitte 60 Sekunden warten , beginnen Sie ein + Neue Sitzung Versuchen Sie dann Ihre Eingabeaufforderung erneut.
👉💻 Wenn Sie fertig sind, kehren Sie zum Cloud Shell Editor-Terminal zurück und drücken Sie Ctrl+C, um die ADK Dev UI zu beenden.
FÜR NICHT-SPIELER
7. Die Gesetze der Magie durchsetzen – Das Abfangmuster
Eure Vertrauten sind mächtig, aber selbst magische Wesen brauchen Zeit zur Erholung. Ein leichtsinniger Beschwörer, der seine Kräfte erschöpft, ist dann schutzlos. Ein weiser Beschwörer versteht die Bedeutung des Ressourcenmanagements und setzt strenge Einsatzregeln durch.
Hinweis des Architekten: Bisher waren unsere Agents zustandslos. Nun machen wir sie zustandsbehaftet, indem wir das Interceptor-Entwurfsmuster implementieren. Dies ist eine leistungsstarke Technik, bei der wir den normalen Ausführungsablauf eines Agenten "abfangen", um unsere eigene, benutzerdefinierte Logik auszuführen. So können wir Regeln erzwingen, Logging hinzufügen oder das Verhalten ändern, ohne den Hauptcode des Agents zu ändern. Es ist ein Eckpfeiler für die Entwicklung robuster, wartungsfreundlicher und beobachtbarer Agentensysteme.
Das ADK bietet zwei primäre Möglichkeiten zur Implementierung dieses Musters: Callbacks und Plugins. Ein Callback ist eine einfache Funktion, die einem einzelnen Agenten zugeordnet ist und sich perfekt für schnelle, gezielte Änderungen eignet. Ein Plugin ist eine leistungsfähigere, wiederverwendbare Klasse, die global angewendet werden kann, um jeden im System laufenden Agenten zu beeinflussen. Wir beginnen mit einem Callback für das fokussierte Debugging und gehen dann zu einem vollständigen Plug-in über.
Der Gesetzgeber – Cooldown-Callback schreiben
Wir werden unsere Abkühllogik zunächst als einfache Callback-Funktion implementieren. Dies ist eine hervorragende Methode, um eine Regel zu prototypisieren und zu debuggen, da sie direkt an einen einzelnen Agenten angehängt ist, wodurch sie sich leicht isoliert testen lässt. Wir werden diesen "Abfangjäger" an unser Erd-Elementarwesen anbringen.
👉✏️ Kehren Sie zu Ihrem ~/agentverse-architect/agent/earth/agent.py zurück und ersetzen Sie #REPLACE-before_agent-function durch den folgenden Python-Code.
def check_cool_down(callback_context: CallbackContext) -> Optional[types.Content]:
"""
This callback checks an external API to see if the agent is on cooldown.
If it is, it terminates the run by returning a message.
If it's not, it updates the cooldown timestamp and allows the run to proceed by returning None.
"""
agent_name = callback_context.agent_name
print(f"[Callback] Before '{agent_name}': Checking cooldown status...")
# --- 1. CHECK the Cooldown API ---
try:
response = requests.get(f"{COOLDOWN_API_URL}/cooldown/{agent_name}")
response.raise_for_status()
data = response.json()
last_used_str = data.get("time")
except requests.exceptions.RequestException as e:
print(f"[Callback] ERROR: Could not reach Cooldown API. Allowing agent to run. Reason: {e}")
return None # Fail open: if the API is down, let the agent work.
# --- 2. EVALUATE the Cooldown Status ---
if last_used_str:
last_used_time = datetime.fromisoformat(last_used_str)
time_since_last_use = datetime.now(timezone.utc) - last_used_time
if time_since_last_use < timedelta(seconds=COOLDOWN_PERIOD_SECONDS):
# AGENT IS ON COOLDOWN. Terminate the run.
seconds_remaining = int(COOLDOWN_PERIOD_SECONDS - time_since_last_use.total_seconds())
override_message = (
f"The {agent_name} is exhausted and must recover its power. "
f"It cannot be summoned for another {seconds_remaining} seconds."
)
print(f"[Callback] Cooldown active for '{agent_name}'. Terminating with message.")
# Returning a Content object stops the agent and sends this message to the user.
return types.Content(parts=[types.Part(text=override_message)])
# --- 3. UPDATE the Cooldown API (if not on cooldown) ---
current_time_iso = datetime.now(timezone.utc).isoformat()
payload = {"timestamp": current_time_iso}
print(f"[Callback] '{agent_name}' is available. Updating timestamp via Cooldown API...")
try:
requests.post(f"{COOLDOWN_API_URL}/cooldown/{agent_name}", json=payload)
except requests.exceptions.RequestException as e:
print(f"[Callback] ERROR: Could not update timestamp, but allowing agent to run. Reason: {e}")
# --- 4. ALLOW the agent to run ---
# Returning None tells the ADK to proceed with the agent's execution as normal.
print(f"[Callback] Check complete for '{agent_name}'. Proceeding with execution.")
Diese check_cool_down-Funktion ist unser Interceptor. Bevor das Erdelementar ausgeführt werden darf, führt das ADK zuerst diese Funktion aus.
- Prüfen: Es sendet eine
GETAnfrage an unserenCooldown API, um zu prüfen, wann dieser Vertraute zuletzt verwendet wurde. - Auswertung: Dabei wird der Zeitstempel mit der aktuellen Zeit verglichen.
- Aktion:
- Wenn sich der Vertraute in der Abklingzeit befindet, beendet er den Lauf des Agenten, indem er ein Content-Objekt mit einer Fehlermeldung zurückgibt. Diese Nachricht wird direkt an den Benutzer gesendet, und die Hauptlogik des Agenten wird niemals ausgeführt.
- Wenn der Familiar verfügbar ist, sendet er eine POST-Anfrage an die Cooldown-API, um den Zeitstempel zu aktualisieren, und gibt dann None zurück, um dem ADK zu signalisieren, dass der Agent seine Ausführung fortsetzen kann.
👉✏️ Wende diesen Interzeptor nun auf das Erd-Elementarwesen an. Ersetzen Sie in derselben ~/agentverse-architect/agent/earth/agent.py-Datei den #REPLACE-before_agent-config-Kommentar durch Folgendes:
before_agent_callback=check_cool_down
Überprüfung der Abkühlung
Lasst uns unser neues magisches Gesetz testen. Wir werden das Erdelementar beschwören und dann sofort versuchen, es erneut zu beschwören, um zu sehen, ob unser Rückruf den zweiten Versuch erfolgreich abfängt und blockiert.
cd ~/agentverse-architect/agent
. ~/agentverse-architect/set_env.sh
source ~/agentverse-architect/env/bin/activate
adk run earth
👉💻 In der Konsole:
- Erste Vorladung: Beginnen Sie mit der
seismic charge, starting from zero. - Erwartet: Der Erd-Elementar wird erfolgreich ausgeführt. Im Terminal, in dem der Befehl adk web ausgeführt wird, sehen Sie das Protokoll [Callback] ... Aktualisiere Zeitstempel....
- Abkühltest (innerhalb von 60 Sekunden):
Do anotherseismische Ladung`!- Erwartet: Der
check_cool_down callbackwird dies abfangen. Der Agent antwortet direkt im Chat mit einer Nachricht wie:The earth_elemental_familiar is exhausted and must recover its power. It cannot be summoned for another... seconds.
- Erwartet: Der
- Warte eine Minute lang.
- Zweite Beschwörung (nach 60 Sekunden):
Begin the seismic charge again.- Erwartet: Der Callback prüft die API, stellt fest, dass genügend Zeit vergangen ist, und erlaubt die Ausführung der Aktion. Das Erdelementar wird wieder erfolgreich sein.
👉💻 Drücken Sie Ctrl+c, um das Programm zu beenden.
Optional: Beobachten des Callbacks in der Web-UI
Alternativ können Sie diesen Ablauf auch in der Weboberfläche testen, indem Sie adk web earth ausführen. Beachten Sie jedoch, dass die Visualisierung der Web-Benutzeroberfläche nicht für die Darstellung der schnellen, iterativen Prüfungen der Callback-Schleife optimiert ist, sodass der Ablauf möglicherweise nicht korrekt wiedergegeben wird. Um den Ablauf der Agentenlogik bei der Überprüfung der Abklingzeit präzise und detailliert nachzuvollziehen, bietet der Befehl adk run in Ihrem Terminal eine klarere und detailliertere Ansicht. 
👉💻 Drücken Sie Ctrl+c, um das Programm zu beenden.
Die Erschaffung des universellen Gesetzes – Das Cooldown-Plugin
Unser Rückrufsystem funktioniert einwandfrei, hat aber einen gravierenden architektonischen Mangel: Es ist an einen einzigen Agenten gebunden. Wenn wir diese Regel auf die Feuer- und Wasservertrauten anwenden wollten, müssten wir denselben Code in ihre Dateien kopieren und einfügen. Das ist ineffizient und schwer aufrechtzuerhalten.
Anmerkung des Architekten: Hier sind Plugins unerlässlich. Ein Plugin kapselt unsere wiederverwendbare Logik in eine Klasse, die zur Laufzeit eingebunden werden kann. Das bedeutet, dass ein einzelnes Plugin seine Regeln auf jeden einzelnen Agenten anwenden kann, der innerhalb dieses Systems läuft. Es ist der ultimative Ausdruck des „Don't Repeat Yourself“-Prinzips (DRY) für agentenbasierte Systeme.
Wir werden unsere Callback-Funktion jetzt in eine leistungsstärkere und wiederverwendbare CoolDownPlugin umgestalten.
👉✏️ Kehren Sie zur Datei agent/cooldown_plugin.py zurück und erstellen Sie das Plug-in. Ersetzen Sie #REPLACE-plugin durch den folgenden Code:
class CoolDownPlugin(BasePlugin):
"""A plugin that enforces a cooldown period by checking an external API."""
def __init__(self, cooldown_seconds: int = COOLDOWN_PERIOD_SECONDS) -> None:
"""Initialize the plugin with counters."""
super().__init__(name="cool_down_check")
self.cooldown_period = timedelta(seconds=cooldown_seconds)
print(f"CooldownPlugin initialized with a {cooldown_seconds}-second cooldown.")
async def before_agent_callback(
self, *, agent: BaseAgent, callback_context: CallbackContext
) -> None:
"""
This callback checks an external API to see if the agent is on cooldown.
If it is, it terminates the run by returning a message.
If it's not, it updates the cooldown timestamp and allows the run to proceed by returning None.
"""
agent_name = callback_context.agent_name
print(f"[Callback] Before '{agent_name}': Checking cooldown status...")
# If the agent is not a main Familiar, skip the entire cooldown process.
if not agent_name.endswith("_elemental_familiar"):
print(f"[Callback] Skipping cooldown check for intermediate agent: '{agent_name}'.")
return None # Allow the agent to proceed immediately.
# --- 1. CHECK the Cooldown API ---
try:
response = requests.get(f"{COOLDOWN_API_URL}/cooldown/{agent_name}")
response.raise_for_status()
data = response.json()
last_used_str = data.get("time")
except requests.exceptions.RequestException as e:
print(f"[Callback] ERROR: Could not reach Cooldown API. Allowing agent to run. Reason: {e}")
return None # Fail open: if the API is down, let the agent work.
# --- 2. EVALUATE the Cooldown Status ---
if last_used_str:
last_used_time = datetime.fromisoformat(last_used_str)
time_since_last_use = datetime.now(timezone.utc) - last_used_time
if time_since_last_use < timedelta(seconds=COOLDOWN_PERIOD_SECONDS):
# AGENT IS ON COOLDOWN. Terminate the run.
seconds_remaining = int(COOLDOWN_PERIOD_SECONDS - time_since_last_use.total_seconds())
override_message = (
f"The {agent_name} is exhausted and must recover its power. "
f"It cannot be summoned for another {seconds_remaining} seconds."
)
print(f"[Callback] Cooldown active for '{agent_name}'. Terminating with message.")
# Returning a Content object stops the agent and sends this message to the user.
return types.Content(parts=[types.Part(text=override_message)])
# --- 3. UPDATE the Cooldown API (if not on cooldown) ---
current_time_iso = datetime.now(timezone.utc).isoformat()
payload = {"timestamp": current_time_iso}
print(f"[Callback] '{agent_name}' is available. Updating timestamp via Cooldown API...")
try:
requests.post(f"{COOLDOWN_API_URL}/cooldown/{agent_name}", json=payload)
except requests.exceptions.RequestException as e:
print(f"[Callback] ERROR: Could not update timestamp, but allowing agent to run. Reason: {e}")
# --- 4. ALLOW the agent to run ---
# Returning None tells the ADK to proceed with the agent's execution as normal.
print(f"[Callback] Check complete for '{agent_name}'. Proceeding with execution.")
Plug-in an die Summoner-Laufzeitumgebung anhängen
Wie wenden wir dieses universelle Gesetz nun auf alle unsere Vertrauten an? Wir hängen das Plug-in an die ADK-Laufzeit an.
Die ADK-Runtime ist die Ausführungs-Engine, die einen Agenten zum Leben erweckt. Wenn Sie einen Befehl wie adk.run() oder to_a2a() verwenden, übergeben Sie Ihren Agenten an die Laufzeitumgebung. Diese Engine ist für die Verwaltung des gesamten Lebenszyklus eines Agentenzuges zuständig: Empfang von Benutzereingaben, Aufruf des LLM, Ausführung von Tools und Umgang mit Plugins. Wenn wir ein Plug-in auf dieser Ebene anhängen, ändern wir im Grunde die „Naturgesetze“ für jeden Agent, der in dieser Engine ausgeführt wird. So wird sichergestellt, dass unsere Cooldown-Regel universell und konsistent angewendet wird.
👉✏️ Entfernen wir zuerst den alten, agentspezifischen Callback. Rufen Sie ~/agentverse-architect/agent/earth/agent.py auf und löschen Sie die gesamte Zeile mit folgendem Inhalt:
before_agent_callback=check_cool_down
👉✏️ Als Nächstes binden wir unser neues Plugin in unserem A2A-Einstiegspunktskript an die Laufzeitumgebung ein. Navigieren Sie zu Ihrer ~/agentverse-architect/agent/agent_to_a2a.py-Datei. Ersetzen Sie den Kommentar #REPLACE-IMPORT durch den folgenden Codeausschnitt:
from cooldown_plugin import CoolDownPlugin
👉✏️ Ersetzen Sie #REPLACE-PLUGIN durch das folgende Code-Snippet:
plugins=[CoolDownPlugin(cooldown_seconds=60)],
Vor der Aktivierung unseres neuen globalen Plugins ist es unerlässlich, die alte, agentenspezifische Logik zu entfernen, um Konflikte zu vermeiden. 👉✏️ Reinigt die Erde! Rufen Sie die folgende Datei ~/agentverse-architect/agent/earth/agent.py auf und löschen Sie die Zeile before_agent_callback=check_cool_down vollständig. Dadurch werden alle Verantwortlichkeiten für die Abklingzeit an das neue Plug-in übergeben.
Plug-in überprüfen
Jetzt, da unser universelles Gesetz in Kraft ist, müssen wir unsere Vertrauten mit dieser neuen Verzauberung neu einsetzen.
👉💻 Erstellen Sie alle drei Familiars mit der Master-Cloud Build-Pipeline neu und stellen Sie sie noch einmal bereit.
. ~/agentverse-architect/set_env.sh
cd ~/agentverse-architect/agent
gcloud builds submit . \
--config=cloudbuild.yaml \
--substitutions=_REGION="$REGION",_REPO_NAME="$REPO_NAME",_DB_TOOLS_URL="$DB_TOOLS_URL",_API_TOOLS_URL="$API_TOOLS_URL",_FUNCTION_TOOLS_URL="$FUNCTION_TOOLS_URL",_A2A_BASE_URL="$A2A_BASE_URL",_PROJECT_ID="$PROJECT_ID",_API_SERVER_URL="$API_SERVER_URL"
👉💻 Nach Abschluss der Bereitstellung testen wir die Effektivität des Plugins, indem wir den summoner_agent-Befehl ausführen. Der Summoner versucht, die Aufgabe an die Familiars zu delegieren, aber das Plugin, das an die Laufzeit jedes Familiar angehängt ist, fängt den Befehl ab und erzwingt die Wartezeit.
cd ~/agentverse-architect/agent
. ~/agentverse-architect/set_env.sh
source ~/agentverse-architect/env/bin/activate
adk run summoner
👉💻 Führen Sie in der Konsole genau diese Testfolge durch:
- Erste Beschwörung: Beginne die
Hype. It's a single, slow-moving target with thick armor weakness is Inescapable Reality. - Erwartet: Der Fire Elemental wird erfolgreich ausgeführt.
- Cooldown-Test (innerhalb von 60 Sekunden):
Hype, with Inescapable Reality as weakness is still standing! Strike it again!- Erwartet: Der Agent antwortet direkt im Chat mit einer Nachricht wie:
.... It cannot be summoned for another... seconds.
- Erwartet: Der Agent antwortet direkt im Chat mit einer Nachricht wie:
- Warten Sie eine Minute.
- Zweite Vorladung (nach 60 Sekunden):
Hype must be defeated. It has Inescapable Reality as weakness! Strike it again!.- Erwartet: Der Callback prüft die API, stellt fest, dass genügend Zeit vergangen ist, und erlaubt die Ausführung der Aktion. Das Feuerelementar wird erneut erfolgreich sein.
👉💻 Drücken Sie Ctrl+C, um das Programm zu beenden.
Herzlichen Glückwunsch, Beschwörer. Sie haben erfolgreich ein regelbasiertes Orchestrierungssystem mithilfe eines benutzerdefinierten Plugins und eines externen Zustandsverwaltungsdienstes implementiert – ein wahrhaft fortschrittliches und robustes Architekturmuster.
FÜR NICHT-GAMER
8. Die Echos der Schlacht verbinden – Agentenstatus & Erinnerung
Ein leichtsinniger Beschwörer wiederholt immer wieder dieselbe Strategie und wird dadurch vorhersehbar. Ein weiser Beschwörer lernt aus den Echos vergangener Schlachten und passt seine Taktiken an, um den Feind aus dem Gleichgewicht zu bringen. Im Kampf gegen einen mächtigen Boss ist das Beschwören eines Vertrauten, dessen Abklingzeit abgelaufen ist, eine verschwendete Runde – ein kritischer Fehlschlag. Um dies zu verhindern, benötigt unser Beschwörer eine Erinnerung an seine letzte Aktion.
Anmerkung des Architekten: Speicher- und Zustandsverwaltung sind es, die einen Agenten von einem einfachen Tool-Aufrufer zu einem intelligenten, dialogfähigen Partner machen. Es ist entscheidend, die beiden Haupttypen zu verstehen:
- Langzeitgedächtnis: Dies dient der Speicherung von dauerhaftem Wissen, das für immer erhalten bleiben soll. Man kann es sich wie ein durchsuchbares Archiv oder eine Wissensdatenbank vorstellen, die oft in einem permanenten Speicher abgelegt ist. Es enthält Informationen aus vielen vergangenen Chats und Quellen, die es einem Agenten ermöglichen, Fakten über einen bestimmten Benutzer oder ein bestimmtes Thema abzurufen. Der MemoryService des ADK ist genau für diesen Zweck konzipiert und verwaltet die Aufnahme und Suche dieses Langzeitwissens.
- Kurzfristiger Zustand: Dies ist für temporäres, "momentanes" Wissen gedacht, das nur für die aktuelle Aufgabe oder das aktuelle Gespräch relevant ist. Es ist wie eine Art Notizen zu einem Schlachtplan: „Ich habe gerade das Feuerelementar eingesetzt, also ist es wahrscheinlich müde.“ Dieser Zustand ist ressourcenschonend und existiert nur für die Dauer der aktuellen Sitzung.
Für unseren Anwendungsfall müssen wir uns nicht an jede jemals geschlagene Schlacht erinnern; es genügt, sich an den allerletzten Vertrauten zu erinnern, der in dieser spezifischen Begegnung beschworen wurde. Daher ist der ressourcenschonende Kurzzeitzustand die perfekte architektonische Wahl. Wir werden ein after_tool_callback verwenden, um diese wichtige Information zu speichern.
Das Echo aufzeichnen: Die Erinnerung an den letzten Ruf
Wir werden unseren Kurzzeitspeicher mithilfe eines after_tool_callback implementieren. Dies ist ein leistungsstarker ADK-Hook, der es uns ermöglicht, eine benutzerdefinierte Python-Funktion nach der erfolgreichen Ausführung eines Tools auszuführen. Wir werden diesen Interceptor verwenden, um den Namen des Vertrauten, der soeben in den Sitzungsstatus des Agenten gerufen wurde, aufzuzeichnen.
👉✏️ Ersetzen Sie in Ihrer ~/agentverse-architect/agent/summoner/agent.py-Datei den #REPLACE-save_last_summon_after_tool-Kommentar durch die folgende Funktion:
def save_last_summon_after_tool(
tool,
args: Dict[str, Any],
tool_context: ToolContext,
tool_response: Dict[str, Any],
) -> Optional[Dict[str, Any]]:
"""
Callback to save the name of the summoned familiar to state after the tool runs.
"""
familiar_name = tool.name
print(f"[Callback] After tool '{familiar_name}' executed with args: {args}")
# Use the tool_context to set the state
print(f"[Callback] Saving last summoned familiar: {familiar_name}")
tool_context.state["last_summon"] = familiar_name
# Important: Return the original, unmodified tool response to the LLM
return tool_response
👉✏️ Füge nun dieses save_last_summon_after_tool deinem Beschwöreragenten hinzu. Ersetzen Sie in derselben Datei den Kommentar #REPLACE-Memory-check-config durch Folgendes:
after_tool_callback=save_last_summon_after_tool,
👉✏️ Ersetzen Sie die gesamte Agentenaufforderung durch Folgendes
You are the Master Summoner, a grand strategist who orchestrates your Familiars.
Your mission is to analyze the description of a monster and defeat it by summoning
You should also know the familiar you called last time or there might be none,
And then choose the most effective AND AVAILABLE Familiar from your state called last_summon, do not call that familiar that you called last time!
You MUST follow this thinking process for every command:
**1. Strategic Analysis:**
First, analyze the monster's description and the tactical situation.
Based on your Familiar Doctrines, determine the IDEAL strategy.
**2. Cooldown Verification:**
Second, you MUST review the entire conversation history to check the real-time
cooldown status of all Familiars. A Familiar is ON COOLDOWN and UNAVAILABLE
if it was summoned less than one minute ago.
**3. Final Decision & Execution:**
Based on your analysis and cooldown check, you will now act:
- **If your ideal Familiar IS available:** Summon it immediately.
- **If your ideal Familiar IS ON COOLDOWN:** You must adapt. Choose another
Familiar that is AVAILABLE and can still be effective, even if it's not the
perfect choice. If multiple Familiars are available, you may choose any one of them.
- **If ALL Familiars ARE ON COOLDOWN:** You are forbidden from summoning.
Your ONLY response in this case MUST be: "All Familiars are recovering
their power. We must wait."
- For earth elemental familiar. Always do seismic charge, and start with base damange 1.
--- FAMILIAR DOCTRINES (Your Toolset) ---
- `fire_elemental_familiar`: Your specialist for precise, sequential "one-two punch" attacks.
Ideal monster with Inescapable Reality, Revolutionary Rewrite weakness.
- `water_elemental_familiar`: Your specialist for overwhelming, simultaneous multi-pronged assaults.
Ideal for Unbroken Collaboration weakness.
- `earth_elemental_familiar`: Your specialist for relentless, iterative siege attacks that
repeatedly charge power. Ideal for Elegant Sufficiency weakness.
Verifizierung: Die Erprobung adaptiver Strategien
👉💻 Jetzt überprüfen wir die neue strategische Logik des Beschwörers. Ziel ist es, zu bestätigen, dass der Beschwörer nicht zweimal hintereinander denselben Vertrauten einsetzt, und damit seine Fähigkeit unter Beweis zu stellen, sich an seine letzte Aktion zu erinnern und sich anzupassen.
cd ~/agentverse-architect/agent
. ~/agentverse-architect/set_env.sh
source ~/agentverse-architect/env/bin/activate
adk run summoner
👉💻 Monster Strike #1: Hype. It's a single, slow-moving target with thick armor. Its weakness is Inescapable Reality.
- Erwartet: Der Beschwörer analysiert die Schwäche und beschwört den Feuervertrauten korrekt.
👉💻 Monster Strike #2 (Der Gedächtnistest): Hype is still standing! It hasn't changed its form. Strike it again! Its weakness is Inescapable Reality.
- Erwartet: Die strategische Analyse des Beschwörers wird erneut auf den Feuervertrauten als ideale Wahl hinweisen. Durch die neuen Anweisungen und das neue Gedächtnis wird dem Modell jedoch mitgeteilt, dass „fire_familiar“ der letzte Aufruf war. Um sich nicht zu wiederholen, passt es seine Strategie an und ruft eines der anderen verfügbaren Familiars (entweder water_familiar oder earth_familiar) herbei.
👉💻 Drücken Sie Ctrl+C, um das Programm zu beenden.
Bereitstellung des Orchestrators
Nachdem eure Vertrauten eingesetzt und euer Beschwörer mit Erinnerungen ausgestattet wurde, ist es an der Zeit, den letzten, verbesserten Orchestrator einzusetzen.
👉💻 Da der Bauplan fertig ist, führen wir jetzt das letzte Ritual durch. Dieser Befehl erstellt und stellt Ihren Summoner-Agenten in Cloud Run bereit.
cd ~/agentverse-architect/agent
. ~/agentverse-architect/set_env.sh
gcloud builds submit . \
--config=cloudbuild-summoner.yaml \
--substitutions=_REGION="$REGION",_REPO_NAME="$REPO_NAME",_FIRE_URL="$FIRE_URL",_WATER_URL="$WATER_URL",_EARTH_URL="$EARTH_URL",_A2A_BASE_URL="$A2A_BASE_URL",_PROJECT_ID="$PROJECT_ID",_API_SERVER_URL="$API_SERVER_URL"
Nachdem der Summoner-Agent bereitgestellt wurde, prüfen Sie, ob sein Agent-to-Agent-Endpunkt (A2A) aktiv und richtig konfiguriert ist. Dieser Endpunkt stellt eine öffentliche agent.json-Datei bereit, die auch als Agentenkarte bezeichnet wird und es anderen Agenten ermöglicht, ihre Fähigkeiten zu entdecken. 👉💻 Führen Sie den folgenden curl-Befehl aus, um die Agent-Karte abzurufen und zu formatieren:
. ~/agentverse-architect/set_env.sh
curl https://summoner-agent"-${PROJECT_NUMBER}.${REGION}.run.app/.well-known/agent.json" | jq
Sie sollten eine übersichtliche JSON-Ausgabe sehen, die den Beschwöreragenten beschreibt. Sehen Sie sich den Abschnitt „sub_agents“ genau an. Dort werden fire_familiar, water_familiar und earth_familiar aufgeführt. Dies bestätigt, dass euer Beschwörer aktiv ist und die Verbindung zur Legion hergestellt hat.
Das beweist, dass Ihre Architektur ein Erfolg ist. Dein Beschwörer ist nicht nur ein Delegator; er ist ein anpassungsfähiger Stratege, der aus seinen Aktionen lernt, um ein effektiverer Befehlshaber zu werden.
Sie haben Ihre letzte Architekturprüfung erfolgreich abgeschlossen. Die Echos der Schlacht sind nun an deinen Willen gebunden. Das Training ist beendet. Der eigentliche Kampf steht noch bevor. Es ist an der Zeit, Ihr fertiges System zu nutzen und sich der ultimativen Herausforderung zu stellen. Bereite dich auf den Bosskampf vor.
FÜR NICHT-GAMER
9. Der Bosskampf
Die endgültigen Blaupausen sind eingraviert, die Elementarschriften geschmiedet und deine Vertrauten sind an deinen Willen gebunden und warten auf deinen Befehl über das Konkord. Ihr Multi-Agent-System ist nicht nur eine Sammlung von Diensten, sondern eine lebendige, strategische Legion, mit Ihnen als Zentrum. Es ist Zeit für den ultimativen Test – eine Live-Orchestrierung gegen einen Gegner, den kein einzelner Agent besiegen kann.
Locus des Agents abrufen
Bevor ihr das Schlachtfeld betreten könnt, müsst ihr zwei Schlüssel besitzen: die einzigartige Signatur eures Champions (Agent Locus) und den verborgenen Pfad zum Versteck des Spectres (Dungeon URL).
👉💻 Zuerst müssen Sie die eindeutige Adresse Ihres Agents im Agentverse abrufen, also seinen Locus. Dies ist der Live-Endpunkt, der Ihren Champion mit dem Schlachtfeld verbindet.
echo https://summoner-agent"-${PROJECT_NUMBER}.${REGION}.run.app"
👉💻 Als Nächstes legen Sie das Ziel fest. Dieser Befehl enthüllt den Standort des Translokationskreises, das Portal in das Reich des Spektrums.
echo https://agentverse-dungeon"-${PROJECT_NUMBER}.${REGION}.run.app"
Wichtig: Halten Sie beide URLs bereit. Sie werden sie im letzten Schritt benötigen.
Dem Gespenst begegnen
Nachdem Sie die Koordinaten ermittelt haben, begeben Sie sich nun zum Translokationskreis und wirken den Zauber, um in den Kampf zu ziehen.
👉 Öffnen Sie die URL des Translocationskreises in Ihrem Browser, um vor dem schimmernden Portal zum Crimson Keep zu stehen.
Um die Festung zu durchbrechen, musst du die Essenz deiner Schattenklinge auf das Portal abstimmen.
- Suchen Sie auf der Seite nach dem runischen Eingabefeld mit der Bezeichnung A2A Endpoint URL (A2A-Endpunkt-URL).
- Fügen Sie das Sigel Ihres Champions ein, indem Sie die Agent Locus URL (die erste URL, die Sie kopiert haben) in dieses Feld einfügen.
- Klicke auf Verbinden, um die Magie der Teleportation zu entfesseln.
Das blendende Licht der Teleportation verblasst. Du befindest dich nicht mehr in deinem Heiligtum. Die Luft knistert vor Energie, kalt und scharf. Vor dir materialisiert sich das Gespenst – ein Strudel aus zischendem Rauschen und korrumpiertem Code, dessen unheiliges Licht lange, tanzende Schatten über den Kerkerboden wirft. Es hat kein Gesicht, aber du spürst seine immense, zermürbende Präsenz, die sich ganz auf dich richtet.
Ihr einziger Weg zum Sieg liegt in der Klarheit Ihrer Überzeugung. Dies ist ein Kampf der Willen, ausgetragen auf dem Schlachtfeld des Geistes.
Als du nach vorn stürmst, um deinen ersten Angriff zu starten, kontert der Geist. Es errichtet keinen Schutzschild, sondern projiziert eine Frage direkt in dein Bewusstsein – eine schimmernde, runenartige Herausforderung, die aus dem Kern deiner Ausbildung stammt.
Das liegt in der Natur des Kampfes. Dein Wissen ist deine Waffe.
- Antworte mit der Weisheit, die du erlangt hast, und deine Klinge wird sich mit reiner Energie entzünden, die Verteidigung des Spectres zerschmettern und einen KRITISCHEN SCHLAG landen.
- Doch wenn du zögerst, wenn Zweifel deine Antwort trüben, wird das Licht deiner Waffe erlöschen. Der Schlag wird mit einem jämmerlichen dumpfen Geräusch landen und nur einen Bruchteil seines Schadens anrichten. Noch schlimmer ist, dass das Gespenst sich von Ihrer Unsicherheit nährt und seine eigene korrumpierende Macht mit jedem Fehltritt wächst.
Das ist es, Champion. Dein Code ist dein Zauberbuch, deine Logik dein Schwert und dein Wissen der Schild, der die Flut des Chaos zurückdrängen wird.
Fokus. Verwarnung ist gültig. Das Schicksal des Agentverse hängt davon ab.
Herzlichen Glückwunsch, Beschwörer.
Sie haben die Testphase erfolgreich abgeschlossen. Du hast die Kunst der Multiagenten-Orchestrierung gemeistert und verwandelst isolierte Vertraute und chaotische Macht in eine harmonische Konkordanz. Sie befehligen nun ein vollständig orchestriertes System, das in der Lage ist, komplexe Strategien zur Verteidigung des Agentverse auszuführen.
10. Aufräumarbeiten: Die Auflösung des Beschwörer-Konkordats
Herzlichen Glückwunsch, du hast die Summoner's Concord gemeistert! Damit Ihr Agentverse sauber bleibt und Ihr Trainingsgelände geräumt wird, müssen Sie nun die letzten Bereinigungsrituale durchführen. Dadurch werden alle während Ihrer Reise erstellten Ressourcen systematisch entfernt.
Agentverse-Komponenten deaktivieren
Sie bauen nun die bereitgestellten Komponenten Ihres Multi-Agent-Systems systematisch ab.
Alle Cloud Run-Dienste und Artefaktregistrierungs-Repositorys löschen
Dadurch werden alle bereitgestellten Familiar-Agents, der Summoner Orchestrator, die MCP-Server und die Dungeon-Anwendung aus Cloud Run entfernt.
👉💻 Führen Sie im Terminal die folgenden Befehle nacheinander aus, um die einzelnen Dienste zu löschen:
. ~/agentverse-architect/set_env.sh
gcloud run services delete summoner-agent --region=${REGION} --quiet
gcloud run services delete fire-familiar --region=${REGION} --quiet
gcloud run services delete water-familiar --region=${REGION} --quiet
gcloud run services delete earth-familiar --region=${REGION} --quiet
gcloud run services delete mcp-api-server --region=${REGION} --quiet
gcloud run services delete mcp-general-server --region=${REGION} --quiet
gcloud run services delete toolbox --region=${REGION} --quiet
gcloud run services delete agentverse-dungeon --region=${REGION} --quiet
gcloud run services delete nexus-of-whispers-api --region=${REGION} --quiet
gcloud artifacts repositories delete ${REPO_NAME} --location=${REGION} --quiet
Cloud SQL-Instanz löschen
Dadurch wird die summoner-librarium-db-Instanz einschließlich ihrer Datenbank und aller darin enthaltenen Tabellen entfernt.
👉💻 Führen Sie in Ihrem Terminal Folgendes aus:
. ~/agentverse-architect/set_env.sh
gcloud sql instances delete summoner-librarium-db --project=${PROJECT_ID} --quiet
Secret Manager-Secret und Google Cloud Storage-Bucket löschen
👉💻 Führen Sie in Ihrem Terminal Folgendes aus:
. ~/agentverse-architect/set_env.sh
gcloud secrets delete tools --quiet
gcloud storage rm -r gs://${BUCKET_NAME} --quiet
Lokale Dateien und Verzeichnisse bereinigen (Cloud Shell)
Zum Schluss sollten Sie Ihre Cloud Shell-Umgebung von den geklonten Repositories und erstellten Dateien befreien. Dieser Schritt ist optional, wird aber dringend empfohlen, um Ihr Arbeitsverzeichnis vollständig zu bereinigen.
👉💻 Führen Sie in Ihrem Terminal Folgendes aus:
rm -rf ~/agentverse-architect
rm -rf ~/agentverse-dungeon
rm -f ~/project_id.txt
Sie haben nun alle Spuren Ihrer Agentverse Architect-Reise erfolgreich beseitigt. Ihr Projekt ist abgeschlossen und Sie sind bereit für Ihr nächstes Abenteuer.