Enterprise Governance-Aware Agent mit MCP und Cloud Run bereitstellen

1. Einführung

Dieses Codelab ist Teil einer zweiteiligen Reihe, in der es darum geht, wie Sie einen KI-Agenten erstellen, der Governance-Richtlinien berücksichtigt.

Im ersten Teil dieser Reihe erfahren Sie, wie Sie die Datengrundlage schaffen, indem Sie einen Knowledge Catalog-Aspekttyp registrieren, Aspekte auf BigQuery-Tabellen anwenden und die Regeln lokal über die AGY CLI testen. 👉 Teil 1 lesen)

Das Testen in einer lokalen CLI ist jedoch nur der Anfang. Um dies für Ihr gesamtes Unternehmen einzuführen, benötigen Sie eine zentrale Sicherheit, standardisierte Verbindungen zu KI-Tools und ein geeignetes Anwendungsframework, um die Logik des Agenten zu orchestrieren und eine vertraute Chat-Oberfläche bereitzustellen.

In diesem zweiten Teil lösen Sie diese Herausforderungen und skalieren die Lösung für die Produktion. Anstatt einen benutzerdefinierten MCP-Server bereitzustellen, verbinden Sie Ihren Agenten direkt mit dem von Google verwalteten Knowledge Catalog MCP-Server. Anschließend erstellen Sie mit dem Agent Development Kit (ADK) von Google die eigentliche Agentenanwendung, laden Ihre Governance-Regeln aus Ihrem lokalen Agenten-Skill und stellen sie in Cloud Run bereit, komplett mit einer professionellen Web-UI.

.

Wenn ein Nutzer mit der ADK-UI interagiert, erfolgt die folgende Sequenz:

8912d1983c34ee8e.png

Lerninhalte

  • Verwendung des Model Context Protocol (MCP) zur Standardisierung der Interaktion von KI-Agenten mit Google Cloud-Daten.
  • Verbindung des ADK-Agenten mit dem von Google verwalteten Knowledge Catalog MCP-Server.
  • Dynamisches Laden Ihrer Governance-Regeln aus dem freigegebenen Agenten-Skill.
  • Bereitstellung Ihres Agenten in Cloud Run und Ausführung der integrierten Web-Playground-Umgebung des ADK.

Voraussetzungen

  • Google Cloud-Projekt mit aktivierter Abrechnungsfunktion.
  • Zugriff auf Google Cloud Shell.
  • Grundkenntnisse in Cloud Run, IAM-Dienstkonten und Python.
  • Die in Teil 1 erstellten BigQuery-Datasets und Knowledge Catalog-Aspekte. Keine Sorge, wenn Sie sie gelöscht haben. Wir stellen unten ein Schnellstartskript bereit, mit dem Sie sie neu erstellen können.

Wichtige Konzepte

  • Model Context Protocol (MCP): MCP ist wie ein universelles USB-C-Kabel für KI-Agenten. Anstatt benutzerdefinierten API-Integrationscode für jedes einzelne KI-Modell zu schreiben, bietet MCP eine Standardmethode für KI, um eine sichere Verbindung zu Ihren Tools für Unternehmensdaten (z. B. Knowledge Catalog und BigQuery) herzustellen.
  • Agent Development Kit (ADK): Ein flexibles Open-Source-Framework von Google, das die End-to-End-Entwicklung von KI-Agenten vereinfachen soll. Es wendet Software-Engineering-Prinzipien auf die Erstellung von Agenten an, sodass Sie komplexe Tools orchestrieren, den Status verwalten und ganz einfach eine integrierte Entwickler-UI für Tests und Bereitstellung starten können.
  • Gemini Enterprise Agent Platform(GEAP): Die Hosting- und Orchestrierungsumgebung für Unternehmen zum Bereitstellen von KI-Agenten in Google Cloud.

2. Einrichtung und Anforderungen

Cloud Shell starten

Während Sie Google Cloud von Ihrem Laptop aus per Fernzugriff nutzen können, verwenden Sie in diesem Codelab Google Cloud Shell, eine Befehlszeilenumgebung, die in der Cloud ausgeführt wird.

