Tutoriel sur les serveurs MCP Google : Déploiement de l'IA agentique sur GCP

Les grands modèles linguistiques (LLM) ont révolutionné notre interaction avec l'IA, mais ils restent encore largement confinés aux interfaces de chat. Pour demander à une IA d'analyser vos dernières données de vente dans BigQuery ou de vérifier l'état du cluster dans GKE, il est généralement nécessaire d'écrire un code de liaison pour chaque outil, chaque modèle et chaque flux de travail.

Découvrez les serveurs MCP gérés par Google : la solution d'entreprise qui connecte les agents IA à la puissante infrastructure Google Cloud, telle que BigQuery, Google Maps, Compute Engine (GCE) et Kubernetes Engine (GKE), sans aucun connecteur personnalisé. 

Basés sur la norme ouverte Model Context Protocol (MCP) d'Anthropic, ces serveurs distants entièrement gérés offrent un accès sécurisé et standardisé, permettant à tout client compatible MCP (tel que Gemini CLI ou Claude Desktop) de transformer l'IA en un opérateur proactif.

Dans ce guide, je vous présenterai l'architecture pratique du MCP et du portefeuille de serveurs de Google, et je vous expliquerai les étapes précises à suivre pour déployer un serveur MCP prêt pour la production. Que vous souhaitiez intégrer l'IA dans les données de votre entreprise ou automatiser des tâches DevOps, vous serez opérationnel en quelques minutes.

Vous débutez avec Google Cloud ? Je vous recommande de commencer par le cours gratuit Introduction au GCP qui couvre la facturation, les projets et les services de base.

Qu'est-ce que le protocole de contexte modèle ?

Le protocole de contexte de modèle (MCP) est une norme open source introduite par Anthropic en novembre 2024. Il agit comme une interface universelle, souvent décrite comme « l'USB-C de l'IA », qui normalise la manière dont les modèles et les agents d'IA se connectent aux sources de données, aux outils et aux systèmes externes.

Avant MCP, l'intégration d'un agent IA à des outils tels que des bases de données, des API ou des services cloud nécessitait la création de connecteurs personnalisés pour chaque modèle IA (par exemple, un code distinct pour Claude, Gemini ou GPT). Cela a entraîné une multiplication des intégrations fragmentées. 

MCP résout ce problème en définissant un protocole unique et cohérent : les développeurs implémentent un outil ou une source de données une seule fois en tant que serveur MCP, et tout client IA compatible MCP (tel que Claude Desktop, Gemini CLI ou des agents personnalisés) peut le détecter et l'utiliser de manière transparente.

Le principal avantage réside dans l'interopérabilité et la réduction de la duplication des données. Écrire un serveur MCP pour BigQuery une seule fois, et il fonctionnera sur tous les modèles d'IA pris en charge sans adaptateurs supplémentaires. Cela accélère le développement des systèmes d'IA agentique, dans lesquels les agents ne se contentent pas de répondre à des requêtes, mais raisonnent activement, interrogent des données et exécutent des actions dans le monde réel.

Le client identifie les outils disponibles à partir des serveurs connectés, le LLM détermine lequel appeler, et les résultats sont renvoyés pour un raisonnement plus approfondi, le tout étant standardisé via le protocole JSON-RPC de MCP.

C'est grâce à cette conception de « traducteur universel » que Google (et d'autres) ont rapidement adopté MCP : leurs serveurs gérés s'intègrent directement dans cet écosystème, rendant les services Google Cloud instantanément accessibles à tout client MCP.

Qu'est-ce qu'un serveur Google MCP ?

Les serveurs MCP de Google sont des implémentations à distance entièrement gérées par Google du protocole MCP (Model Context Protocol). Lancés en décembre 2025, ces serveurs de niveau entreprise offrent de puissants services Google Cloud, à commencer par BigQuery, Google Maps, GCE et GKE, sous forme d'outils standardisés et faciles à trouver que tout client IA compatible MCP peut utiliser immédiatement.

