Google MCP-Server-Tutorial: Agentische KI auf GCP einsetzen

Große Sprachmodelle (LLMs) haben die Art und Weise, wie wir mit KI interagieren, total verändert, aber sie sind immer noch meistens auf Chat-Schnittstellen beschränkt. Wenn du eine KI bitten willst, deine neuesten Verkaufsdaten in BigQuery zu checken oder den Zustand von Clustern in GKE zu überprüfen, musst du normalerweise für jedes Tool, jedes Modell und jeden Workflow einen eigenen Code schreiben.

Hier kommen die verwalteten MCP-Server von Google ins Spiel: die Unternehmenslösung, die KI-Agenten mit der starken Google Cloud-Infrastruktur wie BigQuery, Google Maps, Compute Engine (GCE) und Kubernetes Engine (GKE) verbindet, ohne dass du eigene Konnektoren brauchst. 

Diese komplett verwalteten Remote-Server basieren auf dem offenen Model Context Protocol (MCP)-Standard von Anthropic und bieten sicheren, standardisierten Zugriff, sodass jeder MCP-kompatible Client (wie Gemini CLI oder Claude Desktop) KI in einen proaktiven Operator verwandeln kann.

In diesem Leitfaden zeige ich dir die praktische Architektur von MCP und Googles Serverportfolio und gehe die genauen Schritte durch, die zum Bereitstellen eines produktionsreifen MCP-Servers nötig sind. Egal, ob du KI in Unternehmensdaten einbinden oder DevOps-Aufgaben automatisieren willst – du bist in wenigen Minuten startklar.

Neu bei Google Cloud? Ich empfehle, mit dem kostenlosen Einführungskurs in GCP, der sich mit Abrechnung, Projekten und grundlegenden Diensten befasst.

Was ist das Model Context Protocol?

Das Model Context Protocol (MCP) ist ein Open-Source-Standard, den Anthropic im November 2024 eingeführt hat. Es ist wie eine universelle Schnittstelle – oft als „USB-C für KI” bezeichnet –, die regelt, wie KI-Modelle und -Agenten mit externen Datenquellen, Tools und Systemen verbunden werden.

Vor MCP musste man für die Integration eines KI-Agenten mit Tools wie Datenbanken, APIs oder Cloud-Diensten für jedes KI-Modell eigene Konnektoren entwickeln (z. B. separaten Code für Claude, Gemini oder GPT). Das hat zu einer Menge kleinerer Integrationen geführt. 

MCP löst das Problem, indem es ein einheitliches Protokoll festlegt: Entwickler können ein Tool oder eine Datenquelle einmalig als MCP-Server einrichten, und jeder MCP-kompatible KI-Client (wie Claude Desktop, Gemini CLI oder benutzerdefinierte Agenten) kann es einfach finden und nutzen.

Der Hauptvorteil ist, dass alles zusammenpasst und Doppelte Arbeit weniger werden. Schreib einen MCP-Server für BigQuery einmal schreiben, und er läuft auf allen unterstützten KI-Modellen ohne zusätzliche Adapter. Das beschleunigt die Entwicklung von agentenbasierten KI-Systemen, bei denen Agenten nicht nur auf Anfragen reagieren, sondern auch selbstständig denken, Daten abfragen und Aktionen in der realen Welt ausführen.

Der Client findet verfügbare Tools von verbundenen Servern, das LLM entscheidet, welches aufgerufen wird, und die Ergebnisse kommen zurück, um weiter verarbeitet zu werden – alles standardisiert über das JSON-RPC-basierte Protokoll von MCP.

Dieses „Universalübersetzer“-Design ist der Grund, warum Google (und andere) MCP so schnell angenommen haben: Ihre verwalteten Server fügen sich direkt in dieses Ökosystem ein, sodass alle MCP-Kunden sofort auf Google Cloud-Dienste zugreifen können.

Was ist ein Google MCP-Server?

Google MCP-Server sind Googles komplett verwaltete Remote-Implementierungen des Model Context Protocol (MCP). Diese Server für Unternehmen, die im Dezember 2025 auf den Markt kommen, bieten leistungsstarke Google Cloud-Dienste wie BigQuery, Google Maps, GCE und GKE als standardisierte, leicht auffindbare Tools, die jeder MCP-konforme KI-Client sofort nutzen kann.

Im Gegensatz zu Community- oder Open-Source-MCP-Servern, die man selbst hosten, warten, skalieren und mit eigenen Sicherheitsmaßnahmen ausstatten muss, laufen die verwalteten Server von Google auf der Infrastruktur von Google. Sie bieten:

• Kein Aufwand für die Bereitstellung: Aktiviere einfach den Dienst in deinem Projekt und leite deinen Kunden zum offiziellen Endpunkt weiter (z. B. https://bigquery.googleapis.com/mcp).
• Zuverlässigkeit im Unternehmen: Hohe Verfügbarkeit, automatische Skalierung und globale Endpunkte.
• Eingebaute Sicherheit: IAM-basierte Authentifizierung, Model Armor (Googles LLM-Firewall zum Schutz vor Prompt-Injection und Exfiltration), Audit-Protokollierung und Kontrollen nach dem Prinzip der geringsten Privilegien.
• Führung: Zentrale Aktivierung/Deaktivierung pro Projekt oder Organisation.

Diese Technologie ermöglicht agentenbasierte Arbeitsabläufe. Anstatt nur zu erklären, wie eine SQL-Abfrage funktioniert, kann die KI die Abfrage in BigQuery tatsächlich ausführen, die Ergebnisse analysieren und den nächsten Geschäftsschritt vorschlagen. 

Diese Agenten können zwar selbstständig arbeiten, aber Googles Version unterstützt auch „Human-in-the-Loop“-Konfigurationen, sodass ein Mensch wichtige Änderungen an der Infrastruktur checken und genehmigen kann, bevor sie passieren.

Googles Angebot an MCP-Servern

Google bietet immer mehr komplett verwaltete MCP-Server an, die wichtige Cloud-Dienste sofort als Tools für KI-Agenten verfügbar machen. Diese Server sind nach Funktionen sortiert, sodass die Mitarbeiter alles von der Datenanalyse bis zum Infrastrukturmanagement ohne eigenen Code erledigen können.

Das Ökosystem teilt die Server in zwei Hauptkategorien ein:

• Datenintelligenz: Konzentriert auf das Abfragen, Analysieren und Verankern in realen Daten.
• Infrastrukturbetrieb: Kontrolle und Überwachung von Rechenressourcen möglich machen.

Datenintelligenzserver

Die BigQuery- und Maps-MCP-Server bieten coole Möglichkeiten, Daten in deinen Arbeitsablauf einzubinden.

BigQuery

Mit dem BigQuery MCP-Server können Agenten:

• Führ SQL-Abfragen direkt auf Datensätzen aus
• Liste der verfügbaren Datensätze und Tabellen
• Schema-Metadaten und Beispieldaten abrufen
• Mach analytische Jobs, einschließlich ML-Inferenz über BigQuery ML.

Damit können Agenten komplexe Datenanalysen durchführen, Berichte erstellen oder Trends selbstständig prognostizieren.

Google Maps

Der Google Maps MCP-Server läuft mit Grounding Lite und der Places API und bietet folgende Funktionen:

• Geokodierung und umgekehrte Geokodierung
• Ortsuche und Details abrufen
• Routenberechnung und Wegbeschreibung
• Entfernungsmatrixberechnungen

Anwendungsfall: Echtzeit-Business-Intelligence und Logistikoptimierung. Ein Agent kann Verkaufsdaten in BigQuery abfragen, sie mit Maps abgleichen, um geografische Einblicke zu bekommen, und dann Optimierungen für Lieferrouten vorschlagen – alles in einem einzigen Denkprozess.

Infrastruktur-Betriebsserver

Was die Infrastruktur angeht, kannst du das Kubernetes Engine (GKE) und Compute Engine (GCE) MCP-Server nutzen.

Google Kubernetes Engine

Der GKE MCP-Server bietet Funktionen wie:

• Cluster, Knoten und Pods auflisten
• Überprüfen, ob der Cluster okay ist und wie die Ressourcen genutzt werden
• Protokolle und Ereignisse lesen
• Skalierung von Bereitstellungen (mit den richtigen IAM-Berechtigungen)

Google Compute Engine

Der GCE MCP-Server macht Folgendes möglich:

• VM-Instanzen auflisten, starten, stoppen und neu starten
• Listen von Festplatten oder Maschinentypen
• Abfrage von Instanzmetadaten und Status

Anwendungsfall: Automatisierte Fehlerbehebung und „ChatOps“ für DevOps-Teams. Ein Agent kann einen Pod-Absturz über GKE-Tools erkennen, mit VM-Metriken aus GCE abgleichen und Maßnahmen zur Behebung starten – und so die durchschnittliche Zeit bis zur Lösung von Stunden auf Minuten verkürzen.

Google baut dieses Angebot weiter aus (mit Diensten wie Cloud Storage und AlloyDB, die Anfang 2026 in der Vorschau verfügbar sein werden) und macht damit mehr von Google Cloud nativ für Agenten zugänglich.

Google MCP Server-Kernarchitektur

Die Stärke von MCP liegt in seinen flexiblen und trotzdem standardisierten Kommunikationsschichten, die nahtlose Verbindungen ermöglichen, egal ob du lokal Prototypen entwickelst oder produktionsreife Agenten in großem Maßstab einsetzt. Die verwalteten MCP-Server von Google nutzen hauptsächlich Remote Streamable HTTP für Unternehmensbereitstellungen, während die lokale Entwicklung auf stdio setzt. 

Lokale Kommunikation über stdio

Der Standard-Eingabe-/Ausgabe-Transport ( stdio ) ist die einfachste Art, einen MCP-Server zu betreiben. Hier startet der MCP-Client (z. B. Claude Desktop oder ein benutzerdefinierter Agent) den Server als Unterprozess auf demselben Rechner und kommuniziert über direkte Pipes, ohne dass ein Netzwerk involviert ist.

Vorteile:

• Super einfache Einrichtung für Entwicklung und Tests
• Eingebaute Sicherheit (keine offenen Ports oder Angriffsfläche im Netzwerk)
• Geringe Latenz

Nachteile:

• Kann nicht zwischen Rechnern oder Teams geteilt werden
• Eingeschränkte Skalierbarkeit (abhängig vom Host des Kunden)
• Keine eingebaute Parallelität für mehrere Sitzungen

Dieser Modus ist super, um mit benutzerdefinierten MCP-Servern rumzuexperimentieren oder Verbindungen zu testen, bevor du dich remote einloggst.

Fernkommunikation über streambares HTTP

Für die Produktion und den Einsatz in Unternehmen nutzen die verwalteten Server von Google (und selbst gehostete benutzerdefinierte Server) streambares HTTP über einen einzigen, dauerhaften Endpunkt. Das ersetzt den alten Server-Sent Events (SSE)-Ansatz durch ein stabileres Design, das Folgendes unterstützt:

• HTTP-POST-Anfragen für alle Interaktionen
• Optionales bidirektionales Streaming für große oder inkrementelle Antworten (z. B. Streaming von BigQuery-Ergebnissen)
• Sitzungs-IDs für zustandsbehaftete Konversationen
• Parallele Verbindungen für mehrere parallele Anrufe

Die verwalteten Endpunkte von Google folgen einem einheitlichen Muster, z. B.:

• BigQuery: https://bigquery.googleapis.com/mcp
• Maps: https://mapstools.googleapis.com/mcp
• Compute: https://compute.googleapis.com/mcp

Der ganze Datenverkehr wird mit Google-ID-Tokens (OAuth2) gesichert, damit Anrufe über IAM authentifiziert und autorisiert werden.

So könnte ein Sequenzfluss aussehen:

1. Der Client schickt die Tool-Erkennung/Anfrage per POST an /mcp.

2. Der Server checkt die Identität und leitet zum Backend-Dienst weiter.

3. Das Backend führt Sachen aus (z. B. SQL in BigQuery).

4. Die Antwort kommt in Blöcken (JSON-RPC-Format) zurück, damit man große Datenmengen gut verarbeiten kann.

Erste Schritte mit Google MCP Server

Einer der größten Vorteile der MCP-Server von Google ist, dass sie im Vergleich zu selbst gehosteten Alternativen kaum Einrichtung brauchen. Wir werden im Laufe der Schritte klar zwischen verwalteten und benutzerdefinierten Servern unterscheiden.

• Verwaltete Google MCP-Server: Die sind für Dienste wie BigQuery, Maps, GCE und GKE und werden komplett von Google gehostet. Du musst nichts bereitstellen – schalte einfach die Endpunkte in deinem Projekt frei, erteile IAM-Berechtigungen und konfiguriere deinen Client. Die sind sofort einsatzbereit.
• Benutzerdefinierte MCP-Server: Für interne Tools, APIs von Drittanbietern oder erweiterte Erweiterungen kannst du deinen eigenen Server erstellen und bereitstellen (z. B. mit der MCP Toolbox von Google). Die werden normalerweise in Cloud Run eingesetzt, damit sie skalierbar sind.

Einrichten der GoogleCloud-Umgebung für verwaltete Server

Mach diese Schritte (basierend auf dem offiziellen Tutorial), um verwaltete MCP-Server zu aktivieren und vorzubereiten.

Was du brauchen solltest

• Ein Google Cloud-Projekt mit aktivierter Abrechnung

• Zugang zur Google Cloud Console und Cloud Shell (oder lokale CLI- gcloud )

• Dein Benutzerkonto wird über gcloud auth login

Projekt einrichten und API aktivieren

1. Mach ein Projekt in der Google Cloud Console oder such eins aus.
2. Aktiviere die Abrechnung, falls das noch nicht gemacht wurde.
3. Aktiviere die Core-Service-APIs (in Cloud Shell oder im lokalen Terminal):

gcloud auth list  # Verify you're logged in
gcloud config list project  # Check current project
gcloud config set project YOUR_PROJECT_ID  # If needed

gcloud services enable bigquery.googleapis.com \
  compute.googleapis.com \
  container.googleapis.com \
  mapstools.googleapis.com

Beachte, dass der Maps MCP einen eigenen API-Schlüssel für die Abrechnung und das Kontingent braucht. Mach das mit dem folgenden Befehl:

gcloud alpha services api-keys create --display-name="Maps-MCP-Key"

Kopiere die angezeigte ID „ keyString“ – du brauchst sie für die Client-Konfiguration.

Verwaltete MCP-Server aktivieren (Beta)

MCP-Dienste brauchen eine explizite Beta-Aktivierung:

export PROJECT_ID=$(gcloud config get-value project)
export USER_EMAIL=$(gcloud config get-value account)

gcloud beta services mcp enable bigquery.googleapis.com --project=$PROJECT_ID
gcloud beta services mcp enable mapstools.googleapis.com --project=$PROJECT_ID
gcloud beta services mcp enable compute.googleapis.com --project=$PROJECT_ID
gcloud beta services mcp enable container.googleapis.com --project=$PROJECT_ID

IAM-Konfiguration

Gib dem MCP-Tool eine Benutzerrolle für dein Konto:

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

Füge dienstspezifische Rollen für den Zugriff mit geringsten Rechten hinzu, z. B.:

• BigQuery: roles/bigquery.jobUser und roles/bigquery.dataViewer

• Compute/GKE: roles/compute.viewer oder roles/container.viewer

Die verwalteten Server sind jetzt einsatzbereit! Endpunkte:

• BigQuery: https://bigquery.googleapis.com/mcp
• Maps: https://mapstools.googleapis.com/mcp
• Compute (GCE & GKE): https://compute.googleapis.com/mcp

Bereitstellung benutzerdefinierter Remote-MCP-Server in Cloud Run

Für benutzerdefinierte Tools, die über das verwaltete Portfolio von Google hinausgehen, kannst du deinen eigenen MCP-Server mit Bibliotheken wie FastMCP (Python) erstellen und ihn für Skalierbarkeit und Teamfreigabe in Cloud Run bereitstellen. Wir werden hier nicht zu sehr ins Detail gehen, sondern nur einen groben Überblick über den Prozess geben.

Allgemeine Schritte:

1. Mach ein Python-Projekt und füge FastMCP als Abhängigkeit hinzu (mit Tools wie uv).

2. Implementiere deinen Servercode (z. B. server.py), der benutzerdefinierte Tools definiert, mithilfe von transport="streamable-http".

3. Schreib ein einfaches Dockerfile (basierend auf python:slim), um Abhängigkeiten zu installieren und den Server auf $PORT laufen zu lassen.

4. Aktiviere die benötigten APIs (Cloud Run, Artifact Registry, Cloud Build).

5. Direkt von der Quelle aus bereitstellen oder einen Container erstellen/pushen.

6. Mach den Service sicher: IAM-Authentifizierung (--no-allow-unauthenticated) brauchen, autorisierten Prinzipalen roles/run.invoker geben und Identitäts-Tokens für Client-Verbindungen nutzen.

gcloud run deploy your-mcp-server \
  --source . \
  --region=us-central1 \
  --no-allow-unauthenticated

Bei einfachen Servern dauert das Ganze weniger als 10 Minuten und du kriegst Hosting auf Produktionsniveau mit automatischer Skalierung.

Google MCP Server Client-Konfiguration und Integration

Ein installierter (oder aktivierter) MCP-Server wird richtig stark, wenn er mit einem KI-Client verbunden ist. Hier geht's darum, wie man gängige Clients so einrichtet, dass sie die verwalteten MCP-Server von Google nutzen, und wie man programmatische Agenten erstellt.

Testen mit MCP Inspector

Der MCP Inspector hat eine übersichtliche Web-Oberfläche, mit der du jeden MCP-Server checken kannst, auch die von Google verwalteten. Das ist besonders praktisch, um Probleme bei der Authentifizierung zu lösen, die genauen Namen/Parameter von Tools herauszufinden und echte Antworten zu sehen.

Der Ablauf sieht so aus:

1. Starte den Inspektor
2. Verbinde dich mit einem von Google verwalteten MCP-Server
3. Tools entdecken und ausprobieren

Um den Inspector zu starten, gib diesen Befehl in deinem Terminal ein:

npx @modelcontextprotocol/inspector

Damit startest du einen lokalen Webserver und öffnest die Inspector-Benutzeroberfläche in deinem Standardbrowser. 

Als Nächstes verbinden wir uns mit einem Google MCP-Server. Fangen wir mit Google Maps als Beispiel an. 

In der Inspector-Benutzeroberfläche auf der linken Seite richten wir den MCP Inspector so ein, dass er sich mit unserem Google Maps MCP Server verbindet. Mach einfach mit und gib die genauen Anweisungen und Werte ein:

1. Transportart: Wähle „Streamable HTTP“ aus.

2. URL: Enter https://mapstools.googleapis.com/mcp

3. Verbindungstyp: Wähle „Über Proxy“ (damit wird die Google-Authentifizierung sicher über deine Anmeldedaten für gcloud gemacht).

4. Benutzerdefinierte Kopfzeilen: Einen Header hinzufügen

   • Schlüssel: X-Goog-Api-Key

   • Wert: Dein Maps-API-Schlüssel (der „ keyString ” aus der vorherigen Einrichtung).

5. Klick auf „Verbinden“.

Wenn alles gut läuft, solltest du sehen, dass der MCP Inspector erfolgreich mit dem Server verbunden ist. Im rechten Bereich kannst du die vom Google Maps MCP Server unterstützten Tools aufrufen, indem du auf„ -Listen-Tools“ klickst.

Lass uns die Tools erkunden und ausprobieren:

• Wähle ein beliebiges Tool aus, um sein vollständiges JSON-Schema anzuzeigen: Beschreibung, Parameter (mit Typen und erforderlichen Feldern) und Beispiele. 
• Gib die Parameter ein (z. B. Suchanfrage: „bester Kaffee in Pune, Maharashtra“) und klick auf „Aufrufen“.
• Echte Ergebnisse werden sofort angezeigt und bei umfangreichen Antworten in Teilen gestreamt.

Bei BigQuery- und Compute-Servern ist der Vorgang derselbe, aber einfacher, weil man keinen API-Schlüssel-Header braucht. Die Authentifizierung läuft automatisch über den Proxy.

Gemini CLI einrichten

Gemini CLI ist Googles offizieller Open-Source-Terminalagent mit tiefer, nativer Integration für MCP-Server. Das ist der einfachste Weg, um mit dem Aufbau von agentenbasierten Workflows zu starten. 

Einrichten der Gemini-CLI

Installiere die Gemini-CLI mit dem folgenden Befehl:

npm install -g @google/gemini-cli@latest

Server hinzufügen und die Verbindung testen

Wir nehmen wieder Maps als Beispiel. Um den Google Maps MCP Server hinzuzufügen, benutze den folgenden Befehl und denk dran, YOUR_MAPS_API_KEY durch deinen zuvor erstellten Maps API-Schlüssel zu ersetzen.

gemini mcp add -s user -t http -H 'X-Goog-Api-Key: YOUR_MAPS_API_KEY' maps-grounding-lite-mcp https://mapstools.googleapis.com/mcp

Überprüfe in einer neuen Gemini-Sitzung die Verbindung mit dem Befehl „ /mcp list “.

Bei unserem ersten Kontakt stellen wir eine einfache Frage in natürlicher Sprache: 

Wo kann man in New York günstig frühstücken?

Gemini wählt automatisch die Karten-Tools aus. Sobald du die Ausführung akzeptierst, werden sie aufgerufen und formatierte Ergebnisse zurückgegeben.

Es hat geklappt! Wir haben folgende Antwort bekommen:

Here are some economical breakfast places in New York:
Good Morning Breakfast is a breakfast restaurant located at 1216 Broadway, New York, NY 10001. It is open from 6:00 AM to 12:00 PM on weekdays and 6:30 AM to 12:30 PM on Saturdays. They serve breakfast and lunch and have vegetarian options. The price range is $1-$10.
Andrews NYC Diner is a diner located at 463 7th Ave, New York, NY 10018. They are open from 6:00 AM to 10:00 PM on weekdays, 6:00 AM to 11:00 PM on Fridays and Saturdays, and 7:00 AM to 11:00 PM on Sundays.
They serve breakfast, lunch, and dinner, and have outdoor seating and a children's menu.
The price range is $10-$20.
George's is an American restaurant located at 89 Greenwich St, New York, NY 10006. They are open from 7:00 AM to 6:00 PM daily. They serve breakfast, lunch, and dinner, and have outdoor seating and a children's menu. The price range is $10-$20.
New York Luncheonette is an American restaurant located at 135 E 50th St, New York, NY 10022. They are open from 7:00 AM to 10:00 PM daily. They serve breakfast, lunch, and dinner, and have a children's menu.
The price range is $10-$20.

Der klassische „Hello World“-Moment in Gemini CLI: übersichtliche Tool-Auflistung nach dem Hinzufügen von Servern, gefolgt von Abfragen in natürlicher Sprache, die echte Maps-Tool-Aufrufe auslösen. 

Gemini CLI mit Google Maps MCP Server nutzen

Um fortgeschrittenere Denkfähigkeiten in Verbindung mit den Maps-Daten zu testen, geben wir die folgende Eingabeaufforderung ein: 

Plan mal eine Route von Mumbai nach Goa mit einem Zwischenstopp zum Mittagessen, wo du die Aussicht genießen kannst. Schlag mir doch mal ein gutes Restaurant dort vor.

Wenn du diese Eingabe machst, macht der KI-Agent (Gemini oder Claude) eine komplexe mehrstufige Argumentationsschleife, wobei er nur die Google Maps MCP-Tools nutzt:

1. Die ganze Route berechnen: Der Agent ruft „ compute_routes “ an, mit dem Startpunkt „Mumbai“ und dem Ziel „Goa“. Die Entfernung ist ungefähr 566 km und die Fahrt dauert ungefähr 11 Stunden und 41 Minuten (unter Berücksichtigung des Verkehrs).

2. Überlegungen zum Mittelpunkt: Der Agent rechnet aus, dass die Hälfte der Strecke (~280–300 km) in die Konkan-Region fällt, genauer gesagt in die Nähe von Chiplun, das für seine Flussaussichten, Ghats und landschaftliche Schönheit bekannt ist.

3. Auf der Suche nach Restaurants mit toller Aussicht: Es nutzt search_places mit Suchanfragen, die sich auf Chiplun/Ratnagiri konzentrieren, und filtert nach guten Bewertungen, Außenbereichen/schöner Aussicht und Mittagstischen.

4. Die beste Option aussuchen und beschreiben: Schließlich sucht es sich einen besonders coolen Ort aus (in deinem Fall das Riverview Restaurant in Chiplun) und hebt die Sitzgelegenheiten im Freien und die entspannte Atmosphäre hervor.

Diese Antwort wird live generiert. Die Dauer der Route kommt direkt aus dem Aufruf des Tools „ compute_routes “, den du in der Debug-Ausgabe gesehen hast, und die Restaurantempfehlung basiert auf echten Places-API-Daten: keine fest programmierten Fakten, keine Halluzinationen, sondern einfach nur die sichere und aktuelle Nutzung des Tools.

So ruft die Gemini-CLI das Tool auf und zeigt ihre Empfehlung an:

compute_routes (maps-grounding-lite-mcp MCP Server) {"destination": {"address": "Goa"}, "origin": {"address": "Mumbai" }}
{
  "routes": [
    {
      "distanceMeters": 566414,
      "duration": "42095s"
    }
  ]
}
* A great place to stop for a scenic lunch on your drive from Mumbai to Goa is Chiplun, which is roughly halfway. I recommend The Riverview Restaurant in Chiplun. It offers outdoor seating and is a great spot to relax and enjoy a meal with a view.
The drive from Mumbai to Goa is approximately 566 km and will take about 11 hours and 40 minutes without stops. Enjoy your trip

Programmatische Integration mit LangChain oder LangGraph

Abgesehen von interaktiven Clients wie Gemini CLI oder Claude Desktop zeigt sich die wahre Stärke der von Google verwalteten MCP-Server, wenn du benutzerdefinierte, produktionsreife KI-Agenten in Code erstellst. Das Open-Source-Projekt LangChain-Ökosystem macht das mit dem Paket „ langchain-mcp-adapters “ ganz einfach, das jeden Remote-MCP-Server in ein Standard-LangChain-Tool verwandelt.

Mit diesem Ansatz hast du den vollen Überblick über die Erkennung, Authentifizierung und den Aufruf von Tools: ideal zum Debuggen, zum Erstellen benutzerdefinierter Tool-Router oder zur Integration in bestehende asynchrone Workflows.

Verbindung mit BigQuery MCP Server über LangChain

Um dir das besser zu erklären, schauen wir uns mal ein Beispiel an. Das folgende komplette, lauffähige Skript zeigt, wie man:

• Bei Google Cloud mit den Standardanmeldeinfos der App anmelden

• Verbinde dich über streambares HTTP mit dem verwalteten BigQuery MCP-Endpunkt.

• Schau dir alle verfügbaren Tools an

• Ruf ein bestimmtes Tool auf (list_dataset_ids) und zeig die echten Ergebnisse an.

import asyncio
import google.auth
import google.auth.transport.requests
import httpx

from mcp import ClientSession
from mcp.client.streamable_http import streamable_http_client
from langchain_mcp_adapters.tools import load_mcp_tools

async def list_and_invoke_bigquery():
    # 1. Authenticate with Google Cloud (run: gcloud auth application-default login)
    credentials, project_id = google.auth.default(
        scopes=["https://www.googleapis.com/auth/cloud-platform"]
    )
    auth_request = google.auth.transport.requests.Request()
    credentials.refresh(auth_request)

    url = "https://bigquery.googleapis.com/mcp"
    print(f"Connecting to: {url}...")

    # 2. Setup authenticated HTTP client
    async with httpx.AsyncClient(headers={
        "Authorization": f"Bearer {credentials.token}",
        "x-goog-user-project": project_id,
        "Content-Type": "application/json"
    }) as http_client:
        
        # 3. Establish streamable HTTP transport and MCP session
        async with streamable_http_client(url, http_client=http_client) as (read, write, _):
            async with ClientSession(read, write) as session:
                await session.initialize()
                
                # 4. Discover all tools exposed by Google's BigQuery MCP server
                tools = await load_mcp_tools(session)
                
                print(f"\n--- DISCOVERY: Found {len(tools)} tools ---")
                for tool in tools:
                    print(f"Tool: {tool.name}")
                
                # 5. Invoke a specific tool: list_dataset_ids
                print(f"\n--- INVOCATION: Fetching datasets for project '{project_id}' ---")
                
                dataset_tool = next((t for t in tools if t.name == "list_dataset_ids"), None)
                if dataset_tool:
                    try:
                        result = await dataset_tool.ainvoke({"project_id": project_id})
                        print("SUCCESS! Datasets in your project:")
                        print(result)
                    except Exception as e:
                        print(f"Error invoking tool: {e}")
                else:
                    print("Tool 'list_dataset_ids' not found.")

if __name__ == "__main__":
    asyncio.run(list_and_invoke_bigquery())

Wenn dieses Skript in einem richtig eingerichteten GCP-Projekt läuft, sieht die Ausgabe so aus:

Connecting to: https://bigquery.googleapis.com/mcp…

--- DISCOVERY: Found 5 tools ---
Tool: list_dataset_ids
Tool: get_dataset_info
Tool: list_table_ids
Tool: get_table_info
Tool: execute_sql

--- INVOCATION: Fetching datasets for ‘project’ ---
SUCCESS! Output from BigQuery: (...)

Das bestätigt:

• Sichere Authentifizierung über ADC
• Handshake mit dem Remote-Server von Google geklappt
• Vollständige Tool-Erkennung
• Live-Ausführung, die deine echten BigQuery-Datensätze zurückgibt

Dieses einfache Muster ist echt super, wenn:

• Fehlerbehebung bei Verbindungs- oder Berechtigungsproblemen
• Erstellen einer benutzerdefinierten Tool-Auswahl-Logik
• MCP in FastAPI-Dienste, Hintergrundprozesse oder Streaming-Apps einbauen
• Man braucht eine genaue Kontrolle über asynchrone Abläufe.

Sobald du die Konnektivität auf diese Weise überprüft hast, kannst du getrost auf höherwertige Frameworks wie LangGraph-Agenten (wie in den vorherigen Beispielen gezeigt) umsteigen oder diese Tools in jedes LangChain-kompatible System einbinden.

Mit dieser Grundlage werden Google MCP-Server zu einer sicheren, produktionsreifen Erweiterung deines Python-KI-Stacks, ohne dass du irgendwelchen benutzerdefinierten Glue-Code brauchst.

Sicherheits-Best-Practices für den Google MCP Server

Bei den verwalteten MCP-Servern von Google ist Sicherheit kein Nebengedanke. Stattdessen wurde es von Grund auf neu entwickelt. Durch den Betrieb auf der Infrastruktur von Google und die enge Integration mit der Identitäts- und Zugriffsverwaltung von Google Cloud bieten diese Server Schutz auf Unternehmensniveau, der weit über den Schutz von selbst gehosteten oder experimentellen Alternativen hinausgeht.

Identitäts- und Zugriffsmanagement

Google Cloud nutzt sein starkes IAM-Framework (Identity and Access Management), um zu regeln, wer (oder was) deine MCP-Tools aufrufen darf.

Bei der rollenbasierten Zugriffskontrolle (RBAC) sollte jeder KI-Agent sein eigenes dediziertes Dienstkonto haben. Diese Kontrolle basiert auf zwei verschiedenen Autorisierungsebenen:

• Gateway-Rolle: Um ein Google MCP-Tool nutzen zu können, muss die Identität die Rolle „ roles/mcp.toolUser “ haben.

• Dienstspezifische Berechtigungen: Da „ mcp.toolUser “ nur die Verbindung erlaubt, musst du trotzdem noch bestimmte Berechtigungen für die Aktion erteilen. Wenn die KI zum Beispiel Daten abfragen muss, braucht sie roles/bigquery.jobUser. Wenn es aber nur den VM-Status sehen muss, solltest du ihm roles/compute.viewer geben, nicht roles/compute.admin.

Modellpanzerung

Model Armor ist ein Google Cloud-Dienst, der die Sicherheit deiner KI-Anwendungen verbessern soll. Es checkt proaktiv die Eingabeaufforderungen und Antworten von LLM, schützt vor verschiedenen Risiken und sorgt für verantwortungsbewusste KI-Praktiken. 

Egal, ob du KI in Google Cloud oder bei anderen Cloud-Anbietern einsetzt, Model Armor hilft dir dabei, böswillige Eingaben zu verhindern, die Sicherheit von Inhalten zu überprüfen, sensible Daten zu schützen, Compliance zu gewährleisten und deine KI-Sicherheitsrichtlinien konsequent in all deinen KI-Anwendungen durchzusetzen.

Model Armor ist eine spezielle Web Application Firewall (WAF) für KI:

• Sofortige Desinfektion: Es überprüft jede eingehende Eingabeaufforderung auf Injektionsangriffe und Jailbreak-Versuche, bevor die Anfrage überhaupt deinen MCP-Server erreicht.
• Sicherheit der Inhalte: Es filtert schädliche Inhalte raus und kann mit Vorlagen für den Schutz sensibler Daten (SDP) so eingestellt werden, dass persönliche Daten (Namen, Sozialversicherungsnummern, Kreditkartennummern) sowohl in Eingabeaufforderungen als auch in den Tool-Ausgaben maskiert werden.
• Bodenbeläge: Google schlägt für MCP eine bestimmte „Sicherheitsbasis“ vor, die das obligatorische Scannen nach bösartigen URLs und Prompt-Injection-Mustern beinhaltet.

Beobachtbarkeit und Compliance

Jeder Tool-Aufruf über einen Google MCP-Server wird aufgezeichnet.

• Cloud-Protokollierung: MCP-Aktionen werden automatisch an Cloud Logging weitergeleitet. Dazu gehören die Agenten-ID, die Sitzungs-ID, das aufgerufene Tool und die Nutzlast.

• Prüfpfade: Wenn du die Datenzugriffsprotokolle für den Dienst mcp.googleapis.com aktivierst, kannst du eine dauerhafte Aufzeichnung für Compliance-Prüfungen führen, mit der du folgende Fragen beantworten kannst: Wer (welcher Agent) hat wann auf welche Daten zugegriffen?

Fazit

Keine komplizierten Spezialstecker mehr für jedes Modell oder Werkzeug: Die verwalteten MCP-Server von Google sind ein echter Wendepunkt für agentenbasierte KI auf Google Cloud. Durch die Einführung des offenen MCP-Standards und die Bereitstellung vollständig gehosteter Implementierungen der Enterprise-Klasse für BigQuery, Google Maps, Compute Engine und GKE hat Google die größten Hindernisse für die Entwicklung zuverlässiger, handlungsfähiger Agenten beseitigt.

Wie wir in diesem Leitfaden gesehen haben, macht diese standardisierte Architektur Schluss mit dem Albtraum des „Glue Code“ und lässt dich von lokalen Prototypen zu Cloud Run-Bereitstellungen skalieren, ohne dass du Tools für jeden Kunden neu schreiben musst. Außerdem sind deine Agenten mit Google Cloud IAM und Model Armor von Haus aus vor modernen KI-Bedrohungen geschützt.

Der Weg vom „Chatbot” zum „Agent” geht gerade los. Wenn du Google MCP Server beherrschst, baust du nicht nur eine KI, die Fragen beantwortet – du baust einen digitalen Teamkollegen, der deine Cloud blitzschnell betreiben kann.

Bist du bereit, alles, was du in diesem Leitfaden gelernt hast, in echtes Fachwissen für deine Karriere umzuwandeln? Mach bei unserem Associate AI Engineer für Entwickler Karriereweg.