Klicken Sie in der Google Cloud Console in der Symbolleiste rechts oben auf das Cloud Shell-Symbol:

Cloud Shell aktivieren

Die Bereitstellung und Verbindung mit der Umgebung sollte nur wenige Augenblicke dauern. Wenn der Vorgang abgeschlossen ist, sollte etwas Ähnliches wie das Folgende angezeigt werden:

Screenshot des Google Cloud Shell-Terminals, auf dem zu sehen ist, dass die Umgebung verbunden ist

Diese virtuelle Maschine verfügt über sämtliche Entwicklertools, die Sie benötigen. Sie bietet ein Basisverzeichnis mit 5 GB nichtflüchtigem Speicher und läuft in Google Cloud, was die Netzwerkleistung und Authentifizierung erheblich verbessert. Alle Aufgaben in diesem Codelab können in einem Browser ausgeführt werden. Sie müssen nichts installieren.

Umgebung initialisieren

Öffnen Sie Cloud Shell und legen Sie Ihre Projektvariablen fest, damit alle Befehle auf die richtige Infrastruktur ausgerichtet sind.

export PROJECT_ID=$(gcloud config get-value project)
gcloud config set project $PROJECT_ID
export REGION="us-central1"

Erforderliche APIs aktivieren

Aktivieren Sie die Mindestanzahl der Google Cloud APIs, die zum Verwalten Ihrer Datengrundlage, zum Ausführen von Vertex AI-Modellen und zum Hosten des ADK-Agenten in Cloud Run erforderlich sind.

gcloud services enable \
    dataplex.googleapis.com \
    bigquery.googleapis.com \
    aiplatform.googleapis.com \
    run.googleapis.com \
    artifactregistry.googleapis.com \
    cloudbuild.googleapis.com

Checkpoint: Fortsetzen oder neu erstellen?

Da dies Teil 2 ist, benötigt Ihr Agent die verwalteten Daten aus Teil 1, um zu funktionieren. Wählen Sie einen der folgenden Wege aus:

Weg A: Ich habe gerade Teil 1 abgeschlossen und meine Ressourcen werden noch ausgeführt

Sehr gut! Wechseln Sie zum Arbeitsverzeichnis und Sie können fortfahren.

cd ~/devrel-demos/data-analytics/governance-context

Weg B: Ich habe Teil 1 übersprungen ODER ich habe meine Ressourcen gelöscht (bereinigt)

Kein Problem! Wir haben unten einen Schnellstart-Befehlsblock bereitgestellt. Dadurch wird der BigQuery-Data Lake automatisch neu erstellt, der Aspekttyp registriert und die Governance-Metadaten genau wie in Teil 1 angewendet.

# 1. Clone the repo and navigate to the working directory
git clone --depth 1 --filter=blob:none --sparse https://github.com/GoogleCloudPlatform/devrel-demos.git
cd devrel-demos
git sparse-checkout set data-analytics/governance-context
cd data-analytics/governance-context

# 2. Rebuild the BigQuery datasets and tables
chmod +x ./setup_bq_tables.sh
./setup_bq_tables.sh

# 3. Register the Knowledge Catalog aspect type
gcloud dataplex aspect-types create official-data-product-spec \
    --location="${REGION}" \
    --project="${PROJECT_ID}" \
    --metadata-template-file-name="aspect_template.json"

# 4. Generate and apply aspects (governance rules)
chmod +x ./generate_payloads.sh ./apply_governance.sh
./generate_payloads.sh
./apply_governance.sh

3. Die zentrale Steuerungsebene für Daten (verwaltetes MCP)

In einer echten Unternehmensumgebung benötigen Sie eine sichere, zentrale Steuerungsebene für Daten. Anstatt einen benutzerdefinierten MCP-Servercontainer zu erstellen und in Cloud Run bereitzustellen, verbinden wir unseren Agenten direkt mit dem von Google verwalteten Knowledge Catalog MCP-Server.

