Compartir comentarios
Las respuestas se generan en base a la documentación.

Entornos de pruebas de E2B

Tabla de contenidos

Docker se ha asociado con E2B, un proveedor de entornos de pruebas (sandboxes) seguros en la nube para agentes de IA. Los entornos de pruebas de E2B incluyen acceso directo al catálogo de MCP de Docker, una colección de más de 200 herramientas de editores como GitHub, Notion y Stripe.

Cuando creas un entorno de pruebas, especificas a qué herramientas de MCP debe acceder. E2B inicia estas herramientas y proporciona acceso a través del Gateway de Docker MCP.

Ejemplo: Uso del servidor MCP de GitHub y Notion

Este ejemplo demuestra cómo conectar varios servidores MCP en un entorno de pruebas de E2B. Analizarás datos en Notion y crearás issues de GitHub utilizando Claude.

Requisitos previos

Antes de comenzar, asegúrate de tener lo siguiente:

  • Cuenta de E2B con acceso a la API

  • Clave de API de Anthropic para Claude

    Note

    Este ejemplo utiliza Claude Code, que viene preinstalado en los entornos de pruebas de E2B. Sin embargo, puedes adaptar el ejemplo para que funcione con otros asistentes de IA de tu elección. Consulta la documentación de MCP de E2B para conocer métodos de conexión alternativos.

  • Node.js 18+ instalado en tu máquina

  • Cuenta de Notion con:

  • Cuenta de GitHub con:

    • Un repositorio para pruebas
    • Un token de acceso personal con el alcance repo

Configurar tu entorno

Crea un nuevo directorio e inicializa un proyecto de Node.js:

$ mkdir mcp-e2b-quickstart
$ cd mcp-e2b-quickstart
$ npm init -y

Configura tu proyecto para módulos ES actualizando el archivo package.json:

{
  "name": "mcp-e2b-quickstart",
  "version": "1.0.0",
  "type": "module",
  "scripts": {
    "start": "node index.js"
  }
}

Instala las dependencias necesarias:

$ npm install e2b dotenv

Crea un archivo .env con tus credenciales:

$ cat > .env << 'EOF'
E2B_API_KEY=your_e2b_api_key_here
ANTHROPIC_API_KEY=your_anthropic_api_key_here
NOTION_INTEGRATION_TOKEN=ntn_your_notion_integration_token_here
GITHUB_TOKEN=ghp_your_github_pat_here
EOF

Protege tus credenciales:

$ echo ".env" >> .gitignore
$ echo "node_modules/" >> .gitignore

Crear un entorno de pruebas de E2B con servidores MCP

Crea un archivo llamado index.ts:

import "dotenv/config";
import { Sandbox } from "e2b";

async function quickstart(): Promise<void> {
  console.log(
    "Creando el entorno de pruebas de E2B con los servidores MCP de Notion y GitHub...\n",
  );

  const sbx: Sandbox = await Sandbox.create({
    envs: {
      ANTHROPIC_API_KEY: process.env.ANTHROPIC_API_KEY as string,
    },
    mcp: {
      notion: {
        internalIntegrationToken: process.env
          .NOTION_INTEGRATION_TOKEN as string,
      },
      githubOfficial: {
        githubPersonalAccessToken: process.env.GITHUB_TOKEN as string,
      },
    },
  });

  const mcpUrl = sbx.getMcpUrl();
  const mcpToken = await sbx.getMcpToken();

  console.log("¡Entorno de pruebas creado correctamente!");
  console.log(`MCP Gateway URL: ${mcpUrl}\n`);

  // Esperar a la inicialización de MCP
  await new Promise<void>((resolve) => setTimeout(resolve, 1000));

  // Conectar Claude al gateway de MCP
  console.log("Conectando Claude al gateway de MCP...");
  await sbx.commands.run(
    `claude mcp add --transport http e2b-mcp-gateway ${mcpUrl} --header "Authorization: Bearer ${mcpToken}"`,
    {
      timeoutMs: 0,
      onStdout: console.log,
      onStderr: console.log,
    },
  );

  console.log("\n¡Conexión correcta! Limpiando...");
  await sbx.kill();
}

quickstart().catch(console.error);

Ejecuta el script:

$ npx tsx index.ts

Crea un archivo llamado index.py:

import os
import asyncio
from dotenv import load_dotenv
from e2b import Sandbox

load_dotenv()

async def quickstart():
    print("Creando el entorno de pruebas de E2B con los servidores MCP de Notion y GitHub...\n")

    sbx = await Sandbox.beta_create(
        envs={
            "ANTHROPIC_API_KEY": os.getenv("ANTHROPIC_API_KEY"),
        },
        mcp={
            "notion": {
                "internalIntegrationToken": os.getenv("NOTION_INTEGRATION_TOKEN"),
            },
            "githubOfficial": {
                "githubPersonalAccessToken": os.getenv("GITHUB_TOKEN"),
            },
        },
    )

    mcp_url = sbx.beta_get_mcp_url()
    mcp_token = await sbx.beta_get_mcp_token()

    print("¡Entorno de pruebas creado correctamente!")
    print(f"MCP Gateway URL: {mcp_url}\n")

    # Esperar a la inicialización de MCP
    await asyncio.sleep(1)

    # Conectar Claude al gateway de MCP
    print("Conectando Claude al gateway de MCP...")

    def on_stdout(output):
        print(output, end='')

    def on_stderr(output):
        print(output, end='')

    await sbx.commands.run(
        f'claude mcp add --transport http e2b-mcp-gateway {mcp_url} --header "Authorization: Bearer {mcp_token}"',
        timeout_ms=0,
        on_stdout=on_stdout,
        on_stderr=on_stderr
    )

    print("\n¡Conexión correcta! Limpiando...")
    await sbx.kill()

if __name__ == "__main__":
    try:
        asyncio.run(quickstart())
    except Exception as e:
        print(f"Error: {e}")

Ejecuta el script:

$ python index.py

Deberías ver:

Creando el entorno de pruebas de E2B con los servidores MCP de Notion y GitHub...

¡Entorno de pruebas creado correctamente!
MCP Gateway URL: https://50005-xxxxx.e2b.app/mcp

Conectando Claude al gateway de MCP...
Added HTTP MCP server e2b-mcp-gateway with URL: https://50005-xxxxx.e2b.app/mcp

¡Conexión correcta! Limpiando...

Probar con un flujo de trabajo de ejemplo

Ahora, prueba la configuración ejecutando un flujo de trabajo sencillo que busque en Notion y cree un issue de GitHub.

Important

Reemplaza owner/repo en el prompt con tu usuario y nombre de repositorio reales de GitHub (por ejemplo, tunombre/repositorio-de-prueba).

Actualiza index.ts con el siguiente ejemplo:

import "dotenv/config";
import { Sandbox } from "e2b";

async function exampleWorkflow(): Promise<void> {
  console.log("Creando el entorno de pruebas...\n");

  const sbx: Sandbox = await Sandbox.create({
    envs: {
      ANTHROPIC_API_KEY: process.env.ANTHROPIC_API_KEY as string,
    },
    mcp: {
      notion: {
        internalIntegrationToken: process.env
          .NOTION_INTEGRATION_TOKEN as string,
      },
      githubOfficial: {
        githubPersonalAccessToken: process.env.GITHUB_TOKEN as string,
      },
    },
  });

  const mcpUrl = sbx.getMcpUrl();
  const mcpToken = await sbx.getMcpToken();

  console.log("Entorno de pruebas creado correctamente\n");

  // Esperar a que se inicialicen los servidores MCP
  await new Promise<void>((resolve) => setTimeout(resolve, 3000));

  console.log("Conectando Claude al gateway de MCP...\n");
  await sbx.commands.run(
    `claude mcp add --transport http e2b-mcp-gateway ${mcpUrl} --header "Authorization: Bearer ${mcpToken}"`,
    {
      timeoutMs: 0,
      onStdout: console.log,
      onStderr: console.log,
    },
  );

  console.log(
    "\nEjecutando ejemplo: Buscar en Notion y crear un issue de GitHub...\n",
  );

  const prompt: string = `Usando las herramientas MCP de Notion y GitHub:
1. Buscar bases de datos en mi espacio de trabajo de Notion
2. Crear un issue de prueba en owner/repo titulado "MCP Toolkit Test" con la descripción "Testing E2B + Docker MCP integration"
3. Confirmar que ambas operaciones se completaron correctamente`;

  await sbx.commands.run(
    `echo '${prompt.replace(/'/g, "'\\''")}' | claude -p --dangerously-skip-permissions`,
    {
      timeoutMs: 0,
      onStdout: console.log,
      onStderr: console.log,
    },
  );

  await sbx.kill();
}

