SSD Nodes Learn Hosting plans →
Guías Matt ConnorPor Matt Connor

Cómo alojar Moli, un navegador headless para agentes

Instala Moli en un VPS pequeño, expón CDP en loopback y conecta Playwright o tu agente. Revisa sus límites frente a Chrome, Canvas y multimedia.

Un navegador sin interfaz gráfica que cabe en un VPS pequeño

Moli es un navegador sin interfaz gráfica para agentes de IA y es lo bastante pequeño para alojarlo en un VPS donde no cabe headless Chrome. Es un motor de navegador escrito en Rust, no un wrapper de Chromium, y responde al Chrome DevTools Protocol (CDP), el protocolo que ya utiliza su biblioteca de automatización. Instale un único binario, ejecute moli serve y, después, apunte Playwright o el código de su propio agente a http://127.0.0.1:9222.

Lea las limitaciones antes de instalar nada. El proyecto define claramente su alcance: no incluye un navegador con interfaz gráfica, un compositor GPU, paridad píxel a píxel con Chrome ni reproducción de alta fidelidad de Canvas, WebGL o contenido multimedia. Las páginas que necesitan esas funciones fallarán. Chrome real mediante Playwright sigue siendo la alternativa de respaldo, y la última sección explica cómo decidir qué páginas lo necesitan.

Todos los comandos siguientes proceden del README del proyecto y de sus archivos de skills publicados, comprobados de nuevo el 16 de noviembre de 2026 con la versión fijada. Todas las cifras de los gráficos son datos publicados por el proyecto sobre su propio motor, no mediciones realizadas en este sitio, y cada pie de gráfico lo indica. Si todavía está eligiendo un motor, el análisis más amplio de navegadores sin interfaz gráfica para agentes en un VPS cubre las alternativas.

¿Por qué Chrome sin interfaz gráfica usa tanta memoria?

Chrome es un navegador multiproceso. Agrupa los documentos por sitio y, en Linux de escritorio, el aislamiento completo por sitio mantiene cada sitio, incluidos los iframes de otros sitios, en sus propios procesos de renderizado. Chrome puede permitir que las páginas del mismo sitio compartan un proceso de renderizado, pero una sesión que accede a varios sitios sigue ejecutando varios de estos procesos. Además, cada proceso de renderizado tiene su propio heap de V8 y sus propios búferes gráficos. Este diseño es adecuado para un escritorio, donde una página bloqueada no debe cerrar toda la ventana. En un VPS de 2 GB, una sola etapa de navegación puede consumir más memoria que la aplicación que realmente está ejecutando.

El proyecto rastreó 192 URL públicas variadas con cuatro motores y publicó el resultado.

GráficoMixed public web crawl, 192 URLs, figures published by the Moli project
Los datos de este gráfico
[
  {
    "engine": "Moli",
    "useful_pages": 103,
    "median_rss_mib": 73
  },
  {
    "engine": "Chrome Headless",
    "useful_pages": 101,
    "median_rss_mib": 773
  },
  {
    "engine": "Lightpanda",
    "useful_pages": 85,
    "median_rss_mib": 40
  },
  {
    "engine": "Obscura",
    "useful_pages": 57,
    "median_rss_mib": 39
  }
]

Chrome Headless devolvió 101 páginas útiles y Moli devolvió 103, por lo que, en esa muestra, ambos motores leyeron aproximadamente la misma proporción de la web. La diferencia está en la memoria: una RSS mediana (resident set size, la memoria que un proceso mantiene realmente en RAM) de 773 MiB para Chrome frente a 73 MiB para Moli. La dirección de la diferencia es creíble porque se deduce de la arquitectura de procesos. No debe asumir que la proporción exacta será la misma en sus páginas.

La mediana no es la cifra que causa el problema. El pico sí. Cuando un equipo con 2 GB se queda sin memoria, el kernel selecciona un proceso y lo termina, y el registro queda en dmesg -T o journalctl -k:

Out of memory: Killed process 4211 (chrome) total-vm:2318936kB, anon-rss:1418324kB, file-rss:0kB, shmem-rss:0kB, UID:1000 pgtables:3540kB oom_score_adj:0

