Colab-MCP

Colab-MCP

Un servidor MCP que permite a un agente de IA (Claude, o cualquier cliente MCP) usar Google Colab de principio a fin: crear y detener runtimes de GPU/TPU, ejecutar código, trabajar en notebooks celda por celda, lanzar trabajos largos en segundo plano, y mover archivos y carpetas dentro y fuera de la VM.

Es una capa delgada y segura sobre la CLI de Colab oficial de Google (google-colab-cli). No reimplementa Colab y no depende de una pestaña del navegador.

🇪🇸 Resumen en español al final de este archivo.

Estado

• Probado contra una CLI simulada (118 verificaciones, más 129 para Drive contra una API de Drive simulada, 28 para el montaje de Drive y 17 para limpieza local; tests/): un cliente MCP real habla con el servidor a través de stdio y el código que normalmente se ejecuta en la VM se ejecuta de verdad en una carpeta sandbox.
• Aún no validado contra Colab en vivo. El inicio de sesión y una primera ejecución real son el siguiente paso; los comportamientos que la CLI no documenta (listados en Incógnitas conocidas) se indican a continuación.
• Solo Linux y macOS (la CLI de Colab no soporta Windows).

Herramientas (42 + 8 herramientas opcionales de Drive)

Área	Herramientas
Runtimes	colab_new, colab_ensure_session, colab_sessions, colab_status, colab_runtime_info, colab_restart_kernel, colab_url, colab_usage, colab_stop, colab_install
Ejecutar código	colab_exec (código o archivo; el estado del kernel persiste entre llamadas), colab_run (de un solo uso: VM nueva → script → liberación)
Notebooks (.ipynb local)	colab_notebook_create, _list, _read, _add_cell, _edit_cell, _delete_cell, _move_cell, _clear_outputs, _run_cell, _run_all, _to_script, _delete
Trabajos largos	colab_job_start, _status, _logs, _cancel, _list
Archivos	colab_upload, colab_download, colab_upload_dir, colab_download_dir, colab_ls, colab_rm, colab_log
Drive en la VM	colab_drive_status, colab_drive_mount_start, colab_drive_mount_finish, colab_drive_project_dir (ver Proyectos grandes y Drive)
Huella local	colab_local_footprint, colab_local_cleanup (ver Dónde se guardan las cosas)

Flujos típicos:

• Interactivo: colab_ensure_session(gpu="T4") → colab_notebook_create → añadir celdas → colab_notebook_run_cell una por una (las variables persisten) → leer salidas → colab_stop.
• Por lotes: colab_upload_dir → colab_job_start("python -u train.py") → consultar colab_job_logs → colab_download_dir → colab_stop.

Los proyectos y notebooks de Google Drive son una función separada y opcional (abajo). Deliberadamente no incluidos en ninguna parte: inicio de sesión a través de una herramienta, colab auth, repl, console, ssh, edit. Son interactivos y no pueden funcionar a través de una llamada de herramienta.

Modelo de seguridad

• Las rutas locales están confinadas a COLAB_MCP_WORKDIR. ../, las rutas absolutas y los enlaces simbólicos que escapan se rechazan antes de que se ejecute nada.
• Los secretos nunca llegan al modelo. COLAB_MCP_ENV_FILE apunta a un archivo NAME=value local. El modelo solo pasa nombres (secrets=["OPENROUTER_API_KEY"]); los valores van al kernel con --env y se eliminan de cada resultado. Limitación conocida: mientras el comando se ejecuta, el valor es visible para otros usuarios locales en la lista de procesos, porque la CLI lo toma como argumento.
• Sin shell. La CLI se ejecuta con una lista de argumentos. Los nombres de sesión, tipos de GPU, especificadores de paquetes e IDs de trabajos se validan. Todo lo controlado por el usuario que se incrusta en el código para la VM pasa por repr().
• Las transferencias de carpetas están protegidas. Las subidas omiten .git, cachés, enlaces simbólicos y posibles secretos (.env, *.pem, *.key…); las descargas rechazan archivos con rutas que escapan del destino (zip-slip) o que exceden un límite de tamaño.
• Sin eliminaciones permanentes en tu computadora. colab_notebook_delete mueve el archivo a .colab-mcp-trash/. colab_rm solo toca la VM y rechaza rutas tipo raíz.
• La salida se recorta a COLAB_MCP_MAX_OUTPUT caracteres, y los códigos de color de terminal (tracebacks) se eliminan.
• El código que ejecutas se ejecuta en las máquinas de Google bajo tu cuenta y gasta tus unidades de cómputo. Detén las sesiones que ya no necesites.