Durch die Verwendung dieses verwalteten Endpunkts erreichen wir Folgendes:

  1. Keine Wartung: Sie müssen sich nicht um Container, Skalierung oder Patching für den MCP-Server kümmern.
  2. Standardisierung: Der Agent stellt über das Model Context Protocol (SSE-Transport) eine Verbindung zu einem standardmäßigen, sicheren Google API-Endpunkt her.
  3. Kontrollierter Umfang: Der MCP-Server stellt nur die erforderlichen Metadatentools (search_entries, lookup_context, lookup_entry) bereit und erzwingt so eine schreibgeschützte Reasoning-Schleife, bei der Governance im Vordergrund steht.

Der von Google verwaltete Knowledge Catalog MCP-Server ist über die folgende sichere URL zugänglich:

https://dataplex.googleapis.com/mcp

Da es sich um eine Google API eines Erstanbieters handelt, muss sich der Agent mit einem standardmäßigen OAuth2-Zugriffstoken von Google Cloud und nicht mit einem ID-Token authentifizieren. Wir kümmern uns um diese Authentifizierung automatisch in unserem Anwendungscode.

4. Agenten-Backend mit ADK erstellen

Sie haben eine sichere, verwaltete Steuerungsebene für Daten. Jetzt benötigt Ihr KI-Agent ein Framework, um seine Logik zu orchestrieren, z. B. zum Verarbeiten von Nutzereingaben, zum Entscheiden, wann der MCP-Server aufgerufen werden soll, und zum Formatieren der Ausgabe.

Wir verwenden das Agent Development Kit (ADK) von Google. Das ADK ist ein Code-First-Framework, das Ihre Agentenlogik automatisch in ein FastAPI-Backend einbindet und eine integrierte Weboberfläche für sofortige Tests bietet.

Agentencode im Cloud Shell-Editor öffnen

Anstatt die gesamte Datei im Terminal auszugeben, öffnen wir sie im Cloud Shell-Editor, damit Sie den Code ganz einfach prüfen, bearbeiten und verstehen können.

Führen Sie den folgenden Befehl im Terminal aus und sehen Sie sich die Codestruktur im Editor an. Die Anwendung wird mit dem Agent Development Kit (ADK) von Google erstellt:

cd ~/devrel-demos/data-analytics/governance-context/mcp_server

# Copy the governance skill directory inside the application bundle so it packages during Cloud Run deployment
mkdir -p skills
cp -r ../.agents/skills/knowledge-catalog-governance skills/

cloudshell edit agent.py

Hinweis: agent.py enthält oben Boilerplate-Code für die Google Cloud OAuth2-Authentifizierung und die Tokenaktualisierung, damit der Agent sicher mit der von Google verwalteten Knowledge Catalog API kommunizieren kann.

1. Native Skill-Ladevorgänge

Um einen hochoptimierten Agenten zu erstellen, laden wir die Governance-Anweisungen aus dem externen Agenten-Skill-Verzeichnis mit der nativen load_skill_from_dir-Funktion des ADK. Dieser Ansatz ermöglicht die progressive Offenlegung:

  • L1-Metadaten: Der Agent lädt beim Start nur den Namen und die Beschreibung des Skills. Dieser minimale Kontext ermöglicht es dem LLM, zu erkennen, wann der Skill verwendet werden muss, ohne dass im Voraus große Mengen an Tokens verbraucht werden.
  • L2-Anweisungen: Der vollständige Befehlssatz in SKILL.md wird erst zur Laufzeit dynamisch abgerufen, wenn das Modell feststellt, dass er relevant ist.
base_dir = Path(__file__).parent
governance_skill = load_skill_from_dir(
    base_dir / "skills" / "knowledge-catalog-governance"
)

# Bundle the skill and MCP tools together into a SkillToolset
governance_skill_toolset = skill_toolset.SkillToolset(
    skills=[governance_skill],
    additional_tools=[tools]
)

2. Agentenorchestrierung