Su agente nunca ve esa línea. Ve un navegador que dejó de responder, normalmente como un error de Playwright como page.goto: Page crashed o como un destino cerrado. Ese error no menciona la memoria, por lo que el OOM (out of memory) killer es lo primero que debe comprobar cuando un agente falla aleatoriamente en un equipo pequeño. Dimensionar para el pico es el mismo proceso que elegir RAM y CPU para un VPS de agente.

Instalar el binario de Moli con una versión fijada

El proyecto publica un instalador de shell y archivos tar precompilados en las versiones de GitHub. A fecha de 16 de noviembre de 2026, la versión más reciente es la 1.1.25, publicada el 15 de noviembre de 2026; los comandos siguientes siguen fijados a la 1.1.18. El proyecto midió su puntuación de Lexbench, citada más adelante en esta guía, con la 0.1.1, y el README no indica qué versión sustenta sus otras cifras. Considere todas esas cifras como una referencia aproximada del motor, no como una garantía sobre la compilación que instale.

Fije la versión. Un instalador que siempre resuelve latest mueve su agente a otro motor de navegador en la siguiente compilación, y un cambio en el comportamiento del navegador es el tipo de cambio que debe programar, no descubrir por sorpresa.

El instalador de shell es la forma más rápida de empezar, pero conviene leerlo antes de ejecutarlo.

curl --proto '=https' --tlsv1.2 -fsSL \
  -o /tmp/moli-installer.sh \
  https://github.com/lexmount/moli/releases/download/v1.1.18/moli-installer.sh
less /tmp/moli-installer.sh
sh /tmp/moli-installer.sh

Lea el script antes de ejecutarlo. Es corto. Selecciona un archivo del uname -m y después extrae un único binario en ~/.local/bin. En x86_64 utiliza moli-x86_64-unknown-linux-gnu.tar.gz, y en un servidor Arm utiliza el archivo aarch64, por lo que tanto los planes VPS Arm como los x86 están cubiertos. Defina MOLI_INSTALL_DIR para instalarlo en otra ubicación. Observe qué versión resuelve: la versión más reciente, no la etiqueta desde la que obtuvo el script. Esto está bien para una primera prueba, pero no para una compilación reproducible.

Por tanto, para cualquier instalación permanente, haga manualmente lo que hace el instalador y especifique usted mismo el archivo exacto. Así también puede colocar el binario en una ubicación accesible para un servicio del sistema y evita canalizar un script descargado a un shell.

cd /tmp
curl --proto '=https' --tlsv1.2 -fsSLO \
  https://github.com/lexmount/moli/releases/download/v1.1.18/moli-x86_64-unknown-linux-gnu.tar.gz
mkdir -p moli-pkg
tar -xzf moli-x86_64-unknown-linux-gnu.tar.gz -C moli-pkg --strip-components=1
sudo install -m 0755 moli-pkg/moli /usr/local/bin/moli
moli --version

moli --version imprimir la versión que fijó es toda la comprobación necesaria. moli: command not found justo después del instalador indica que el directorio de instalación no está en su PATH, y el instalador muestra una línea con el directorio que debe añadir.

Extracción puntual con moli fetch

Muchos trabajos que un agente asigna a un navegador consisten en «carga esta URL y dime qué dice». Para eso no hace falta ningún servidor. moli fetch inicia el motor, carga una página, escribe un artefacto en la salida estándar y termina, de modo que no conserva memoria entre llamadas.

moli fetch --dump markdown --wait-until networkidle https://example.com
moli fetch --dump semantic_tree_text --wait-selector "main" https://example.com
moli fetch --dump json --wait-until networkidle https://example.com > page.json

El primero muestra la página como Markdown y comienza con # Example Domain. Markdown es el formato más económico para entregar a un modelo porque elimina el marcado y conserva el texto. semantic_tree_text conserva los roles y la estructura. Es lo que necesita en una página con mucha navegación, donde los enlaces importan tanto como el texto. --dump json incluye el estado HTTP y el seguimiento de la solicitud. Úselo cuando una obtención devuelva contenido vacío y necesite saber por qué.