Proyectos grandes y Drive en la VM

Para conjuntos de datos grandes, checkpoints o resultados que deben sobrevivir a la sesión, monta Google Drive en la VM. Esto es independiente de la función opcional "Drive notebooks" de abajo y usa el inicio de sesión propio de la CLI de Colab.

1. Móntalo desde el chat, sin terminal. colab_drive_mount_start ejecuta el colab drivemount oficial en una pseudo-terminal (la CLI nunca abre un navegador; solo imprime un enlace y espera Enter), abre la página de aprobación de Google en tu navegador. El enlace no se repite en el chat (contiene el correo de tu cuenta); solo se devuelve si el navegador no pudo abrirse o con show_link=true. Tú haces clic en Permitir (el agente nunca ve credenciales ni códigos) y se lo dices al agente; colab_drive_mount_finish entonces envía el Enter que la CLI estaba esperando y colab_drive_status confirma. Solo se abren enlaces https://*.google.com, un montaje pendiente se elimina después de 15 minutos, y hay como máximo uno por sesión. Si lo prefieres, colab drivemount -s SESSION en una terminal sigue funcionando. Montar da acceso a todo tu Drive al código que se ejecuta en esa VM (Colab no puede limitarlo); móntalo solo cuando lo necesites y detén la sesión después.
2. El agente llama a colab_drive_project_dir("my-project"), que crea /content/drive/MyDrive/Colab-MCP/my-project y devuelve la ruta. Los conjuntos de datos, checkpoints y salidas van allí.
3. Detén la sesión cuando termines. Los archivos en esa carpeta de Drive permanecen; todo lo demás en la VM se pierde.

Protección: las herramientas de archivos (colab_upload*, colab_download*, colab_ls, colab_rm) rechazan cualquier ruta de Drive fuera de /content/drive/MyDrive/Colab-MCP/ (nombre de carpeta configurable con COLAB_MCP_DRIVE_PROJECTS), incluyendo .., trucos relativos y de mayúsculas. colab_drive_status nunca lista tus archivos.

Riesgo residual, dicho claramente: una vez que Drive está montado, cualquier código que se ejecute en la VM (colab_exec, colab_run, trabajos, celdas de notebook) puede leer y cambiar todo tu Drive; la protección de ruta solo cubre las herramientas de archivos de este servidor, y no puede ver enlaces simbólicos creados en la VM. Monta solo cuando lo necesites, revisa el código que ejecutas y detén la sesión después.

Dónde se guardan las cosas (y cuán poco permanece en tu computadora)

Dónde	Qué	Por qué
El disco de la VM de Colab (alrededor de 200 GB libres observados en una T4 ⚠️ no garantizado)	Conjuntos de datos, entrenamiento, cualquier cosa pesada	Rápido, gratis, desaparece cuando la sesión se detiene
Drive, carpeta Colab-MCP/<project>/	Notebooks y resultados que deben persistir	Sobrevive a las sesiones; la única parte de Drive que esta herramienta puede ver
Tu computadora	Casi nada: una copia de trabajo temporal mientras editas un notebook	Limpieza automática (abajo)

Reglas de huella local (footprint.py):

• Los zips de transferencia se eliminan justo después de usarse y se barren después de 1 hora; los gráficos guardados después de 2 días (COLAB_MCP_IMAGE_DAYS); los notebooks "eliminados" localmente después de 7 días (COLAB_MCP_TRASH_DAYS, 0 = conservar); las copias de trabajo de notebooks de Drive después de 24 h (COLAB_MCP_DRIVE_COPY_HOURS, 0 = conservar) e inmediatamente cuando guardas. El barrido se ejecuta cuando el servidor arranca y en colab_local_cleanup.
• Solo se eliminan archivos dentro de .colab-mcp/ y .colab-mcp-trash/. Los enlaces simbólicos no se siguen. Tus propios notebooks y datos nunca se tocan.
• Protecciones antes de descargas: al menos COLAB_MCP_MIN_FREE_GB (por defecto 5) deben permanecer libres en el disco y la carpeta de trabajo no puede exceder COLAB_MCP_WORKDIR_MAX_GB (por defecto 20, 0 = sin límite). colab_local_footprint muestra los números. Mantén los datos grandes en la VM o en Drive y descarga solo resultados.

