Cours
Introduction to Google Workspace with Gemini
30 min
2.6K
Les agents IA sont extrêmement puissants, mais ils souffrent souvent d’un défaut majeur : ils sont déconnectés de notre travail quotidien — nos emails, nos agendas et nos documents. Sans accès à vos données en direct, un LLM n’est qu’un brainstormer très éloquent.
Dans ce tutoriel, je vous montre comment combler le fossé entre les modèles d’IA et vos données d’entreprise en configurant le serveur MCP de Google Workspace, en comprenant les derniers mécanismes de sécurité et en construisant un assistant automatisé.
À la fin, vous saurez :
- Comprendre l’architecture du Model Context Protocol (MCP) appliqué à Google Workspace.
- Configurer les contrôles OAuth et l’accès API requis dans Google Cloud.
- Tester la connectivité avec Gemini CLI et Google Antigravity.
- Construire un assistant IA d’entreprise en Python avec le Google ADK capable de lire des emails, consulter votre agenda et rédiger des documents au sein d’une même boucle de raisonnement.
Prérequis
- Un projet Google Cloud avec la facturation activée.
- Des notions de base en Python et sur les APIs REST.
- Un compte Google Workspace.
Qu’est-ce que le serveur MCP Google Workspace ?
Le serveur MCP Google Workspace est une implémentation standardisée du Model Context Protocol (MCP) qui permet à n’importe quel client IA compatible (Claude Desktop, Gemini CLI ou agents personnalisés) d’interagir en toute sécurité avec les applications Google Workspace.
Au lieu de coder des wrappers REST spécifiques pour Gmail, Google Docs, Drive et Calendar à chaque nouveau projet IA, le serveur MCP expose ces capacités sous forme d’« outils » standardisés que le LLM comprend nativement.
Je vous recommande de suivre le cours Introduction to Model Context Protocol (MCP) pour en avoir une prise en main concrète.
Normalement, créer un workflow inter‑applications impose d’écrire un code d’intégration fragile. Avec MCP, vous mettez simplement les outils à disposition du LLM. L’agent peut lire un fil d’emails, détecter un conflit d’agenda en vérifiant votre calendrier et rédiger un résumé dans Google Docs, le tout en autonomie.
Sécurité et contrôles d’administration Workspace
Donner accès à des modèles d’IA à des emails et fichiers d’entreprise fait de la sécurité des données le principal frein à l’adoption.
Le serveur Workspace MCP a été conçu dès le départ pour répondre à cette exigence.
Il gère l’authentification en s’appuyant entièrement sur OAuth 2.0 et un IAM Google Cloud strict.
Il n’existe pas de « master keys » génériques. L’agent agit uniquement au nom de l’utilisateur explicitement authentifié, en respectant strictement tous les partages Google Workspace existants et les ACL des documents.
En outre, il introduit des contrôles d’administration robustes.
Les administrateurs Workspace peuvent autoriser une liste précise d’outils MCP, surveiller l’usage des APIs dans l’organisation et appliquer des règles de prévention des pertes de données (DLP) pour éviter que des agents ne divulguent par inadvertance des documents Drive sensibles ou des emails vers des domaines externes non autorisés.
Configurer l’accès au serveur MCP Workspace
Avant d’écrire du code, « configurer » signifie ici paramétrer les autorisations Google Cloud pour accéder au serveur distant.
Configuration du projet Google Cloud
Commencez par activer à la fois les APIs Workspace standard et les services MCP dédiés dans votre projet Google Cloud.
- Accédez à la Google Cloud Console.
- Activez les APIs Workspace requises : Gmail API, Google Drive API, Google Docs API et Google Calendar API.
- Activez les services MCP : gmailmcp.googleapis.com, drivemcp.googleapis.com et calendarmcp.googleapis.com.
- Allez dans APIs & Services > Écran de consentement OAuth. Configurez votre écran de consentement pour un public Interne. Sous Accès aux données > Ajouter ou supprimer des étendues, ajoutez manuellement les étendues suivantes pour les serveurs que vous prévoyez d’utiliser :
- Google Calendar : https://www.googleapis.com/auth/calendar.calendarlist.readonly, https://www.googleapis.com/auth/calendar.events.freebusy, https://www.googleapis.com/auth/calendar.events.readonly
- Google Chat : https://www.googleapis.com/auth/chat.spaces.readonly, https://www.googleapis.com/auth/chat.memberships.readonly, https://www.googleapis.com/auth/chat.messages.readonly, https://www.googleapis.com/auth/chat.users.readstate.readonly
- Google Drive : https://www.googleapis.com/auth/drive.readonly, https://www.googleapis.com/auth/drive.file
- Gmail : https://www.googleapis.com/auth/gmail.readonly, https://www.googleapis.com/auth/gmail.compose
- People API : https://www.googleapis.com/auth/directory.readonly, https://www.googleapis.com/auth/userinfo.profile, https://www.googleapis.com/auth/contacts.readonly
Générer des identifiants utilisateur
Comme les données Workspace sont propres à chaque utilisateur, le point de terminaison MCP distant exige un en‑tête Authorization : Bearer <TOKEN> représentant l’utilisateur humain.
Allez dans APIs & Services > Identifiants et créez un ID client OAuth 2.0 (type Application de bureau).
Téléchargez le fichier JSON des identifiants. Il servira à obtenir le jeton d’accès OAuth 2.0 nécessaire via un parcours de connexion dans le navigateur.
Cliquez sur Create et copiez le Client ID et le Client Secret. Vous en aurez besoin à l’étape suivante.
Tester la connexion (Gemini CLI et Antigravity)
Avant d’écrire le moindre code Python complexe, il est fortement recommandé d’effectuer un test « Hello World » pour valider vos identifiants et vérifier l’accessibilité des points de terminaison MCP distants.
Tester la connexion dans un environnement simplifié permet d’isoler les problèmes d’authentification de votre logique applicative.
Même si la connexion peut être testée avec Gemini CLI et l’interface Google Antigravity, nous allons nous concentrer ici sur Gemini CLI.
Connexion via Gemini CLI
Le moyen le plus rapide de tester la connectivité est d’utiliser Gemini CLI.
Étant donné que Workspace impose une authentification stricte, vous devez configurer le point de terminaison et vos identifiants OAuth dans votre fichier ~/.gemini/settings.json :
{
"mcpServers": {
"calendar": {
"httpUrl": "https://calendarmcp.googleapis.com/mcp/v1",
"oauth": {
"enabled": true,
"clientId": "<YOUR_CLIENT_ID>",
"clientSecret": "<YOUR_CLIENT_SECRET>",
"scopes": [
"https://www.googleapis.com/auth/calendar.calendarlist.readonly",
"https://www.googleapis.com/auth/calendar.events.freebusy",
"https://www.googleapis.com/auth/calendar.events.readonly"
]
}
},
"drive": {
"httpUrl": "https://drivemcp.googleapis.com/mcp/v1",
"oauth": {
"enabled": true,
"clientId": "<YOUR_CLIENT_ID>",
"clientSecret": "<YOUR_CLIENT_SECRET>",
"scopes": [
"https://www.googleapis.com/auth/drive.readonly",
"https://www.googleapis.com/auth/drive.file"
]
}
},
"gmail": {
"httpUrl": "https://gmailmcp.googleapis.com/mcp/v1",
"oauth": {
"enabled": true,
"clientId": "<YOUR_CLIENT_ID>",
"clientSecret": "<YOUR_CLIENT_SECRET>",
"scopes": [
"https://www.googleapis.com/auth/gmail.readonly",
"https://www.googleapis.com/auth/gmail.compose"
]
}
}
}
}
Une fois votre fichier de configuration à jour, lancez Gemini CLI et exécutez la commande /mcp list.
Vous verrez les serveurs Workspace nouvellement configurés listés comme « Ready » mais indiquant « (OAuth not authenticated) ».
Cela confirme que le CLI a bien lu votre configuration et connaît les outils distants.
Exécuter des tests Workspace de base
Maintenant que les serveurs sont reconnus, vous devez vous authentifier avant de pouvoir les utiliser. Commencez par exécuter la commande d’authentification pour votre point de terminaison Gmail :
/mcp auth gmailCela lance un parcours OAuth 2.0 dans le navigateur.
Le CLI va tenter d’ouvrir automatiquement votre navigateur par défaut, vous invitant à vous connecter avec votre compte Google Workspace et à accorder les autorisations demandées.
Si le navigateur ne s’ouvre pas automatiquement, le CLI fournira une URL sécurisée à copier‑coller. Une fois l’authentification terminée, le CLI confirmera la réussite et rechargera les outils pour ce serveur.
Une fois authentifié, vous pouvez tester la connexion avec une invite en langage naturel :
my email for any messages containing the word 'Invoice'.Le CLI exécutera l’outil en arrière‑plan, récupèrera les données de votre boîte de réception et l’agent les formatera en une réponse utile :
Projet démo : créer un agent Workspace avec Google ADK
Créons un agent Workspace qui se connecte aux cinq services (Calendar, Chat, Drive, Gmail, People) et gère l’authentification de manière sécurisée.
Générer des Application Default Credentials (auth.py)
Avant de s’exécuter, l’agent a besoin d’un jeton OAuth à transmettre aux points de terminaison MCP.
Gemini CLI gère cela automatiquement avec /mcp auth, mais pour une application Python, nous devons générer notre propre jeton et l’enregistrer en tant qu’Application Default Credentials (ADC).
Créez un fichier nommé auth.py à la racine du projet. Assurez‑vous d’avoir votre client_secret.json téléchargé dans le même répertoire.
Ce script utilise la bibliothèque officielle google-auth-oauthlib pour générer une URL d’authentification, échanger le code contre un refresh token et l’écrire dans le chemin standard ~/.config/gcloud/application_default_credentials.json, où l’ADK pourra le trouver.
import json
import os
from urllib.parse import urlparse, parse_qs
import google.auth
from google_auth_oauthlib.flow import InstalledAppFlow
CLIENT_SECRET_FILE = 'client_secret.json'
SCOPES = [
"https://www.googleapis.com/auth/cloud-platform",
"https://www.googleapis.com/auth/calendar",
"https://www.googleapis.com/auth/chat.spaces.readonly",
"https://www.googleapis.com/auth/chat.messages",
"https://www.googleapis.com/auth/drive.readonly",
"https://www.googleapis.com/auth/gmail.readonly",
"https://www.googleapis.com/auth/gmail.compose",
"https://www.googleapis.com/auth/directory.readonly",
"https://www.googleapis.com/auth/contacts.readonly"
]
# Initialize the flow
flow = InstalledAppFlow.from_client_secrets_file(
CLIENT_SECRET_FILE,
scopes=SCOPES,
redirect_uri='http://localhost:8085/'
)
# Generate Auth URL
auth_url, expected_state = flow.authorization_url(prompt='consent', access_type='offline')
print("Copy this link and paste it into your browser:\\n", auth_url)
redirected_url = input("\\nPaste the full localhost URL here: ").strip()
# Exchange code for tokens
parsed_url = urlparse(redirected_url)
code = parse_qs(parsed_url.query).get('code', [None])[0]
flow.fetch_token(code=code)
# Save ADC
adc_data = {
"client_id": flow.credentials.client_id,
"client_secret": flow.credentials.client_secret,
"refresh_token": flow.credentials.refresh_token,
"type": "authorized_user"
}
adc_path = os.path.expanduser("~/.config/gcloud/application_default_credentials.json")
os.makedirs(os.path.dirname(adc_path), exist_ok=True)
with open(adc_path, "w") as f:
json.dump(adc_data, f, indent=2)
print(f"Success! ADC saved to: {adc_path}")Exécutez le script dans votre terminal : python3 auth.py
Lors de l’exécution, vous devrez suivre une authentification manuelle :
- Le script affiche une longue URL OAuth Google commençant par https://accounts.google.com/o/oauth2/auth?...
- Copiez l’URL complète depuis votre terminal et collez‑la dans votre navigateur.
- Sélectionnez votre compte Google Workspace et cliquez sur Allow pour autoriser l’application.
- Votre navigateur vous redirigera ensuite vers une page localhost. Remarque : il est tout à fait normal que votre navigateur affiche une erreur « Site can't be reached » pour cette page.
- Copiez l’URL complète depuis la barre d’adresse (elle commence par http://localhost:8085/?state=...&code=...).
- Collez cette URL complète dans votre terminal à l’invite Paste the full localhost URL here: puis appuyez sur Entrée.
Le script échangera le code contre un jeton OAuth, l’enregistrera dans ~/.config/gcloud/application_default_credentials.json, et générera un fichier .env dans votre répertoire workspace_agent contenant les paramètres de votre projet Google Cloud.
Votre environnement local est maintenant entièrement authentifié !
Construire l’agent (agent.py)
Créez maintenant un fichier nommé agent.py.
Comme les données Workspace sont très sensibles, les serveurs MCP exigent que le jeton d’accès que nous venons de générer soit injecté dans les en‑têtes HTTP de chaque requête.
Nous devons également configurer l’environnement ADK de manière sécurisée.
Décomposons le code :
1. Environnement et mise en cache du jeton (TokenRelay)
Nous chargeons d’abord les Application Default Credentials (ADC) de l’utilisateur générés à l’étape précédente.
Un point clé pour les agents en entreprise est de mettre en cache les jetons efficacement. Si nous les actualisons à chaque exécution d’outil, nous risquons d’atteindre des limites d’API ou de déclencher des boucles d’actualisation infinies lors des relances.
La classe TokenRelay met le jeton en cache en mémoire et ne le renouvelle que lorsqu’il est à moins de 5 minutes de son expiration.
import os
import datetime
import google.auth
from google.auth.transport.requests import Request
from google.adk.agents.llm_agent import LlmAgent
from google.adk.tools.mcp_tool.mcp_toolset import McpToolset
from google.adk.tools.mcp_tool.mcp_session_manager import StreamableHTTPConnectionParams
# Enable graceful error handling so timeouts return as tool outputs
os.environ["ADK_ENABLE_MCP_GRACEFUL_ERROR_HANDLING"] = "1"
# Inject User ADC path globally
_adc_path = os.path.expanduser("~/.config/gcloud/application_default_credentials.json")
if not os.path.exists(_adc_path):
raise FileNotFoundError("Please run 'python3 auth.py' first to generate credentials.")
os.environ["GOOGLE_APPLICATION_CREDENTIALS"] = _adc_path
creds, _ = google.auth.default()
class TokenRelay:
"""Manages in-memory caching of Google OAuth access tokens."""
def __init__(self, credentials):
self._creds = credentials
self._cached_token = None
self._expiry = None
def get_token(self) -> str:
now = datetime.datetime.now()
if (self._cached_token is None or self._expiry is None
or now >= (self._expiry - datetime.timedelta(minutes=5))):
self._creds.refresh(Request())
self._cached_token = self._creds.token
self._expiry = now + datetime.timedelta(minutes=50)
return self._cached_token or ""
token_relay = TokenRelay(creds)
token_relay.get_token()
def auth_header_provider(tool_context=None) -> dict[str, str]:
return {"Authorization": f"Bearer {token_relay.get_token()}"}
2. Configurer les jeux d’outils MCP
Avec notre cache de jeton prêt, nous configurons nos 5 connexions MCP. Nous utilisons StreamableHTTPConnectionParams pour nous connecter aux points de terminaison SSE (Server‑Sent Events).
La force de McpToolset est d’interroger dynamiquement le point de terminaison distant. Il récupère automatiquement les outils disponibles et leurs schémas JSON. Vous n’avez rien à coder en dur !
# Initialize the 5 GWS MCP servers with dynamic runtime provider
calendar_mcp = McpToolset(
connection_params=StreamableHTTPConnectionParams(url="https://calendarmcp.googleapis.com/mcp/v1"),
header_provider=auth_header_provider
)
chat_mcp = McpToolset(
connection_params=StreamableHTTPConnectionParams(url="https://chatmcp.googleapis.com/mcp/v1"),
header_provider=auth_header_provider
)
drive_mcp = McpToolset(
connection_params=StreamableHTTPConnectionParams(url="https://drivemcp.googleapis.com/mcp/v1"),
header_provider=auth_header_provider
)
gmail_mcp = McpToolset(
connection_params=StreamableHTTPConnectionParams(url="https://gmailmcp.googleapis.com/mcp/v1"),
header_provider=auth_header_provider
)
people_mcp = McpToolset(
connection_params=StreamableHTTPConnectionParams(url="https://people.googleapis.com/mcp/v1"),
header_provider=auth_header_provider
)3. Initialiser l’agent
Enfin, nous instancions notre LlmAgent. Nous utilisons le modèle gemini-2.5-flash, injectons dynamiquement la date du jour dans l’invite système pour que le LLM comprenne le temps relatif (« cette semaine », « aujourd’hui »), et lui transmettons les 5 jeux d’outils.
current_date = datetime.datetime.now().strftime("%Y-%m-%d")
root_agent = LlmAgent(
model="gemini-2.5-flash",
name='gws_adk_agent',
instruction=f"""You are a helpful assistant grounded in the user's Google Workspace data.
Today's current date is {current_date}. Always calculate relative dates (like 'this week' or 'upcoming meetings') using this reference.
Use the provided MCP tools to answer questions about their Calendar, Chat, Drive, Gmail, and Contacts.
If a tool returns an error indicating a timeout, inform the user that the service took too long to respond.""",
tools=[calendar_mcp, chat_mcp, drive_mcp, gmail_mcp, people_mcp]
)Exécution avec ADK Web
Plutôt que d’écrire une boucle Python maison, nous pouvons tester et exécuter immédiatement cet agent via l’interface ADK Web intégrée. Depuis votre terminal, lancez le serveur web :
adk web Cela démarre un serveur de développement local. Accédez à http://localhost:8080 dans votre navigateur.
Votre agent est chargé et prêt.
Depuis cette interface, vous pouvez dialoguer avec l’agent nativement et le voir passer sans couture entre Gmail, Calendar et Drive pour répondre à vos demandes !
Tester l’agent en conditions réelles
Maintenant que l’agent tourne, interrogez‑le avec des requêtes complexes et transverses qui vous feraient normalement ouvrir trois onglets différents.
Par exemple :
Invite 1 : Consulte mon agenda pour demain et résume les thématiques de mes réunions. Y a‑t‑il des documents pertinents dans mon Drive pour ces rendez‑vous ?
Ce qui se passe en coulisses :
- L’agent comprend qu’il a d’abord besoin des données d’agenda et exécute l’outil list_events, en calculant dynamiquement la date de demain depuis l’invite système.
- Il analyse la réponse JSON pour identifier les titres des réunions.
- Constatant qu’il lui faut des documents associés, il extrait des mots‑clés de ces titres et les transmet sans couture à un second appel d’outil : search_files.
- Enfin, il synthétise les résultats de Calendar et Drive en un seul brief clair et lisible.
Au lieu d’écrire des wrappers d’API et une logique d’intégration, vous avez simplement posé une question, et le LLM a orchestré les étapes multiples.
Invite 2 : Retrouve tous les emails envoyés par [Insérer l’email] au cours des 7 derniers jours.
Ce qui se passe en coulisses :
- L’agent traduit automatiquement votre demande en langage naturel dans la syntaxe exacte attendue par l’API Gmail.
- Il appelle l’outil search_threads en lui passant la requête générée dynamiquement.
- Il récupère les fils récents, en extrait les métadonnées pertinentes et vous renvoie objets et dates de manière soignée.
Autres invites à essayer
Les possibilités sont immenses lorsque toutes vos données d’entreprise sont connectées à un moteur de raisonnement.
Essayez ces autres invites dans votre environnement local :
- « Trouve le dernier email que j’ai reçu de mon manager. M’a‑t‑il demandé quelque chose ? »
- « Trouve le diaporama de lancement de projet dans mon Drive, lis son contenu et dis‑moi quels sont les objectifs du T3. »
- « Y a‑t‑il des conflits de planning dans mon agenda pour la semaine prochaine ? »
Et ensuite ? Vers l’automatisation d’entreprise
En combinant l’Agent Development Kit de Google avec les serveurs MCP Workspace standardisés, vous venez de créer un assistant de niveau entreprise en moins de cent lignes de code.
Et ce n’est qu’un début.
Voici ce que cette architecture permet aux développeurs et aux entreprises :
- Systèmes multi‑agents : plutôt qu’un agent monolithique, vous pouvez utiliser l’ADK pour bâtir une flotte de sous‑agents spécialisés. L’un gère spécifiquement votre agenda et résout les conflits de planning, un autre surveille strictement une boîte partagée d’équipe et catégorise les demandes entrantes.
- Outils d’entreprise personnalisés : MCP étant un standard, vous n’êtes pas limité à Workspace. Vous pouvez facilement ajouter d’autres outils MCP à votre agent — par exemple un serveur MCP Postgres pour interroger la base de ventes de votre société, ou un serveur MCP Jira pour créer automatiquement des tickets à partir de messages Chat.
- Workflows automatisés : vous pouvez extraire cet agent de l’UI ADK Web et le déployer sans interface. Imaginez une tâche CRON qui réveille votre agent chaque matin à 8 h, analyse votre boîte et votre agenda, puis vous envoie un brief synthétique via Google Chat.
Conclusion
Le serveur MCP Google Workspace supprime le « glue code » nécessaire pour connecter l’IA aux applications de productivité d’entreprise. En fournissant un point de terminaison distant sécurisé et entièrement géré, il permet aux développeurs de créer des workflows agentiques profondément intégrés qui respectent les permissions utilisateur et les standards de sécurité d’entreprise dès le départ.
Rappel de bonnes pratiques : appliquez toujours le principe du moindre privilège.
Lors de l’attribution d’étendues OAuth à vos agents IA, n’accordez jamais un accès en écriture (par ex. https://www.googleapis.com/auth/drive.file) si l’agent n’a besoin que de lire des données.
Prêt à construire ?
Poursuivez votre apprentissage avec nos cours guidés DataCamp :