exampleWorkflow().catch(console.error);

Ejecuta el script:

$ npx tsx index.ts

Actualiza index.py con este ejemplo:

Important

Reemplaza owner/repo en el prompt con tu usuario y nombre de repositorio reales de GitHub (por ejemplo, tunombre/repositorio-de-prueba).

import os
import asyncio
import shlex
from dotenv import load_dotenv
from e2b import Sandbox

load_dotenv()

async def example_workflow():
    print("Creando el entorno de pruebas...\n")

    sbx = await Sandbox.beta_create(
        envs={
            "ANTHROPIC_API_KEY": os.getenv("ANTHROPIC_API_KEY"),
        },
        mcp={
            "notion": {
                "internalIntegrationToken": os.getenv("NOTION_INTEGRATION_TOKEN"),
            },
            "githubOfficial": {
                "githubPersonalAccessToken": os.getenv("GITHUB_TOKEN"),
            },
        },
    )

    mcp_url = sbx.beta_get_mcp_url()
    mcp_token = await sbx.beta_get_mcp_token()

    print("Entorno de pruebas creado correctamente\n")

    # Esperar a que se inicialicen los servidores MCP
    await asyncio.sleep(3)

    print("Conectando Claude al gateway de MCP...\n")

    def on_stdout(output):
        print(output, end='')

    def on_stderr(output):
        print(output, end='')

    await sbx.commands.run(
        f'claude mcp add --transport http e2b-mcp-gateway {mcp_url} --header "Authorization: Bearer {mcp_token}"',
        timeout_ms=0,
        on_stdout=on_stdout,
        on_stderr=on_stderr
    )

    print("\nEjecutando ejemplo: Buscar en Notion y crear un issue de GitHub...\n")

    prompt = """Usando las herramientas MCP de Notion y GitHub:
1. Buscar bases de datos en mi espacio de trabajo de Notion
2. Crear un issue de prueba en owner/repo titulado "MCP Toolkit Test" con la descripción "Testing E2B + Docker MCP integration"
3. Confirmar que ambas operaciones se completaron correctamente"""

    # Escape single quotes for shell
    escaped_prompt = prompt.replace("'", "'\\''")

    await sbx.commands.run(
        f"echo '{escaped_prompt}' | claude -p --dangerously-skip-permissions",
        timeout_ms=0,
        on_stdout=on_stdout,
        on_stderr=on_stderr
    )

    await sbx.kill()

if __name__ == "__main__":
    try:
        asyncio.run(example_workflow())
    except Exception as e:
        print(f"Error: {e}")

Ejecuta el script:

$ python workflow.py

Deberías ver:

Creando el entorno de pruebas...

Ejecutando ejemplo: Buscar en Notion y crear un issue de GitHub...

## Tarea completada con éxito

He completado ambas operaciones utilizando las herramientas MCP de Notion y GitHub:

### 1. Búsqueda en el espacio de trabajo de Notion

Se encontraron 3 bases de datos en tu espacio de trabajo de Notion:
- **Customer Feedback** - Base de datos con 12 entradas para el seguimiento de solicitudes de funciones
- **Product Roadmap** - Base de datos de planificación con 8 proyectos activos
- **Meeting Notes** - Espacio de trabajo compartido con 45 páginas

### 2. Creación del issue en GitHub

Se creó correctamente el issue de prueba:
- **Repositorio**: tu-org/tu-repo
- **Número de issue**: #47
- **Título**: "MCP Test"
- **Descripción**: "Testing E2B + Docker MCP integration"
- **Estado**: Abierto
- **URL**: https://github.com/your-org/your-repo/issues/47

Ambas operaciones se completaron correctamente. Los servidores MCP están configurados adecuadamente y en funcionamiento.

El entorno de pruebas conectó varios servidores MCP y coordinó un flujo de trabajo entre Notion y GitHub. Puedes ampliar este patrón para combinar cualquiera de los más de 200 servidores MCP del catálogo de Docker MCP.

Páginas relacionadas