# Entornos de pruebas de E2B


Docker se ha asociado con [E2B](https://e2b.dev/), 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](https://hub.docker.com/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](https://e2b.dev/docs/quickstart) 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](https://e2b.dev/docs/mcp/quickstart)
  > para conocer métodos de conexión alternativos.

- Node.js 18+ instalado en tu máquina
- Cuenta de Notion con:
  - A database containing sample data
  - [Token de integración](https://www.notion.com/help/add-and-manage-connections-with-the-api)
- 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:

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

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

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

Instala las dependencias necesarias:

```console
$ npm install e2b dotenv
```

Crea un archivo `.env` con tus credenciales:

```console
$ 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:

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

### Crear un entorno de pruebas de E2B con servidores MCP

**Typescript**



Crea un archivo llamado `index.ts`:

```typescript
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:

```console
$ npx tsx index.ts
```

**Python**



Crea un archivo llamado `index.py`:

```python
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:

```console
$ python index.py
```



Deberías ver:

```console
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.

**Typescript**



> [!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:

```typescript
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:

```console
$ npx tsx index.ts
```

**Python**



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`).

```python
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:

```console
$ python workflow.py
```



Deberías ver:

```console
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

- [Cómo crear un flujo de trabajo de calidad de código impulsado por IA con SonarQube y E2B](/guides/github-sonarqube-sandbox/)
- [Docker + E2B: Construyendo el futuro de la IA confiable](https://www.docker.com/blog/docker-e2b-building-the-future-of-trusted-ai/)
- [Entornos de pruebas de Docker](/ai/sandboxes/)
- [Catálogo y kit de herramientas de Docker MCP](/ai/mcp-catalog-and-toolkit/)
- [Gateway de Docker MCP](/ai/mcp-catalog-and-toolkit/mcp-gateway/)
- [Documentación de MCP de E2B](https://e2b.dev/docs/mcp)