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

O Google lançou o colab-mcp, um servidor aberto que permite a agentes de IA controlar notebooks do Google Colab via MCP e executar código no runtime sem trabalho manual na interface.

Como o colab-mcp funciona

O colab-mcp é um servidor MCP para o Google Colab que transforma o notebook no navegador em um ambiente de trabalho programável. O agente pode não só ler a estrutura do notebook, mas também adicionar células, executar código e receber os resultados de volta como tool calls comuns.

O tutorial mostra como esse esquema é montado, desde um registro básico de ferramentas até um servidor completo em FastMCP, para que o desenvolvedor entenda não só a API, mas também a mecânica interna do registro de tools, do JSON Schema e do despacho assíncrono.

Os autores começam com um MCPToolRegistry mínimo, escrito à mão em Python. Nesse exemplo, vê-se como uma função vira uma ferramenta, como o esquema de parâmetros é gerado a partir de type hints e como o cliente chama a tool pelo nome, com argumentos. A abordagem é útil além do Colab: ela explica o modelo básico do MCP sem a mágica do framework e ajuda a entender o que o FastMCP faz por baixo dos panos quando mostra ao agente a lista de ações disponíveis.

Há ainda um destaque para a arquitetura de dois modos adotada pelo Google. No Session Proxy Mode, o agente trabalha por uma ponte WebSocket entre o cliente MCP local e o Colab aberto no navegador. No Runtime Mode, ele vai direto ao kernel e executa código Python sem ações visuais na interface. A separação é importante: o primeiro modo é conveniente para o trabalho interativo com o notebook; o segundo, para cenários headless, em que é preciso executar cálculos diretamente e rodar código de forma estável no lado do runtime.

Cinco passos até o agente

A parte prática é dividida em cinco blocos independentes, que levam do demo aos padrões de produção. Primeiro, o autor monta à mão um registro MCP mínimo e registra ferramentas como execute_code, add_code_cell, add_text_cell e get_cells. Depois, a mesma abordagem é levada ao FastMCP, onde sobe um servidor mais realista, com um conjunto de ferramentas de proxy e de runtime. O resultado não é uma arquitetura abstrata, mas um caminho em sequência: primeiro entender o protocolo, depois trocar as peças caseiras por infraestrutura de verdade.

Em seguida, o tutorial mostra como é a conexão ao vivo entre o agente e o Colab. No exemplo, sobe um servidor WebSocket protegido por token, simula-se a conexão de um cliente de navegador e verifica-se a passagem de chamadas JSON-RPC entre o frontend e o cliente MCP. Depois disso, é construído um motor de runtime com estado persistente, lazy initialization e tratamento de saída no estilo Jupyter. Ou seja, o agente não vê apenas que o código foi executado, mas um resultado estruturado, erros e dados intermediários com os quais pode seguir para o próximo passo.

O nível seguinte é um ciclo de agente completo. Ele recebe uma tarefa em linguagem natural, escolhe a tool adequada, executa o código, analisa o resultado e, se necessário, dá mais um passo. Segundo os autores, é esse o padrão usado em integrações reais com Claude Code e Gemini CLI. No fim, o Colab deixa de ser uma aba separada para trabalho manual e vira um backend de computação que o LLM pode controlar como parte de um workflow maior.

• Registro MCP básico e geração de esquemas
• Migração para o 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
• Agent loop completo com escolha de tools e análise de resultados

Confiabilidade e execução

A parte mais aplicada é a orquestração de produção sobre o runtime. O artigo apresenta o RobustNotebookOrchestrator, que adiciona retentativas automáticas com exponential backoff, timeouts via asyncio.wait_for e execução de células com dependências. Se uma célula falha, as etapas downstream podem ser puladas, e blocos específicos podem ser executados à força, se necessário. A abordagem é útil para notebooks longos, tarefas de GPU e pipelines em que um erro no meio não deve derrubar todo o processo de forma imprevisível, mas ser isolado e registrado corretamente.

Na demonstração, roda um notebook de sete células: várias terminam com sucesso, uma provoca propositalmente um NameError, outra é pulada automaticamente por causa de uma dependência, e mais uma é executada apesar da falha anterior. Em seguida, o sistema gera um relatório estruturado por célula, com status, duração e número de tentativas. Já não é um demo de brinquedo, e sim a base para cenários reais de pesquisa e engenharia, em que observabilidade, controle de erros e previsibilidade de execução importam.

O autor também mostra um caminho rápido para começar sem grande integração: instalar o uv, adicionar o colab-mcp à configuração MCP, abrir o Colab no navegador e dar ao agente um comando em linguagem natural, por exemplo, montar um notebook para análise de dados. Há suporte a clientes locais populares, como Claude Code, Gemini CLI e Windsurf, e, para agentes customizados, é apresentado um modelo de conexão via API, com descrição das tools e um ciclo de tratamento de tool_use. Isso reduz a barreira de entrada: dá para conectar primeiro um cliente pronto e só depois escrever a própria camada de agente.

O que isso significa

O colab-mcp empurra o Google Colab do modo de notebook manual para um ambiente programável para agentes de IA. Para os desenvolvedores, é um caminho direto para automatizar análise de dados, experimentos e treinamento de modelos, sem escrever uma automação de UI à parte e sem alternar o tempo todo entre chat, código e navegador. Se a ferramenta se firmar no ecossistema MCP, o Colab pode se tornar um dos backends de computação mais convenientes para cenários com agentes.