Google Drive: proyectos y notebooks (opt-in)

Desactivado por defecto. Con COLAB_MCP_DRIVE=1 (el instalador lo configura cuando configuras Drive) aparecen estas herramientas, y solo estas:

Herramienta	Qué hace
drive_sign_in	Abre una ventana del navegador en tu computadora donde tú haces clic en Permitir. Ningún código o token pasa nunca por el chat
drive_project_create / drive_project_list	Una carpeta por proyecto de Colab dentro de Colab-MCP. Las carpetas se pueden crear, nunca eliminar ni renombrar
drive_notebook_create	Crea un notebook (inicio vacío, o un .ipynb local con salidas eliminadas), opcionalmente dentro de un proyecto
drive_notebook_list	Lista los notebooks que este servidor creó
drive_notebook_open / drive_notebook_save	Descarga un notebook a una copia local temporal, edítalo con las herramientas colab_notebook_*, escribe el contenido de vuelta al mismo archivo. Guardar elimina la copia local
drive_notebook_delete	Mueve uno de ellos a la papelera de Drive (nunca permanente)

Disposición en tu Drive: Colab-MCP/<project>/<notebook>.ipynb. El permiso de Google (drive.file) solo alcanza archivos y carpetas que esta aplicación creó, por lo que tu carpeta existente "Colab Notebooks" y todo lo demás permanece invisible para ella.

Una habilidad que mantiene al agente exactamente en esto vive en skills/colab-drive-notebooks/SKILL.md: copia esa carpeta a ~/.claude/skills/ (Claude Code) o añádela como habilidad en tu cliente.

Quién es responsable de qué

Nadie comparte credenciales. Cada usuario inicia sesión por sí mismo, y el token vive solo en su propio disco. Tú eliges una vez entre dos clientes OAuth (abajo); este proyecto nunca ve tu token. El modelo nunca ve un enlace de inicio de sesión, código o token.

Inicio rápido (cada usuario)

bash install.sh pregunta "¿Configurar Drive ahora?", ejecuta la elección única de abajo y registra el servidor con las herramientas de Drive habilitadas. Manualmente:

git clone https://github.com/amgallego8/Colab-MCP ~/Colab-MCP && cd ~/Colab-MCP
uv sync
uv run colab-cli-mcp-drive login     # asks once how you want to sign in, remembers it, signs you in

login te guía para crear tu propio cliente "Desktop app" de Google Cloud (alrededor de 10 minutos, una vez, gratis; pasos abajo). Cuando le das la ruta del JSON que descargaste, lo almacena por ti (0600). Tú respondes ante Google por tu proyecto. Después de eso, iniciar sesión es solo: se abre un enlace en tu navegador, haces clic en Permitir, listo. No hay código que pegar.

No se envía ningún cliente compartido de un clic todavía. Si este repositorio alcanza 1,000 estrellas, el mantenedor tiene la intención de publicar uno (un cliente listo para que iniciar sesión no requiera configuración de Google Cloud en absoluto). Eso es un plan, no una promesa. El código ya existe: si una compilación incluye colab_cli_mcp/shared_client.json, login ofrece un menú con compartido y propio.

El cliente compartido nunca se usa sin una elección explícita (una respuesta de terminal o --shared). Tu elección se recuerda en ~/.config/colab-mcp/drive/preference.json. A partir de entonces, cuando una herramienta de Drive necesite acceso y no haya un token válido (primer uso, o después de la expiración de 7 días de las aplicaciones en modo Testing), el propio servidor abre la página de consentimiento del navegador y espera tu clic; luego repites la solicitud. El inicio de sesión, el alcance drive.file, el archivo de token y cada protección son idénticos en ambos casos.

Luego deja la aprobación por llamada activada para drive_notebook_delete en tu cliente MCP — ese aviso es la confirmación humana real; el servidor no puede forzarla. uv run colab-cli-mcp-drive status muestra lo que está configurado.

Para salir: colab-cli-mcp-drive logout (elimina el token y lo revoca en Google), y elimina la aplicación en https://myaccount.google.com/permissions si la revocación no pudo confirmarse.

Creando tu propio cliente (lo que login te pide que hagas)