La estrategia de espera determina si obtiene contenido o una carcasa vacía. --wait-until networkidle devuelve el resultado cuando la red deja de tener actividad. --wait-until domstable devuelve el resultado cuando el DOM deja de cambiar. Es una opción mejor para una página que consulta datos en segundo plano y, por tanto, nunca deja la red completamente inactiva. --wait-selector espera a que aparezca un selector específico. Es la única estrategia que conoce algo de la página que está obteniendo. Por eso es la más fiable cuando conoce el destino.

Las capturas de pantalla y los PDF necesitan una maquetación real, que está desactivada de forma predeterminada:

moli fetch --layout --dump screenshot https://example.com > page.png
moli fetch --layout --dump screenshot_full https://example.com > full-page.png
moli fetch --layout --dump pdf https://example.com > page.pdf

El README identifica la política de maquetación predeterminada como LayoutPolicy::Mock: la geometría se simula y no se pinta nada, porque la maquetación y el pintado son la parte más costosa de un navegador. Este valor predeterminado explica las cifras de memoria anteriores. También significa que un PNG vacío suele deberse a la falta de la opción --layout, no a un fallo de la página.

Para las URL que ha encontrado el agente, en lugar de las URL que usted eligió, añada --block-private-networks. Un agente que sigue los enlaces que ha leído en una página puede acabar obteniendo http://169.254.169.254/ para consultar credenciales de instancias en la nube, o un puerto de base de datos en localhost que nunca debía estar expuesto a Internet. Esa opción bloquea las direcciones privadas en las solicitudes conectadas directamente, y --block-cidrs añade rangos bloqueados específicos. Los destinos resueltos por el proxy deben filtrarse en el proxy. Cuando el trabajo consiste en rastrear varias páginas y no en leer una sola, el diseño de esa canalización se explica en alternativas autoalojadas a Firecrawl. El paso anterior, encontrar las URL, se explica en una skill de búsqueda basada en SearXNG para agentes.

Apuntar un agente a Moli mediante CDP

Para un agente que navega y hace clic durante muchos pasos, ejecute el servidor por separado.

moli serve --host 127.0.0.1 --port 9222

127.0.0.1 y el puerto 9222 son los valores predeterminados, por lo que un moli serve sin argumentos ya se enlaza sólo a loopback. Aun así, especifique ambos valores en cualquier configuración permanente. La siguiente persona que lea el archivo de servicio no tendrá que recordar cuál era el valor predeterminado.

Compruebe el servidor antes de conectar un cliente:

curl -s http://127.0.0.1:9222/json/version

Un servidor operativo responde con un objeto JSON que contiene un campo webSocketDebuggerUrl. Esa URL es el punto al que se conecta un cliente CDP. curl: (7) Failed to connect to 127.0.0.1 port 9222: Connection refused significa que no hay ningún proceso escuchando. En ese caso, lea el terminal desde el que inició el servidor o ejecute journalctl -u moli -n 50 si ya lo configuró como servicio. /json/list muestra los destinos abiertos y /json/protocol muestra los dominios que implementa esta compilación. Así puede comprobar si existe aquí un método CDP del que dependa.

Playwright se conecta a ese endpoint en lugar de iniciar su propio navegador:

import { chromium } from "playwright";

const browser = await chromium.connectOverCDP("http://127.0.0.1:9222");
const context = browser.contexts()[0];
const page = context.pages()[0] ?? await context.newPage();

await page.goto("https://example.com");
console.log(await page.locator("body").innerText());

await browser.close();

La línea importante es connectOverCDP, no chromium.launch(). Aquí no existe ningún proceso secundario de Chromium, por lo que executablePath y las opciones habituales de contenedor, como --no-sandbox, no tienen ningún efecto. Por la misma razón, las opciones de proxy, cookies y agente de usuario se pasan al servidor Moli mediante sus propias opciones. Espere una cobertura parcial de CDP, no todo el protocolo de Chrome. Un error explícito de método no compatible indica un límite del motor, no un error del código.