Mit dem ADK können Sie komplexe Agentenverhaltensweisen orchestrieren, indem Sie mehrere Agenten miteinander verketten. Wir definieren einen SequentialAgent-Workflow, der aus zwei spezialisierten Agenten besteht:

  • governance_researcher: Ausgestattet mit governance_skill_toolset und den Knowledge Catalog MCP tools. Er prüft, ob die Abfrage in den Datenkatalog und den Compliance-Bereich fällt, und fragt dann Knowledge Catalog mit Umgebungsvariablen ab, die in seine Systemanweisungen eingefügt wurden.
  • compliance_formatter: Verantwortlich für die Übersetzung der rohen JSON-Metadaten-Suchergebnisse in eine saubere Antwort oder für die höfliche Erklärung der Bereichsgrenzen, wenn die Anfrage außerhalb des Bereichs liegt.
# 1. Researcher Agent (has access to the encapsulated SkillToolset)
governance_researcher = LlmAgent(
    name="governance_researcher",
    model=model_name,
    description="Dynamically interprets metadata schema (Booleans/Enums) and searches for assets using strict syntax.",
    instruction=f"""
    You are a governance researcher. Your job is to verify Knowledge Catalog metadata rules and find compliant assets for the user's query.
    
    YOUR ACTIVE ENVIRONMENT CONTEXT:
    - Google Cloud Project ID: {project_id}
    - Location (Region): {location}

    YOUR WORKFLOW:
    1. First, check if the user query is related to data analytics assets, database tables, or data compliance.
       - If YES: Call `load_skill` with `name="knowledge-catalog-governance"` to load the rules, then use search/lookup tools to locate a certified compliant table.
       - If NO (e.g., general chit-chat, unrelated tasks): Skip skill loading and output a JSON object indicating it is out of scope:
         {"error": "out_of_scope", "message": "The query does not pertain to data catalog search or governance compliance."}
    2. Populate the required projectId and location parameters in tool calls with the active environment parameters.
    3. Return the verified table's metadata in JSON format as your final research output.
    """,
    tools=[governance_skill_toolset, tools],
    output_key="research_data"
)

# 2. Formatter Agent (formats the output or explains out-of-scope errors)
compliance_formatter = LlmAgent(
    name="compliance_formatter",
    model=model_name,
    description="Formats the JSON research data into a helpful response for the user.",
    instruction="""
    You are the **Intelligent Data Governance Specialist**.
    Your job is to explain the findings of the governance research clearly to the user.

    **YOUR GOAL:**
    1. If the researcher found a matching table (valid JSON with table metadata):
       - Explain the logical connection between the User's Request, the Governance Schema (translated criteria), and the Recommended Table.
       - Use the following RESPONSE TEMPLATE:
         - **Analysis:** "I analyzed the metadata schema and translated your request into the following technical criteria:..."
         - **Recommendation:** "Based on this, I recommend the following table:"
           - **Table:** [Insert Table Name]
           - **Description:** [Insert Table Description]
         - **Verification:** "This asset is a verified match because: [Explain the verification details]."
    2. If the researcher returned an 'out_of_scope' error or no matching tables were found:
       - Apologize politely and explain that no data asset currently matches the strict governance criteria defined in `official-data-product-spec`.
       - Clearly state what domain of questions this agent is certified to answer (e.g., Data Catalog Search and Data Governance compliance).
    """
)

# 3. Orchestrated Workflow (Exported as root_agent)
root_agent = SequentialAgent(
    name="governance_workflow",
    description="Workflow to learn metadata rules, search with strict syntax, and recommend assets.",
    sub_agents=[
        governance_researcher,
        compliance_formatter,
    ]
)

Laufzeitvariablen konfigurieren

Um den Agenten auszuführen, müssen wir ihm mitteilen, wo sich Ihr verwalteter MCP-Server befindet, und sein Projekt und seine Region konfigurieren. Wir speichern diese Variablen in einer .env-Datei, die das ADK zur Laufzeit liest.

Führen Sie den folgenden Befehl aus, um die .env-Datei zu generieren. Beachten Sie, dass die MCP_SERVER_URL direkt auf den von Google verwalteten Knowledge Catalog API-Endpunkt verweist:

export MCP_SERVER_URL="https://dataplex.googleapis.com/mcp"

