SlimAtlas AI

Características

• Automatización de navegador: Navega, haz clic, rellena formularios y evalúa JavaScript

• Ligero por defecto: ~5 veces menos memoria que Chromium, ~25 veces menos snapshots que HTML sin procesar

• Snapshots de página: Obtén snapshots compactos del árbol de accesibilidad en YAML con IDs de nodo únicos para apuntar a elementos con precisión

• Contexto optimizado para LLM: Los snapshots se reducen a lo esencial semántico, manteniendo el uso de contexto mínimo para que quepan más páginas y sesiones más largas en la misma ventana

• Navegador de respaldo configurable: Modelo de dos niveles — primero el navegador ligero, luego escalar a Chrome con interfaz, Browserless o los navegadores en la nube de Browserbase solo cuando el predeterminado es detectado como bot, falla o se agota el tiempo

• Limitación de velocidad: Mantente bajo el radar. Aplica un retraso mínimo configurable entre solicitudes a dominios específicos con patrones comodín (*, *.reddit.com) más jitter opcional, para que tu agente se dosifique en lugar de saturar un sitio y activar sus defensas antibots

• Soporte de proxy: Enruta cada solicitud a través de un proxy HTTP con una única configuración de PROXY_SERVER — aplicada automáticamente a ambas capas del navegador, para que tu IP real nunca toque el objetivo. Soporta autenticación básica en línea (http://user:pass@host:port)

• Gestión robusta de sesiones: Serialización por sesión, límite de sesiones opcional (MAX_SESSIONS), recuperación de fallos a mitad de sesión con reproducción del historial y cierre ordenado

• Gestión de sesiones: Reutiliza sesiones en múltiples operaciones con IDs de sesión únicos

• Multiplataforma: Funciona en Linux y macOS, con respaldo configurable a un navegador real cuando sea necesario

Related MCP server: opencode-browser-control

Benchmark

SlimAtlas fue comparado con Playwright MCP (Chromium sin interfaz y con interfaz) usando slim-atlas-bench — 25 sitios web reales en 5 categorías, 3 ejecuciones cada uno (225 en total), todo en Docker en localhost.

Configuración: Cada servicio se ejecuta como un servidor MCP en su propio contenedor Docker. El harness de benchmark mide la latencia por herramienta (navegación + snapshot) mediante langchain-mcp-adapters, y captura la RAM del contenedor a través de la API de estadísticas de Docker. Los snapshots se estiman en tokens a ~4 caracteres por token (misma metodología que el HTML sin procesar).

SlimAtlas intercambia velocidad de navegación por un uso de recursos drásticamente menor. Chromium es más rápido al cargar páginas, pero usa 5–6 veces más RAM y produce 2–4 veces más tokens por snapshot — los dos costos que dominan a escala en los flujos de trabajo de agentes.

Resultados

Instalación

Requiere Bun ≥1.1.

# Install dependencies
bun install

El binario del navegador se descarga automáticamente en la primera ejecución.

Navegador de respaldo: El nivel 1 es siempre el navegador ligero. El nivel 2 es FALLBACK_BROWSER — uno de headful (Chrome con interfaz), browserbase (nube), browserless (nube) o none (sin respaldo, predeterminado). Cuando el predeterminado falla, se agota el tiempo o es detectado como bot, la sesión cambia una vez al navegador de respaldo configurado. Chrome viene incluido con Puppeteer; Browserbase/Browserless requieren credenciales de API (ver más abajo).

Uso

Ejecutar el servidor MCP

# Standalone HTTP server (default)
bun run src/index.ts --port=8080

# Remote, authenticated
MCP_AUTH_TOKEN=s3cret bun run src/index.ts --host=0.0.0.0 --port=8080

SlimAtlas expone un único endpoint HTTP de streaming /mcp. Cada cliente obtiene su propia sesión mediante la cabecera mcp-session-id; MAX_SESSIONS limita la concurrencia. Apunta tu cliente MCP a:

{
  "mcpServers": {
    "slimatlas": {
      "url": "http://localhost:8080/mcp",
      "transport": "http"
    }
  }
}

Con autenticación:

{
  "mcpServers": {
    "slimatlas": {
      "url": "http://your-host:8080/mcp",
      "transport": "http",
      "headers": { "Authorization": "Bearer s3cret" }
    }
  }
}

Consejo: Usa --host=0.0.0.0 para exponerlo de forma remota, pero establece siempre MCP_AUTH_TOKEN al hacerlo. El servidor solo habla HTTP sin cifrar — termina TLS en el frontal (Caddy/nginx) o el token Bearer viajará por la red en texto plano.

Docker

La imagen incluye el binario de Lightpanda en el momento de la compilación, por lo que el contenedor arranca autónomo y nunca vuelve a descargar nada:

docker build -t slimatlas .
docker run -p 8080:8080 -e MCP_AUTH_TOKEN=s3cret slimatlas
# -> http://localhost:8080/mcp

Fija una versión de Lightpanda para compilaciones reproducibles (cualquier etiqueta lightpanda-io/browser — por defecto nightly):

docker build --build-arg LIGHTPANDA_VERSION=0.3.3 -t slimatlas:0.3.3 .

La arquitectura múltiple se maneja automáticamente — la compilación detecta la arquitectura del contenedor mediante uname -m (x86_64 → lightpanda-x86_64-linux, aarch64 → lightpanda-aarch64-linux), por lo que el binario siempre coincide con la plataforma en la que se ejecuta.

Apple Silicon (Macs con chip M): pasa --platform linux/arm64 para compilar/ejecutar de forma nativa. Sin ello, Docker Desktop puede usar amd64 por defecto y ejecutar el contenedor bajo Rosetta, lo que impide que el binario de Lightpanda se inicie (rosetta error: failed to open elf …).

docker build --platform linux/arm64 --build-arg FALLBACK_BROWSER=headful -t slimatlas .
docker run --platform linux/arm64 --name slimatlas -p 8080:8080 -e MCP_AUTH_TOKEN=s3cret -e LIGHTPANDA_POOL_SIZE=10 -e CHROME_POOL_SIZE=10 slimatlas

Variante con respaldo con interfaz. La imagen predeterminada ejecuta solo Lightpanda (FALLBACK_BROWSER=none). Para habilitar el respaldo de Chrome con interfaz (necesario solo si estableces FALLBACK_BROWSER=headful en tiempo de ejecución), compila la variante con interfaz — añade las bibliotecas de Chrome + Xvfb (~150MB) y preconfigura FALLBACK_BROWSER=headful:

docker build --build-arg LIGHTPANDA_VERSION=0.3.3 FALLBACK_BROWSER=headful -t slimatlas:headful .
docker run -p 8080:8080 -e MCP_AUTH_TOKEN=s3cret slimatlas:headful

Xvfb se inicia de forma diferida dentro del contenedor en la primera sesión que escala a Chrome con interfaz — sin necesidad de entrypoint ni xvfb-run manual.

Modo stdio

Para clientes MCP que generan el servidor como subproceso (local, de un solo cliente), usa el transporte stdio:

bun run src/index.ts

{
  "mcpServers": {
    "slimatlas": {
      "command": "bun",
      "args": ["run", "path/to/mcp/src/index.ts"]
    }
  }
}

Configuración

Añade a la configuración de tu cliente MCP:

{
  "mcpServers": {
    "slimatlas": {
      "command": "bun",
      "args": ["run", "path/to/mcp/src/index.ts"]
    }
  }
}

Consejo: Establece FALLBACK_BROWSER=none para usar solo el navegador ligero y propagar los errores de forma honesta. Usa headful o browserbase para habilitar un respaldo con navegador real.

Consulta docs/configs.md para todas las variables de entorno y banderas de línea de comandos.

Navegador de respaldo

Omite el navegador predeterminado para dominios conocidos como difíciles con SKIP_LIGHTPANDA_DOMAINS (separados por comas, consciente de subdominios). Los hosts coincidentes comienzan directamente en el navegador de respaldo. Requiere FALLBACK_BROWSER != none (de lo contrario, la lista se ignora con una advertencia).

Limitación de velocidad

Dosificación educada y antidetectora para tu agente. RateLimiter aplica un retraso mínimo a nivel de servidor entre llamadas a browser_navigate hacia los dominios que enumeras, con jitter aleatorio opcional para que la cadencia no sea un intervalo fijo y rastreable. Los buckets se asignan por host en todas las sesiones (porque el sitio objetivo ve tu IP, no tus sesiones), y los patrones admiten comodines:

Deshabilitado por defecto. Actívalo con una lista de dominios no vacía y un retraso distinto de cero:

# Via CLI flags
bun run src/index.ts --rate-limit-domains=*.reddit.com,g2.com --rate-limit-min-delay-ms=2000 --rate-limit-jitter-ms=1500

# Or via environment / .env
RATE_LIMIT_DOMAINS=*.reddit.com,g2.com
RATE_LIMIT_MIN_DELAY_MS=2000
RATE_LIMIT_JITTER_MS=1500

Proxy

Mantén tu IP real fuera del objetivo. Establece un único PROXY_SERVER y SlimAtlas enruta todo el tráfico HTTP de ambas capas del navegador a través de él — sin necesidad de configurar cada navegador por separado:

• Navegador ligero (nivel 1) — reenviado mediante su bandera nativa --http-proxy.

• Respaldo de Chrome (nivel 2) — aplicado mediante --proxy-server en el arranque.

# Via CLI flag
bun run src/index.ts --proxy-server=http://host:8080

# Or via environment / .env
PROXY_SERVER=http://user:pass@host:8080

La autenticación básica en línea (http://user:pass@host:port) es compatible en la capa del navegador ligero. Para proxies con listas de IP permitidas (sin credenciales) funciona directamente en ambas capas. (La autenticación de Chrome por página mediante page.authenticate está en la hoja de ruta.)

Banderas de línea de comandos

Cada variable de entorno también se puede pasar como bandera de línea de comandos en minúsculas con el formato --flag=valor. Las banderas de línea de comandos anulan las variables de entorno. Las banderas desconocidas hacen que el servidor se cierre al iniciar. Consulta docs/configs.md para la lista completa.

bun run src/index.ts --fallback-browser=headful --lightpanda-pool-size=3 --skip-lightpanda-domains=g2.com --navigate-timeout=60000

Para usar banderas desde un cliente MCP, añádelas al array args:

{
  "mcpServers": {
    "slimatlas": {
      "command": "bun",
      "args": [
        "run",
        "path/to/mcp/src/index.ts",
        "--fallback-browser=headful",
        "--skip-lightpanda-domains=g2.com,linkedin.com",
        "--chrome-pool-size=3"
      ]
    }
  }
}

Flujo de trabajo de uso

# Example: Navigate, snapshot, and interact with a page

# 1. Navigate to a URL (creates a new session automatically)
result = mcp.call("browser_navigate", {"url": "https://example.com"})
# Returns: session_id: abc1, result: Navigated to https://example.com. Title: Example Domain

# 2. Take a snapshot to see the page structure
snapshot = mcp.call("browser_snapshot", {"session_id": "abc1"})
# Returns YAML with node IDs like: 0: {type: div, children: ...}

# 3. Click a node by ID (from the snapshot)
mcp.call("browser_click", {"session_id": "abc1", "nodeId": 2})

# 4. Type into a search box
mcp.call("browser_type", {"session_id": "abc1", "nodeId": 5, "text": "search query"})

# 5. Close the session when done
mcp.call("browser_close", {"session_id": "abc1"})

Herramientas disponibles

Ejecución de las pruebas

# Run all tests
bun test

# Run tests in watch mode
bun test --watch

Requisitos

• Bun ≥1.1

• Linux o macOS (se descarga automáticamente) o Chrome/Chromium (alternativa)

Licencia

MIT