Contrairement aux serveurs MCP communautaires ou open source qui nécessitent un hébergement, une maintenance, une mise à l'échelle et un renforcement de la sécurité personnalisés, les serveurs gérés par Google fonctionnent sur l'infrastructure de Google. Ils fournissent :

• Aucun coût de déploiement : Veuillez activer le service dans votre projet et diriger votre client vers le point de terminaison officiel (par exemple, https://bigquery.googleapis.com/mcp).
• Fiabilité de l'entreprise : Haute disponibilité, mise à l'échelle automatique et points de terminaison mondiaux.
• Sécurité intégrée : Authentification basée sur IAM, Model Armor (pare-feu LLM de Google pour la protection contre l'injection de commandes et l'exfiltration), journalisation d'audit et contrôles des privilèges minimaux.
• Gouvernance : Activation/désactivation centralisée par projet ou par organisation.

Cette technologie permet de mettre en œuvre des les flux de travail agentique. Au lieu de se contenter d'expliquer le fonctionnement d'une requête SQL, l'IA peut réellement exécuter la requête dans BigQuery, analyser les résultats et proposer la prochaine étape à suivre pour l'entreprise. 

Bien que ces agents puissent agir de manière autonome, la mise en œuvre de Google prend en charge les configurations « human-in-the-loop », garantissant qu'un être humain puisse examiner et approuver les modifications critiques de l'infrastructure avant qu'elles ne soient effectuées.

Gamme de serveurs MCP de Google

Google propose un ensemble croissant de serveurs MCP entièrement gérés qui rendent les services cloud essentiels immédiatement disponibles en tant qu'outils pour les agents IA. Ces serveurs sont classés par fonction, ce qui permet aux agents de gérer tous les aspects, de l'analyse des données à la gestion de l'infrastructure, sans avoir recours à un code personnalisé.

L'écosystème regroupe les serveurs en deux catégories principales :

• Intelligence des données : Axé sur la recherche, l'analyse et l'ancrage dans des données du monde réel.
• Opérations liées aux infrastructures : Permettre le contrôle et la surveillance des ressources informatiques.

Serveurs de données intelligentes

Les serveurs BigQuery et Maps MCP offrent des possibilités intéressantes pour intégrer des données dans votre flux de travail.

BigQuery

Le serveur BigQuery MCP permet aux agents de :

• Exécutez des requêtes SQL directement sur des ensembles de données.
• Veuillez énumérer les ensembles de données et les tableaux disponibles.
• Récupérer les métadonnées du schéma et les données d'exemple
• Exécutez des tâches analytiques, y compris l'inférence ML via BigQuery ML.

Cela permet aux agents d'effectuer des analyses de données complexes, de générer des rapports ou de prévoir les tendances de manière autonome.

Google Maps

Le serveur MCP de Google Maps est optimisé par Grounding Lite et l'API Places, et prend en charge :

• Géocodage et géocodage inversé
• Recherche de lieux et récupération de détails
• Calcul d'itinéraire et indications
• Calculs de matrices de distance

s sur les cas d'utilisation: Intelligence économique en temps réel et optimisation logistique. Un agent peut consulter les données de vente dans BigQuery, les recouper avec Maps pour obtenir des informations géographiques et recommander des optimisations des itinéraires de livraison, le tout en une seule boucle de raisonnement.

Serveurs d'exploitation des infrastructures

En ce qui concerne l'infrastructure, vous pouvez utiliser le Kubernetes Engine (GKE) et Compute Engine (GCE) MCP.

Moteur Google Kubernetes

Le serveur GKE MCP expose des opérations telles que :

• Répertorier les clusters, les nœuds et les pods
• Vérification de l'état du cluster et de l'utilisation des ressources
• Journalisation des lectures et des événements
• Déploiements à grande échelle (avec les autorisations IAM appropriées)

Google Compute Engine

Le serveur GCE MCP permet :

• Répertorier, démarrer, arrêter et redémarrer des instances VM
• Veuillez lister les disques ou les types de machines.
• Interroger les métadonnées et l'état d'une instance

s sur les cas d'utilisation: Dépannage automatisé et « ChatOps » pour les équipes DevOps. Un agent peut détecter une panne de pod à l'aide des outils GKE, établir une corrélation avec les métriques VM de GCE et lancer des mesures correctives, réduisant ainsi le temps moyen de résolution de plusieurs heures à quelques minutes.

Google continue d'élargir ce portefeuille (avec des services tels que Cloud Storage et AlloyDB en préversion depuis début 2026), rendant ainsi davantage de fonctionnalités de Google Cloud accessibles de manière native aux agents.

Architecture centrale du serveur Google MCP

La puissance de MCP réside dans ses couches de communication flexibles mais standardisées, qui permettent des connexions transparentes, que vous réalisiez des prototypes localement ou que vous exécutiez des agents prêts pour la production à grande échelle. Les serveurs MCP gérés par Google utilisent principalement le protocole HTTP distant diffusable en continu pour les déploiements d'entreprise, tandis que le développement local exploite le protocole stdio. 

Communication locale via stdio

Le transport standard d'entrée/sortie ( stdio ) constitue la méthode la plus simple pour exécuter un serveur MCP. Ici, le client MCP (par exemple, Claude Desktop ou un agent personnalisé) lance le serveur en tant que sous-processus sur la même machine, communiquant via des canaux directs et sans aucun réseau impliqué.

Avantages :

• Configuration extrêmement simple pour le développement et les tests
• Sécurité intégrée (aucun port exposé ni surface d'attaque réseau)
• Faible latence

Inconvénients :

• Non partageable entre les machines ou les équipes
• Évolutivité limitée (liée à l'hôte du client)
• Pas de concurrence intégrée pour les sessions multiples

Ce mode est idéal pour tester des serveurs MCP personnalisés ou vérifier les connexions avant de passer en mode distant.

Communication à distance via HTTP diffusable en continu

Pour la production et l'utilisation en entreprise, les serveurs gérés par Google (et les serveurs personnalisés auto-hébergés) utilisent le protocole HTTP diffusable via un point de terminaison unique et persistant. Cela remplace l'ancienne approche Server-Sent Events (SSE) par une conception plus robuste prenant en charge :

• Demandes HTTP POST pour toutes les interactions
• Diffusion bidirectionnelle facultative pour les réponses volumineuses ou incrémentielles (par exemple, diffusion des résultats BigQuery)
• Identifiants de session pour les conversations avec état
• Connexions simultanées pour appels parallèles multi-outils

Les terminaux gérés par Google suivent un modèle cohérent, par exemple :

• BigQuery : https://bigquery.googleapis.com/mcp
• Cartes : https://mapstools.googleapis.com/mcp
• Calculer : https://compute.googleapis.com/mcp

Tout le trafic est sécurisé à l'aide de jetons d'identification Google (OAuth2), garantissant ainsi que les appels sont authentifiés et autorisés via IAM.

Voici à quoi pourrait ressembler un flux de séquence :

1. Le client envoie une requête de découverte d'outils via POST à l'adresse /mcp.

2. Le serveur vérifie l'identité et achemine vers le service backend.

3. Le backend exécute (par exemple, exécute SQL dans BigQuery).

4. Les flux de réponse sont renvoyés par blocs (format JSON-RPC) pour une gestion efficace des sorties volumineuses.

Premiers pas avec Google MCP Server

L'un des principaux avantages des serveurs MCP de Google réside dans leur configuration minimale par rapport aux alternatives auto-hébergées. Nous ferons une distinction claire entre les serveurs gérés et les serveurs personnalisés au fur et à mesure que nous avancerons dans les étapes.

• Serveurs MCP Google gérés : Ces services sont destinés à des services tels que BigQuery, Maps, GCE et GKE, et sont entièrement hébergés par Google. Vous n'avez rien à déployer : il vous suffit d'activer les points de terminaison dans votre projet, d'accorder les autorisations IAM et de configurer votre client. Ils sont prêts à l'emploi dès leur sortie de l'emballage.
• Serveurs MCP personnalisés : Pour les outils internes, les API tierces ou les extensions avancées, vous devez créer et déployer votre propre serveur (par exemple, à l'aide de la boîte à outils MCP de Google). Ils sont généralement déployés sur Cloud Run pour des raisons d'évolutivité.

Configuration del'environnement Google Cloudpour les serveurs gérés

Veuillez suivre ces étapes (basées sur le tutoriel officiel) pour activer et préparer les serveurs MCP gérés.

Conditions préalables

• Un projet Google Cloud avec facturation activée

• Accès à Google Cloud Console et Cloud Shell (ou CLI d'gcloud e locale)

• Votre compte utilisateur est authentifié via gcloud auth login

Configuration du projet et activation de l'API

1. Veuillez créer ou sélectionner un projet dans la console Google Cloud.
2. Veuillez activer la facturation si cela n'a pas encore été effectué.
3. Activez les API des services principaux (dans la shell cloud ou dans un terminal local) :

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

Veuillez noter que Maps MCP nécessite sa propre clé API pour la facturation et le quota. Veuillez en créer un à l'aide de la commande suivante :

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

Veuillez copier l' keyStringaffichée — vous en aurez besoin pour la configuration du client.

Activer les serveurs MCP gérés (version bêta)

Les services MCP nécessitent une activation bêta explicite :

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

Configuration IAM

Veuillez attribuer un rôle utilisateur à l'outil MCP sur votre compte :

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

Ajoutez des rôles spécifiques au service pour un accès avec le moins de privilèges possible, par exemple :

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

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

Les serveurs gérés sont désormais disponibles. Points finaux :

• BigQuery : https://bigquery.googleapis.com/mcp
• Cartes : https://mapstools.googleapis.com/mcp
• Calcul (GCE et GKE) : https://compute.googleapis.com/mcp

Déploiement de serveurs MCP distants personnalisés sur Cloud Run

Pour les outils personnalisés qui ne font pas partie du portefeuille géré par Google, veuillez créer votre propre serveur MCP à l'aide de bibliothèques telles que FastMCP (Python) et le déployer sur Cloud Run pour bénéficier d'une évolutivité et d'un partage en équipe. Nous n'entrerons pas trop dans les détails ici, mais nous vous donnerons un aperçu général du processus.

Étapes de haut niveau:

1. Veuillez créer un projet Python et ajouter FastMCP en tant que dépendance (en utilisant des outils tels que uv).

2. Veuillez implémenter votre code serveur (par exemple, server.py) en définissant des outils personnalisés, à l'aide de transport="streamable-http".

3. Veuillez rédiger un fichier Dockerfile léger (basé sur python:slim) afin d'installer les dépendances et d'exécuter le serveur sur $PORT.

4. Veuillez activer les API requises (Cloud Run, Artifact Registry, Cloud Build).

5. Déployez directement à partir de la source ou créez/transférez un conteneur.

6. Veuillez sécuriser le service : Exigez l'authentification IAM (--no-allow-unauthenticated), accordez l'roles/run.invoker aux entités autorisées et utilisez des jetons d'identité pour les connexions client.

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

Ce processus prend moins de 10 minutes pour les serveurs simples et fournit un hébergement de qualité professionnelle avec mise à l'échelle automatique.

Configuration et intégration du serveur client Google MCP

Un serveur MCP déployé (ou activé) devient véritablement puissant lorsqu'il est connecté à un client IA. Cette section traite de la configuration des clients courants pour l'utilisation des serveurs MCP gérés par Google et de la création d'agents programmatiques.

Test avec MCP Inspector

MCP Inspector fournit une interface utilisateur web claire permettant d'explorer n'importe quel serveur MCP, y compris ceux gérés par Google. Il est particulièrement utile pour le dépannage de l'authentification, la découverte des noms/paramètres exacts des outils et la visualisation des réponses réelles.

Le processus se déroule comme suit :

1. Veuillez ouvrir l'Inspecteur.
2. Connectez-vous à un serveur MCP géré par Google.
3. Explorer et tester les outils

Pour lancer l'Inspecteur, veuillez exécuter cette commande dans votre terminal :

npx @modelcontextprotocol/inspector

Cela permet de démarrer un serveur Web local et d'ouvrir l'interface utilisateur de l'inspecteur dans votre navigateur par défaut. 

Ensuite, nous nous connectons à un serveur Google MCP. Commençons par prendre Google Maps comme exemple. 

Dans l'interface utilisateur de l'inspecteur, sur le côté gauche, nous allons configurer l'inspecteur MCP pour qu'il se connecte à notre serveur Google Maps MCP. Veuillez suivre les instructions et saisir les valeurs spécifiques :

1. Type de transport : Sélectionner HTTP diffusable

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

3. Type de connexion : Veuillez sélectionner « Via un proxy » (ceci permet de gérer l'authentification Google de manière sécurisée à l'aide de vos identifiants gcloud connectés).

4. En-têtes personnalisés : Veuillez ajouter un en-tête.

   • Clé : X-Goog-Api-Key

   • Valeur : Votre clé API Maps ( keyString, fournie lors de la configuration précédente).

5. Veuillez cliquer sur « Connecter ».

Si tout se déroule correctement, vous devriez voir l'inspecteur MCP se connecter avec succès au serveur. Dans le panneau de droite, vous pourrez accéder aux outils pris en charge par le serveur MCP de Google Maps en cliquant sur «Outils de liste d' ».

Explorons et testons les outils :

• Veuillez sélectionner un outil pour afficher son schéma JSON complet : description, paramètres (avec types et champs obligatoires) et exemples. 
• Veuillez saisir les paramètres (par exemple, requête : « meilleur café à Pune, Maharashtra ») et cliquer sur « Invoke ».
• Les résultats réels apparaissent instantanément, diffusés par lots pour les réponses volumineuses.

Pour les serveurs BigQuery et Compute, le processus est identique mais plus simple, car aucun en-tête de clé API n'est nécessaire. L'authentification s'effectue automatiquement via le proxy.

Configuration de l'interface CLI Gemini

Gemini CLI est l'agent terminal open source officiel de Google, offrant une intégration native approfondie pour les serveurs MCP. C'est la manière la plus simple de commencer à créer des workflows agencés. 

Configuration de l'interface CLI Gemini

Veuillez installer l'interface CLI Gemini à l'aide de la commande suivante :

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

Ajouter des serveurs et vérifier la connexion

Nous utiliserons à nouveau Maps comme exemple. Pour ajouter le serveur MCP Google Maps, veuillez utiliser la commande suivante et n'oubliez pas de remplacer YOUR_MAPS_API_KEY par votre clé API Maps créée précédemment.

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

Dans une nouvelle session Gemini, veuillez vérifier la connexion à l'aide de la commande /mcp list.

Lors de notre première interaction, nous posons une question simple en langage naturel : 

Quels sont les établissements proposant des petits-déjeuners abordables à New York ?

Gemini sélectionne automatiquement les outils Maps. Une fois que vous avez accepté leur exécution, le système les appelle et renvoie les résultats formatés.

Cela a fonctionné ! Nous avons reçu la réponse suivante :

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.

Le moment classique « Hello World » dans Gemini CLI : liste claire des outils après l'ajout de serveurs, suivie de requêtes en langage naturel déclenchant des appels réels à l'outil Maps. 

Utilisation de Gemini CLI avec le serveur Google Maps MCP

Afin de tester des capacités de raisonnement plus avancées en combinaison avec les données Maps, nous transmettons l'invite suivante : 

Veuillez planifier un itinéraire routier de Mumbai à Goa avec une halte panoramique pour déjeuner à mi-chemin. Veuillez recommander un restaurant de qualité dans cette région.

Lorsque vous envoyez cette invite, l'agent IA (Gemini ou Claude) effectue une boucle de raisonnement sophistiquée en plusieurs étapes en utilisant uniquement les outils MCP de Google Maps :

1. Calcul de l'itinéraire complet : L'agent effectue un appel vers compute_routes, avec Mumbai comme point de départ et Goa comme destination. Il indique une distance d'environ 566 km et une durée de trajet d'environ 11 heures 41 minutes (en tenant compte du trafic).

2. Réflexion sur le point médian : L'agent estime que la moitié du trajet (environ 280 à 300 km) se trouve dans la région de Konkan, plus précisément près de Chiplun, réputée pour ses vues sur le fleuve, ses ghats et la beauté de ses paysages.

3. Recherche de restaurants pittoresques : Il utilise search_places avec des requêtes axées sur Chiplun/Ratnagiri, en filtrant les notes élevées, les vues extérieures/paysages et la disponibilité du déjeuner.

4. Sélectionner et décrire la meilleure option : Enfin, il sélectionne un lieu remarquable (dans votre cas, le restaurant The Riverview à Chiplun) et met en avant sa terrasse et son atmosphère relaxante.

Cette réponse est générée en temps réel. La durée du trajet provient directement de l'appel à l'outil compute_routes que vous avez observé dans la sortie de débogage, et la recommandation de restaurant est basée sur les données réelles de l'API Places : aucune donnée n'est codée en dur, aucune information n'est inventée, mais il s'agit simplement d'une utilisation sécurisée et actualisée de l'outil.

Voici comment l'interface CLI Gemini appelle l'outil et affiche sa recommandation :

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

Intégration programmatique avec LangChain ou LangGraph

Au-delà des clients interactifs tels que Gemini CLI ou Claude Desktop, la véritable puissance des serveurs MCP gérés par Google se révèle lorsque vous créez des agents IA personnalisés et prêts à l'emploi dans le code. L'écosystème open source LangChain simplifie cette opération grâce au package langchain-mcp-adapters, qui transforme n'importe quel serveur MCP distant en outils LangChain standard.

Cette approche vous offre une visibilité complète sur la découverte, l'authentification et l'invocation des outils : idéale pour le débogage, la création de routeurs d'outils personnalisés ou l'intégration dans des workflows asynchrones existants.

Utilisation de LangChain pour se connecter au serveur BigQuery MCP

Pour vous permettre de mieux comprendre, illustrons cela à l'aide d'un exemple. Le script complet et exécutable suivant montre comment :

• Veuillez vous authentifier auprès de Google Cloud en utilisant les informations d'identification par défaut de l'application.

• Connectez-vous au point de terminaison MCP BigQuery géré via HTTP diffusable.

• Découvrez tous les outils disponibles

• Veuillez utiliser un outil spécifique (list_dataset_ids) et imprimer les résultats réels.

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

Lorsqu'il est exécuté dans un projet GCP correctement configuré, ce script génère un résultat similaire à celui-ci :

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

Cela confirme :

• Authentification sécurisée via ADC
• Connexion réussie avec le serveur distant géré par Google.
• Découverte complète des outils
• Exécution en direct renvoyant vos ensembles de données BigQuery réels

Ce modèle de bas niveau est particulièrement utile lorsque :

• Dépannage des problèmes de connexion ou d'autorisation
• Développement d'une logique de sélection d'outils personnalisée
• Intégration de MCP dans les services FastAPI, les tâches en arrière-plan ou les applications de streaming
• Nécessité d'un contrôle précis des flux asynchrones

Une fois la connectivité vérifiée de cette manière, vous pouvez passer en toute confiance à des frameworks de niveau supérieur tels que les agents LangGraph (comme illustré dans les exemples précédents) ou intégrer ces outils dans n'importe quel système compatible avec LangChain.

Grâce à cette base, les serveurs Google MCP constituent une extension sécurisée et prête à l'emploi de votre pile Python AI, sans nécessiter de code de liaison personnalisé.

Meilleures pratiques en matière de sécurité pour le serveur Google MCP

La sécurité n'est pas une considération secondaire avec les serveurs MCP gérés par Google. Au contraire, il est intégré dès le départ. Grâce à leur fonctionnement sur l'infrastructure de Google et à leur intégration approfondie avec la gestion des identités et des accès de Google Cloud, ces serveurs offrent des protections de niveau professionnel qui surpassent largement celles des alternatives auto-hébergées ou expérimentales.

Gestion des identités et des accès

Google Cloud utilise son solide cadre IAM (Identity and Access Management, gestion des identités et des accès) pour déterminer qui (ou quoi) peut appeler vos outils MCP.

Dans le cadre du contrôle d'accès basé sur les rôles (RBAC), chaque agent IA doit disposer de son propre compte de service dédié. Ce contrôle repose sur deux niveaux distincts d'autorisation :

• Rôle de passerelle : Pour utiliser un outil Google MCP, l'identité doit disposer du rôle roles/mcp.toolUser.

• Autorisations spécifiques au service : Étant donné qu'mcp.toolUser autorise uniquement la connexion, il est nécessaire d'accorder des autorisations spécifiques pour l'action. Par exemple, si l'IA doit interroger des données, elle a besoin d'roles/bigquery.jobUser. À l'inverse, si vous avez uniquement besoin de consulter l'état de la VM, veuillez lui attribuer l'adresse roles/compute.viewer et non roles/compute.admin.

Modèle Armor

Model Armor est un service Google Cloud conçu pour renforcer la sécurité et la sûreté de vos applications d'IA. Il fonctionne en analysant de manière proactive les invites et les réponses du LLM, en protégeant contre divers risques et en garantissant des pratiques responsables en matière d'IA. 

Que vous déployiez l'IA dans Google Cloud ou chez d'autres fournisseurs de cloud, Model Armor peut vous aider à prévenir les entrées malveillantes, à vérifier la sécurité du contenu, à protéger les données sensibles, à maintenir la conformité et à appliquer vos politiques de sécurité et de sûreté de l'IA de manière cohérente dans toutes vos applications d'IA.

Model Armor agit comme un pare-feu d'application Web (WAF) spécialisé pour l'IA :

• Assainissement rapide : Il examine chaque invite entrante à la recherche d'attaques par injection et de tentatives de jailbreak avant que la requête n'atteigne votre serveur MCP.
• Sécurité du contenu : Il filtre les contenus préjudiciables et peut être configuré à l'aide de modèles SDP (Sensitive Data Protection) afin de masquer les informations personnelles identifiables (noms, numéros de sécurité sociale, numéros de carte de crédit) dans les invites et les résultats des outils.
• Configuration des étages : Google recommande un « niveau de sécurité » spécifique pour MCP, qui comprend l'analyse obligatoire des URL malveillantes et des modèles d'injection rapide.

Observabilité et conformité

Chaque appel d'outil effectué via un serveur Google MCP constitue un événement documenté.

• Enregistrement dans le cloud : Les actions MCP sont automatiquement transmises à Cloud Logging. Cela comprend l'identifiant de l'agent, l'identifiant de session, l'outil spécifique appelé et la charge utile.

• Pistes d'audit : En activant les journaux d'accès aux données pour le service mcp.googleapis.com, vous pouvez conserver un enregistrement permanent à des fins de vérification de conformité, ce qui vous permet de répondre aux questions suivantes : « Qui (quel agent) a accédé à quelles données, et à quel moment ? »

Conclusion

Il n'est plus nécessaire d'utiliser des connecteurs personnalisés fragiles pour chaque modèle ou outil : Les serveurs MCP gérés par Google marquent un tournant pour l'IA agentique sur Google Cloud. En adoptant la norme ouverte MCP et en proposant des implémentations entièrement hébergées et de niveau entreprise pour BigQuery, Google Maps, Compute Engine et GKE, Google a éliminé les principaux obstacles à la création d'agents fiables et capables d'agir.

Comme nous l'avons vu dans ce guide, cette architecture standardisée élimine le problème du « code de liaison » et vous permet de passer de prototypes locaux à des déploiements Cloud Run sans avoir à réécrire des outils pour chaque client. De plus, grâce à Google Cloud IAM et Model Armor, vos agents sont protégés de manière native contre les menaces liées à l'intelligence artificielle moderne.

La transition du « chatbot » à l'« agent » est en cours. En maîtrisant les serveurs Google MCP, vous ne vous contentez pas de créer une IA capable de répondre à des questions, vous construisez un coéquipier numérique capable de faire fonctionner votre cloud à la vitesse de la pensée.

Êtes-vous prêt à transformer tout ce que vous avez appris dans ce guide en une expertise professionnelle ? Inscrivez-vous à notre programme de formation d'ingénieur IA associé pour développeurs.