1. En la consola de Google Cloud crea un proyecto y habilita la API de Google Drive (guía).
2. Configura la pantalla de consentimiento / Plataforma de autenticación de Google (guía): bajo Audiencia elige Externa y añádete a Usuarios de prueba; bajo Acceso a datos → Añadir o eliminar alcances añade solo .../auth/drive.file.
3. Plataforma de autenticación de Google → Clientes → Crear cliente → Aplicación de escritorio (pasos de Google). Descarga el JSON y da su ruta a login.

Para el mantenedor: publicar un cliente compartido

Crea el cliente como se indicó arriba (idealmente en una cuenta y proyecto de Google dedicados), luego coloca el JSON en colab_cli_mcp/shared_client.json y confírmalo a propósito (git add -f; el archivo está en git-ignore por defecto). Los secretos de cliente de aplicaciones de escritorio no son confidenciales por diseño, pero el proyecto, su pantalla de consentimiento (correo de soporte, enlace de política de privacidad) y cualquier requisito de verificación de Google pasan a ser tuyos. Consulta TERMS.md.

Modelo de amenazas (qué protege y qué no)

Capa	Qué te ofrece
Alcance drive.file solamente	El token solo puede acceder a archivos que este cliente OAuth haya creado. No puede leer ni eliminar el resto de tu Drive, incluso si todo lo demás fallara. Google clasifica este alcance como no sensible.
Tu propio cliente OAuth	El cliente de otro usuario o de un proveedor no puede tocar tus archivos, y puedes revocar todo el cliente desde tu propio proyecto.
Manejo de tokens	Archivo 0600, rechazado si es legible por grupo o por otros, rechazado si tiene cualquier alcance distinto de drive.file. Nunca se devuelve mediante ninguna herramienta. Separado del token del CLI de Colab (que tiene alcances más amplios).
Superficie de herramientas	Crear carpetas; crear / listar / abrir / guardar / enviar a la papelera cuadernos que este servidor haya creado. Sin eliminación permanente, sin eliminación de carpetas, sin compartir, sin permisos, sin lectura de otros archivos, sin consultas ni IDs de forma libre. Una prueba verifica que nunca se use una solicitud DELETE ni un endpoint de permisos/exportación/copia.
Protecciones de archivos (abrir, guardar, eliminar)	El archivo debe llevar el marcador de este servidor, ser un cuaderno de Colab, ser tuyo, estar directamente en la carpeta de la aplicación o en una de sus carpetas de proyecto, y no estar en la papelera. Eliminar también requiere volver a escribir el nombre exacto. Guardar solo cambia el contenido: nunca el nombre, la ubicación ni el uso compartido.
Límites y rastreo	Por hora: 20 creaciones de cuadernos, 10 carpetas de proyecto, 60 guardados, 5 eliminaciones, 6 intentos de inicio de sesión (COLAB_MCP_DRIVE_MAX_CREATES_PER_HOUR, _MAX_PROJECTS_PER_HOUR, _MAX_SAVES_PER_HOUR, _MAX_DELETES_PER_HOUR, _MAX_LOGINS_PER_HOUR); registro de auditoría de solo añadido (audit.log, 0600) que nunca almacena contenido.
Higiene de contenido	Los cuadernos subidos desde un archivo pierden sus salidas; los guardados conservan las salidas (desactívelo con keep_outputs=False). Cualquier subida o guardado se rechaza si contiene un valor de tu archivo de secretos. Los nombres leídos de Drive tienen caracteres de control y bidireccionales eliminados y se etiquetan como datos.

Riesgos residuales, expresados con claridad. «Completamente seguro» no es una afirmación que nadie pueda hacer; esto es lo que queda:

• Un agente inyectado por un prompt o equivocado aún puede crear cuadernos basura (con límite de velocidad) o enviar a la papelera un cuaderno creado por este servidor si apruebas la llamada. Siguen siendo recuperables en la papelera de Drive.
• La verificación por nombre evita accidentes, no a un modelo decidido a repetir el nombre; el aviso de aprobación humana en tu cliente es el control real.
• Cualquiera que pueda leer los archivos de tu cuenta de usuario puede usar tu token hasta que cierres sesión. El cifrado del disco y una cuenta bloqueada son tu responsabilidad.
• Los cuadernos que crees pueden contener código que se ejecutará más tarde en Colab con tu cuenta; revisa lo que abras.
• En el modo Testing, Google caduca los tokens de actualización después de 7 días para aplicaciones externas, por lo que es posible que debas iniciar sesión nuevamente cada semana.
• Si una carpeta de Drive llamada Colab-MCP también es creada por código que se ejecuta en una VM con Drive montado, Drive puede terminar con dos carpetas con ese nombre que esta herramienta trata por separado (⚠️ no verificado). Prefiere una ruta por proyecto.
• Aún no se ha probado contra Google Drive real (ver Incógnitas conocidas).

