1. Einführung
Ein MVP lässt sich schnell erstellen, aber wenn Sie Funktionen hinzufügen, indem Sie immer mehr Prompts eingeben, kann das Projekt scheitern. Sie benötigen eine Möglichkeit, Struktur und realen Kontext in die KI-gestützte Entwicklung zu bringen. Hier kommt die Antigravity CLI ins Spiel – ein KI-Coding-Agent, der in Ihrem Terminal ausgeführt wird. Es kann Ihre Codebasis verstehen, Befehle ausführen und Dateien bearbeiten. Das eigentliche Potenzial des Geräts liegt in den angeschlossenen Geräten:
- Skills vermitteln dem Agenten Methodik und Fachwissen. Ein Methodik-Skill erzwingt strukturierte Entwicklungs-Workflows, während ein Domain-Skill genaues API-Wissen bereitstellt, damit der Agent keine Halluzinationen hat.
- MCP-Server ermöglichen dem Agenten Live-Verbindungen zu externen Systemen. So kann er echte Schemas prüfen, Abfragen ausführen und seine Arbeit anhand tatsächlicher Daten validieren, anstatt sich auf veraltetes Trainingswissen zu verlassen.
Skills bestimmen, wie der Agent denkt. MCP bestimmt, was der Agent sehen und womit er interagieren kann. Zusammen machen sie aus einem Agenten für allgemeine Zwecke, der Code schreibt, einen Agenten, der einem strukturierten Workflow folgt, der auf realen Daten basiert. In diesem Codelab wird diese Kombination von der Installation von Plug-ins bis zur Bereitstellung einer Funktion beschrieben.
Umfang
Die Muster in diesem Codelab – Skills für Methodik und Fachwissen installieren, MCP-Server für den Live-Datenzugriff verbinden und einen spezifikationsgesteuerten Entwicklungszyklus durchführen – gelten für alle Funktionen, die Sie mit der Antigravity CLI erstellen, unabhängig von Sprache, Framework oder Google Cloud-Produkten. Um diese Muster zu veranschaulichen, wird ein konkretes Beispiel durchgearbeitet: die BigQuery-Integration in ein E-Commerce-Analysedashboard.
Die Starter-App ist eine FastAPI-Web-App, die Verkaufsdaten aus statischen CSV-Dateien liest und Diagramme rendert (Umsatztrends, Top-Produkte, Aufschlüsselung des Bestellstatus, Kategorieleistung). Am Ende der Übung fragt die App Live-Daten aus BigQuery ab – dem serverlosen Data Warehouse von Google Cloud, mit dem Sie SQL-Abfragen für große Datasets ausführen können, ohne die Infrastruktur verwalten zu müssen. Sie stellen eine Verbindung zum Dataset thelook_ecommerce her und erhalten so Zugriff auf den vollständigen Katalog von Bestellungen, Produkten und Kunden, der in einer CSV-Datei mit 500 Zeilen nicht enthalten ist. Sie entwickeln dieses Feature vollständig über die Antigravity CLI, wobei Sie von Skills und MCP unterstützt werden.
Die Agentkonfiguration, die wir mit der Antigravity CLI verwenden, sieht so aus:
Lerninhalte
- Antigravity CLI in Cloud Shell verwenden – TUI starten, darin navigieren und Slash-Befehle ausführen
- Was sind Agent-Skills und wie sorgt das progressive Offenlegungsmuster (Metadaten → Anweisungen → Ressourcen) für einen effizienten Kontext?
- Drei Kategorien von Fähigkeiten: Methodik (Superkräfte), Effizienz (Höhlenmensch) und Fachwissen (Google/Fähigkeiten)
- Was MCP ist und wie Sie einen Remote-MCP-Server (BigQuery MCP) für die Antigravity CLI konfigurieren
- Spezifikationsgesteuerte Entwicklung durchführen: Spezifizieren → Planen → Implementieren
- (Optional) So funktionieren untergeordnete Agents in der Antigravity CLI und so werden sie verwaltet
google-cloud-bigquery-Python-Clientbibliothek in eine FastAPI-Anwendung einbinden- (Optional) App mit der Antigravity CLI mit einem Domain-Skill in Cloud Run bereitstellen
Voraussetzungen
- Ein Google Cloud-Konto
- Grundkenntnisse in Python, REST APIs und Terminalbefehlen
2. Umgebung einrichten
In diesem Schritt wird das Starter-Repository geklont, Ihr Google Cloud-Projekt konfiguriert und die erforderlichen APIs werden aktiviert.
Cloud Shell öffnen
Öffnen Sie Cloud Shell in Ihrem Browser. Cloud Shell bietet eine vorkonfigurierte Umgebung mit allen Tools, die Sie für dieses Codelab benötigen. Klicken Sie auf Autorisieren, wenn Sie dazu aufgefordert werden.
Klicken Sie dann auf Ansicht -> Terminal, um das Terminal zu öffnen.Die Benutzeroberfläche sollte so aussehen:
Das ist unsere Hauptschnittstelle: oben die IDE, unten das Terminal.
Arbeitsverzeichnis einrichten
Klonen Sie das zugehörige Repository, das den Startcode für dieses Codelab enthält:
git clone https://github.com/alphinside/sdd-agy-bigquery-dashboard.git
cloudshell workspace sdd-agy-bigquery-dashboard && cd sdd-agy-bigquery-dashboard
Dieses Repository enthält eine vollständige, funktionierende E-Commerce-Dashboard-App, die statische CSV-Dateien liest. In diesem Codelab verwenden Sie die Antigravity CLI, um die BigQuery-Integration als neues Feature hinzuzufügen.
Die wichtigsten Dateien und Verzeichnisse:
src/main.py– FastAPI-Anwendung mit API-Endpunkten, die Dashboard-Daten bereitstellensrc/data_service.py– Datenschicht, die Daten aus CSV-Dateien mit Pandas liestsrc/templates/dashboard.html– Jinja2-Vorlage mit Chart.js-Visualisierungendata/: statische CSV-Dateien (orders.csv,products.csv,order_items.csv) mit einer kleinen Teilmenge von E-Commerce-Daten
Die App ist ein einfaches schreibgeschütztes Dashboard: main.py definiert API-Endpunkte, data_service.py liest CSV-Dateien und gibt strukturierte Daten zurück und dashboard.html rendert diese Daten als Diagramme. Die von Ihnen erstellte BigQuery-Integration ersetzt data_service.py durch ein Modul, das Live-Daten abfragt, anstatt statische Dateien zu lesen.
Terminal konfigurieren
Google Cloud-Projekt erstellen ( optional)
Sie können ein neues Projekt über die Cloud Console-UI erstellen. Klicken Sie dazu oben links auf die Projektauswahl und dann auf New Project.
ODER: Wenn Sie eine schnellere Methode bevorzugen, führen Sie den folgenden Befehl im Terminal aus.
PROJECT_ID="sdd-agy-cli-$(openssl rand -hex 5)"
gcloud projects create "$PROJECT_ID"
echo $PROJECT_ID
Dadurch wird ein Google Cloud-Projekt mit einer zufälligen Projekt-ID erstellt. Der Befehl gibt die generierte Projekt-ID aus. Verwenden Sie sie später als YOUR_PROJECT_ID in der Konfiguration.
Terminal aktivieren
Als Nächstes müssen wir das Terminal mit dem ausgewählten Google Cloud-Projekt konfigurieren. Führen Sie den folgenden Befehl aus, um Ihre verfügbaren Projekte aufzulisten und die gewünschte Projekt-ID zu finden.
gcloud projects list
Es wird eine Liste wie diese angezeigt. Merken Sie sich die Projekt-ID, die Sie verwenden möchten, oder kopieren Sie sie.
PROJECT_ID: alvin-exploratory-2 NAME: alvin-exploratory-2 PROJECT_NUMBER: 109790610330
Führen Sie nun den folgenden Befehl aus, um ein Skript zum Aktivieren des Terminals zu erstellen ( oder erstellen Sie diese Datei einfach selbst):
cloudshell edit configure_terminal.sh
Kopieren Sie dann den folgenden Code in das Skript.
#!/bin/bash
gcloud config set project YOUR_PROJECT_ID
export GOOGLE_CLOUD_PROJECT=$(gcloud config get-value project)
echo $GOOGLE_CLOUD_PROJECT
Ersetzen Sie YOUR_PROJECT_ID durch Ihre Projekt-ID. Mit dem vorherigen Befehl wird die Projekt-ID auch als Umgebungsvariable für die Verwendung im gesamten Codelab exportiert. Speichern Sie die Datei und führen Sie sie aus.
bash configure_terminal.sh
Prüfen Sie, ob das Projekt richtig festgelegt ist. Sehen Sie dazu im Cloud Shell-Terminal-Prompt nach dem gelben Text neben Ihrem Arbeitsverzeichnis. Dort sollte Ihre Projekt-ID angezeigt werden.
Erforderliche APIs aktivieren
Als Nächstes interagieren wir mit BigQuery, was mit unserem Anwendungsfallszenario zusammenhängt. Aktivieren Sie die Google Cloud APIs, die für dieses Codelab erforderlich sind:
gcloud services enable bigquery.googleapis.com
Über diese API können wir auf BigQuery zugreifen. Bereiten wir nun unser ursprüngliches Dataset für dieses Codelab-Szenario vor.
3. BigQuery-Dataset einrichten
Das Szenario: Ihr Unternehmen hat bereits E-Commerce-Daten in BigQuery gespeichert, darunter Bestellungen, Produkte und Bestellpositionen. Sie entwickeln eine Anwendung, um das Dashboard mit den Bestelldaten anzuzeigen. Derzeit wird jedoch nur ein kleiner CSV-Auszug dieser Daten gelesen, damit Sie sich anfangs auf das Frontend konzentrieren können. Jetzt möchten Sie ein Upgrade durchführen, damit das vollständige Dataset direkt in BigQuery abgefragt wird.
Um dies zu simulieren, verwenden Sie TheLook E-commerce, ein von Google verwaltetes öffentliches Dataset mit realistischen synthetischen E-Commerce-Daten (über 125.000 Bestellungen, über 29.000 Produkte). Sie kopieren die relevanten Tabellen in die BigQuery-Instanz Ihres eigenen Projekts, damit sie als „Daten Ihres Unternehmens“ fungieren.
In Cloud Shell ist die bq-Befehlszeile bereits verfügbar. Wir können sie verwenden, um direkt mit BigQuery zu interagieren und unsere Daten vorzubereiten.
Erstellen Sie ein Dataset in Ihrem Projekt:
bq mk --dataset $GOOGLE_CLOUD_PROJECT:thelook_ecommerce
Kopieren Sie die drei Tabellen aus dem öffentlichen Dataset in Ihr neues Dataset:
bq cp bigquery-public-data:thelook_ecommerce.orders $GOOGLE_CLOUD_PROJECT:thelook_ecommerce.orders
bq cp bigquery-public-data:thelook_ecommerce.order_items $GOOGLE_CLOUD_PROJECT:thelook_ecommerce.order_items
bq cp bigquery-public-data:thelook_ecommerce.products $GOOGLE_CLOUD_PROJECT:thelook_ecommerce.products
Prüfen Sie, ob die Tabellen in Ihrem Dataset vorhanden sind:
bq ls $GOOGLE_CLOUD_PROJECT:thelook_ecommerce
Sie sollten drei Tabellen sehen: orders, order_items und products.
tableId Type Labels Time Partitioning Clustered Fields ------------- ------- -------- ------------------- ------------------ order_items TABLE orders TABLE products TABLE
Führen Sie eine kurze Testabfrage aus, um zu prüfen, ob auf die Daten zugegriffen werden kann:
bq query --nouse_legacy_sql \
"SELECT COUNT(*) as total_orders FROM \`$GOOGLE_CLOUD_PROJECT.thelook_ecommerce.orders\`"
+--------------+ | total_orders | +--------------+ | 125957 | +--------------+
Sie sollten mehr als 100.000 Bestellungen sehen.
4. Erste Webanwendung ausführen
Bevor wir die App aktualisieren, führen wir sie im aktuellen Zustand aus, um zu sehen, wie das CSV-basierte Dashboard aussieht.
uv ist ein schneller Python-Paket- und Projektmanager, der in Rust geschrieben wurde ( Dokumentation). In diesem Codelab wird sie aus Gründen der Geschwindigkeit und Einfachheit verwendet. Wenn Sie Cloud Shell für diese Anleitung verwenden, ist es bereits auf der Instanz vorinstalliert. In dieser Anleitung erfahren Sie, wie Sie die Erweiterung lokal installieren.
Installieren Sie die Projektabhängigkeiten. Dadurch wird auch die virtuelle Umgebung für Sie vorbereitet:
uv sync
Wenn Sie mit Python vertraut sind, führen wir danach anstelle eines python-Befehls jeden Befehl mit dem uv-Binärprogramm aus. Starten Sie den FastAPI-Entwicklungsserver:
uv run uvicorn src.main:app --host 0.0.0.0 --port 8080
Öffnen Sie das Dashboard in Ihrem Browser mit der Webvorschau von Cloud Shell. Klicken Sie in der Cloud Shell-Symbolleiste auf die Schaltfläche Webvorschau (das Augensymbol) und wählen Sie Vorschau auf Port 8080 aus.
Das Dashboard enthält vier Diagrammbereiche:
- Umsatztrend: Ein Liniendiagramm mit dem täglichen Umsatz im Datumsbereich der CSV-Daten
- Top-Produkte nach Umsatz: Ein horizontales Balkendiagramm, in dem Produkte nach Gesamtumsatz sortiert sind
- Aufschlüsselung des Bestellstatus: Ein Ringdiagramm mit der Verteilung der Bestellungen nach „Abgeschlossen“, „Versandt“, „In Bearbeitung“, „Storniert“ und „Zurückgegeben“
- Leistung nach Kategorie: Ein horizontales Balkendiagramm mit dem Umsatz nach Produktkategorie
Beachten Sie das Symbol Datenquelle: CSV in der Kopfzeile. Die Zusammenfassungskarten enthalten Gesamtsummen, die aus 500 Bestellungen und etwa 750 Bestellartikeln berechnet wurden. Das ist nur ein kleiner Teil des vollständigen TheLook-Datasets. Der Zeitraum ist auf Oktober bis Dezember 2023 begrenzt.
Das ist unsere Baseline-App. Jetzt werden wir sie mit der Antigravity-Befehlszeile in BigQuery einbinden.
5. Antigravity CLI einrichten
In diesem Schritt wird die Antigravity CLI vorgestellt, die Terminal-Benutzeroberfläche beschrieben und drei Kategorien von Plug-ins installiert, um den Entwicklungs-Workflow zu optimieren. Dabei erfahren Sie, was Agenten-Skills und MCP sind und wie sie die Funktionen eines KI-Coding-Agenten erweitern.
Was ist die Antigravity CLI?
Die Antigravity CLI ist eine Variante des KI-Programmier-Agents von Google: Antigravity für das Terminal. Es handelt sich um eine schlanke Terminal-Benutzeroberfläche (Terminal User Interface, TUI), die in Go entwickelt wurde und mit derselben Agent-Harness verbunden ist, die die Antigravity 2.0-Desktopanwendung unterstützt. Es liest Ihren Code, führt Befehle aus, bearbeitet Dateien und stellt über das Model-Context-Protocol (MCP) eine Verbindung zu externen Tools her – alles über das Terminal.
Wenn Sie Cloud Shell für diese Anleitung verwenden, ist die Antigravity CLI bereits vorinstalliert. Mit dem folgenden Befehl können Sie dies prüfen:
agy --help
Es werden die folgenden Befehlsoptionen angezeigt:
Usage of agy: --add-dir Add a directory to the workspace (repeatable) (default []) -c Short alias for --continue --continue Continue the most recent conversation --conversation Resume a previous conversation by ID --dangerously-skip-permissions Auto-approve all tool permission requests without prompting -i Short alias for --prompt-interactive --log-file Override CLI log file path --model Model for the current CLI session --new-project Create a new project for this session -p Short alias for --print --print Run a single prompt non-interactively and print the response --print-timeout Timeout for print mode wait (default 5m0s) --project Project ID for the current CLI session --prompt Alias for --print --prompt-interactive Run an initial prompt interactively and continue the session --sandbox Run in a sandbox with terminal restrictions enabled Available subcommands: changelog Show changelog and release notes help Show help for subcommands install Configure environment paths and shell settings models List available models plugin Manage plugins (install, uninstall, list, enable, disable) plugins Alias for plugin update Update CLI
Antigravity CLI starten
Wenn Sie die Antigravity CLI zum ersten Mal verwenden, müssen Sie sie einrichten. Starten Sie das Terminal in Ihrem neuen Tab.
agy
Wenn Sie das Tool zum ersten Mal ausführen, werden Sie aufgefordert, die Authentifizierungsmethode auszuwählen.
In dieser Anleitung verwenden wir Google OAuth. Sie werden aufgefordert, eine URL zu öffnen, über die Sie das Google-Konto auswählen können, das Sie für die Anmeldung verwenden möchten.
Klicken Sie nach der Authentifizierung auf das Google-Konto und dann auf Sign In.
Es wird ein String angezeigt, der kopiert werden muss. Klicken Sie auf Copy to Clipboard, um ihn zu kopieren.
Fügen Sie ihn dann in den Antigravity CLI-Prompt ein, wie unten dargestellt.
Danach werden Sie aufgefordert, ein Farbschema und eine Vereinbarung für die Nutzungsbedingungen auszuwählen.
Sie werden außerdem aufgefordert, dem aktuellen Arbeitsbereichverzeichnis zu vertrauen. Akzeptieren Sie dies, damit wir fortfahren können. Dies ist der Haupteintrag für unsere Interaktion mit der Antigravity CLI im Terminal.
Beenden Sie jetzt die Antigravity CLI und fahren Sie mit dem nächsten Abschnitt fort.
6. Anpassung – Agenten-Skills
Die Antigravity CLI kann Ihre Codebasis lesen, Shell-Befehle ausführen und Dateien bearbeiten. Sie verfügt über einen eingeschränkten integrierten spezifikationsgesteuerten Entwicklungs-Workflow und ihr Wissen über bestimmte APIs ist auf das beschränkt, was in ihren Trainingsdaten enthalten war. Bei einer Aufgabe wie der Integration von BigQuery in eine vorhandene App gibt es zwei Lücken:
- Prozesslücke: Ohne Struktur springt die Antigravity CLI möglicherweise direkt zum Schreiben von Code. Für kleine Korrekturen ist das in Ordnung. Bei einer Funktion, die mehrere Dateien und Endpunkte betrifft, kommt es zu inkonsistenten Implementierungen, fehlenden Grenzbedingungen und keiner Dokumentation der Entscheidungen oder der Gründe dafür.
- Wissenslücke: Die Trainingsdaten des Modells enthalten möglicherweise veraltete BigQuery-Clientbibliotheksmuster, eingestellte API-Aufrufe oder falsche Tabellenschemas. Es gibt keine Möglichkeit, den aktuellen Zustand des Datasets zu prüfen.
Skills schließen die Prozesslücke. Eine Entwicklungsmethoden-Skill wie superpowers erzwingt einen Zyklus aus Spezifizieren, Planen und Implementieren. Der Agent schreibt erst Code, wenn Sie eine Spezifikation genehmigen. Ein Domänen-Skill wie „bigquery-basics“ bietet aktuelle, von Google verwaltete API-Dokumentation, damit der Agent korrekte Clientbibliotheksmuster verwendet.
MCP-Server schließen die Wissenslücke zur Laufzeit. BigQuery MCP bietet dem Agenten eine Live-Verbindung zu Ihrem tatsächlichen Dataset. Er kann Tabellen auflisten, Spaltentypen prüfen und Beispielabfragen ausführen. Der Agent verwendet echte Schemadaten und keine Vermutungen.
Sehen wir uns diese beiden genauer an.
KI-Agenten-Skills
Agenten-Skills sind ein einfaches, offenes Format, mit dem sich die Funktionen von KI-Agenten mit spezialisiertem Wissen und spezialisierten Workflows erweitern lassen. Jede Skill ist ein portables, versionskontrolliertes Verzeichnis mit einer SKILL.md-Datei. Diese ist ein maschinenlesbarer Vertrag, der definiert, wie der Agent eine bestimmte Aufgabe ausführt.
Ein Skill-Verzeichnis sieht so aus:
skills/<skill-name>/ ├── SKILL.md # Required: YAML frontmatter + workflow instructions ├── scripts/ # Optional: helper scripts ├── references/ # Optional: reference implementations ├── assets/ # Optional: templates or assets └── ... # Any additional files or directories
Im Grunde ist ein Skill ein Ordner, der eine SKILL.md-Datei enthält. Diese Datei enthält Metadaten (mindestens Name und Beschreibung) und Anweisungen, die einem Agent mitteilen, wie eine bestimmte Aufgabe ausgeführt werden soll. Skills können auch Skripts, Referenzmaterialien, Vorlagen und andere Ressourcen enthalten.
Hier ist die SKILL.md für den bigquery-basics-Skill, den Sie später in diesem Codelab verwenden:
--- name: bigquery-basics metadata: category: BigDataAndAnalytics description: >- Manages datasets, tables, and jobs in BigQuery. Use when you need to interact with BigQuery, run SQL queries, manage BigQuery resources (datasets, tables, views), or perform basic data ingestion and analysis. --- # BigQuery Basics [Detailed instructions about BigQuery APIs, SQL patterns, client library usage, data ingestion patterns, etc.]
Die YAML-Frontmatter (Name + Beschreibung + Metadaten) wird beim Start von Antigravity CLI geladen – es handelt sich um einfache Metadaten. Der Markdown-Text unter --- enthält den vollständigen Befehlssatz, der nur geladen wird, wenn Antigravity eine BigQuery-bezogene Aufgabe erkennt.
Nach und nach weitere Funktionen freischalten
Skills verwenden ein dreischichtiges progressives Offenlegungsmuster, das eine Sättigung des Kontextfensters verhindert:
- Ebene 1 (Erkennung): Beim Start liest Antigravity nur die YAML-Metadaten für jeden installierten Skill. Es weiß, dass der Skill existiert, aber nicht mehr.
- Ebene 2 (Aktivierung): Wenn Ihre Aufgabe mit der Beschreibung eines Skills übereinstimmt, liest AGY die vollständige
SKILL.mdin den aktiven Kontext ein. Jetzt weiß sie, was zu tun ist. - Ebene 3 (Ausführung): Bei Bedarf greift Antigravity auf die Skripts, Beispiele oder Ressourcen des Skills zu. Jetzt weiß sie, wie das geht.
Nur relevantes Wissen wird zum richtigen Zeitpunkt geladen. Ein Skill für die Cloud Run-Bereitstellung verbraucht keinen Kontext, wenn Sie beispielsweise an einer BigQuery-Abfrage arbeiten.
Drei Kategorien von Skills
Es gibt viele verschiedene Arten von Agent-Skills. In diesem Codelab verwenden wir drei Skills, die jeweils eine andere Kategorie von Skills repräsentieren:
Kategorie | Kompetenzen | Purpose |
Domänenwissen | google/skills | Was der Agent über bestimmte Technologien weiß |
Methodik | obra/superpowers | Wie entwickeln – erzwingt die spezifikationsgetriebene Entwicklung, Planung und Tests |
Effizient | JuliusBrussee/caveman | Wie effizient Tokens verwendet werden |
google/skills bietet von Google verwaltete eigene Agent-Skills für Google-Produkte. So erhält der Agent beispielsweise genaues, aktuelles Wissen über BigQuery APIs, Cloud Run-Bereitstellungsmuster und andere Dienste. Ohne Domänen-Skills stützt sich der Agent auf Trainingsdaten, die möglicherweise veraltet oder unvollständig sind. Domänen-Skills ersetzen das Raten durch aktuelle Dokumentation.
obra/superpowers ist eine meinungsbasierte Implementierung eines SDD-Workflows (Spec-Driven Development). Ohne ein SDD-Framework springen Agents direkt zum Code, wenn Sie eine Funktion beschreiben. Das funktioniert bei kleinen Korrekturen, führt aber bei größeren Änderungen zu inkonsistenten, schwer zu wartenden Ergebnissen. SDD erzwingt einen strukturierten Zyklus: Anforderungen klären → Spezifikation schreiben → Plan erstellen → gemäß der Spezifikation implementieren. In jeder Phase wird ein überprüfbares Artefakt erstellt. Der Agent beginnt erst mit dem Programmieren, wenn Sie die Spezifikation genehmigen. Es gibt auch andere SDD-Frameworks wie spec-kit und agent-skills, die jeweils unterschiedliche Ansichten zum Specify-Plan-Implement-Zyklus vertreten. In diesem Codelab werden Superkräfte als konkretes Beispiel verwendet. Die zugrunde liegende Disziplin (Spezifizieren und Planen vor dem Programmieren) gilt unabhängig davon, welches Framework Sie auswählen.
JuliusBrussee/caveman komprimiert die Ausgabe von Agenten um bis zu 75%. Füllwörter, Höflichkeitsformen und ausführliche Erklärungen werden entfernt, während alle technischen Inhalte erhalten bleiben. Weniger Tokens pro Antwort bedeuten produktivere Interaktionen pro Sitzung und schnellere Antworten. Aktivieren Sie die Funktion mit /caveman oder weisen Sie den Agenten an, effizient zu kommunizieren. Bei Sicherheitswarnungen und irreversiblen Aktionen wird die Funktion automatisch deaktiviert.
Installation von Agent-Skills
Offizielle Google-Skill-Installation
Zuerst installieren wir die erforderlichen Google-Skills, mit denen wir interagieren werden. In dieser Anleitung werden wir uns hauptsächlich mit BigQuery und Cloud Run beschäftigen. Lass uns diese Skills installieren. Wir verwenden den Befehl npx skills, um das zu installieren.
npx skills add google/skills
Dadurch wird eine interaktive Terminal-Benutzeroberfläche geöffnet. Es gibt viele Skills. Verwenden Sie die Pfeiltasten und die Leertaste, um die für dieses Codelab erforderlichen Kenntnisse auszuwählen.
Suchen Sie nach bigquery-basics und cloud-run-basics und klicken Sie auf Bereich, um sie auszuwählen. Das Kästchen sollte dunkelgrau sein, wie unten dargestellt.
Klicken Sie dann bei der Auswahl der Agents einfach auf Enter, um die Auswahl zu überspringen, da Antigravity CLI standardmäßig bereits enthalten ist.
Wählen wir den Installationsbereich Projekt aus. Dadurch werden die Skills im Verzeichnis .agents in unserem Arbeitsverzeichnis installiert.
Klicken Sie zum Schluss auf Eingabe, um mit Ja zu antworten und die Installation abzuschließen. Optional können Sie auch mit Ja antworten, um den find-skills-Skill zu installieren, wenn Sie viele Skills konfiguriert haben.
Installation von Drittanbieter-Skills als Plug-ins
Als Nächstes installieren wir die Skills obra/superpowers und JuliusBrussee/caveman. Diese Skills können als Antigravity CLI-Plug‑ins installiert werden. Daher können wir sie mit diesen Befehlen installieren.
agy plugin install https://github.com/obra/superpowers
agy plugin install https://github.com/JuliusBrussee/caveman
Anschließend können wir die Installation mit dem folgenden Befehl überprüfen.
agy plugin list
Es wird die folgende Ausgabe angezeigt:
{
"imports": [
{
"name": "superpowers",
"source": "gemini-cli",
"importedAt": "2026-07-06T01:50:36Z",
"components": [
"skills",
"hooks"
]
},
{
"name": "caveman",
"source": "gemini-cli",
"importedAt": "2026-07-06T01:50:37Z",
"components": [
"skills",
"agents",
"commands"
]
}
]
}
Damit ist die Einrichtung der Skills abgeschlossen. Machen wir mit der nächsten Frage weiter.
7. Individuelle Anpassung – MCP-Tools
MCP (Model Context Protocol) ist ein offenes Protokoll, das die Art und Weise standardisiert, wie KI-Agenten externe Tools erkennen und mit ihnen interagieren. Es wird ein Client-Server-Modell definiert: Der Agent hostet einen MCP-Client und Tools werden von MCP-Servern bereitgestellt. Jeder MCP-kompatible Client kann jeden MCP-kompatiblen Server verwenden. Der Agent benötigt also keinen benutzerdefinierten Integrationscode für jedes Tool.
Das MCP basiert auf einer Client-Server-Architektur:
- Host: Die Anwendung, in der sich das KI-Modell befindet (in diesem Fall die Antigravity CLI)
- Client: Eine Komponente innerhalb des Hosts, die die MCP-Kommunikation übernimmt (in die Antigravity CLI integriert)
- Server: Ein einfaches Programm, das der KI Funktionen zur Verfügung stellt. In diesem Fall verwenden wir den von Google Cloud verwalteten BigQuery MCP-Server.
Wenn die Antigravity CLI den SDD-Workflow später in diesem Codelab ausführt, benötigt sie genaue Informationen zum BigQuery-Dataset-Schema, z. B. Tabellennamen, Spaltentypen und Beziehungen. Mit BigQuery MCP kann die Antigravity CLI das Live-Schema direkt prüfen. So werden Spezifikationen und Code erstellt, die auf tatsächliche Tabellen und Spalten verweisen, nicht auf imaginäre.
Konfiguration des verwalteten MCP für BigQuery
Google hostet einen verwalteten BigQuery-MCP-Server in der Google Cloud-Infrastruktur. Eine lokale Einrichtung ist nicht erforderlich. Andere Google Cloud-Produkte, die unterstützt werden, finden Sie in dieser Dokumentation. Konfigurieren Sie die Antigravity CLI so, dass sie eine Verbindung zum MCP-Server herstellt. Erstellen Sie dazu die MCP-Konfigurationsdatei in Ihrem Projektverzeichnis:
mkdir -p .agents
cat > .agents/mcp_config.json << EOF
{
"mcpServers": {
"bigquery": {
"serverUrl": "https://bigquery.googleapis.com/mcp",
"transport": "http",
"authProviderType": "google_credentials"
}
}
}
EOF
Diese Konfiguration legt für AGY Folgendes fest:
- BigQuery MCP-Server (
serverUrl) - Google-Anmeldedaten für die Authentifizierung verwenden (
authProviderType)
Die Konfiguration erfolgt auf Arbeitsbereichsebene (.agents/mcp_config.json).
Wir können die Konfiguration über die Antigravity CLI überprüfen. Führen wir sie zuerst aus.
agy
Prüfen Sie dann die Konfiguration mit dem Slash-Befehl /mcp.
/mcp
Es wird etwa Folgendes angezeigt:
Drücken Sie dann die Esc-Taste, um die Interaktion mit dem Slash-Befehl zu beenden.
Beenden Sie die Antigravity CLI (drücken Sie zweimal Ctrl+D).
8. Funktionsentwicklung mit spezifikationsbasierter Entwicklung
Nachdem Sie Skills/Plug-ins installiert und BigQuery MCP verbunden haben, können Sie den spezifikationsgesteuerten Entwicklungs-Workflow verwenden, um die BigQuery-Integrationsfunktion formal zu spezifizieren. In diesem Schritt wird das Prinzip Vor dem Programmieren spezifizieren konkret.
Geben Sie Antigravity CLI ein. Für diese Demo erlauben wir die Ausführung aller Tools mit diesem Flag.
agy --dangerously-skip-permissions
Höhlenmenschenmodus aktivieren
Aktivieren Sie vor dem Start des SDD-Zyklus den Caveman-Modus, um die Tokennutzung im gesamten mehrstufigen Workflow effizient zu halten:
/caveman:caveman
Die Antworten von Antigravity CLI werden knapper. Füllwörter und Höflichkeitsformeln werden weggelassen, während alle technischen Informationen erhalten bleiben. Weniger Tokens pro Austausch bedeuten produktivere Unterhaltungen innerhalb desselben Kontingents.
SDD-Spezifikation starten
Geben Sie den Feature Request in die Antigravity CLI ein:
I want to add a BigQuery integration feature to this e-commerce dashboard app. Currently it reads
from CSV files in the data/ directory. I want to replace the CSV reads with live queries
against the thelook_ecommerce dataset in my BigQuery project using the
google-cloud-bigquery Python client library.
The dashboard should show the same panels (revenue trend, top products, order status,
category performance) but with the full dataset instead of the 500-row CSV subset.
Follow spec-driven-development for development workflow, ensure spec and plan docs created following the superpowers standard in current working directory; also use Bigquery MCP to figure out the data schema.
Der Superpowers-Skill wird automatisch aktiviert, wenn eine Anfrage auf Funktionsebene erkannt wird. AGY durchläuft den SDD-Zyklus, anstatt direkt mit dem Programmieren zu beginnen.
Die Antigravity-CLI startet den Prozess, um das aktuelle Projekt zu analysieren und den erforderlichen Kontext zu erfassen. Es werden Befehle wie ListDir und Read ausgeführt, wie unten dargestellt.
Außerdem wird die BigQuery MCP-Verbindung verwendet, die wir zuvor eingerichtet haben, um das Schema des Datasets zu ermitteln.
So wird sichergestellt, dass die Antigravity CLI vor dem Beginn der Entwicklung den richtigen Kontext hat.
Klarstellung der Anforderungen
Antigravity CLI kann gezielte Fragen zum Funktionsumfang stellen. Typische Fragen sind:
- Wie muss die Projekt-ID konfiguriert werden?
- Wie sollte das Diagramm zum Umsatztrend aggregiert und dargestellt werden?
- Wie sollte die Integration erfolgen? Direktes SQL im Vergleich zu lokalem Pandas
Sie können diese Fragen gemäß der Empfehlung des Kundenservicemitarbeiters beantworten.
Spezifikation prüfen
Nach der Klärung wird ein formelles Spezifikationsdokument erstellt. Wenn die Anleitung korrekt befolgt wird, wird die obra/superpowers-Skill-Konvention eingehalten und das Spezifikationsdokument wird wie unten gezeigt im Verzeichnis docs/superpowers/specs erstellt.
Das Spezifikationsdokument sieht in etwa so aus:
# BigQuery Integration Design Specification ## Overview This document specifies ... ## Architecture The application currently reads ... ## Data Schema & Sources All tables reside in the BigQuery ... ...
Nachdem wir das geprüft haben, müssen wir die Spezifikationen bestätigen, damit es in die Planungsphase übergeht.
proceed with the specs
Planungsphase und Ausführung von untergeordneten Agents
Nachdem Sie die Spezifikation genehmigt haben, zerlegt die Antigravity CLI sie in einen Implementierungsplan, der in das Verzeichnis docs/superpowers/plans geschrieben wird.
In den Planunterlagen werden mehrere Dinge aufgeführt, wie im folgenden Beispiel:
- Zu ändernde Dateien
- Zu erstellende/aktualisierende Dateien
- Änderungen an Abhängigkeiten
- Aufschlüsselung der Aufgabe
Außerdem wird die Verwendung von subagent driven development empfohlen, das von der Antigravity CLI unterstützt wird. Anstatt dass ein einzelner Agent alles sequenziell erledigt, kann die Antigravity CLI Aufgaben an spezialisierte untergeordnete Agents delegieren. Während der Implementierung werden möglicherweise untergeordnete Agents wie die folgenden angezeigt:
- Task Implementer (Aufgabenimplementierer): schreibt den Code für eine bestimmte Aufgabe aus dem Plan
- Task Reviewer: prüft den implementierten Code anhand der Spezifikation
- Final Code Reviewer: Führt vor Abschluss eine ganzheitliche Überprüfung aller Änderungen durch.
Wenn Sie so aufgefordert werden, antworten Sie so:
Use subagent driven development
Später werden wir sehen, dass die Unter-Agents die Aufgaben einzeln übernehmen.
Nach einer Weile ist die Entwicklung abgeschlossen ( wahrscheinlich nach dem Erstellen von Final Code Reviewer Agent). Als Nächstes können wir das Ergebnis prüfen.
Aktualisierte manuelle App-Überprüfung
Sobald alle Aufgaben erledigt sind, können wir die aktualisierte App prüfen. Beenden Sie die Antigravity CLI, indem Sie zweimal Ctrl+D drücken, und führen Sie dann den folgenden Befehl aus:
bash configure_terminal.sh && uv run uvicorn src.main:app --host 0.0.0.0 --port 8080
Wenn die Entwicklung erfolgreich ist, sollten Sie jetzt Total Orders mit mehr als 120.000 Bestellungen sehen, die in BigQuery integriert sind.
Das wars! Sie haben das Lab erfolgreich abgeschlossen. Sie haben BigQuery jetzt erfolgreich in Ihre Webanwendung eingebunden und dabei die Antigravity-Befehlszeile verwendet.
9. (Optional) Mit der Antigravity CLI in Cloud Run bereitstellen
Das Dashboard funktioniert lokal über die Cloud Shell-Webvorschau. In diesem optionalen Schritt wird die Anwendung als öffentlich zugänglicher Webdienst in Cloud Run bereitgestellt. So wird gezeigt, wie sich die Domänenkenntnisse der Antigravity CLI von der Entwicklung auf den Betrieb erstrecken.
Der cloud-run-basics-Skill (aus dem google/skills-Plug-in, das Sie zuvor installiert haben) vermittelt der Antigravity CLI Wissen über Cloud Run-Bereitstellungsmuster, Dockerfile-Anforderungen, Portbindung und gcloud run deploy-Flags. Bei der quellcodebasierten Bereitstellung (gcloud run deploy --source .) werden Build und Bereitstellung in einem Befehl ausgeführt. Cloud Build übernimmt die Containerisierung automatisch.
Cloud Run APIs aktivieren
Aktivieren Sie die für die Bereitstellung erforderlichen APIs:
gcloud services enable \
run.googleapis.com \
cloudbuild.googleapis.com \
cloudresourcemanager.googleapis.com
Geben Sie dann „Antigravity CLI“ ein.
agy --dangerously-skip-permissions
Antigravity CLI zum Bereitstellen auffordern
Weisen wir es an, unsere Anwendungen bereitzustellen.
Deploy this application to Cloud Run, name the service "bigquery-dashboard" and make it publicly accessible
Es liest den cloud-run-basics-Skill, um die Anforderungen für die Bereitstellung der aktuellen Projekt-Webanwendung zu ermitteln.
Anschließend wird geprüft, ob die Bereitstellung erfolgreich war. Sie erhalten eine Zusammenfassung des zuvor ausgeführten Bereitstellungsprozesses, wie im Beispiel unten dargestellt. Sie können über die angegebene URL auf Ihre Anwendung zugreifen.
Ihre Live-Anwendung ist jetzt vollständig bereitgestellt und mit der Antigravity CLI zugänglich.
10. Zu guter Letzt
Sie haben ein E-Commerce-Dashboard von statischen CSV-Dateien auf Live-BigQuery-Daten umgestellt, ohne Anwendungscode manuell schreiben zu müssen. Die Antigravity CLI hat die Implementierung über einen disziplinierten, spezifikationsgesteuerten Entwicklungs-Workflow abgewickelt, der durch wiederverwendbare Skills und eine Live-Verbindung zu Ihren Daten über MCP unterstützt wurde.
Das haben Sie gelernt
- Antigravity CLI in Cloud Shell für KI-gestützte Entwicklung verwenden
- Was Agenten-Skills sind und wie die progressive Offenlegung das Kontextfenster effizient hält
- Drei Kategorien von Fähigkeiten: Methodik (Superkräfte), Effizienz (Höhlenmensch), Fachwissen (Google/Fähigkeiten)
- Was ist MCP und wie wird BigQuery MCP für den Live-Datenzugriff konfiguriert?
- So führen Sie einen spezifikationsgesteuerten Entwicklungszyklus (Spezifizieren → Planen → Implementieren) anstelle von Vibe Coding durch
- So kann die Antigravity CLI Sub-Agenten erstellen, um die Entwicklung fokussierter und effizienter zu gestalten
Aufräumen
Damit Ihrem Google Cloud-Konto die in diesem Codelab erstellten Ressourcen nicht in Rechnung gestellt werden, können Sie entweder die einzelnen Ressourcen oder das gesamte Projekt löschen.
Option 1: Projekt löschen (empfohlen)
Am einfachsten bereinigen Sie, indem Sie das Projekt löschen. Dadurch werden alle mit dem Projekt verknüpften Ressourcen entfernt.
gcloud projects delete $GOOGLE_CLOUD_PROJECT
Option 2: Einzelne Ressourcen löschen
Wenn Sie das Projekt behalten, aber nur die in diesem Codelab erstellten Ressourcen entfernen möchten:
bq rm -r -f $GOOGLE_CLOUD_PROJECT:thelook_ecommerce
gcloud run services delete bigquery-dashboard --region us-central1 --quiet