Dos opciones del servidor determinan lo que puede hacer el agente. --layout activa la geometría real, necesaria para hacer clic en coordenadas y tomar capturas de pantalla. --resource carga las imágenes, fuentes y archivos multimedia opcionales. Esto consume ancho de banda y memoria en cada carga de página, así que déjelo desactivado hasta que una página demuestre que lo necesita. --profile-dir conserva las cookies y el almacenamiento entre ejecuciones. Sin esta opción, cada ejecución es desechable.

GráficoOne agent episode, Moli against Chromium, figures published by the Moli project
Los datos de este gráfico
[
  {
    "engine": "Moli",
    "cdp_ready_ms": 34.85,
    "peak_pss_mib": 102.46,
    "processes": 1
  },
  {
    "engine": "Chromium",
    "cdp_ready_ms": 169.37,
    "peak_pss_mib": 348.82,
    "processes": 11
  }
]

En la carga de trabajo de agente de ejemplo del proyecto, Moli aceptó una conexión CDP después de 34.85 ms, frente a 169.37 ms para Chromium, con un PSS máximo (tamaño proporcional del conjunto residente; la memoria de las páginas compartidas se divide entre los procesos que las comparten) de 102.46 MiB, frente a 348.82 MiB. La diferencia estructural está en la última columna: 1 proceso, frente a 11. Un proceso es una única unidad que systemd debe supervisar y un único cgroup al que aplicar límites. Esto permite que la siguiente sección sea breve.

Ejecute moli serve como un servicio de systemd en loopback

Ejecute el servidor como servicio cuando un agente necesite un navegador en espera. Siga usando moli fetch por URL cuando no lo necesite, porque un servidor inactivo sigue ocupando memoria.

No exponga el puerto 9222 en una interfaz pública. CDP no tiene ningún mecanismo de autenticación. Cualquiera que pueda acceder a ese puerto puede controlar el navegador y leer todo lo que el navegador pueda alcanzar, incluidas las cookies del directorio de perfil. Manténgalo en 127.0.0.1. Acceda desde otra máquina mediante un túnel SSH (ssh -L 9222:127.0.0.1:9222 user@your-vps) o a través de una interfaz VPN privada, y haga que el agente se conecte a http://127.0.0.1:9222 en su propio extremo del túnel.

Cree un usuario de servicio y, después, el archivo de unidad:

sudo useradd --system --home-dir /var/lib/moli --shell /usr/sbin/nologin moli

Escriba /etc/systemd/system/moli.service:

[Unit]
Description=Moli headless browser CDP server
After=network-online.target
Wants=network-online.target

[Service]
Type=simple
User=moli
Group=moli
ExecStart=/usr/local/bin/moli serve --host 127.0.0.1 --port 9222 --profile-dir /var/lib/moli/profile --block-private-networks
Restart=on-failure
RestartSec=2
StateDirectory=moli
MemoryAccounting=yes
MemoryMax=768M
NoNewPrivileges=yes
PrivateTmp=yes
ProtectHome=yes
ProtectSystem=strict

[Install]
WantedBy=multi-user.target
sudo systemctl daemon-reload
sudo systemctl enable --now moli.service
systemctl status moli.service
curl -s http://127.0.0.1:9222/json/version

systemctl status debería mostrar active (running), y curl debería devolver el JSON de descubrimiento. ProtectSystem=strict hace que el sistema de archivos sea de sólo lectura, excepto los sistemas de archivos de API y las excepciones configuradas; StateDirectory=moli crea /var/lib/moli, propiedad del usuario de servicio, y lo mantiene escribible. Con PrivateTmp=yes, /tmp y /var/tmp privados de la unidad también son escribibles. Una unidad que se inicia y después termina con un error de permisos en journalctl -u moli casi siempre intenta escribir en una ubicación que ProtectSystem acaba de hacer de sólo lectura, así que mueva esa ruta al directorio de estado.

