Google MCP-servers Tutorial: Agentische AI uitrollen op GCP

Grote taalmodellen (LLM’s) hebben onze interactie met AI veranderd, maar zitten nog steeds grotendeels vast in chatinterfaces. Een AI vragen om je nieuwste verkoopdata in BigQuery te analyseren of de clustergezondheid in GKE te controleren, vereist meestal glue code voor elke tool, elk model en elke workflow.

Maak kennis met Google’s beheerde MCP-servers: de enterprise-oplossing die AI-agenten zonder maatwerkconnectors verbindt met krachtige Google Cloud-infrastructuur zoals BigQuery, Google Maps, Compute Engine (GCE) en Kubernetes Engine (GKE). 

Gebouwd op de open Model Context Protocol (MCP)-standaard van Anthropic bieden deze volledig beheerde remote servers veilige, gestandaardiseerde toegang, zodat elke MCP-compatibele client (zoals Gemini CLI of Claude Desktop) AI kan omtoveren tot een proactieve operator.

In deze gids laat ik je de praktische architectuur van MCP en Google’s serverportfolio zien en neem ik je stap voor stap mee om een productieklare MCP-server uit te rollen. Of je nou AI verankert in enterprise-data of DevOps-taken automatiseert: je bent binnen enkele minuten up-and-running.

Nieuw bij Google Cloud? Ik raad aan te starten met de gratis Introduction to GCP-cursus om billing, projecten en basisservices te behandelen.

Wat is het Model Context Protocol?

Het Model Context Protocol (MCP) is een open-sourcestandaard geïntroduceerd door Anthropic in november 2024. Het fungeert als een universele interface—vaak omschreven als de "USB-C voor AI"—die standaardiseert hoe AI-modellen en -agenten verbinding maken met externe databronnen, tools en systemen.

Voor MCP vereiste de integratie van een AI-agent met tools zoals databases, API’s of cloudservices het bouwen van maatwerkconnectors voor elk AI-model (bijv. aparte code voor Claude, Gemini of GPT). Dit zorgde voor een wildgroei aan gefragmenteerde integraties. 

MCP lost dit op door één consistent protocol te definiëren: ontwikkelaars implementeren een tool of databron één keer als een MCP-server, en elke MCP-compatibele AI-client (zoals Claude Desktop, Gemini CLI of maatwerkagenten) kan deze naadloos ontdekken en gebruiken.

Het kernvoordeel is interoperabiliteit en minder duplicatie. Schrijf één MCP-server voor BigQuery en hij werkt met alle ondersteunde AI-modellen zonder extra adapters. Dit versnelt de ontwikkeling van agentische AI-systemen, waarin agenten niet alleen antwoorden, maar actief redeneren, data opvragen en acties uitvoeren in de echte wereld.

De client ontdekt beschikbare tools van verbonden servers, het LLM beslist welke het aanroept, en resultaten stromen terug voor verdere redenering—allemaal gestandaardiseerd via MCP’s op JSON-RPC gebaseerde protocol.

Dit "universele vertaler"-ontwerp is waarom Google (en anderen) MCP snel heeft omarmd: hun beheerde servers passen direct in dit ecosysteem, waardoor Google Cloud-services meteen toegankelijk zijn voor elke MCP-client.

Wat is een Google MCP-server?

Google MCP-servers zijn Google’s volledig beheerde, remote implementaties van het Model Context Protocol (MCP). Gelanceerd in december 2025, stellen deze enterprise-grade servers krachtige Google Cloud-services beschikbaar—te beginnen met BigQuery, Google Maps, GCE en GKE—als gestandaardiseerde, ontdekbare tools die elke MCP-compatibele AI-client direct kan gebruiken.

In tegenstelling tot community- of open-source MCP-servers die zelfhosting, onderhoud, schaalvergroting en maatwerkbeveiliging vereisen, draaien Google’s beheerde servers op Google’s infrastructuur. Ze bieden:

• Geen deployment-overhead: Schakel de service in je project in en wijs je client naar het officiële endpoint (bijv. https://bigquery.googleapis.com/mcp).
• Enterprise-betrouwbaarheid: Hoge beschikbaarheid, automatische schaalvergroting en wereldwijde endpoints.
• Ingebouwde beveiliging: IAM-gebaseerde authenticatie, Model Armor (Google’s LLM-firewall voor bescherming tegen promptinjection en exfiltratie), auditlogging en least-privilege-controles.
• Governance: Gecentraliseerd in- en uitschakelen per project of organisatie.

Deze technologie ontgrendelt agentische workflows. In plaats van dat een AI alleen uitlegt hoe een SQL-query werkt, kan hij de query daadwerkelijk uitvoeren in BigQuery, de resultaten analyseren en de volgende zakelijke stap voorstellen. 

Hoewel deze agenten autonoom kunnen handelen, ondersteunt Google’s implementatie configuraties met een "human-in-the-loop", zodat een mens kritieke infrastructuurwijzigingen kan beoordelen en goedkeuren voordat ze plaatsvinden.

Als je geïnteresseerd bent in AI-gestuurde browserautomatisering, bekijk dan onze Chrome DevTools MCP-tutorial.

Google’s portfolio van MCP-servers

Google biedt een groeiende set volledig beheerde MCP-servers die belangrijke cloudservices direct beschikbaar maken als tools voor AI-agenten. Deze servers zijn gecategoriseerd op functie, waardoor agenten alles aankunnen van data-analyse tot infrastructuurbeheer zonder maatwerkcode.

Het ecosysteem groepeert servers in twee hoofdcategorieën:

• Data-intelligentie: Gericht op het bevragen, analyseren en verankeren in real-world data.
• Infrastructuuroperaties: Voor het aansturen en monitoren van compute-resources.

Data-intelligentie-servers

De BigQuery- en Maps-MCP-servers bieden spannende mogelijkheden om data in je workflow op te nemen.

BigQuery

De BigQuery MCP-server stelt agenten in staat om:

• SQL-queries direct op datasets uit te voeren
• Beschikbare datasets en tabellen op te sommen
• Schema-metadata en voorbeelddata op te halen
• Analytische jobs te draaien, inclusief ML-inferentie via BigQuery ML

Dit stelt agenten in staat om complexe data-analyses uit te voeren, rapporten te genereren of trends autonoom te voorspellen.

Google Maps

De Google Maps MCP-server draait op Grounding Lite en de Places API, en ondersteunt:

• Geocodering en reverse geocodering
• Zoeken naar plaatsen en details ophalen
• Routeberekening en routebeschrijvingen
• Afstandsmatrix-berekeningen

Use case: Real-time business intelligence en logistieke optimalisatie. Een agent kan verkoopdata in BigQuery bevragen, met Maps geografische inzichten kruisen en optimalisaties voor bezorgroutes aanbevelen—alles in één redeneringslus.

Servers voor infrastructuuroperaties

Aan de infrastructuurkant kun je de Kubernetes Engine (GKE)- en Compute Engine (GCE)-MCP-servers gebruiken.

Google Kubernetes Engine

De GKE MCP-server stelt bewerkingen beschikbaar zoals:

• Clusters, nodes en pods oplijsten
• Clustergezondheid en resourcegebruik controleren
• Logs en events lezen
• Deployments schalen (met de juiste IAM-rechten)

Google Compute Engine

De GCE MCP-server maakt het mogelijk om:

• VM-instances te lijsten, starten, stoppen en herstarten
• Disks of machine types te lijsten
• Instancemetadata en -status op te vragen

Use case: Geautomatiseerde troubleshooting en "ChatOps" voor DevOps-teams. Een agent kan een pod-crash detecteren via GKE-tools, correleren met VM-metrics uit GCE en remediatiestappen initiëren—waardoor de mean-time-to-resolution daalt van uren naar minuten.

Google breidt dit portfolio continu uit (met services zoals Cloud Storage en AlloyDB in preview begin 2026), waardoor steeds meer van Google Cloud native toegankelijk wordt voor agenten.

Kernarchitectuur van Google MCP-servers

De kracht van MCP ligt in de flexibele maar gestandaardiseerde communicatielagen, die naadloze verbindingen mogelijk maken, of je nu lokaal prototypet of productieklare agenten op schaal draait. Google’s beheerde MCP-servers gebruiken primair remote streamable HTTP voor enterprise-deployments, terwijl lokale ontwikkeling stdio benut. 

Lokale communicatie via stdio

Het stdio (standard input/output)-transport is de simpelste manier om een MCP-server te draaien. Hierbij start de MCP-client (bijv. Claude Desktop of een maatwerkagent) de server als subprocess op dezelfde machine en verloopt de communicatie via directe pipes, zonder netwerk.

Voordelen:

• Extreem eenvoudige setup voor ontwikkeling en testen
• Inherente beveiliging (geen open poorten of netwerk-aanvalsoppervlak)
• Lage latency

Nadelen:

• Niet te delen tussen machines of teams
• Beperkte schaalbaarheid (gekoppeld aan de host van de client)
• Geen ingebouwde gelijktijdigheid voor meerdere sessies

Deze modus is perfect om te experimenteren met custom MCP-servers of om connecties te testen voordat je remote gaat.

Remote communicatie via streamable HTTP

Voor productie en enterprise-gebruik gebruiken Google’s beheerde servers (en zelfgehoste custom servers) streamable HTTP over één persistent endpoint. Dit vervangt de eerdere Server-Sent Events (SSE)-aanpak door een robuuster ontwerp met ondersteuning voor:

• HTTP POST-requests voor alle interacties
• Optionele bidirectionele streaming voor grote of incrementele responses (bijv. streaming BigQuery-resultaten)
• Sessie-ID’s voor stateful conversaties
• Gelijktijdige verbindingen voor parallelle multi-tool-calls

Google’s beheerde endpoints volgen een consistent patroon, bijvoorbeeld:

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

Al het verkeer wordt beveiligd met Google ID-tokens (OAuth2), zodat aanroepen via IAM worden geauthenticeerd en geautoriseerd.

Zo kan een sequentiestroom eruitzien:

1. Client stuurt tool discovery/aanvraag via POST naar /mcp.

2. Server valideert identiteit en routet naar de backendservice.

3. Backend voert uit (bijv. draait SQL in BigQuery).

4. Respons streamt terug in chunks (JSON-RPC-formaat) voor efficiënte afhandeling van grote outputs.

Aan de slag met Google MCP-server

Een van de grootste voordelen van Google’s MCP-servers is hoe weinig setup ze vereisen vergeleken met zelfgehoste alternatieven. We maken duidelijk onderscheid tussen beheerde en custom servers terwijl we de stappen doorlopen.

• Beheerde Google MCP-servers: Deze zijn voor services zoals BigQuery, Maps, GCE en GKE, en worden volledig door Google gehost. Je deployt niets—schakel gewoon de endpoints in je project in, ken IAM-rechten toe en configureer je client. Ze zijn direct klaar voor gebruik.
• Custom MCP-servers: Voor interne tools, third-party API’s of geavanceerde uitbreidingen bouw en deploy je je eigen server (bijv. met Google’s MCP Toolbox). Deze worden meestal op Cloud Run uitgerold voor schaalbaarheid.

Het Google Cloud-omgeving inrichten voor beheerde servers

Volg deze stappen (gebaseerd op de officiële tutorial) om beheerde MCP-servers in te schakelen en voor te bereiden.

Vereisten

• Een Google Cloud-project met billing ingeschakeld

• Toegang tot Google Cloud Console en Cloud Shell (of lokale gcloud CLI)

• Je gebruikersaccount is geauthenticeerd via gcloud auth login

Projectsetup en API-inschakeling

1. Maak een project aan of selecteer er een in de Google Cloud Console.
2. Schakel billing in als dat nog niet is gebeurd.
3. Schakel de kernservice-API’s in (in Cloud Shell of lokale 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

Let op dat de Maps MCP een eigen API-sleutel vereist voor billing en quota. Maak er een aan met het volgende commando:

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

Kopieer de weergegeven keyString—die heb je nodig voor de clientconfiguratie.

Beheerde MCP-servers inschakelen (beta)

MCP-services vereisen expliciete beta-inschakeling:

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-configuratie

Geef de MCP-tool een gebruikersrol op je account:

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

Voeg servicespecifieke rollen toe voor least-privilege-toegang, bijvoorbeeld:

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

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

Beheerde servers zijn nu klaar! Endpoints:

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

Custom remote MCP-servers deployen naar Cloud Run

Voor custom tools buiten Google’s beheerde portfolio bouw je je eigen MCP-server met bibliotheken zoals FastMCP (Python) en deploy je die naar Cloud Run voor schaalbaarheid en teamdeling. We gaan hier niet te diep op in, maar geven een overzicht op hoofdlijnen.

Stappen op hoofdlijnen:

1. Maak een Python-project en voeg FastMCP als dependency toe (met tools zoals uv).

2. Implementeer je servercode (bijv. server.py) met custom tools, met transport="streamable-http".

3. Schrijf een lichte Dockerfile (gebaseerd op python:slim) om dependencies te installeren en de server te draaien op $PORT.

4. Schakel vereiste API’s in (Cloud Run, Artifact Registry, Cloud Build).

5. Deploy direct vanaf bron of build/push een container.

6. Beveilig de service: vereis IAM-authenticatie (--no-allow-unauthenticated), geef roles/run.invoker aan geautoriseerde principals en gebruik identity tokens voor clientverbindingen.

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

Dit proces duurt minder dan 10 minuten voor simpele servers en biedt productiehosting met autoscaling.

Clientconfiguratie en integratie voor Google MCP-server

Een uitgerolde (of ingeschakelde) MCP-server wordt pas echt krachtig wanneer deze is verbonden met een AI-client. In deze sectie behandelen we het configureren van populaire clients om Google’s beheerde MCP-servers te gebruiken en het bouwen van programmatische agenten.

Testen met MCP Inspector

De MCP Inspector biedt een overzichtelijke web-UI om elke MCP-server te verkennen, inclusief die van Google. Het is vooral handig voor het troubleshooten van authenticatie, het ontdekken van exacte toolnamen/-parameters en het bekijken van echte responses.

Het proces ziet er zo uit:

1. Start de Inspector
2. Verbind met een door Google beheerde MCP-server
3. Verken en test tools

Om de Inspector te starten, voer je dit commando uit in je terminal:

npx @modelcontextprotocol/inspector

Dit start een lokale webserver en opent de Inspector-UI in je standaardbrowser. 

Vervolgens verbinden we met een Google MCP-server. Laten we beginnen met Google Maps als voorbeeld. 

In de Inspector-UI gaan we links de MCP Inspector configureren om met onze Google Maps MCP-server te verbinden. Volg mee en voer de specifieke instructies en waarden in:

1. Transporttype: Selecteer Streamable HTTP

2. URL: Voer https://mapstools.googleapis.com/mcp in

3. Verbindingstype: Kies via Proxy (dit handelt Google-authenticatie veilig af met je ingelogde gcloud-credentials).

4. Aangepaste headers: Voeg één header toe

   • Sleutel: X-Goog-Api-Key

   • Waarde: Je Maps API-sleutel (de keyString uit de eerdere setup).

5. Klik op Connect.

Als alles goed gaat, zie je dat de MCP Inspector succesvol verbinding maakt met de server. In het rechterpaneel kun je de tools ophalen die worden ondersteund door de Google Maps MCP-server door op List Tools te klikken.

Laten we de tools verkennen en testen:

• Selecteer een tool om het volledige JSON-schema te bekijken: beschrijving, parameters (met types en verplichte velden) en voorbeelden. 
• Vul parameters in (bijv. query: "best coffee in Pune, Maharashtra") en klik op Invoke.
• Echte resultaten verschijnen direct, gestreamd in chunks voor grote responses.

Voor BigQuery- en Compute-servers is het proces identiek maar eenvoudiger, omdat geen API-key-header nodig is. Authenticatie verloopt automatisch via de proxy.

Gemini CLI configureren

Gemini CLI is Google’s officiële open-source terminalagent met diepe, native integratie voor MCP-servers. Het is de soepelste manier om agentische workflows te bouwen. 

De Gemini CLI instellen

Installeer de Gemini CLI met het volgende commando:

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

Servers toevoegen en de verbinding testen

We gebruiken opnieuw Maps als voorbeeld. Voeg de Google Maps MCP-server toe met het volgende commando en vervang YOUR_MAPS_API_KEY door je Maps API-sleutel die we eerder hebben gemaakt.

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

Controleer in een nieuwe Gemini-sessie de verbinding met het commando /mcp list.

Bij onze eerste interactie stellen we een eenvoudige vraag in natuurlijke taal: 

“Wat zijn betaalbare ontbijtplekken in New York?”

Gemini selecteert automatisch de Maps-tools. Zodra je hun uitvoering accepteert, roept het ze aan en krijg je geformatteerde resultaten terug.

Gelukt! We kregen de volgende response:

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.

Het klassieke "Hello World"-moment in Gemini CLI: een nette tool-lijst na het toevoegen van servers, gevolgd door natuurlijke taalvragen die echte Maps-toolcalls triggeren. 

Gemini CLI gebruiken met Google Maps MCP-server

Om meer geavanceerde redeneervaardigheden te testen in combinatie met de Maps-data, geven we de volgende prompt mee: 

"Plan een autoroute van Mumbai naar Goa met een schilderachtige lunchstop halverwege. Stel daar een goed restaurant voor."

Wanneer je deze prompt verstuurt, voert de AI-agent (Gemini of Claude) een verfijnde, meerstaps redeneringslus uit met alleen de Google Maps MCP-tools:

1. De volledige route berekenen: De agent roept compute_routes aan met origin "Mumbai" en destination "Goa". Het resultaat is een afstand van ~566 km met een duur van ~11 uur en 41 minuten (verkeersbewust).

2. Redeneren over het halverwegepunt: De agent berekent dat halverwege (~280–300 km) rond de Konkan-regio ligt, specifiek nabij Chiplun, bekend om rivieruitzichten, ghats en natuurschoon.

3. Zoeken naar schilderachtige restaurants: Hij gebruikt search_places met queries gericht op Chiplun/Ratnagiri, gefilterd op hoge waarderingen, buiten-/scenic views en lunchbeschikbaarheid.

4. De beste optie selecteren en beschrijven: Uiteindelijk kiest hij een uitblinker (in jouw geval The Riverview Restaurant in Chiplun) en licht de buitenzitplaatsen en relaxte sfeer uit.

Deze response wordt live gegenereerd. De routeduur komt rechtstreeks uit de compute_routes-aanroep die je in de debugoutput zag, en de restaurantaanbeveling is gegrond in echte Places API-data: geen hardcoded feiten, geen hallucinaties, maar veilige, actuele toolgebruik.

Zo roept de Gemini CLI de tool aan en geeft zijn aanbeveling weer:

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 integratie met LangChain of LangGraph

Naast interactieve clients zoals Gemini CLI of Claude Desktop komt de echte kracht van Google’s beheerde MCP-servers naar voren wanneer je maatwerk, productieklare AI-agenten in code bouwt. Het open-source LangChain-ecosysteem maakt dit eenvoudig met het pakket langchain-mcp-adapters, dat elke remote MCP-server omzet in standaard LangChain-tools.

Deze aanpak geeft je volledige zicht op tooldiscovery, authenticatie en aanroepen: perfect voor debugging, het bouwen van custom toolrouters of integratie in bestaande async-workflows.

LangChain gebruiken om te verbinden met de BigQuery MCP-server

Om dit te verduidelijken, laten we het zien in een voorbeeld. Het onderstaande complete, uitvoerbare script demonstreert hoe je:

• Authenticeert bij Google Cloud met Application Default Credentials

• Verbindt met het beheerde BigQuery MCP-endpoint via streamable HTTP

• Alle beschikbare tools ontdekt

• Een specifieke tool aanroept (list_dataset_ids) en echte resultaten print

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())

Bij uitvoering in een correct geconfigureerd GCP-project levert dit script output op zoals:

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: (...)

Dit bevestigt:

• Veilige authenticatie via ADC
• Geslaagde handshake met Google’s beheerde remote server
• Volledige tooldiscovery
• Live-executie die je eigen BigQuery-datasets retourneert

Dit low-level patroon is van onschatbare waarde wanneer je:

• Verbindings- of toestemmingsproblemen debugt
• Custom logica voor toolselectie bouwt
• MCP integreert in FastAPI-services, achtergrondworkers of streaming-apps
• Nauwkeurige controle over async-flows nodig hebt

Zodra je de connectiviteit op deze manier hebt geverifieerd, kun je met vertrouwen opschalen naar hoger-niveau-frameworks zoals LangGraph-agenten (zoals eerder getoond) of deze tools in elk LangChain-compatibel systeem voeden.

Met dit fundament worden Google MCP-servers een veilige, productieklare extensie van je Python AI-stack, zonder benodigde glue code.

Beveiligingsbest practices voor Google MCP-server

Beveiliging is geen bijzaak bij Google’s beheerde MCP-servers. Het is vanaf de basis ingebouwd. Doordat ze draaien op Google’s infrastructuur en diep geïntegreerd zijn met Google Cloud’s identity- en accessmanagement, bieden deze servers enterprise-grade bescherming die ver uitstijgt boven zelfgehoste of experimentele alternatieven.

Identity and Access Management

Google Cloud gebruikt zijn robuuste IAM (Identity and Access Management)-raamwerk om te bepalen wie (of wat) je MCP-tools mag aanroepen.

Onder Role-Based Access Control (RBAC) zou elke AI-agent zijn eigen serviceaccount moeten hebben. Deze controle steunt op twee afzonderlijke autorisatielagen:

• Gateway-rol: Om een Google MCP-tool te gebruiken, moet de identiteit de rol roles/mcp.toolUser hebben.

• Servicespecifieke permissies: Omdat mcp.toolUser alleen de verbinding toestaat, moet je nog specifieke rechten geven voor de actie. Als de AI bijvoorbeeld data moet bevragen, heeft hij roles/bigquery.jobUser nodig. Wil hij alleen VM-status zien, geef dan roles/compute.viewer, niet roles/compute.admin.

Model Armor

Model Armor is een Google Cloud-service die is ontworpen om de beveiliging en veiligheid van je AI-toepassingen te vergroten. Het werkt door LLM-prompts en responses proactief te screenen, beschermt tegen diverse risico’s en zorgt voor verantwoord AI-gebruik. 

Of je nu AI uitrolt in Google Cloud of andere cloudproviders: Model Armor helpt kwaadaardige input te voorkomen, inhoudsveiligheid te verifiëren, gevoelige data te beschermen, compliance te behouden en je AI-veiligheids- en beveiligingsbeleid consistent af te dwingen in je AI-applicaties.

Model Armor fungeert als een gespecialiseerde Web Application Firewall (WAF) voor AI:

• Prompt-sanitization: Het screent elke inkomende prompt op injectieaanvallen en jailbreakpogingen voordat het verzoek je MCP-server bereikt.
• Inhoudsveiligheid: Het filtert schadelijke content en kan worden geconfigureerd met Sensitive Data Protection (SDP)-templates om PII (namen, sofinummers, creditcardnummers) te maskeren in zowel prompts als tooloutputs.
• Bodeminstellingen: Google raadt een specifieke "security floor" aan voor MCP, met verplichte scanning op kwaadaardige URL’s en promptinjection-patronen.

Observability en compliance

Elke toolaanroep via een Google MCP-server is een gedocumenteerd event.

• Cloud logging: MCP-acties worden automatisch doorgestuurd naar Cloud Logging. Dit omvat de agent-ID, de sessie-ID, de specifieke aangeroepen tool en de payload.

• Audittrails: Door data access logs voor de service mcp.googleapis.com in te schakelen, kun je een permanent dossier bijhouden voor compliancecontroles, zodat je kunt beantwoorden: "Wie (welke agent) heeft welke data wanneer benaderd?"

Conclusie

Geen fragiele maatwerkconnectors meer voor elk model of elke tool: Google’s beheerde MCP-servers markeren een keerpunt voor agentische AI op Google Cloud. Door de open MCP-standaard te adopteren en volledig gehoste, enterprise-grade implementaties te leveren voor BigQuery, Google Maps, Compute Engine en GKE, heeft Google de grootste barrières weggenomen voor het bouwen van betrouwbare, handelende agenten.

Zoals we in deze gids hebben gezien, elimineert deze gestandaardiseerde architectuur de glue code-nachtmerrie en kun je opschalen van lokale prototypes naar Cloud Run-deployments zonder tools opnieuw te schrijven voor elke client. Bovendien zijn je agenten met Google Cloud IAM en Model Armor van nature beschermd tegen moderne AI-bedreigingen.

De overgang van "Chatbot" naar "Agent" is nu gaande. Door Google MCP-servers te beheersen, bouw je niet alleen een AI die vragen beantwoordt—je bouwt een digitale teammate die je cloud bedient met de snelheid van je gedachten.

Klaar om alles wat je in deze gids hebt geleerd om te zetten in carrièrebepalende expertise? Schrijf je in voor onze Associate AI Engineer for Developers-carrièretrack.