Entorno: COLAB_MCP_DRIVE (habilitar), COLAB_MCP_DRIVE_COPY_HOURS, COLAB_MCP_DRIVE_DIR (por defecto ~/.config/colab-mcp/drive), COLAB_MCP_DRIVE_CLIENT, COLAB_MCP_DRIVE_TOKEN, COLAB_MCP_DRIVE_AUDIT, COLAB_MCP_DRIVE_FOLDER (por defecto Colab-MCP).

Instalación

Más rápido: bash install.sh (macOS/Linux). Pregunta antes de instalar cualquier cosa, te inicia sesión en Colab y registra el servidor con Claude Code (o imprime la configuración de Claude Desktop). Los pasos manuales están a continuación.

# 1. uv and the official CLI
curl -LsSf https://astral.sh/uv/install.sh | sh
uv tool install google-colab-cli

# 2. Sign in ONCE (open the link, paste the code)
colab sessions

# 3. This server
git clone https://github.com/amgallego8/Colab-MCP ~/Colab-MCP

Archivo de secretos opcional (fuera de cualquier repositorio, legible solo por ti):

mkdir -p ~/.config/colab-mcp
printf 'OPENROUTER_API_KEY=your-key-here\n' > ~/.config/colab-mcp/secrets.env
chmod 600 ~/.config/colab-mcp/secrets.env

Regístrate en Claude Code:

claude mcp add colab-cli \
  -e COLAB_MCP_WORKDIR="$HOME/colab-work" \
  -e COLAB_MCP_ENV_FILE="$HOME/.config/colab-mcp/secrets.env" \
  -- uv run --directory ~/Colab-MCP colab-cli-mcp

Regístrate en Claude Desktop (claude_desktop_config.json):

{
  "mcpServers": {
    "colab-cli": {
      "command": "uv",
      "args": ["run", "--directory", "/Users/YOU/Colab-MCP", "colab-cli-mcp"],
      "env": {
        "COLAB_MCP_WORKDIR": "/Users/YOU/colab-work",
        "COLAB_MCP_ENV_FILE": "/Users/YOU/.config/colab-mcp/secrets.env"
      }
    }
  }
}

Cada persona que lo use repite estos pasos con su propia cuenta de Google: el token de inicio de sesión es personal y no debe compartirse.

Variables de entorno

Variable	Por defecto	Propósito
COLAB_MCP_WORKDIR	directorio actual	La única carpeta local que toca el servidor
COLAB_MCP_ENV_FILE	—	Archivo NAME=value con secretos
COLAB_MCP_AUTH	CLI por defecto	oauth2 o adc (el --auth del CLI)
COLAB_MCP_MAX_OUTPUT	20000	Máximo de caracteres devueltos por llamada
COLAB_MCP_MAX_UPLOAD_MB	100	Límite de subida por archivo/zip (el CLI envía un archivo en una sola solicitud)
COLAB_MCP_MAX_DOWNLOAD_MB	1024	Límite para descargas de directorios desempaquetados
COLAB_BIN	colab	Ruta al ejecutable del CLI
COLAB_MCP_MIN_FREE_GB	5	Espacio libre en disco que debe quedar después de una descarga
COLAB_MCP_WORKDIR_MAX_GB	20	Presupuesto para la carpeta de trabajo (0 = sin límite)
COLAB_MCP_IMAGE_DAYS / COLAB_MCP_TRASH_DAYS / COLAB_MCP_DRIVE_COPY_HOURS	2 / 7 / 24	Edad tras la cual se limpian los gráficos guardados, los cuadernos eliminados localmente y las copias de trabajo de Drive (0 = conservar papelera/copias)
COLAB_MCP_DRIVE_PROJECTS	Colab-MCP	La única carpeta de Drive (bajo MyDrive) que las herramientas de archivos pueden usar cuando Drive está montado en la VM

Cómo funcionan los cuadernos

Los cuadernos son archivos .ipynb ordinarios dentro del directorio de trabajo, editados localmente con nbformat, por lo que la edición no necesita runtime. colab_notebook_run_cell envía una celda al runtime a través de colab exec; el kernel mantiene sus variables entre llamadas, y la salida de la celda (texto, errores, un gráfico mostrado) se escribe de vuelta en el cuaderno. Las celdas se abordan por id (estable) o índice. Los gráficos se guardan en .colab-mcp/images/.

