Google lança colab-mcp: como agentes automatizam notebooks Colab em produção

Google lançou um servidor colab-mcp de código aberto que permite que agentes de IA gerenciem notebooks do Google Colab através de MCP e executem código em tempo de execução sem trabalho manual na interface.

Como o colab-mcp funciona

colab-mcp é um servidor MCP para Google Colab que transforma um notebook do navegador em um ambiente de trabalho programável. Um agente não apenas pode ler a estrutura do notebook, mas também adicionar células, executar código e obter resultados de volta como chamadas de ferramenta normais. A análise mostra como esse esquema é montado desde um registro de ferramentas básico até um servidor FastMCP completo, para que os desenvolvedores entendam não apenas a API, mas a mecânica interna do registro de ferramentas, JSON Schema e dispatching assíncrono.

Os autores começam com um MCPToolRegistry mínimo construído manualmente em Python. Esse exemplo mostra como uma função se torna uma ferramenta, como type hints constroem um esquema de parâmetros e como o cliente chama uma ferramenta por nome com argumentos. Essa abordagem é útil além do Colab: explica o modelo MCP básico sem magia de framework e ajuda a entender o que o FastMCP faz por baixo dos panos quando os agentes recebem a lista de ações disponíveis.

Ênfase especial é colocada na arquitetura de dois modos do Google. No Session Proxy Mode, o agente funciona através de uma ponte WebSocket entre um cliente MCP local e o Colab aberto no navegador. No Runtime Mode, ele vai diretamente para o kernel e executa código Python sem ações visuais na interface.

Essa separação é importante: o primeiro modo é conveniente para trabalho interativo com notebooks, o segundo é para cenários headless, onde é necessária execução direta de computações e execução estável de código no lado do runtime.

Cinco passos para um agente

A parte prática é dividida em cinco blocos independentes que levam de demonstração para padrões de produção. Primeiro, o autor monta um registro MCP mínimo manualmente e registra ferramentas como execute_code, add_code_cell, add_text_cell e get_cells. Então a mesma abordagem é transferida para FastMCP, onde um servidor mais realista é iniciado com um conjunto de ferramentas proxy e runtime.

Isso fornece não uma arquitetura abstrata, mas um caminho sequencial: primeiro entender o protocolo, depois substituir componentes caseiros por infraestrutura funcional. A seguir, o tutorial mostra como é uma conexão ao vivo entre um agente e o Colab. No exemplo, um servidor WebSocket seguro é iniciado com um token, a conexão do cliente do navegador é emulada e as chamadas JSON-RPC são verificadas entre o frontend e o cliente MCP.

Depois disso, um motor de runtime é construído com estado persistente, inicialização lazy e tratamento de saída em estilo Jupyter. Ou seja, o agente não apenas vê o fato da execução do código, mas um resultado estruturado, erros e dados intermediários que podem ser usados para continuar com a próxima etapa. O próximo nível é um ciclo de agente completo.

Ele recebe uma tarefa em linguagem natural, seleciona a ferramenta certa, executa código, analisa o resultado e, se necessário, faz outro passo. Esse é exatamente o padrão usado em integrações reais com Claude Code e Gemini CLI, de acordo com os autores. Como resultado, o Colab se torna não uma aba separada para trabalho manual, mas um backend computacional que um LLM pode gerenciar como parte de um fluxo de trabalho geral.

• Registro MCP básico e geração de esquema
• Transição para FastMCP e um servidor mais realista
• Session Proxy Mode com WebSocket, token e JSON-RPC
• Runtime Mode com execução direta de código e estado do kernel
• Ciclo completo do agente com seleção de ferramentas e análise de resultados

Confiabilidade e lançamento

A parte mais prática é orquestração de produção sobre o runtime. O artigo mostra RobustNotebookOrchestrator, que adiciona tentativas automáticas com exponential backoff, timeouts via asyncio.wait_for e execução de células dependentes.

Se uma célula falhar, as etapas downstream podem ser ignoradas e blocos individuais podem ser forçados a executar se necessário. Essa abordagem é útil para notebooks longos, tarefas GPU e pipelines onde um erro no meio não deveria quebrar de forma imprevisível o processo inteiro, mas deveria ser corretamente localizado e registrado em log. Na demonstração, um notebook com sete células é executado: várias passam com sucesso, uma intencionalmente dispara um NameError, uma é automaticamente ignorada devido a uma dependência e outra é executada apesar da falha anterior.

O sistema então gera um relatório estruturado para cada célula com status, duração e número de tentativas. Isso não é mais o nível de demos triviais, mas um template para cenários reais de pesquisa e engenharia onde observabilidade, controle de erros e previsibilidade de execução importam. O autor também mostra um caminho rápido para lançamento sem integração importante: instalar uv, adicionar colab-mcp ao config MCP, abrir Colab em um navegador e dar ao agente um comando em linguagem natural, como construir um notebook para análise de dados.

Clientes locais populares como Claude Code, Gemini CLI e Windsurf são suportados, e para agentes personalizados, um template para conexão via API é mostrado com descrições de ferramentas e um loop de processamento tool_use. Isso reduz a barreira de entrada: primeiro você pode conectar um cliente pronto e depois escrever seu próprio wrapper de agente.

O que isso significa

colab-mcp move Google Colab do modo de notebook manual para um ambiente programável para agentes de IA. Para desenvolvedores, este é um caminho direto para automatizar análise de dados, experimentos e treinamento de modelos sem escrever automação de UI separada e sem ficar constantemente alternando entre chat, código e navegador. Se a ferramenta se consolidar no ecossistema MCP, o Colab pode se tornar um dos backends computacionais mais convenientes para cenários de agentes.