Google lance colab-mcp : des agents qui automatisent les notebooks Colab en production

Google a lancé colab-mcp, un serveur ouvert qui permet aux agents d'IA de piloter les notebooks Google Colab via MCP et d'exécuter du code dans le runtime, sans manipulation manuelle dans l'interface.

Comment fonctionne colab-mcp

colab-mcp est un serveur MCP pour Google Colab qui transforme le notebook du navigateur en environnement de travail programmable. L'agent peut non seulement lire la structure du notebook, mais aussi ajouter des cellules, exécuter du code et recevoir les résultats sous forme de tool calls classiques.

Le tutoriel détaille la construction de ce schéma, depuis un registre d'outils de base jusqu'à un serveur complet sous FastMCP, afin que le développeur comprenne non seulement l'API, mais aussi la mécanique interne de l'enregistrement des tools, du JSON Schema et du dispatching asynchrone.

Les auteurs partent d'un MCPToolRegistry minimal, écrit à la main en Python. Cet exemple montre comment une fonction devient un outil, comment le schéma des paramètres est généré à partir des type hints et comment le client appelle un tool par son nom, avec ses arguments. L'approche est utile au-delà de Colab : elle explique le modèle MCP de base sans la magie du framework et aide à comprendre ce que fait FastMCP sous le capot lorsqu'il présente à l'agent la liste des actions disponibles.

Un accent particulier est mis sur l'architecture à deux modes adoptée par Google. En Session Proxy Mode, l'agent passe par un pont WebSocket entre le client MCP local et le Colab ouvert dans le navigateur. En Runtime Mode, il s'adresse directement au noyau et exécute du code Python sans aucune action visuelle dans l'interface. Cette séparation compte : le premier mode convient au travail interactif sur le notebook, le second aux scénarios headless, où il faut lancer des calculs directement et exécuter le code de façon stable côté runtime.

Cinq étapes vers l'agent

La partie pratique se découpe en cinq blocs indépendants, qui mènent de la démo aux patterns de production. L'auteur commence par assembler à la main un registre MCP minimal et y enregistre des outils comme execute_code, add_code_cell, add_text_cell et get_cells. La même approche est ensuite transposée à FastMCP, où l'on monte un serveur plus réaliste, avec un ensemble d'outils proxy et runtime. On obtient non pas une architecture abstraite, mais un parcours progressif : comprendre d'abord le protocole, puis remplacer les briques maison par une infrastructure éprouvée.

Le tutoriel montre ensuite à quoi ressemble la liaison en direct entre l'agent et Colab. L'exemple lance un serveur WebSocket protégé par un jeton, simule la connexion d'un client navigateur et vérifie le passage des appels JSON-RPC entre le frontend et le client MCP. Un moteur runtime est alors construit, avec état persistant, lazy initialization et gestion de la sortie dans le style Jupyter. L'agent ne voit donc pas seulement que le code a été exécuté : il obtient un résultat structuré, les erreurs et des données intermédiaires pour passer à l'étape suivante.

Le niveau suivant est une boucle d'agent complète. L'agent reçoit une tâche en langage naturel, choisit le tool approprié, exécute le code, analyse le résultat et, si nécessaire, fait un pas de plus. Selon les auteurs, ce schéma est celui utilisé dans les intégrations réelles avec Claude Code et Gemini CLI. Au final, Colab n'est plus un onglet séparé pour le travail manuel, mais un backend de calcul que le LLM peut piloter dans le cadre d'un workflow global.

• Registre MCP de base et génération de schémas
• Passage à FastMCP et à un serveur plus réaliste
• Session Proxy Mode avec WebSocket, jeton et JSON-RPC
• Runtime Mode avec exécution directe du code et état du noyau
• Boucle d'agent complète avec choix des tools et analyse des résultats

Fiabilité et lancement

La partie la plus concrète concerne l'orchestration de production au-dessus du runtime. L'article présente RobustNotebookOrchestrator, qui ajoute des relances automatiques avec exponential backoff, des timeouts via asyncio.wait_for et une exécution des cellules tenant compte des dépendances. Si une cellule échoue, les étapes downstream peuvent être ignorées, et certains blocs peuvent au besoin être exécutés de force. Cette approche est utile pour les longs notebooks, les tâches GPU et les pipelines où une erreur en cours de route ne doit pas faire s'effondrer l'ensemble de façon imprévisible, mais être correctement isolée et journalisée.

La démonstration exécute un notebook de sept cellules : plusieurs réussissent, une déclenche volontairement une NameError, une est ignorée automatiquement à cause d'une dépendance, et une autre s'exécute malgré l'échec précédent. Le système produit ensuite un rapport structuré pour chaque cellule, avec le statut, la durée et le nombre de relances. On n'est plus au niveau de la démo-jouet, mais face à une base pour de vrais scénarios de recherche et d'ingénierie, où l'observabilité, le contrôle des erreurs et la prévisibilité de l'exécution comptent.

L'auteur montre aussi une voie rapide pour démarrer sans intégration lourde : installer uv, ajouter colab-mcp à la configuration MCP, ouvrir Colab dans le navigateur et donner à l'agent une commande en langage naturel, par exemple construire un notebook d'analyse de données. Les clients locaux populaires comme Claude Code, Gemini CLI et Windsurf sont pris en charge, et pour les agents sur mesure, un modèle de connexion via API est fourni, avec description des tools et boucle de traitement de tool_use. Cela abaisse le seuil d'entrée : on peut d'abord brancher un client prêt à l'emploi, puis écrire sa propre couche d'agent.

Ce que cela change

colab-mcp fait passer Google Colab du mode notebook manuel à un environnement programmable pour agents d'IA. Pour les développeurs, c'est une voie directe vers l'automatisation de l'analyse de données, des expériences et de l'entraînement de modèles, sans écrire d'automatisation d'interface à part et sans jongler en permanence entre chat, code et navigateur. Si l'outil s'impose dans l'écosystème MCP, Colab pourrait devenir l'un des backends de calcul les plus pratiques pour les scénarios d'agents.