Google Colab Now Has an Open-Source MCP (Model Context Protocol) Server: Use Colab Runtimes with GPUs from Any Local AI Agent

Introduction

Google Colab's new Model Context Protocol (MCP) server implementation opens up exciting possibilities for AI agents to interact programmatically with cloud-hosted Jupyter notebooks. This tutorial will guide you through setting up and using the MCP server to connect your local AI agent with a Colab runtime, enabling GPU-accelerated code execution and development workflows. You'll learn how to configure the MCP server, establish connections, and execute Python code remotely.

Prerequisites

• Basic understanding of Python and Jupyter notebooks
• Access to a Google Colab account with GPU runtime
• Local machine with Python 3.8+ installed
• Basic knowledge of AI agent concepts and protocols
• Installed packages: requests, websockets, pydantic

Step-by-Step Instructions

1. Setting Up Your Colab Environment

1.1. Launch a GPU Runtime

First, open Google Colab and create a new notebook. Select the GPU runtime by navigating to Runtime > Change runtime type > Hardware accelerator > GPU. This ensures you have access to GPU resources for computationally intensive tasks.

1.2. Install Required Packages

Run the following commands in a Colab cell to install the MCP server dependencies:

!pip install mcp-server websockets pydantic

This installs the Model Context Protocol server implementation along with necessary WebSocket support for real-time communication.

2. Configuring the MCP Server

2.1. Create MCP Server Script

Create a new Python script in Colab to initialize the MCP server:

import asyncio
import json
from mcp_server import MCP

# Initialize the MCP server
mcp = MCP()

# Configure server settings
mcp.config = {
    "port": 8080,
    "host": "0.0.0.0",
    "allowed_origins": ["*"]
}

# Start the server
async def start_server():
    await mcp.start_server()

# Run the server
asyncio.run(start_server())

This script initializes the MCP server with a configuration that allows connections from any origin and listens on port 8080.

2.2. Expose Your Colab Runtime

Use ngrok or similar tunneling service to expose your Colab runtime to the internet:

!pip install pyngrok
from pyngrok import ngrok

# Create tunnel
public_url = ngrok.connect(8080)
print(f"Public URL: {public_url}")

Ngrok creates a secure tunnel that exposes your local Colab server to the internet, making it accessible to external AI agents.

3. Connecting Your Local AI Agent

3.1. Install Agent Dependencies

On your local machine, install the required libraries for connecting to the MCP server:

pip install websockets requests

These libraries enable WebSocket communication and HTTP requests to interact with the MCP server.

3.2. Create Agent Connection Script

Write a Python script to connect your local AI agent to the Colab runtime:

import asyncio
import websockets
import json

async def connect_to_mcp_server(url):
    async with websockets.connect(url) as websocket:
        # Send connection message
        connect_msg = {
            "type": "connect",
            "protocol": "mcp",
            "version": "1.0"
        }
        await websocket.send(json.dumps(connect_msg))
        
        # Receive response
        response = await websocket.recv()
        print(f"Connection response: {response}")
        
        # Execute code
        code_execution = {
            "type": "execute",
            "code": "print('Hello from Colab!')",
            "language": "python"
        }
        await websocket.send(json.dumps(code_execution))
        
        # Get execution result
        result = await websocket.recv()
        print(f"Execution result: {result}")

# Replace with your ngrok public URL
url = "wss://your-ngrok-url.ngrok.io"
asyncio.run(connect_to_mcp_server(url))

This script establishes a WebSocket connection to the MCP server and demonstrates code execution capabilities.

4. Executing Code Remotely

4.1. Implement Code Execution Functions

Extend your agent script to support multiple code execution scenarios:

async def execute_code(websocket, code):
    execution_msg = {
        "type": "execute",
        "code": code,
        "language": "python",
        "timeout": 30
    }
    await websocket.send(json.dumps(execution_msg))
    result = await websocket.recv()
    return json.loads(result)

async def create_file(websocket, filename, content):
    file_msg = {
        "type": "create_file",
        "filename": filename,
        "content": content
    }
    await websocket.send(json.dumps(file_msg))
    return await websocket.recv()

These functions allow your agent to execute code snippets and create files on the remote Colab environment.

4.2. Test Your Setup

Run a test script that executes a more complex Python operation:

async def test_complex_execution():
    # Connect to server
    async with websockets.connect(url) as ws:
        # Execute complex code
        complex_code = '''
import numpy as np
import pandas as pd

data = np.random.rand(100, 5)
print(f"Data shape: {data.shape}")
'''
        
        result = await execute_code(ws, complex_code)
        print(result)

asyncio.run(test_complex_execution())

This test demonstrates the capability to run computationally intensive Python code on the Colab GPU.

5. Advanced Configuration

5.1. Secure Your Connection

For production use, implement authentication:

import hashlib
import secrets

# Generate secure token
secret_token = secrets.token_hex(16)

# Add token to connection message
connect_msg["token"] = secret_token

Adding authentication tokens prevents unauthorized access to your Colab environment.

5.2. Monitor Resource Usage

Implement resource monitoring in your Colab notebook:

def get_resource_usage():
    import psutil
    import GPUtil
    
    cpu_percent = psutil.cpu_percent(interval=1)
    memory = psutil.virtual_memory()
    gpus = GPUtil.getGPUs()
    
    return {
        "cpu_percent": cpu_percent,
        "memory_used": memory.used,
        "memory_total": memory.total,
        "gpu_count": len(gpus)
    }

This monitoring function helps track resource consumption during agent operations.

Summary

This tutorial demonstrated how to set up and use Google Colab's MCP server to enable local AI agents to interact with cloud-hosted Jupyter notebooks. You learned to configure the MCP server, establish secure connections, and execute Python code remotely on GPU-accelerated Colab environments. The implementation allows for sophisticated agent workflows where local agents can leverage Colab's powerful computational resources while maintaining programmatic control over code execution, file management, and resource monitoring.

Key takeaways include the importance of secure tunneling for exposing local services, proper authentication mechanisms, and the ability to execute complex Python operations on remote GPU resources. This setup opens doors for advanced AI agent development, automated code generation, and distributed computational workflows.