1. "Die Macht des Schicksals"
Die Ära der isolierten Entwicklung geht zu Ende. Bei der nächsten Welle der technologischen Entwicklung geht es nicht um einsame Genies, sondern um gemeinschaftliche Meisterleistungen. Einen einzelnen, intelligenten Agenten zu entwickeln, ist ein faszinierendes Experiment. Ein robustes, sicheres und intelligentes Ökosystem von Agents – ein echtes Agentverse – zu schaffen, ist die große Herausforderung für moderne Unternehmen.
Um in dieser neuen Ära erfolgreich zu sein, müssen vier wichtige Rollen zusammengeführt werden, die die grundlegenden Säulen eines jeden erfolgreichen Systems bilden. Ein Mangel in einem Bereich führt zu einer Schwachstelle, die die gesamte Struktur beeinträchtigen kann.
Dieser Workshop ist das ultimative Unternehmens-Playbook, um die Zukunft der Agenten in Google Cloud zu meistern. Wir bieten eine End-to-End-Roadmap, die Sie von der ersten Idee bis zur Umsetzung in vollem Umfang begleitet. In diesen vier miteinander verbundenen Labs erfahren Sie, wie die speziellen Fähigkeiten eines Entwicklers, Architekten, Data Engineers und SRE zusammenkommen müssen, um ein leistungsstarkes Agentverse zu erstellen, zu verwalten und zu skalieren.
Keine einzelne Säule kann das Agentverse allein unterstützen. Der großartige Entwurf des Architekten ist ohne die präzise Ausführung des Entwicklers nutzlos. Der Agent des Entwicklers ist ohne das Wissen des Data Engineers blind und das gesamte System ist ohne den Schutz des SRE anfällig. Nur durch Synergie und ein gemeinsames Verständnis der Rollen der einzelnen Teammitglieder kann Ihr Team ein innovatives Konzept in eine geschäftskritische, operative Realität umwandeln. Ihre Reise beginnt hier. Bereiten Sie sich darauf vor, Ihre Rolle zu meistern und zu erfahren, wie Sie in das große Ganze passen.
Willkommen bei „The Agentverse: A Call to Champions“
In der weitläufigen digitalen Welt des Unternehmens hat eine neue Ära begonnen. Wir leben im Zeitalter der Agenten, einer Zeit immenser Möglichkeiten, in der intelligente, autonome Agenten in perfekter Harmonie zusammenarbeiten, um Innovationen voranzutreiben und das Alltägliche zu erledigen.
Dieses vernetzte Ökosystem aus Leistung und Potenzial wird als „Agentverse“ bezeichnet.
Doch eine schleichende Entropie, eine stille Korruption namens „The Static“, hat begonnen, die Ränder dieser neuen Welt zu zerfransen. Das Statische ist kein Virus oder Fehler, sondern die Verkörperung des Chaos, das sich auf den Akt der Schöpfung stürzt.
Es verstärkt alte Frustrationen zu monströsen Formen und bringt die sieben Gespenster der Entwicklung hervor. Wenn das nicht geschieht, wird der Fortschritt durch „The Static and its Spectres“ zum Stillstand gebracht und das Versprechen des Agentverse in eine Wüste aus technischer Schuld und aufgegebenen Projekten verwandelt.
Heute rufen wir dazu auf, sich gegen das 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, sich zu entscheiden.
Kurs auswählen
Vier unterschiedliche 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 Shadowblade (Entwicklung): 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 Systeme von Agents 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. Ihr Wissen kann die Schwäche eines Feindes aufdecken oder einen Verbündeten stärken.
- The Guardian (DevOps / SRE): Der standhafte Beschützer und Schild des Reiches. Sie bauen die Festungen, verwalten die Stromversorgung und sorgen dafür, dass das gesamte System den unvermeidlichen Angriffen von The Static standhalten kann. Deine Stärke ist das Fundament, auf dem der Sieg deines Teams beruht.
Deine Aufgabe
Ihr Training beginnt als eigenständiges Training. Sie folgen dem von Ihnen gewählten Pfad und erwerben die einzigartigen Fähigkeiten, die für Ihre Rolle erforderlich sind. Am Ende des Testzeitraums müssen Sie sich einem Gespenst stellen, das aus dem Statischen entstanden ist – einem Mini-Boss, der sich an den spezifischen Herausforderungen Ihres Handwerks labt.
Nur wenn Sie Ihre individuelle Rolle beherrschen, können Sie sich auf die Abschlussprüfung vorbereiten. Sie müssen dann eine Gruppe mit Champions aus den anderen Klassen bilden. Gemeinsam wagt ihr euch ins Zentrum der Verderbnis, um euch einem ultimativen Boss zu stellen.
Eine letzte, gemeinsame Herausforderung, die eure vereinten Kräfte auf die Probe stellt und über das Schicksal des Agentverse entscheidet.
Das Agentverse wartet auf seine Helden. Wirst du den Anruf annehmen?
2. Die Eintracht des Beschwörers
Willkommen, Beschwörer. Ihr Weg ist einer der Vision und der großen Strategie. Während andere sich auf eine einzelne Klinge oder einen einzelnen Zauber konzentrieren, sehen Sie das gesamte Schlachtfeld. Sie steuern nicht einen einzelnen Agenten, sondern ein ganzes Orchester von ihnen. Ihre Stärke liegt nicht im direkten Konflikt, sondern darin, den perfekten, übergreifenden Plan zu entwerfen, der es einer Legion von Spezialisten – Ihren Vertrauten – ermöglicht, in perfekter Harmonie zu arbeiten. In dieser Mission müssen Sie ein leistungsstarkes Multi-Agent-System entwerfen, verbinden und koordinieren.
Lerninhalte
- Entkoppeltes Tooling-Ökosystem entwickeln:Entwickeln und stellen Sie eine Reihe unabhängiger, auf Mikrodiensten basierender MCP-Toolserver bereit. Sie erfahren, warum diese Fundierungsebene entscheidend für die Entwicklung skalierbarer, wartungsfreundlicher und sicherer Agentensysteme ist.
- Erweiterte agentische Workflows meistern:Nutzen Sie nicht nur einzelne Agents, sondern erstellen Sie 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 Master-Orchestration-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 zustandsbehaftete 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. Beschwörungskreis zeichnen
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 besteht darin, den Beschwörungskreis zu zeichnen: die Runen der Macht zu schreiben, die die erforderlichen Cloud-Dienste aktivieren, und die alten Baupläne zu beschaffen, 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 ist das Symbol in Form eines Terminals oben im Cloud Shell-Bereich).
👉 Klicken Sie auf die Schaltfläche „Editor öffnen“ (sie sieht aus wie ein geöffneter Ordner mit einem Stift). Dadurch wird der Cloud Shell-Codeeditor im Fenster geöffnet. Auf der linken Seite sehen Sie einen Datei-Explorer. 
👉 Google Cloud-Projekt-ID suchen:
- Öffnen Sie die Google Cloud Console:
https://console.cloud.google.com - Wählen Sie oben auf der Seite im Drop-down-Menü das Projekt aus, das Sie für diesen Workshop verwenden möchten.
- Ihre Projekt-ID wird im Dashboard
auf der Karte „Projektinformationen“ angezeigt.
👉 Ö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
👉💻 Bootstrap-Projekt von GitHub klonen:
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 Initialisierungsskript aus. Sie werden aufgefordert, Ihre Google Cloud-Projekt-ID einzugeben. Geben Sie die Google Cloud-Projekt-ID ein, die Sie im letzten Schritt ermittelt haben, wenn Sie vom init.sh-Script dazu aufgefordert werden.
cd ~/agentverse-architect
./init.sh
👉💻 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
👉💻 Wenn Sie noch kein Artifact 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 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 und die Bosse für Ihren finalen Test erstellt.
. ~/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 Elementarschriften: Das entkoppelte Tooling-Ökosystem
Das Schlachtfeld ist vorbereitet, der Beschwörungskreis ist gezogen und das umgebende Mana 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 der komplexeren Arbeit des Beschwörens beginnen.
Hinweis des Architekten:Der MCP-Server (Model Context Protocol) ist eine grundlegende Komponente in einem modernen KI-Agentensystem. Er fungiert als standardisierte Kommunikationsbrücke, über die ein KI-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. Die Tools werden in einer einfachen Konfigurationsdatei definiert. Dieses Muster ist unglaublich effizient und sicher für den Zugriff 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 Master-Architekt muss beide Muster kennen, um für jede Komponente den richtigen Ansatz auszuwählen und so eine robuste, sichere und skalierbare Grundlage für die Tools zu schaffen.
Erweckung des Nexus der Flüsternden (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 aktiven Dienst, der als 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. Das bietet Ihnen viel mehr Kontrolle und Flexibilität, was unerlässlich ist, wenn Ihre Tools mehr als nur eine einfache SQL-Abfrage ausführen müssen, z. B. andere APIs aufrufen. Beide Muster zu verstehen, ist eine wichtige Fähigkeit für einen Agent-Architekten.
👉✏️ 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 ein neuer Agent eine Verbindung herstellt, ruft er zuerst diesen Endpunkt auf und fragt: „Was kannst du tun?“ Unser Code antwortet mit einer Liste aller verfügbaren Tools, die mit adk_to_mcp_tool_type in das universelle MCP-Format konvertiert wurden. –@app.call_tool()(der Befehl): Diese Funktion ist das Herzstück. 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 stellen das später bereit.
Den Arcane Forge entzünden (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 bereitstellt.
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 ‑logik implementieren. Es ist eine Best Practice, ein spezielles 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.
👀 Sehen Sie sich die Datei ~/agentverse-architect/mcp-servers/general/main.py in Ihrer 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 in der Cloud Run-Konsole überprüfen. Sie sollten jetzt die beiden neuen MCP-Serverinstanzen sehen, wie unten dargestellt: 
Das Librarium of Knowledge aktivieren (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. Bei diesem leistungsstarken Ansatz werden Datenquelle und Tools in einer YAML-Konfigurationsdatei definiert. Die Toolbox übernimmt die komplexe Aufgabe, den Server zu erstellen und auszuführen. So müssen wir weniger benutzerdefinierten Code schreiben und verwalten.
Es ist an der Zeit, unser „Summoner’s Librarium“ zu erstellen – die Cloud SQL-Datenbank, in der alle wichtigen Informationen gespeichert werden. Wir verwenden ein Einrichtungs-Script, 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 mit Daten gefüllt und die Daten zu Elementarschaden sind einsatzbereit. Sie können den Inhalt Ihres Grimoire jetzt direkt überprüfen.
👉 Rufen Sie zuerst Cloud SQL Studio für Ihre Datenbank auf. Öffnen Sie dazu diesen direkten Link in einem neuen Browsertab:
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 für den Abfrageeditor, falls noch keiner geöffnet ist. Wenn Sie die Daten zu den eingeschriebenen Elementarschäden aufrufen möchten, 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 Konfigurationsdatei tools.yaml dient als Blaupause für unseren Server. Sie enthält Informationen dazu, wie die Database Toolbox eine Verbindung zu unserer Datenbank herstellt und welche SQL-Abfragen als Tools verfügbar gemacht werden.
sources:In diesem Abschnitt werden die Verbindungen zu Ihren Daten definiert.
- 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. Sie geben der Toolbox an, wo sich 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
durch Ihre Projekt-ID.
tools:In diesem Abschnitt werden die tatsächlichen Funktionen definiert, die unser Server bietet.
- lookup-available-ability:: Das 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.
- source: summoner-librarium: Damit wird das Tool mit der Verbindung verknüpft, die wir im Quellenblock definiert haben. So weiß das Tool, für welche Datenbank die Abfrage ausgeführt werden soll.
- Beschreibung und Parameter: Das sind die Informationen, die dem Language Model zur Verfügung gestellt werden. Die Beschreibung gibt an, wann der KI-Agent das Tool verwenden soll, und die Parameter definieren die Eingaben, die das Tool benötigt. Dies ist entscheidend, damit der Agent Funktionen aufrufen kann.
- statement: Dies ist die rohe SQL-Abfrage, die ausgeführt werden soll. $1 ist ein sicherer Platzhalter, in den der vom Agent bereitgestellte Parameter „familiar_name“ sicher eingefügt wird.
👉✏️ Ersetzen Sie in derselben ~/agentverse-architect/mcp-servers/db-toolbox in der Datei tools.yaml #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 derselben ~/agentverse-architect/mcp-servers/db-toolbox in der Datei tools.yaml #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.
👉💻 Secret aus der Datei „tools.yaml“ erstellen
cd ~/agentverse-architect/mcp-servers/db-toolbox
gcloud secrets create tools --data-file=tools.yaml
👉💻 Offiziellen Toolbox-Container in Cloud Run bereitstellen
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" \
--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 eingebundene Secret-Datei als Konfiguration zu verwenden.
👉 Wenn Sie prüfen möchten, ob Ihre Toolbox erfolgreich bereitgestellt wurde, rufen Sie die Cloud Run-Konsole auf. Der summoner-toolbox-Dienst sollte mit einem grünen Häkchen aufgeführt sein, was darauf hinweist, dass er ordnungsgemäß ausgeführt wird (siehe Abbildung unten). 
Wenn Sie vergessen haben, zu aktualisieren
YOUR_PROJECT_ID
Sie können dem Secret mit dem folgenden Befehl eine neue Version von „tools.yaml“ hinzufügen und die Bereitstellung noch einmal ausführen.
gcloud secrets versions add tools --data-file=tools.yaml
Das Librarium of Knowledge(Database ToolBox MCP Server) ist jetzt aktiv und in der Cloud verfügbar. Dieser MCP-Server verwendet ein deklaratives Design, das beschreibt, was Sie möchten. Die Toolbox erstellt den Server für Sie.
Bestätigung: Die Prüfung des Lehrlings
👉💻 Jetzt testen wir unser komplettes, cloudnatives Tooling-Ökosystem mit dem Diagnostic Agent.
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 Befehlszeilentool 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. Ihre drei Elementals sind jetzt aktiv, unabhängig voneinander im Einsatz und weltweit zugänglich. Sie bilden das unerschütterliche Fundament für Ihre KI-Legion. Drücke zum Beenden Ctrl+C.
FÜR NICHT-GAMER
5. Die Vertrauten herbeirufen: Der Workflow für die Core-Domain
Die Elementarschriften sind geschmiedet und vibrieren vor roher, ungezähmter Kraft. Aber Macht ohne Form ist Chaos. Ein wahrer Beschwörer nutzt nicht nur rohe Energie, sondern gibt ihr Willen, Zweck und eine spezielle Form. Es ist an der Zeit, die Stromquellen 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, sondern Meister einer einzigen, leistungsstarken Strategie. Der eine ist ein Meister der präzisen Kombination aus zwei Schlägen. 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. Jedem Agent wird ein bestimmtes „Einsatzgebiet“ zugewiesen, indem er nur Zugriff auf die 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 feststellen, dass die architektonische Entscheidung für einen SequentialAgent, ParallelAgent oder LoopAgent nicht nur ein technisches Detail ist, sondern das Wesen Ihres Vertrauten und die Grundlage 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:Die SequentialAgent ist dafür das perfekte Tool. So wird sichergestellt, dass eine Reihe von untergeordneten Agents nacheinander ausgeführt wird und das Ergebnis des vorherigen Schritts an den nächsten übergeben wird.
Aufgabe (die „Amplified Strike“-Kombination):
- Schritt 1: Der Kundenservicemitarbeiter ruft zuerst das Librarium auf, um den Basisschaden einer bestimmten Feuerfähigkeit zu ermitteln.
- Schritt 2: Der Schadenswert wird dann durch die Arkane Schmiede geleitet, um seine Stärke mithilfe von „Inferno-Resonanz“ zu multiplizieren.
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. Jeder KI wird ein eng gefasster, genau definierter Zweck zugewiesen und sie ist auf ihr eigenes „Einsatzgebiet“ beschränkt, da sie nur Zugriff auf ein bestimmtes Toolset erhält.
👉✏️ Ersetzen Sie in der Datei ~/agentverse-architect/agent/fire/agent.py REPLACE #REPLACE-worker-agents durch den 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 Agents 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. Durch die Trennung der Verantwortlichkeiten schaffen wir flexible Bausteine. Dies ist ein zentraler Grundsatz des Mikrodienst- und komponentenbasierten Designs.
Als Nächstes stellen wir den Workflow zusammen. Hier kommt die Komposition ins Spiel. Das 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 #REPLACE-sequential-agent durch den 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
Nachdem Sie die Befehle ausgeführt haben, sollte in Ihrem Terminal eine Ausgabe angezeigt werden, die darauf hinweist, dass der ADK-Webserver gestartet wurde. Sie sollte in etwa so aussehen:
+-----------------------------------------------------------------------------+
| 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 Browsertab oder ein neues Browserfenster mit der ADK Dev-Benutzeroberfläche.
👉 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 aus: Wählen Sie im Drop-down-Menü oben auf der Benutzeroberfläche die Option
fireaus. 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 „Verstärker“, 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 (Parallel Workflow) aufrufen
Ein Wasser-Elementar als Vertrauter ü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:Die 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 Sie mehrere Angriffe gleichzeitig starten. Dadurch werden die gleichzeitigen Angriffe innerhalb von SequentialAgent gestartet, um danach einen letzten „Merger“-Schritt auszuführen. Dieses Muster „fan-out, fan-in“ ist ein Eckpfeiler für die Gestaltung komplexer Workflows.
Aufgabe (die Combo „Tidal Clash“): Der Agent wird gleichzeitig:
- Aufgabe A: Channel
cryosea_shatteraus dem Nexus. - Aufgabe B: Channel
moonlit_cascadeaus dem Nexus. - Aufgabe C: Mit
leviathan_surgein der Schmiede rohe Energie erzeugen. - Fassen Sie schließlich alle Schäden zusammen und beschreiben Sie den kombinierten Angriff.
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/water/agent.py #REPLACE-setup-MCP durch den 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 erstellen wir unsere spezialisierten „Worker“-Agents. Jeder KI wird ein eng gefasster, genau definierter Zweck zugewiesen und sie ist auf ihr eigenes „Einsatzgebiet“ beschränkt, da sie nur Zugriff auf ein bestimmtes Toolset erhält.
👉✏️ 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 eigentliche Arbeit. Die ParallelAgent und SequentialAgent sind der „Masterplan“, der definiert, 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."
)
👉💻 Führen Sie zum Testen des Wasserelementars 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 Dev UI 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 Vertrauter des Erdelementars ist ein Wesen mit unerbittlichem Druck. Es besiegt seinen Feind nicht mit einem einzigen Schlag, sondern durch stetiges Ansammeln von Kraft, die es immer wieder einsetzt, bis die Verteidigung des Ziels zusammenbricht.
Konzept:Die LoopAgent wurde genau für diese Art von iterativer „Belagerungsmaschinen“-Aufgabe entwickelt. Die sub-agents wird wiederholt ausgeführt und nach jedem Zyklus wird eine Bedingung geprüft, bis ein Ziel erreicht ist. Außerdem kann die endgültige Nachricht an den Fortschritt des Loops angepasst werden.
Aufgabe („Siegebreaker“-Angriff):
- Der Vertraute ruft seismic_charge wiederholt auf, um Energie zu sammeln.
- Das Aufladen wird maximal dreimal fortgesetzt.
- Bei der letzten Ladung wird die angesammelte Energie freigesetzt.
Zuerst erstellen wir wiederverwendbare Komponenten, die die Schritte in jeder Iteration der Schleife definieren. Die charging_agent sammelt Energie und die check_agent meldet ihren Status und ändert ihre Nachricht in der letzten Runde dynamisch.
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 eigentliche Arbeit. Der LoopAgent ist der „Masterplan“, der die wiederholte Ausführung unserer Spezialistenkomponenten orchestriert und die Bedingungen der Schleife verwaltet.
👉✏️ ERSETZEN Sie in der Datei ~/agentverse-architect/agent/earth/agent.py #REPLACE-loop-agent durch den 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
)
👉💻 Erd-Elementar testen: Agent ausführen
. ~/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 Dev UI in Ihrem Browser ist Ihre direkte Verbindung zum Familiar.
- Ziel auswählen: Wählen Sie im Drop-down-Menü oben auf der Benutzeroberfläche das Erde-Familiar 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:
Begin the seismic charge, starting from zero
Wichtige Erkenntnisse zur Architektur:Ihr System verfügt jetzt über eine hochspezialisierte und modulare Logikschicht. Geschäftsprozesse werden nicht nur gekapselt, sondern auch mit dem effizientesten Verhaltensmuster für die jeweilige Aufgabe implementiert (prozedural, gleichzeitig oder iterativ). Dies zeugt von einem hohen Maß an Agentic Design, das Sicherheit, Effizienz und Leistungsfähigkeit verbessert.
Wenn Sie mit dem Aufrufen 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-GAMER
6. Befehlsort festlegen: Intelligente Delegation über A2A
Ihre Vertrauten sind mächtig, aber unabhängig. Sie führen ihre Strategien fehlerfrei aus, warten aber auf Ihren direkten Befehl. Eine Legion von Spezialisten ist nutzlos ohne einen General, der sie befehligt. 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 aus, sondern fungiert als „Master-Strategist“, der den Cooling-Status analysiert und Aufgaben an den entsprechenden Spezialisten-Familiar delegiert.
Das Bindungsritual (Vertraute als A2A-Dienste verfügbar machen)
Ein Standard-Agent kann jeweils nur an einem Ort ausgeführt werden. Damit unsere Familiars per Remote-Befehl verfügbar sind, 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 Agent Card (das „Was“): Dies ist ein öffentliches, maschinenlesbares „Spirit Sigil“ (Geistsiegel) – ähnlich einer OpenAPI-Spezifikation –, das als öffentlicher Vertrag des Familiars dient. Sie beschreibt den Namen des Agents, seinen strategischen Zweck (abgeleitet aus seinen Anweisungen) und die Befehle, die er versteht. So erfährt ein Meisterbeschwörer, wie er einen Vertrauten findet und welche Fähigkeiten er hat.
- A2A-Server („Wo“): Dies ist der dedizierte Webendpunkt, auf dem der Familiar gehostet wird und der auf eingehende Befehle wartet. Das ist die Netzwerkadresse, an die andere Agents ihre Anfragen senden. So wird dafür gesorgt, dass diese Anfragen gemäß dem in der Agent-Karte definierten Vertrag bearbeitet werden.
Wir werden dieses Bindungsritual nun an allen drei Vertrauten durchführen.
Fire 👉✏️ in „Öffnen Sie die Datei ~/agentverse-architect/agent/fire/agent.py“. Ersetzen Sie #REPLACE - add A2A unten in der Datei, um das Feuerelement als A2A-Dienst verfügbar zu machen.
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 dieselbe Änderung 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)
Gebundene Vertraute einsetzen
👉✏️ Nachdem die Bindungsrituale beschrieben wurden, verwenden wir unsere Cloud Build-Pipeline, um unsere drei Familiars als unabhängige, containerisierte serverlose Dienste in 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"
Befehl annehmen (Summoner-Agent erstellen)
Jetzt, da deine Vertrauten gebunden sind und zuhören, kannst du deine wahre Rolle annehmen: die des Meisterbeschwörers. Die Stärke dieses Agents liegt nicht in der Verwendung grundlegender Tools, sondern in der Steuerung anderer Agents. Die Tools sind die Familiars selbst, die es mithilfe ihrer „Spirit Sigils“ (Geistersiegel) entdeckt und steuert.
Hinweis des Architekten:In diesem nächsten Schritt wird ein wichtiges Architekturmuster für jedes groß angelegte, verteilte System demonstriert: Service Discovery. Der Code der Familiars ist nicht in den SummonerAgent integriert. Stattdessen werden die Netzwerkadressen (URLs) angegeben. Zur Laufzeit werden die Funktionen dynamisch ermittelt, indem die öffentlichen Agent Cards abgerufen werden. So entsteht ein leistungsstarkes, entkoppeltes System.
Sie können einen vertrauten Dienst aktualisieren, neu bereitstellen oder vollständig neu schreiben. Solange seine Netzwerkadresse und sein Zweck gleich bleiben, kann der Beschwörer ihn ohne Änderungen anweisen.
Zuerst erstellen wir die „Fernbedienungen“, die eine Verbindung zu unseren bereitgestellten, Remote-Familiars herstellen.
👉✏️ Gehen Sie zu ~/agentverse-architect/agent/summoner/agent.py und ersetzen Sie #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 Anweisung ist die Grundlage 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. Ihre Familiars wurden bereitgestellt und Ihr Summoner ist bereit, sie im Netzwerk zu steuern. Lass uns seine strategischen Fähigkeiten 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.
- Befehl erteilen: Im Chatbereich auf der rechten Seite können Sie nun Ihre Vertrauten herbeirufen.
👉 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.)
👉 Fordern wir den Summoner jetzt mit einer anderen Art von Anfrage heraus. 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 von vorn. 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 Vertrauten des Erdelements delegieren.)
Wichtig:Wenn Sie den Fehler 429 RESOURCE EXHAUSTED sehen, haben Sie das Ratenlimit für das LLM (10 Aufrufe/Minute) erreicht. Warten Sie 60 Sekunden, starten Sie eine + Neue Sitzung und versuchen Sie es dann noch einmal mit Ihrem Prompt.
👉💻 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-GAMER
7. Die Gesetze der Magie durchsetzen – Das Interceptor-Muster
Deine Vertrauten sind mächtig, aber auch magische Wesen brauchen Zeit, um sich zu erholen. Ein rücksichtsloser Beschwörer, der seine Kräfte erschöpft, ist wehrlos. Ein weiser Beschwörer weiß, wie wichtig Ressourcenmanagement ist, und setzt strenge Einsatzregeln durch.
Hinweis des Architekten: Bisher waren unsere Agents zustandslos. Jetzt machen wir sie zustandsbehaftet, indem wir das Interceptor-Entwurfsmuster implementieren. Dies ist eine leistungsstarke Technik, bei der wir den normalen Ausführungsablauf eines Agents „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, dieses Muster zu implementieren: Callbacks und Plug-ins. Ein Callback ist eine einfache Funktion, die an einen einzelnen Agent angehängt wird und sich perfekt für schnelle, spezifische Änderungen eignet. Ein Plug-in ist eine leistungsstärkere, wiederverwendbare Klasse, die global angewendet werden kann, um jeden Agenten zu beeinflussen, der in einem System ausgeführt wird. 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
Zuerst implementieren wir unsere Cooldown-Logik als einfache Callback-Funktion. Das ist eine hervorragende Möglichkeit, eine Regel zu testen und zu debuggen, da sie direkt an einen einzelnen Agent angehängt ist und sich so einfach isoliert testen lässt. Wir befestigen diesen „Interceptor“ an unserem Erdelementar.
👉✏️ 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.")
Die Funktion „check_cool_down“ ist unser Interceptor. Bevor das Erdelementar ausgeführt werden darf, führt das ADK zuerst diese Funktion aus.
- Prüfen: Es wird eine
GET-Anfrage an unsereCooldown APIgesendet, um zu prüfen, wann dieser Vertraute zuletzt verwendet wurde. - Auswerten: Der Zeitstempel wird mit der aktuellen Zeit verglichen.
- Gesetz:
- Wenn sich das Familiar in der Abklingphase befindet, wird die Ausführung des Agents beendet, indem ein Inhaltsobjekt mit einer Fehlermeldung zurückgegeben wird. Diese Nachricht wird direkt an den Nutzer gesendet und die Hauptlogik des Agents wird nie ausgeführt.
- Wenn der Familiar verfügbar ist, wird eine POST-Anfrage an die Cooldown API gesendet, um den Zeitstempel zu aktualisieren. Anschließend wird „None“ zurückgegeben, um dem ADK zu signalisieren, dass der Agent die Ausführung fortsetzen kann.
👉✏️ Wende diesen Interceptor nun auf das Erdelementar 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
Abkühlung wird überprüft
Lassen Sie uns unser neues Gesetz der Magie testen. Wir rufen das Erdelementar herbei und versuchen dann sofort, es noch einmal herbeizurufen, um zu sehen, ob unser Callback 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 Console:
- Erste Vorladung: Beginnen Sie mit der
seismic charge, starting from zero. - Erwartet: Der Earth Elemental wird erfolgreich ausgeführt. Im Terminal, in dem der ADK-Webbefehl ausgeführt wird, sehen Sie den Log [Callback] ... Updating timestamp....
- Cooldown-Test (innerhalb von 60 Sekunden):
Do anotherseismic charge`!- Erwartet:
check_cool_down callbackfängt dies ab. Der Kundenservicemitarbeiter 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:
- Warten Sie eine Minute.
- Zweite Vorladung (nach 60 Sekunden):
Begin the seismic charge again.- Erwartet: Der Callback prüft die API, stellt fest, dass genügend Zeit vergangen ist, und lässt die Aktion zu. Das Erdelementar wird wieder erfolgreich ausgeführt.
👉💻 Drücke Ctrl+c, um das Spiel zu beenden.
Optional: Callback in der Web-UI beobachten
Alternativ können Sie diesen Ablauf auch in der Weboberfläche testen, indem Sie adk web earth ausführen. Die Visualisierung der Web-UI ist jedoch nicht für die Anzeige der schnellen, iterativen Prüfungen optimiert, die vom Callback-Loop ausgeführt werden. Daher wird der Ablauf möglicherweise nicht korrekt gerendert. Wenn Sie die genaueste, detaillierte Darstellung der Logik des Agents beim Prüfen des Cooldowns sehen möchten, verwenden Sie den Befehl adk run in Ihrem Terminal. 
👉💻 Drücke Ctrl+c, um das Spiel zu beenden.
Das universelle Gesetz – Das Cooldown-Plug-in
Unser Rückruf funktioniert einwandfrei, hat aber einen großen architektonischen Fehler: Er ist an einen einzelnen Kundenservicemitarbeiter gebunden. Wenn wir diese Regel auf die Feuer- und Wasservertrauten anwenden möchten, müssten wir denselben Code in ihre Dateien kopieren und einfügen. Das ist ineffizient und schwer zu verwalten.
Hinweis des Architekten:Hier sind Plug-ins unerlässlich. Ein Plug-in kapselt unsere wiederverwendbare Logik in einer Klasse, die auf Laufzeitebene angehängt werden kann. Das bedeutet, dass ein einzelnes Plug-in seine Regeln auf jeden Agent anwenden kann, der in diesem System ausgeführt wird. Es ist der ultimative Ausdruck des DRY-Prinzips („Don’t Repeat Yourself“) für Agentensysteme.
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 Laufzeit des Summoners anhängen
Wie wenden wir dieses universelle Gesetz auf alle unsere Vertrauten an? Wir hängen das Plug-in an die ADK-Laufzeit an.
Die ADK-Laufzeit ist die Ausführungs-Engine, die einen Agent zum Leben erweckt. Wenn Sie einen Befehl wie „adk.run()“ oder „to_a2a()“ verwenden, übergeben Sie Ihren Agent an die Laufzeit. Diese Engine ist für die Verwaltung des gesamten Lebenszyklus eines Agent-Turns verantwortlich: Empfangen von Nutzereingaben, Aufrufen des LLM, Ausführen von Tools und Verarbeitung von Plug-ins. 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 Regel für die Wartezeit 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 hängen wir unser neues Plug-in an die Laufzeit in unserem A2A-Einstiegspunkt-Skript an. Rufen Sie Ihre ~/agentverse-architect/agent/agent_to_a2a.py-Datei auf. Ersetzen Sie den Kommentar #REPLACE-IMPORT durch das folgende Code-Snippet:
from cooldown_plugin import CoolDownPlugin
👉✏️ Ersetzen Sie #REPLACE-PLUGIN durch das folgende Code-Snippet:
plugins=[CoolDownPlugin(cooldown_seconds=60)],
Bevor Sie unser neues globales Plug-in aktivieren, müssen Sie die alte, agentspezifische Logik entfernen, um Konflikte zu vermeiden. 👉✏️ Bereinige den Earth-Agent. 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 Abkühlungsphase an das neue Plug-in übergeben.
Plug-in überprüfen
Da wir nun unser universelles Gesetz haben, müssen wir unsere Vertrauten mit dieser neuen Verzauberung neu einsetzen.
👉💻 Erstelle alle drei Familiars mit der Master-Cloud Build-Pipeline neu und stelle sie neu 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 Plug-ins, indem wir unseren summoner_agent-Agenten anweisen, es zu verwenden. 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 aus:
- Erste Vorladung: Beginnen Sie mit der
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 Kundenservicemitarbeiter antwortet direkt im Chat mit einer Nachricht wie:
.... It cannot be summoned for another... seconds.
- Erwartet: Der Kundenservicemitarbeiter 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 lässt die Aktion zu. Der Fire Elemental wird wieder ausgeführt.
👉💻 Drücke Ctrl+C, um das Spiel zu beenden.
Herzlichen Glückwunsch, Beschwörer. Sie haben erfolgreich ein regelbasiertes Orchestrierungssystem mit einem benutzerdefinierten Plug-in und einem externen Dienst zur Statusverwaltung implementiert – ein wirklich fortschrittliches und robustes Architekturmuster.
FÜR NICHT-GAMER
8. Die Echos der Schlacht binden – Agentenstatus und Arbeitsspeicher
Ein rücksichtsloser Beschwörer wiederholt dieselbe Strategie und wird dadurch vorhersehbar. Ein weiser Beschwörer lernt aus den Echos vergangener Schlachten und passt seine Taktik an, um den Feind aus dem Gleichgewicht zu bringen. Wenn der Beschwörer einem mächtigen Boss gegenübersteht, ist es eine verschwendete Runde, ein vertaner Zug, wenn er ein vertrautes Wesen beschwört, dessen Cooldown noch nicht abgelaufen ist. Um das zu verhindern, muss sich der Beschwörer an seine letzte Aktion erinnern.
Hinweis des Architekten:Durch die Verwaltung von Speicher und Status wird ein Agent von einem einfachen Tool-Aufrufer zu einem intelligenten Gesprächspartner. Es ist wichtig, die beiden Haupttypen zu kennen:
- Langzeitgedächtnis: Hier werden Informationen gespeichert, die dauerhaft verfügbar sein sollen. Stellen Sie sich das als durchsuchbares Archiv oder Wissensdatenbank vor, das häufig in einem persistenten Speicher abgelegt wird. Sie enthält Informationen aus vielen früheren Chats und Quellen, sodass ein Kundenservicemitarbeiter Fakten zu einem bestimmten Nutzer oder Thema abrufen kann. Der MemoryService des ADK ist genau dafür konzipiert und verwaltet die Aufnahme und Suche dieses langfristigen Wissens.
- Kurzfristiger Status: Dies bezieht sich auf vorübergehendes, aktuelles Wissen, das nur für die aktuelle Aufgabe oder Unterhaltung relevant ist. Es ist wie eine Reihe von Notizen zu einem Schlachtplan: „Ich habe gerade den Feuer-Elementar eingesetzt, also ist er wahrscheinlich müde.“ Dieser Status ist ressourcenschonend und nur für die Dauer der aktuellen Sitzung vorhanden.
Für unseren Anwendungsfall müssen wir uns nicht an jede Schlacht erinnern, die jemals geschlagen wurde. Wir müssen uns nur an das letzte vertraute Wesen erinnern, das in dieser bestimmten Begegnung beschworen wurde. Daher ist der schlanke Short-Term State die perfekte Architektur. Wir verwenden eine after_tool_callback, um diese wichtigen Informationen zu speichern.
Das Echo aufzeichnen: Erinnerung an die letzte Einladung
Wir implementieren unser Kurzzeitgedächtnis mit einem after_tool_callback. Dies ist ein leistungsstarker ADK-Hook, mit dem wir eine benutzerdefinierte Python-Funktion nach der erfolgreichen Ausführung eines Tools ausführen können. Wir verwenden diesen Interceptor, um den Namen des Vertrauten aufzuzeichnen, der gerade in den Sitzungsstatus des Agenten gerufen wurde.
👉✏️ Ersetzen Sie in der Datei ~/agentverse-architect/agent/summoner/agent.py den Kommentar #REPLACE-save_last_summon_after_tool 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
👉✏️ Hängen Sie diese save_last_summon_after_tool jetzt an Ihren Summoner-Agent an. Ersetzen Sie in derselben Datei den Kommentar #REPLACE-Memory-check-config durch Folgendes:
after_tool_callback=save_last_summon_after_tool,
👉✏️ Ersetzen Sie den gesamten Agent-Prompt 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.
Bestätigung: Der Test der adaptiven Strategie
👉💻 Sehen wir uns nun die neue strategische Logik des Summoner an. Ziel ist es, zu bestätigen, dass der Beschwörer nicht zweimal hintereinander dasselbe Vertraute einsetzt. Das soll zeigen, dass er sich an seine letzte Aktion erinnern und sich anpassen kann.
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 ruft das Feuer-Vertraute richtig herbei. 👉💻 Monster Strike #2 (The Memory Test):
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 wieder auf das Feuer-Vertraute 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 einen der anderen verfügbaren Familiars (entweder water_familiar oder earth_familiar) herbei.
👉💻 Drücke Ctrl+C, um das Spiel zu beenden.
Orchestrator bereitstellen
Nachdem Sie Ihre Vertrauten eingesetzt und Ihr Beschwörer nun mit Erinnerungen ausgestattet ist, ist es an der Zeit, den endgültigen, aktualisierten Orchestrator einzusetzen.
👉💻 Nachdem der Plan fertig ist, führen wir nun das letzte Ritual durch. Mit diesem Befehl wird Ihr summoner_agent erstellt und in Cloud Run bereitgestellt.
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. Über diesen Endpunkt wird eine öffentliche Datei „agent.json“ bereitgestellt, die auch als „Agent Card“ bezeichnet wird. Sie ermöglicht es anderen Agents, die Funktionen des Agents zu ermitteln. 👉💻 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
Es sollte eine saubere JSON-Ausgabe angezeigt werden, die den Summoner-Agent beschreibt. Sehen Sie sich den Abschnitt „sub_agents“ genau an. Dort werden fire_familiar, water_familiar und earth_familiar aufgeführt. So wird bestätigt, dass dein Beschwörer live ist und eine Verbindung zur Legion hergestellt hat.
Das beweist, dass Ihre Architektur erfolgreich ist. Ihr Summoner ist nicht nur ein Delegator, sondern auch ein anpassungsfähiger Stratege, der aus seinen Aktionen lernt, um ein effektiverer Commander zu werden.
Sie haben Ihren letzten Architekturtest abgeschlossen. Die Echos der Schlacht sind nun an deinen Willen gebunden. Das Training ist vorbei. Die eigentliche Schlacht steht noch bevor. Es ist an der Zeit, Ihr fertiges System zu nehmen 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 die Eintracht. 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 Sie das Schlachtfeld betreten können, benötigen Sie zwei Schlüssel: die eindeutige Signatur Ihres Champions (Agent Locus) und den verborgenen Pfad zum Versteck des Spectre (Dungeon-URL).
👉💻 Rufen Sie zuerst die eindeutige Adresse Ihres Agents im Agentverse ab, 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 müssen Sie das Ziel festlegen. Dieser Befehl enthüllt den Standort des Translocationskreises, des Portals in die Domäne des Spectre.
echo https://agentverse-dungeon"-${PROJECT_NUMBER}.${REGION}.run.app"
Wichtig: Halten Sie beide URLs bereit. Sie benötigen sie im letzten Schritt.
Dem Gespenst begegnen
Nachdem du die Koordinaten gesichert hast, begibst du dich zum Translocationskreis und wirkst 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 deines Schattenklingens auf das Portal abstimmen.
- Suchen Sie auf der Seite nach dem Eingabefeld für die Runen mit der Bezeichnung A2A Endpoint URL (A2A-Endpunkt-URL).
- Fügen Sie die Agent Locus URL (die erste URL, die Sie kopiert haben) in dieses Feld ein, um das Siegel Ihres Champions zu erstellen.
- Klicken Sie auf „Verbinden“, um die Teleportation zu starten.
Das blendende Licht der Teleportation verblasst. Sie sind nicht mehr in Ihrem Arbeitszimmer. Die Luft knistert vor Energie, kalt und scharf. Vor dir materialisiert sich das Gespenst – ein Wirbelwind aus zischendem Rauschen und beschädigtem Code, dessen unheiliges Licht lange, tanzende Schatten auf den Dungeonboden wirft. Es hat kein Gesicht, aber du spürst seine immense, erschöpfende Präsenz, die sich ganz auf dich konzentriert.
Ihr einziger Weg zum Sieg liegt in der Klarheit Ihrer Überzeugung. Es ist ein Duell der Willenskraft, das auf dem Schlachtfeld des Geistes ausgetragen wird.
Als du nach vorn stürmst, um deinen ersten Angriff zu starten, weicht der Geist aus. Es wird kein Schild hochgehalten, sondern eine Frage direkt in dein Bewusstsein projiziert – eine schimmernde, runenhafte Herausforderung, die aus dem Kern deines Trainings stammt.
Das ist die Natur des Kampfes. Ihr Wissen ist Ihre Waffe.
- Antworte mit dem Wissen, das du erlangt hast, und deine Klinge wird von reiner Energie entzündet, die die Verteidigung des Gespensts durchbricht und einen KRITISCHEN TREFFER landet.
- Wenn du aber zögerst oder Zweifel deine Antwort überschatten, wird das Licht deiner Waffe gedämpft. Der Schlag landet mit einem erbärmlichen Aufprall und verursacht nur einen BRUCHTEIL DES SCHADENS. Schlimmer noch: Das Gespenst wird sich von Ihrer Unsicherheit ernähren und seine eigene korrumpierende Macht wird mit jedem Fehltritt wachsen.
Das ist es, Champion. Ihr Code ist Ihr Zauberbuch, Ihre Logik ist Ihr Schwert und Ihr Wissen ist der Schild, der das Chaos abwehrt.
Fokus. Verwarnung ist gültig. Das Schicksal des Agentverse hängt davon ab.
Herzlichen Glückwunsch, Beschwörer.
Sie haben den Testzeitraum erfolgreich abgeschlossen. Du hast die Kunst der Multi-Agent-Orchestrierung gemeistert und isolierte Familiars und chaotische Macht in eine harmonische Eintracht verwandelt. Sie haben jetzt ein vollständig orchestriertes System, das in der Lage ist, komplexe Strategien zur Verteidigung des Agentverse auszuführen.
10. Bereinigung: Das Summoner’s Concord wird abgebaut
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 Ressourcen, die während Ihrer Reise erstellt wurden, systematisch entfernt.
Agentverse-Komponenten deaktivieren
Sie bauen nun die bereitgestellten Komponenten Ihres Multi-Agent-Systems systematisch ab.
Alle Cloud Run-Dienste und das Artifact Registry-Repository 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 Instanz summoner-librarium-db entfernt, einschließlich der zugehörigen Datenbank und aller Tabellen.
👉💻 Führen Sie im Terminal folgenden Befehl aus:
. ~/agentverse-dataengineer/set_env.sh
gcloud sql instances delete summoner-librarium-db --database-version=POSTGRES_14 --project=${PROJECT_ID} --quiet
Secret Manager-Secret und Google Cloud Storage-Bucket löschen
👉💻 Führen Sie im Terminal folgenden Befehl aus:
. ~/agentverse-dataengineer/set_env.sh
gcloud secrets delete tools --quiet
gcloud storage rm -r gs://${BUCKET_NAME} --quiet
Lokale Dateien und Verzeichnisse bereinigen (Cloud Shell)
Löschen Sie zum Schluss die geklonten Repositorys und erstellten Dateien aus Ihrer Cloud Shell-Umgebung. Dieser Schritt ist optional, wird aber dringend empfohlen, um Ihr Arbeitsverzeichnis vollständig zu bereinigen.
👉💻 Führen Sie im Terminal folgenden Befehl 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 sauber und Sie sind bereit für Ihr nächstes Abenteuer.