Auto-héberger Moli, navigateur headless pour agents
Chrome headless est le plus gros processus de votre petit VPS. Installez Moli, exposez CDP en loopback et repérez les pages qui échouent.
Un navigateur headless adapté à un petit VPS
Moli est un navigateur headless pour les agents d’IA. Il est suffisamment léger pour être auto-hébergé sur un VPS où headless Chrome ne tient pas. Il s’agit d’un moteur de navigateur écrit en Rust, et non d’un wrapper autour de Chromium. Il répond au Chrome DevTools Protocol (CDP), le protocole utilisé par votre bibliothèque d’automatisation. Installez un seul binaire, exécutez moli serve, puis configurez Playwright ou le code de votre agent pour utiliser http://127.0.0.1:9222.
Prenez connaissance des compromis avant toute installation. Le projet définit clairement son périmètre : pas de navigateur graphique, pas de compositeur GPU, pas de parité pixel par pixel avec Chrome, et pas de prise en charge haute fidélité de Canvas, WebGL ou de la lecture multimédia. Les pages qui en dépendent échoueront. Chrome réel avec Playwright reste la solution de repli. La dernière section explique comment déterminer quelles pages en ont besoin.
Toutes les commandes ci-dessous proviennent du README du projet et de ses fichiers de compétences publiés. Elles ont été vérifiées de nouveau le 16 novembre 2026 avec la version épinglée. Chaque nombre des graphiques est une donnée publiée par le projet au sujet de son propre moteur, et non une mesure effectuée sur ce site. La légende de chaque graphique le précise. Si vous choisissez encore un moteur, l’étude plus large des navigateurs headless pour les agents sur un VPS présente les autres solutions.
Pourquoi Chrome headless utilise-t-il autant de mémoire ?
Chrome est un navigateur multiprocessus. Il regroupe les documents par site et, sur Linux pour poste de travail, la fonction complète Site Isolation exécute chaque site, y compris les iframes intersites, dans ses propres processus de rendu. Chrome peut laisser les pages du même site partager un processus de rendu, mais une session qui accède à plusieurs sites en exécute tout de même plusieurs. Chaque processus de rendu possède son propre tas V8 et ses propres tampons graphiques. Cette conception convient à un poste de travail, où une page qui plante ne doit pas faire tomber toute la fenêtre. Sur un VPS de 2 GB, une seule étape de navigation peut donc consommer plus de mémoire que l’application que vous exécutez réellement.
Le projet a parcouru 192 URL publiques variées avec quatre moteurs et a publié le résultat.
Les données de ce graphique
[
{
"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 a renvoyé 101 pages utiles et Moli en a renvoyé 103. Sur cet échantillon, les deux moteurs ont donc consulté une part à peu près équivalente du Web. C’est au niveau de la mémoire qu’ils se distinguent : le RSS médian (resident set size, c’est-à-dire la mémoire qu’un processus conserve réellement en RAM) est de 773 MiB pour Chrome, contre 73 MiB pour Moli. Cette différence est cohérente avec l’architecture multiprocessus. Vous ne devez toutefois pas supposer que le rapport exact sera le même sur vos pages.
La médiane n’est pas la valeur qui vous pose problème. C’est le pic. Lorsqu’un serveur de 2 GB n’a plus de mémoire, le kernel sélectionne un processus et le tue. L’événement est alors enregistré dans dmesg -T ou 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:0Votre agent ne voit jamais cette ligne. Il voit un navigateur qui ne répond plus, généralement sous la forme d’une erreur Playwright comme page.goto: Page crashed ou d’une cible fermée. Cette erreur ne mentionne jamais la mémoire. C’est pourquoi il faut commencer par vérifier l’OOM (out of memory) killer lorsqu’un agent échoue de manière aléatoire sur un petit serveur. Dimensionner la mémoire pour le pic revient à choisir la RAM et le CPU d’un VPS pour agent : choisir la RAM et le CPU d’un VPS pour agent.
Installer le binaire Moli en le verrouillant sur une version
Le projet publie un installateur shell et des archives tar précompilées dans les releases GitHub. Au 16 novembre 2026, la dernière release est la version 1.1.25, publiée le 15 novembre 2026 ; les commandes ci-dessous restent verrouillées sur la version 1.1.18. Le projet a mesuré son score Lexbench, cité plus loin dans ce guide, avec la version 0.1.1, et le README ne précise pas quelle version se trouve derrière ses autres chiffres. Considérez ces chiffres comme une indication approximative des capacités du moteur, et non comme une garantie concernant le build que vous installez.
Verrouillez la version. Un installateur qui résout toujours latest fait passer votre agent à un autre moteur de navigateur lors du prochain rebuild. Une modification du comportement du navigateur doit être planifiée, et non découverte par hasard.
L’installateur shell est la méthode la plus rapide pour commencer. Il est toutefois préférable de le lire avant de l’exécuter.
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.shLisez le script avant de l’exécuter. Il est court. Il sélectionne une archive depuis votre uname -m, puis décompresse un seul binaire dans ~/.local/bin. Sur x86_64, il utilise moli-x86_64-unknown-linux-gnu.tar.gz ; sur un serveur Arm, il utilise l’archive aarch64. Les VPS Arm et x86 sont donc pris en charge. Définissez MOLI_INSTALL_DIR pour installer le binaire ailleurs. Vérifiez la version qu’il résout : il s’agit de la dernière release, et non du tag depuis lequel vous avez récupéré le script. Cela convient pour un premier test, mais pas pour un rebuild reproductible.
Pour toute installation permanente, faites donc manuellement ce que fait l’installateur et indiquez vous-même l’archive exacte. Cela permet aussi de placer le binaire dans un répertoire accessible à un service système, sans envoyer un script téléchargé directement à 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 --versionmoli --version afficher la version que vous avez verrouillée est la seule vérification nécessaire. Si moli: command not found juste après l’installation, le répertoire d’installation ne figure pas dans votre PATH, et l’installateur affiche une ligne indiquant le répertoire à ajouter.
Extraction ponctuelle avec moli fetch
Beaucoup de tâches confiées à un agent consistent à « charger cette URL et me dire ce qu’elle contient ». Cela ne nécessite aucun serveur. moli fetch démarre le moteur, charge une page, écrit un artefact sur la sortie standard, puis se termine. Rien ne conserve donc de mémoire entre les appels.
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.jsonLa première commande affiche la page au format Markdown, en commençant par # Example Domain. Le Markdown est le format le moins coûteux à transmettre à un modèle, car il supprime le balisage et conserve le texte. semantic_tree_text conserve les rôles et la structure. C’est le format à privilégier sur une page riche en navigation, où les liens sont aussi importants que le texte. --dump json inclut le code d’état HTTP et la trace de la requête. Utilisez-le lorsqu’un fetch renvoie un résultat vide et que vous devez en déterminer la cause.
La stratégie d’attente détermine si vous obtenez le contenu ou une coquille vide. --wait-until networkidle renvoie le résultat dès que le trafic réseau s’arrête. --wait-until domstable renvoie le résultat lorsque le DOM cesse de changer. C’est le meilleur choix pour une page qui interroge régulièrement le serveur en arrière-plan et qui ne devient donc jamais complètement inactive. --wait-selector attend un sélecteur que vous indiquez. C’est la seule stratégie qui connaît la page récupérée, ce qui en fait la plus fiable lorsque vous connaissez la cible.
Les captures d’écran et les PDF nécessitent une mise en page réelle, désactivée par défaut :
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.pdfLe README indique que la politique de mise en page par défaut est LayoutPolicy::Mock : la géométrie est simulée et rien n’est peint, car la mise en page et le rendu constituent la partie la plus coûteuse d’un navigateur. C’est la raison pour laquelle les valeurs de mémoire indiquées plus haut sont celles que vous observez. Cela signifie également qu’un fichier PNG vide indique généralement l’absence de l’option --layout, et non une page défaillante.
Pour les URL trouvées par votre agent plutôt que choisies par vous, ajoutez --block-private-networks. Un agent qui suit les liens lus sur une page peut être amené à récupérer http://169.254.169.254/ pour obtenir des identifiants d’instances cloud, ou à contacter un port de base de données sur localhost qui n’était pas destiné à être exposé sur Internet. Cette option bloque les adresses privées pour les requêtes directement connectées, et --block-cidrs ajoute des plages spécifiques à bloquer ; les cibles résolues par le proxy doivent être filtrées par celui-ci. Lorsque la tâche consiste à explorer un site plutôt qu’à lire une seule page, la structure de ce pipeline est décrite dans des alternatives auto-hébergées à Firecrawl. L’étape précédente, qui consiste à trouver les URL, est décrite dans une compétence de recherche pour agents basée sur SearXNG.
Diriger un agent vers Moli via CDP
Pour un agent qui navigue et effectue de nombreux clics, exécutez plutôt le serveur.
moli serve --host 127.0.0.1 --port 9222127.0.0.1 et le port 9222 sont les valeurs par défaut. Un simple moli serve est donc déjà lié à la loopback uniquement. Indiquez-les quand même tous les deux dans toute configuration persistante. Ainsi, la personne qui consultera ensuite votre fichier de service n’aura pas à se souvenir de la valeur par défaut.
Vérifiez le serveur avant d’y connecter un client :
curl -s http://127.0.0.1:9222/json/versionUn serveur opérationnel répond avec un objet JSON contenant un champ webSocketDebuggerUrl. Cette URL est celle à laquelle un client CDP se connecte. curl: (7) Failed to connect to 127.0.0.1 port 9222: Connection refused signifie que rien n’écoute. Consultez donc le terminal dans lequel vous avez démarré le serveur, ou utilisez journalctl -u moli -n 50 s’il s’agit d’un service. /json/list liste les cibles ouvertes et /json/protocol liste les domaines implémentés par ce build. Cela permet de vérifier qu’une méthode CDP dont vous dépendez est disponible.
Playwright se connecte à cet endpoint au lieu de lancer son propre navigateur :
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 ligne importante est connectOverCDP, pas chromium.launch(). Aucun processus Chromium enfant n’est lancé ici. executablePath et les options habituelles des conteneurs, comme --no-sandbox, n’ont donc rien à contrôler. Pour la même raison, transmettez les paramètres de proxy, de cookie et de user-agent au serveur Moli sous la forme de ses propres options. La couverture CDP est partielle, et non équivalente à l’ensemble du protocole Chrome. Une erreur explicite indiquant qu’une méthode n’est pas prise en charge marque une limite du moteur, pas un bug dans votre code.
Deux options du serveur déterminent ce que l’agent peut faire. --layout active la géométrie réelle, nécessaire aux clics par coordonnées et aux captures d’écran. --resource récupère les images, les polices et les médias facultatifs. Cela consomme de la bande passante et de la mémoire à chaque chargement de page. Laissez donc cette option désactivée jusqu’à ce qu’une page démontre qu’elle est nécessaire. --profile-dir conserve les cookies et le stockage entre les exécutions. Sans cette option, chaque exécution est éphémère.
Les données de ce graphique
[
{
"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
}
]Sur la charge de travail d’agent fournie en exemple par le projet, Moli a accepté une connexion CDP après 34.85 ms, contre 169.37 ms pour Chromium, avec un PSS maximal (proportional set size, mémoire comptabilisée avec les pages partagées réparties entre les processus qui les partagent) de 102.46 MiB, contre 348.82 MiB. La différence structurelle apparaît dans la dernière colonne : 1 processus contre 11. Un seul processus constitue une unité à superviser pour systemd et un seul cgroup à limiter. C’est ce qui permet de garder la section suivante courte.
Exécuter moli serve comme service systemd sur loopback
Exécutez le serveur comme un service lorsqu’un agent a besoin qu’un navigateur reste en attente. Continuez à utiliser moli fetch par URL lorsque ce n’est pas le cas, car un serveur inactif conserve sa mémoire.
N’exposez pas le port 9222 sur une interface publique. CDP ne comporte aucune étape d’authentification. Toute personne pouvant atteindre ce port peut piloter le navigateur et lire tout ce à quoi le navigateur peut accéder, y compris les cookies présents dans votre répertoire de profil. Laissez-le sur 127.0.0.1. Depuis une autre machine, utilisez un tunnel SSH (ssh -L 9222:127.0.0.1:9222 user@your-vps) ou une interface VPN privée, puis laissez l’agent se connecter à http://127.0.0.1:9222 de son côté du tunnel.
Créez un utilisateur de service, puis le fichier d’unité :
sudo useradd --system --home-dir /var/lib/moli --shell /usr/sbin/nologin moliÉcrivez /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.targetsudo systemctl daemon-reload
sudo systemctl enable --now moli.service
systemctl status moli.service
curl -s http://127.0.0.1:9222/json/versionsystemctl status doit afficher active (running), et curl doit renvoyer le JSON de découverte. ProtectSystem=strict rend le système de fichiers accessible en lecture seule, à l’exception des systèmes de fichiers d’API et des exceptions configurées ; StateDirectory=moli crée /var/lib/moli, qui appartient à l’utilisateur de service, et le laisse accessible en écriture. Avec PrivateTmp=yes, les /tmp et /var/tmp privés de l’unité sont également accessibles en écriture. Une unité qui démarre puis s’arrête avec une erreur de permission dans journalctl -u moli essaie presque toujours d’écrire à un emplacement que ProtectSystem vient de rendre accessible en lecture seule. Déplacez donc ce chemin sous le répertoire d’état.
MemoryMax=768M limite l’utilisation mémoire de l’unité. L’unité dispose de son propre cgroup. Lorsque l’utilisation atteint la limite, le noyau tente de récupérer de la mémoire. S’il est impossible de réduire cette utilisation, l’OOM killer est invoqué à l’intérieur de ce cgroup et ne tue pas les processus qui se trouvent en dehors. Le journal enregistre un kill :
moli.service: A process of this unit has been killed by the OOM killer.Considérez cette ligne comme un indicateur de dimensionnement. Les pages sont soit plus lourdes que prévu, soit la limite est trop basse. Définissez cette valeur à partir d’une mesure effectuée sur vos propres pages. C’est le sujet de la section suivante. La comptabilisation mesure l’utilisation ; des contrôles distincts, tels que MemoryMax et CPUQuota, imposent des limites à d’autres services, et limiter la mémoire et le CPU avec systemd s’appuie sur les autres mécanismes.
Mesurez vous-même le pic de mémoire
Les chiffres publiés proviennent du matériel et des pages de quelqu’un d’autre. Le pic de mémoire détermine si votre serveur tiendra, et ce pic dépend entièrement de ce que vous chargez. Mesurez avant de dimensionner.
Pour une récupération ponctuelle, utilisez le binaire time, qui fournit bien plus d’informations que la commande shell intégrée du même nom :
sudo apt update && sudo apt install -y time
/usr/bin/time -v moli fetch --dump markdown --wait-until networkidle https://example.com > /dev/nullLa sortie se termine par un bloc de statistiques de ressources qui inclut Maximum resident set size (kbytes). Divisez cette valeur par 1024 pour obtenir des MiB. Exécutez la commande sur dix pages que votre agent consulte réellement, plutôt que sur example.com, et conservez le résultat le plus élevé au lieu de la moyenne, car l’OOM killer réagit aux pics.
Pour le service, lisez le compteur que le kernel conserve déjà pour son cgroup :
cat /sys/fs/cgroup/system.slice/moli.service/memory.peak
systemd-cgtop -mmemory.peak est une valeur en octets. Il s’agit du pic maximal depuis la création du cgroup. Un redémarrage du service ne réinitialise cette valeur que si le cgroup est recréé. C’est cette valeur que MemoryMax doit dépasser, avec une marge supplémentaire pour la page la plus lourde que vous n’avez pas encore visitée. systemd-cgtop -m affiche l’utilisation actuelle par unité. C’est le moyen le plus rapide de voir quel service du serveur consomme le plus de mémoire aujourd’hui.
Où Moli échoue-t-il, et quand avez-vous encore besoin de Chrome ?
Le projet exécute également un benchmark de 1,308 tâches comparables d’automatisation de navigateur et publie le score de plusieurs moteurs.
Les données de ce graphique
[
{
"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
}
]Sur ces 5 moteurs, Moli 0.1.1 a terminé 81.88 pour cent des tâches, tandis que Chrome, le moteur de référence, en a terminé 99.85 pour cent. Le projet s’évalue lui-même sur sa propre suite de tests. Il faut donc considérer ce résultat comme une affirmation, et non comme un résultat indépendant.
L’interprétation pratique est simple. Moli 0.1.1 a échoué à 237 des 1,308 tâches sélectionnées, soit environ une tâche sur cinq. Si votre agent consulte un ensemble fixe de pages que vous contrôlez, ce ratio vous apprend peu de choses, car vos pages fonctionnent ou non, et vous pouvez le vérifier cet après-midi. Le rapport décrit des observations, pas des limites maximales de capacité. Ces échecs ne prouvent donc ni que certaines fonctionnalités ne sont pas prises en charge, ni l’existence d’un taux d’échec donné sur le Web ouvert.
Le périmètre indiqué par le projet recense les charges de travail à vérifier avec Chrome.
- Les applications qui nécessitent un rendu Canvas haute fidélité ; Moli implémente les opérations de dessin Canvas, donc Canvas seul ne suffit pas à justifier le recours à Chrome
- Tout ce qui nécessite WebGL haute fidélité ou une composition GPU, car aucun compositeur GPU n’est disponible
- La lecture multimédia exigeante
- Les tests visuels qui vérifient des captures d’écran au pixel près par rapport à Chrome, puisque la parité avec Chrome n’est pas un objectif
L’autre chiffre cité par le projet, à savoir qu’une exécution complète réussit 1.612 million de tests de la plate-forme Web, concerne la couverture des standards. Il ne garantit rien pour les sites que votre agent consultera. Une page peut n’utiliser que des standards correctement pris en charge et échouer malgré tout à une vérification anti-bot. Aucun score de moteur ne couvre ce cas.
Conservez donc un mécanisme de fallback dans l’architecture. Envoyez d’abord chaque URL à Moli. Lorsqu’une page revient vide ou qu’un sélecteur n’apparaît jamais, réessayez cette URL avec Playwright pilotant un véritable Chrome, sur une machine plus puissante ou selon un calendrier où un processus de 773 MiB reste abordable. La plupart des agents passent l’essentiel de leur temps sur des pages ordinaires. Le petit moteur absorbe donc le volume, et le moteur coûteux prend en charge les cas résiduels.
FAQ
Moli peut-il remplacer Chrome headless pour mon agent ?
Pour lire des pages, extraire du texte et effectuer des clics ordinaires, généralement oui. Dans le benchmark du projet portant sur 1,308 tâches, il a réussi 81.88 pour cent des tâches, contre 99.85 pour cent pour Chrome, avec 237 tâches en échec sur Moli 0.1.1 ; ces observations ne prouvent pas que chaque échec nécessite une capacité non prise en charge. Le Canvas/WebGL et la lecture multimédia haute fidélité ne font pas partie du périmètre déclaré du projet, mais l’utilisation de Canvas seule ne rend pas une application incompatible. Redirigez vers Chrome les URL qui échouent à vos vérifications, au lieu de tout basculer de nouveau vers Chrome.
De combien de RAM Moli a-t-il besoin sur un VPS ?
Le projet indique un RSS médian de 73 MiB lors d’un crawl de 192 URL, ainsi qu’un PSS maximal de 102.46 MiB pendant un épisode d’agent, contre une valeur médiane de 773 MiB pour Chrome headless. Ce sont les valeurs indiquées par le projet sur ses pages. Mesurez votre consommation avec /usr/bin/time -v autour d’un appel à moli fetch pour une utilisation ponctuelle, ou consultez /sys/fs/cgroup/system.slice/moli.service/memory.peak pour le service, puis définissez MemoryMax au-dessus de la valeur maximale observée.
Est-il sûr d’exposer le port 9222 sur Internet ?
Non. CDP n’a aucune authentification. Toute personne pouvant atteindre ce port peut piloter votre navigateur et lire tout ce auquel le navigateur peut accéder. Conservez --host 127.0.0.1, puis accédez au endpoint depuis une autre machine par un tunnel SSH ou via une interface VPN privée. Si vous devez lier une autre adresse, utilisez une interface privée et contrôlez l’accès avec le firewall.
Pourquoi ma capture d’écran est-elle vide, ou pourquoi mon clic n’aboutit-il à rien ?
La mise en page est désactivée par défaut. Le README indique que la policy par défaut est LayoutPolicy::Mock. La géométrie des éléments n’est donc pas réelle, et tout ce qui dépend d’un bloc sur la page ne peut pas fonctionner. Démarrez le serveur avec moli serve --layout, ou ajoutez --layout à moli fetch. La capture d’écran et les parcours utilisant les coordonnées commencent alors à fonctionner. Les images manquantes dépendent d’un autre flag : --resource.
Quelle version de Moli dois-je installer ?
Verrouillez une version et notez-la. Au 16 novembre 2026, la dernière release est la 1.1.25 ; les commandes de ce guide restent verrouillées sur la 1.1.18. Le score Lexbench du projet a été mesuré avec la version 0.1.1. Comparez donc les versions avant de comparer vos résultats avec ceux d’une autre personne. Téléchargez le moli-x86_64-unknown-linux-gnu.tar.gz de ce tag et installez vous-même le binaire, plutôt que d’utiliser le shell installer, qui résout la dernière release au lieu du tag depuis lequel vous l’avez récupéré, puis vérifiez avec moli --version.