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

Google a lancé un serveur colab-mcp open source qui permet aux agents IA de gérer les notebooks Google Colab via MCP et d'exécuter du code au moment de l'exécution sans travail manuel dans l'interface.

Comment fonctionne colab-mcp

colab-mcp est un serveur MCP pour Google Colab qui transforme un notebook de navigateur en un environnement de travail programmable. Un agent peut non seulement lire la structure du notebook, mais aussi ajouter des cellules, exécuter du code et récupérer les résultats sous forme d'appels d'outils ordinaires. La décomposition montre comment ce schéma est assemblé à partir d'un registre d'outils basique jusqu'à un serveur FastMCP complet, afin que les développeurs comprennent non seulement l'API mais la mécanique interne de l'enregistrement des outils, JSON Schema et la distribution asynchrone.

Les auteurs commencent par un MCPToolRegistry minimal construit manuellement en Python. Cet exemple montre comment une fonction devient un outil, comment les type hints construisent un schéma de paramètres et comment le client appelle un outil par son nom avec des arguments. Cette approche est utile au-delà de Colab : elle explique le modèle MCP basique sans la magie du framework et aide à comprendre ce que FastMCP fait sous le capot quand les agents voient la liste des actions disponibles.

Une attention particulière est accordée à l'architecture à double mode de Google. En Session Proxy Mode, l'agent fonctionne via un pont WebSocket entre un client MCP local et Colab ouvert dans le navigateur. En Runtime Mode, il va directement au kernel et exécute du code Python sans actions visuelles dans l'interface.

Cette séparation est importante : le premier mode est pratique pour le travail interactif avec les notebooks, le second pour les scénarios headless, où l'exécution directe des calculs et l'exécution stable du code du côté du runtime sont nécessaires.

Cinq étapes vers un agent

La partie pratique est divisée en cinq blocs indépendants qui mènent de la démo aux modèles de production. D'abord, l'auteur assemble un registre MCP minimal manuellement et enregistre des outils comme execute_code, add_code_cell, add_text_cell et get_cells. Ensuite, la même approche est transférée à FastMCP, où un serveur plus réaliste est lancé avec un ensemble d'outils proxy et runtime.

Cela fournit non pas une architecture abstraite mais un chemin séquentiel : d'abord comprendre le protocole, puis remplacer les composants maison par une infrastructure fonctionnelle. Ensuite, le tutoriel montre à quoi ressemble une connexion en direct entre un agent et Colab. Dans l'exemple, un serveur WebSocket sécurisé est lancé avec un token, la connexion du client navigateur est émulée et les appels JSON-RPC sont vérifiés entre le frontend et le client MCP.

Après cela, un moteur runtime est construit avec état persistant, initialisation lazy et gestion de la sortie en style Jupyter. C'est-à-dire que l'agent ne voit pas seulement le fait de l'exécution du code mais un résultat structuré, des erreurs et des données intermédiaires qui peuvent être utilisées pour continuer à l'étape suivante. Le niveau suivant est une boucle d'agent complète.

Elle reçoit une tâche en langage naturel, sélectionne l'outil approprié, exécute du code, analyse le résultat et si nécessaire, fait une autre étape. C'est exactement le modèle utilisé dans les intégrations réelles avec Claude Code et Gemini CLI, selon les auteurs. En résultat, Colab devient non pas un onglet séparé pour le travail manuel mais un backend computationnel qu'un LLM peut gérer comme partie d'un flux de travail général.

• Registre MCP basique et génération de schéma
• Transition vers FastMCP et un serveur plus réaliste
• Session Proxy Mode avec WebSocket, token et JSON-RPC
• Runtime Mode avec exécution directe du code et état du kernel
• Boucle d'agent complète avec sélection d'outils et analyse des résultats

Fiabilité et lancement

La partie la plus pratique est l'orchestration de production en haut du runtime. L'article montre RobustNotebookOrchestrator, qui ajoute des tentatives automatiques avec exponential backoff, des timeouts via asyncio.wait_for et l'exécution dépendante des cellules.

Si une cellule échoue, les étapes downstream peuvent être ignorées et des blocs individuels peuvent être forcés de s'exécuter si nécessaire. Cette approche est utile pour les longs notebooks, les tâches GPU et les pipelines où une erreur au milieu ne devrait pas casser de manière imprévisible tout le processus mais devrait être correctement localisée et enregistrée. Dans la démonstration, un notebook avec sept cellules est exécuté : plusieurs réussissent, une déclenche intentionnellement un NameError, une est automatiquement ignorée en raison 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 statut, durée et nombre de tentatives. Ce n'est plus le niveau des démos jouets mais un modèle pour les scénarios réels de recherche et d'ingénierie où l'observabilité, le contrôle des erreurs et la prévisibilité de l'exécution importent. L'auteur montre également un chemin rapide pour lancer sans intégration majeure : installer uv, ajouter colab-mcp à la config MCP, ouvrir Colab dans un navigateur et donner à l'agent une commande en langage naturel, par exemple construire un notebook pour l'analyse de données.

Les clients locaux populaires comme Claude Code, Gemini CLI et Windsurf sont supportés, et pour les agents personnalisés, un modèle pour la connexion via API est montré avec les descriptions d'outils et une boucle de traitement tool_use. Cela abaisse le seuil d'entrée : d'abord vous pouvez connecter un client prêt, puis écrire votre propre wrapper d'agent.

Ce que cela signifie

colab-mcp fait passer Google Colab du mode notebook manuel vers un environnement programmable pour les agents IA. Pour les développeurs, c'est un chemin direct pour automatiser l'analyse de données, les expériences et l'entraînement de modèles sans écrire une automatisation UI séparée et sans basculer constamment entre chat, code et navigateur. Si l'outil s'établit dans l'écosystème MCP, Colab pourrait devenir l'un des backends computationnels les plus pratiques pour les scénarios d'agents.