MemoryMax=768M limita el uso de memoria de la unidad. La unidad obtiene su propio cgroup y, cuando el uso alcanza el límite, el kernel intenta recuperar memoria. Si no se puede reducir el uso, el OOM killer se invoca dentro de ese cgroup y no termina procesos que estén fuera de él. El journal registra una terminación:

moli.service: A process of this unit has been killed by the OOM killer.

Interprete esa línea como una señal para dimensionar el límite. Las páginas pueden consumir más memoria de la prevista o el límite puede ser demasiado bajo. Establezca el valor a partir de una medición de sus propias páginas; esa es la siguiente sección. La contabilidad mide el uso; controles independientes como MemoryMax y CPUQuota imponen límites a otros servicios, y limitar la memoria y la CPU con systemd funciona mediante el resto de estos controles.

Mida usted mismo el uso máximo de memoria

Las cifras publicadas proceden del hardware y las páginas de otra persona. El uso máximo de memoria determina si su servidor seguirá funcionando, y depende por completo de lo que cargue. Mídalo antes de dimensionar el servidor.

Para una descarga puntual, use el binario time, que informa de muchos más datos que el builtin del shell con el mismo nombre:

sudo apt update && sudo apt install -y time
/usr/bin/time -v moli fetch --dump markdown --wait-until networkidle https://example.com > /dev/null

La salida termina con un bloque de estadísticas de recursos que incluye Maximum resident set size (kbytes). Divídalo entre 1024 para obtener MiB. Ejecútelo con diez páginas que su agente visite realmente, no con example.com, y conserve el peor resultado en lugar del promedio, porque el OOM killer reacciona a los picos.

Para el servicio, lea el contador que el kernel ya mantiene para su cgroup:

cat /sys/fs/cgroup/system.slice/moli.service/memory.peak
systemd-cgtop -m

memory.peak es un contador de bytes y representa el valor máximo alcanzado desde que se creó el cgroup; reiniciar el servicio sólo lo restablece si se vuelve a crear el cgroup. Ese valor debe ser inferior a MemoryMax, dejando margen para la página más pesada que aún no haya visitado. systemd-cgtop -m muestra el uso actual por unidad y es la forma más rápida de ver qué servicio del servidor está consumiendo más recursos hoy.

¿Dónde falla Moli y cuándo sigue siendo necesario Chrome?

El proyecto también ejecuta una prueba de referencia con 1,308 tareas comparables de automatización del navegador y publica la puntuación de varios motores.

GráficoLexbench headless browser suite, 1,308 tasks, figures published by the Moli project
Los datos de este gráfico
[
  {
    "engine": "Chrome",
    "success_rate_pct": 99.85
  },
  {
    "engine": "Moli 0.1.1",
    "success_rate_pct": 81.88
  },
  {
    "engine": "Kitesurf",
    "success_rate_pct": 62.08
  },
  {
    "engine": "Lightpanda",
    "success_rate_pct": 53.29
  },
  {
    "engine": "Obscura",
    "success_rate_pct": 44.88
  }
]

Entre esos 5 motores, Moli 0.1.1 completó el 81.88 por ciento de las tareas y Chrome, el motor de referencia, completó 99.85 por ciento. El propio proyecto se puntúa en su propia suite, así que debe interpretarse como una afirmación y no como un resultado independiente.

La lectura práctica es sencilla. Moli 0.1.1 falló en 237 de las 1,308 tareas seleccionadas, aproximadamente una de cada cinco. Si el agente visita un conjunto fijo de páginas que usted controla, esa proporción aporta muy poca información, porque sus páginas funcionan o no funcionan y puede comprobarlo esta misma tarde. El informe describe observaciones, no límites de capacidad, por lo que esos fallos no demuestran que haya funciones no compatibles ni establecen una tasa de fallos en la web abierta.

El alcance declarado del proyecto identifica las cargas de trabajo que deben comprobarse con Chrome.

  • Aplicaciones que requieren renderizado de Canvas de alta fidelidad; Moli implementa operaciones de dibujo de Canvas, por lo que Canvas por sí solo no demuestra que sea necesario usar Chrome
  • Cualquier elemento que necesite WebGL de alta fidelidad o composición mediante GPU, porque no existe un compositor de GPU
  • Reproducción multimedia exigente
  • Pruebas visuales que comparan capturas de pantalla píxel por píxel con Chrome, porque la paridad con Chrome no es un objetivo