colab_exec con un archivo .ipynb ejecuta todo el cuaderno y el CLI guarda <name>_output.ipynb junto a él.

Incógnitas conocidas (para confirmar contra Colab real)

Estas provienen de leer el código fuente y la documentación del CLI, no de ejecutarlo:

• Variables del kernel que persisten entre llamadas exec (el código fuente reutiliza el mismo id de kernel, por lo que debería funcionar).
• La detección de éxito/fallo de celdas depende de que get_ipython().run_cell esté disponible en el kernel de Colab.
• Si --output-image guarda todas las formas de imagen (maneja datos de visualización PNG/JPEG).
• El límite real de tamaño de subida (el CLI envía un archivo en una sola solicitud; el límite de 100 MB es una estimación conservadora).
• Si los Secretos de Colab (userdata) son legibles en el kernel cuando se ejecuta a través del CLI — sin documentar. Usa secrets=[...] en su lugar.
• Google Drive (opt-in, ver más abajo): el tipo MIME de Colab application/vnd.google.colaboratory no se encontró en la documentación de Drive de Google. El servidor verifica lo que Drive almacenó después de cada creación y lo deshace si difiere, pero esto aún no se ha ejecutado contra Drive real.
• Si una aplicación de Google Cloud que permanece sin verificar puede ser utilizada por su propietario sin la caducidad de 7 días del token de actualización del modo "Testing" (los documentos de Google dicen que los tokens de actualización de aplicaciones externas en Testing caducan después de 7 días; las reglas para aplicaciones sin verificar "En producción" no se confirmaron).

Desarrollo

pip install "mcp<2" nbformat google-auth google-auth-oauthlib requests
python tests/test_server.py   # the Colab tools, with a simulated CLI
python tests/test_drive.py    # the Drive tools, with a simulated Drive API
python tests/test_footprint.py # local cleanup and disk guards
python tests/test_mount.py     # Drive mount from the chat, with a simulated CLI

El pin del SDK mcp<2 es intencional: 2.x renombró FastMCP a MCPServer.

Términos de uso y privacidad

Consulta TERMS.md: sin servidor ni recopilación de datos por parte del mantenedor, qué se almacena localmente, responsabilidades del usuario, quién responde ante Google bajo cada opción de inicio de sesión y la cláusula de ausencia de garantía.

Licencia

Apache License 2.0 — consulta LICENSE. Copyright 2026 de los contribuyentes de Colab-MCP (amgallego8). El CLI oficial de Colab que este proyecto envuelve es un trabajo separado, también Apache-2.0, y no se incluye aquí.

---

Resumen en español

Servidor MCP para que un agente use Google Colab de punta a punta: crear y detener runtimes con GPU/TPU, ejecutar código, trabajar en cuadernos celda por celda, lanzar trabajos largos en segundo plano y mover archivos y carpetas hacia y desde la VM. Envuelve el Colab CLI oficial de Google.

• Estado: probado con un CLI simulado (92 comprobaciones). Falta validar con Colab real (ver «Known unknowns»).
• Seguridad: las rutas locales quedan confinadas a COLAB_MCP_WORKDIR; las claves viven en un archivo local y nunca se devuelven al modelo; no hay shell; los borrados de cuadernos van a una papelera recuperable.
• Instalación: cada persona repite los pasos de «Install» con su propia cuenta de Google. El token de sesión es personal.
• Google Drive (opcional): carpetas de proyecto y cuadernos de Colab en Colab-MCP/<proyecto>/ de tu Drive (crear, abrir, guardar, borrar a la papelera), nada más. Eliges una sola vez entre el cliente compartido y el tuyo; después el propio servidor abre el navegador cuando haga falta y tú solo pulsas «Permitir» (el código y el token nunca pasan por el chat). El permiso es drive.file: solo ve lo que esta herramienta crea. Tu computador queda casi vacío: los temporales se limpian solos y lo pesado va al disco de la VM o a Drive. Hay una skill (skills/colab-drive-notebooks) que limita al agente a eso. Ver «Google Drive» y el modelo de amenazas, con sus riesgos residuales. Aún sin probar contra Drive real.
• Costo: lo que ejecutes consume tus unidades de cómputo de Colab. Detén las sesiones que no uses.