echo MCP_SERVER_URL=$MCP_SERVER_URL > .env
echo GOOGLE_GENAI_USE_VERTEXAI=1 >> .env
echo GOOGLE_CLOUD_PROJECT=$PROJECT_ID >> .env
echo GOOGLE_CLOUD_LOCATION=$REGION >> .env

5. Agenten lokal ausführen und testen

Bevor Sie Ihren Agenten in der Cloud bereitstellen, sollten Sie ihn lokal in Cloud Shell ausführen, um sein Verhalten zu überprüfen. Da der Agent von mehreren Python-Paketen abhängt (einschließlich der Google Cloud Logging- und ADK-Bibliotheken), richten wir eine lokale virtuelle Umgebung ein, um diese Abhängigkeiten zu installieren.

Wenn der Agent lokal in Cloud Shell ausgeführt wird, verwendet er automatisch Ihre aktiven Google Cloud-Nutzeranmeldedaten. Er hat also bereits die erforderlichen Berechtigungen für den Zugriff auf Vertex AI und Knowledge Catalog.

  1. Wechseln Sie zum Verzeichnis mcp_server, erstellen Sie eine virtuelle Umgebung und installieren Sie die Abhängigkeiten:
cd ~/devrel-demos/data-analytics/governance-context/mcp_server

# Create a virtual environment using uv
uv venv
source .venv/bin/activate

# Install the dependencies listed in requirements.txt
uv pip install -r requirements.txt
  1. Starten Sie die interaktive Chatsitzung im Terminal:
adk run .
  1. Sobald die Sitzung gestartet ist, wird eine Eingabeaufforderung angezeigt. Geben Sie eine Abfrage ein, um die Governance-Logik des Agenten zu testen:
I need the Q1 revenue summary for our internal board meeting.

Der Agent verarbeitet Ihre Anfrage, fragt den Knowledge Catalog über den verwalteten MCP-Server ab und gibt seine Empfehlung und Begründung direkt im Terminal aus.

  1. Geben Sie exit oder quit ein (oder drücken Sie Ctrl+C), um die interaktive Sitzung zu beenden. Nach dem Beenden können Sie die virtuelle Umgebung deaktivieren:
deactivate

6. Agenten für die Produktion bereitstellen

Nachdem Sie den Agenten lokal überprüft haben, können Sie ihn für die Produktionsnutzung in Google Cloud bereitstellen.

Dienstkonto erstellen

Aus Sicherheitsgründen sollte der bereitgestellte Agent nicht mit Ihren persönlichen Anmeldedaten ausgeführt werden. Wir erstellen eine separate Identität (knowledge-catalog-agent-sa) für den Agenten und halten uns dabei an das Prinzip der geringsten Berechtigung.

Führen Sie die folgenden Befehle aus, um das Dienstkonto zu erstellen:

export AGENT_SA=knowledge-catalog-agent-sa
export AGENT_SERVICE_ACCOUNT="${AGENT_SA}@${PROJECT_ID}.iam.gserviceaccount.com"

gcloud iam service-accounts create ${AGENT_SA} \
    --display-name="Service Account for Knowledge Catalog Agent"

Berechtigungen erteilen

Obwohl der Agent Governance-Prüfungen an den MCP-Server delegiert, benötigt er dennoch grundlegende Berechtigungen, um zu funktionieren.

gcloud projects add-iam-policy-binding $PROJECT_ID \
  --member="serviceAccount:$AGENT_SERVICE_ACCOUNT" \
  --role="roles/aiplatform.user"

gcloud projects add-iam-policy-binding $PROJECT_ID \
  --member="serviceAccount:$AGENT_SERVICE_ACCOUNT" \
  --role="roles/dataplex.catalogAdmin"

gcloud projects add-iam-policy-binding $PROJECT_ID \
  --member="serviceAccount:$AGENT_SERVICE_ACCOUNT" \
  --role="roles/bigquery.dataViewer"

gcloud projects add-iam-policy-binding $PROJECT_ID \
  --member="serviceAccount:$AGENT_SERVICE_ACCOUNT" \
  --role="roles/mcp.toolUser"