La otra cifra que cita el proyecto, una ejecución completa con 1.612 millones de pruebas de la plataforma web superadas, es una afirmación sobre la cobertura de estándares. No garantiza el funcionamiento en los sitios que visitará el agente. Una página puede utilizar únicamente estándares compatibles y aun así fallar en una comprobación para bots, y ninguna puntuación del motor cubre ese caso.

Por tanto, mantenga el mecanismo de reserva en el diseño. Envíe primero cada URL a Moli. Si una página devuelve contenido vacío o un selector no aparece nunca, reintente esa URL con Playwright controlando un Chrome real, en una máquina más grande o según un horario en el que sea asumible un proceso de 773 MiB. La mayoría de los agentes pasa la mayor parte del tiempo en páginas normales, así que el motor pequeño gestiona el volumen y el motor costoso gestiona los casos excepcionales.

FAQ

¿Puede Moli sustituir a Chrome sin interfaz gráfica para mi agente?

Para leer páginas, extraer texto y hacer clic de forma normal, normalmente sí. En la propia prueba de referencia del proyecto, con 1,308 tareas, completó 81.88 por ciento frente al 99.85 por ciento de Chrome, y dejó 237 tareas fallidas en Moli 0.1.1; esas observaciones no demuestran que todos los fallos requieran una capacidad no compatible. El procesamiento de alta fidelidad de Canvas/WebGL y la reproducción multimedia están fuera del alcance declarado del proyecto, pero usar Canvas por sí solo no hace que una aplicación sea incompatible. Encamine a Chrome real las URL que fallen en sus comprobaciones, en lugar de volver a cambiarlo todo.

¿Cuánta RAM necesita Moli en un VPS?

El proyecto informa de un RSS mediano de 73 MiB en un rastreo de 192 URL, y de un PSS máximo de 102.46 MiB en un episodio de agente de muestra, frente a una mediana de 773 MiB para Chrome sin interfaz gráfica. Esas son sus cifras en sus propias páginas. Mida las suyas con /usr/bin/time -v alrededor de una llamada a moli fetch para un uso puntual, o lea /sys/fs/cgroup/system.slice/moli.service/memory.peak para el servicio. Después, establezca MemoryMax por encima de la cifra más alta que observe.

¿Es seguro exponer el puerto 9222 a Internet?

No. CDP no tiene autenticación. Cualquiera que pueda acceder a ese puerto puede controlar el navegador y leer todo lo que el navegador pueda alcanzar. Mantenga --host 127.0.0.1 y acceda al endpoint desde otra máquina mediante un túnel SSH o a través de una interfaz VPN privada. Si debe enlazar otra dirección, asígnela a una interfaz privada y controle el acceso con el firewall.

¿Por qué la captura de pantalla está vacía o el clic no cae sobre ningún elemento?

El diseño está desactivado de forma predeterminada. El README denomina LayoutPolicy::Mock a la política predeterminada. Por tanto, la geometría de los elementos no es real y todo lo que depende de un cuadro en la página no puede funcionar. Inicie el servidor con moli serve --layout o añada --layout a moli fetch. Entonces funcionarán la captura de pantalla y las rutas basadas en coordenadas. Las imágenes ausentes corresponden a otra opción: --resource.

¿Qué versión de Moli debo instalar?

Fije una versión y registre cuál es. A fecha de 16 November 2026, la versión más reciente es 1.1.25; los comandos de esta guía siguen fijados en 1.1.18. La puntuación de Lexbench del proyecto se midió con 0.1.1. Compare las versiones antes de comparar resultados con otra persona. Descargue el moli-x86_64-unknown-linux-gnu.tar.gz de esa etiqueta e instale el binario usted mismo en lugar de depender del instalador del shell. Este resuelve la versión más reciente, no la etiqueta desde la que lo descargó. Después, confirme la instalación con moli --version.

¿Te resultó útil este artículo?