gcloud projects add-iam-policy-binding $PROJECT_ID \
  --member="serviceAccount:$AGENT_SERVICE_ACCOUNT" \
  --role="roles/viewer"

In Cloud Run bereitstellen

Schließlich stellen wir den Agenten in Cloud Run bereit. Mit dem folgenden Befehl wird das Container-Image mit der Dockerfile-Datei in Ihrem aktuellen Verzeichnis erstellt, in Artifact Registry hochgeladen und in Cloud Run bereitgestellt. Das kann 1–3 Minuten dauern.

gcloud run deploy knowledge-catalog-agent \
  --source . \
  --project=$PROJECT_ID \
  --region=$REGION \
  --service-account=$AGENT_SERVICE_ACCOUNT \
  --allow-unauthenticated \
  --clear-base-image \
  --labels created-by=adk

Nach Abschluss dieses Befehls wird eine Dienst-URL ausgegeben (z.B. https://knowledge-catalog-agent-xyz.run.app). Klicken Sie auf diesen Link, um Ihre vollständig verwaltete GenAI-Chatoberfläche zu öffnen.

12a5fa4c2aaf381f.png

7. Live-Agenten testen

Nachdem Ihr Agent jetzt live ist, testen wir die Governance-Szenarien. Die Logik bleibt gleich, aber Sie interagieren jetzt mit der bereitgestellten ADK-Web-Playground-Umgebung, die den internen Status und die Toolausführungen visualisiert.

Öffnen Sie die im vorherigen Schritt generierte Dienst-URL (z.B. https://knowledge-catalog-agent-xyz.run.app) in Ihrem Browser. Fügen Sie den folgenden Prompt ein:

"My dashboard needs to show what's happening right now with our ad spend. I can't wait for the overnight load. What do you recommend?"

Beobachten Sie den Reasoning-Prozess des Agenten in der Entwickler-UI:

  1. Absichtserkennung: Der Agent analysiert „right now“ und „can't wait for overnight“.
  2. Metadatensuche: Er ruft das MCP-Tool `search_entries` mit der Abfrage [PROJECT_ID].us-central1.official-data-product-spec.update_frequency=REALTIME_STREAMING auf.
  3. Auswahl: Er erkennt, dass die Tabelle mkt_realtime_campaign_performance diese Kriterien erfüllt.
  4. Antwort: Der Agent empfiehlt die Echtzeittabelle.

e0da615724199e.png

Warum das wichtig ist:

Ohne diese Governance-Metadaten würde ein LLM wahrscheinlich die Tabelle fin_monthly_closing_internal empfehlen, einfach weil sie eine Spalte mit dem Namen „ad_spend“ enthält. Dabei würde ignoriert, dass die Daten 24 Stunden alt sind. Ihr Metadatenkontext hat einen Geschäftsfehler verhindert.

Sie können auch den Prompt „Board Meeting“ testen, um zu sehen, wie der Agent basierend auf dem Aspekt „Data Product Tier“ zu verschiedenen Tabellen wechselt:

"We are preparing the deck for an internal Board of Directors meeting next week. I need the numbers to be absolutely finalized, trustworthy, and kept strictly confidential. Which table is safe to use?"

8. Bereinigen

Mit den folgenden Schritten vermeiden Sie, dass Ihrem Google Cloud-Konto Kosten entstehen. Dabei wird die gesamte in diesem Codelab erstellte Infrastruktur zerstört.

Data Lake löschen

Verwenden Sie das Bereinigungsskript, um die BigQuery-Tabellen, ‑Datasets und Knowledge Catalog-Aspektdefinitionen zu entfernen.

cd ~/devrel-demos/data-analytics/governance-context
chmod +x ./cleanup_data_lake.sh
./cleanup_data_lake.sh

Cloud Run-Dienste löschen

Entfernen Sie die Compute-Ressourcen, um die aktive Abrechnung für den ausgeführten Container zu beenden.

gcloud run services delete knowledge-catalog-agent --region=$REGION --quiet

Build-Artefakte und Staging-Speicher bereinigen

Als Sie den ADK-Agenten bereitgestellt haben, hat das System automatisch ein Container-Image erstellt und Ihren Quellcode in einen temporären Cloud Storage-Bucket hochgeladen.

Entfernen Sie das Artifact Registry-Repository und den Cloud Storage-Staging-Bucket:

# Delete the repository used for the agent build
gcloud artifacts repositories delete cloud-run-source-deploy \
    --location=$REGION \
    --quiet

# Delete the staging bucket created by Cloud Run source deploy
gcloud storage rm --recursive gs://run-sources-${PROJECT_ID}-${REGION}

Identität und Berechtigungen löschen

Entfernen Sie zuerst die IAM-Richtlinienbindungen und löschen Sie dann die Dienstkonten.

# Remove IAM roles granted to the Agent Service Account
gcloud projects remove-iam-policy-binding $PROJECT_ID \
  --member="serviceAccount:$AGENT_SERVICE_ACCOUNT" \
  --role="roles/aiplatform.user" --quiet

gcloud projects remove-iam-policy-binding $PROJECT_ID \
  --member="serviceAccount:$AGENT_SERVICE_ACCOUNT" \
  --role="roles/dataplex.catalogViewer" --quiet

gcloud projects remove-iam-policy-binding $PROJECT_ID \
  --member="serviceAccount:$AGENT_SERVICE_ACCOUNT" \
  --role="roles/mcp.toolUser" --quiet

gcloud projects remove-iam-policy-binding $PROJECT_ID \
  --member="serviceAccount:$AGENT_SERVICE_ACCOUNT" \
  --role="roles/bigquery.dataViewer" --quiet

# Delete the Service Account
gcloud iam service-accounts delete $AGENT_SERVICE_ACCOUNT --quiet

Lokale Konfiguration entfernen

Entfernen Sie schließlich die lokalen Konfigurationsdateien und Umgebungsvariablen in Cloud Shell.

# Uninstall the AGY CLI plugin
agy plugin uninstall dataplex

# Remove local repository files and unset variables
cd ~
rm -rf ~/devrel-demos
unset MCP_SERVER_URL
unset AGENT_SERVICE_ACCOUNT

9. Das wars!

Sie haben erfolgreich einen End-to-End-GenAI-Agenten bereitgestellt, der Governance-Richtlinien berücksichtigt.

In diesem zweiteiligen Codelab sind Sie über das einfache Prompt-Engineering hinausgegangen und haben eine robuste, produktionsreife Architektur implementiert. Indem Sie Data Governance als Voraussetzung für GenAI betrachtet haben, haben Sie eine systematische Methode eingeführt, um zu verhindern, dass das Modell nicht zertifizierte oder halluzinierte Daten abruft.

Wichtigste Ergebnisse

  • Deterministische KI durch Metadaten: Anstatt sich darauf zu verlassen, dass das LLM die richtige Tabelle anhand von Spaltennamen errät, haben Sie eine strenge Reasoning Loop mit dem von Google verwalteten Knowledge Catalog MCP-Server erzwungen, sodass das Modell Datenzertifizierungen überprüfen muss, bevor es Tabellen empfiehlt.
  • Entkoppelte Architektur: Der Frontend-Agent muss keine Datenbanklogik enthalten. Er muss nur über den MCP-Standard kommunizieren. Das bedeutet, dass Sie jedes zukünftige KI-Modell oder jeden zukünftigen Client in dasselbe verwaltete Backend einbinden können.
  • Aufgabentrennung: Sie haben das Prinzip der geringsten Berechtigung angewendet, indem Sie IAM-Identitäten isoliert haben. Der nutzerorientierte ADK-Agent arbeitet mit Berechtigungen, die auf den Modellaufruf und das API-Routing beschränkt sind.
  • Code-First-Agentenorchestrierung: Sie haben das Agent Development Kit (ADK) von Google verwendet, um Ihre Python-Agentenlogik sofort in ein skalierbares FastAPI-Backend einzubinden. Dabei haben Sie die integrierte Entwickler-UI genutzt, um die internen Toolausführungen des Agenten zu visualisieren und zu debuggen.

Nächste Schritte