SSD Nodes Learn Hosting plans →
Guide Matt ConnorDi Matt Connor

Come eseguire Moli self-hosted per agenti AI

Scopri come installare Moli su un piccolo VPS, esporre CDP su loopback e collegarlo a Playwright, con limiti e casi in cui Chrome resta necessario.

Un browser headless adatto a un piccolo VPS

Moli è un browser headless per agenti AI ed è abbastanza leggero da poter essere eseguito su un VPS sul quale Chrome headless non entrerebbe. È un motore browser scritto in Rust, non un wrapper per Chromium, e supporta il Chrome DevTools Protocol (CDP), il protocollo già utilizzato dalla libreria di automazione. È sufficiente installare un solo binario, eseguire moli serve, quindi configurare Playwright o il codice del proprio agente per usare http://127.0.0.1:9222.

Prima di installare qualsiasi componente, valutate il compromesso. Il progetto definisce chiaramente il proprio ambito: non include un browser con interfaccia grafica, un compositor GPU, la parità pixel per pixel con Chrome né il supporto ad alta fedeltà per Canvas/WebGL e la riproduzione multimediale. Le pagine che richiedono queste funzionalità non funzioneranno. Chrome reale tramite Playwright resta l'alternativa di fallback; l'ultima sezione spiega come determinare quali pagine ne hanno bisogno.

Ogni comando riportato di seguito proviene dal README del progetto e dai relativi skill file pubblicati, verificati nuovamente il 16 novembre 2026 rispetto alla versione fissata. Ogni numero nei grafici è un dato pubblicato dal progetto sul proprio motore, non una misurazione eseguita da questo sito, e ogni didascalia lo specifica. Se state ancora scegliendo un motore, la panoramica più ampia sui browser headless per agenti su un VPS descrive le alternative.

Perché Chrome headless usa così tanta memoria?

Chrome è un browser multiprocesso. Raggruppa i documenti per sito e, su Linux desktop, il completo Site Isolation mantiene ogni sito, inclusi gli iframe cross-site, nei propri processi renderer. Chrome può consentire alle pagine dello stesso sito di condividere un renderer, ma una sessione che accede a più siti esegue comunque diversi processi di questo tipo. Ogni renderer ha il proprio heap V8 e i propri buffer grafici. Questo design è corretto su un desktop, dove una pagina che va in crash non deve causare la chiusura dell'intera finestra. Su un VPS da 2 GB, però, una singola fase di navigazione può richiedere più memoria dell'applicazione in esecuzione.

Il progetto ha eseguito il crawling di 192 URL pubblici eterogenei con quattro motori e ha pubblicato il risultato.

GraficoMixed public web crawl, 192 URLs, figures published by the Moli project
I dati alla base di questo grafico
[
  {
    "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 ha restituito 101 pagine utili, mentre Moli ne ha restitituite 103. In questo campione, quindi, i due motori hanno analizzato all'incirca la stessa quota del Web. La differenza riguarda la memoria: un RSS mediano (resident set size, ovvero la memoria che un processo mantiene effettivamente in RAM) di 773 MiB per Chrome, contro 73 MiB per Moli. La direzione del risultato è plausibile perché deriva dall'architettura dei processi. Non bisogna presumere che il rapporto esatto sia lo stesso sulle proprie pagine.

La mediana non è il valore che causa i problemi. Lo è il picco. Quando un sistema da 2 GB esaurisce la memoria, il kernel seleziona un processo e lo termina. L'evento viene registrato in 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

Il tuo agent non vede quella riga. Vede un browser che ha smesso di rispondere, in genere con un errore di Playwright come page.goto: Page crashed oppure con un target chiuso. L'errore non indica la memoria. Per questo, quando un agent fallisce casualmente su un sistema con risorse limitate, il primo controllo deve riguardare l'OOM (out of memory) killer. Dimensionare il sistema per il picco equivale a scegliere RAM e CPU per un VPS destinato all'agent.

Installare il binario Moli con una versione bloccata

Il progetto pubblica un installer shell e archivi tar precompilati nelle release di GitHub. Al 16 novembre 2026, la release più recente è la 1.1.25, pubblicata il 15 novembre 2026; i comandi riportati di seguito restano bloccati sulla 1.1.18. Il progetto ha misurato il punteggio Lexbench, citato più avanti in questa guida, sulla versione 0.1.1, mentre il README non indica la versione alla base degli altri valori. Considerali tutti come un’indicazione approssimativa delle capacità del motore, non come una garanzia sul build che installerai.

Blocca la versione. Un installer che risolve sempre latest sposta l’agente su un motore browser diverso al rebuild successivo. Una variazione nel comportamento del browser deve essere pianificata, non scoperta casualmente.

L’installer shell è il modo più rapido per iniziare. Conviene leggerlo prima di eseguirlo.

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

Leggi lo script prima di eseguirlo. È breve. Seleziona un archivio dal tuo uname -m, quindi estrae un singolo binario in ~/.local/bin. Su x86_64 usa l’archivio moli-x86_64-unknown-linux-gnu.tar.gz, mentre su un server Arm usa l’archivio aarch64; sono quindi supportati sia i piani VPS Arm sia quelli x86. Imposta MOLI_INSTALL_DIR per installare il binario in un’altra posizione. Verifica quale versione risolve: la release più recente, non il tag da cui hai scaricato lo script. Va bene per una prima valutazione, ma non per un rebuild ripetibile.

Per qualsiasi installazione permanente, esegui manualmente le stesse operazioni dell’installer e specifica direttamente l’archivio esatto. In questo modo puoi collocare il binario in una posizione raggiungibile da un servizio di sistema ed evitare di passare uno script scaricato direttamente a una 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 che stampa la versione bloccata è sufficiente per il controllo. Se esegui moli: command not found subito dopo l’installer, significa che la directory di installazione non è presente in PATH. L’installer stampa una riga con il nome della directory da aggiungere.

Estrazione one-shot con moli fetch

Molti job assegnati da un agent a un browser consistono nel «caricare questo URL e dirmi che cosa contiene». Per questo non serve alcun server. moli fetch avvia il motore, carica una pagina, scrive un artifact su standard output e termina, quindi tra una chiamata e l'altra non viene mantenuto nulla in memoria.

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

Il primo comando stampa la pagina in Markdown, iniziando da # Example Domain. Il Markdown è il formato più economico da passare a un modello, perché rimuove il markup e conserva il testo. semantic_tree_text mantiene ruoli e struttura: è la scelta corretta per una pagina con molta navigazione, in cui i link sono importanti quanto il testo. --dump json include lo stato HTTP e la traccia della richiesta; usalo quando un fetch restituisce una risposta vuota e devi capire il motivo.

La strategia di attesa determina se ottieni il contenuto o solo una struttura vuota. --wait-until networkidle restituisce il risultato quando il traffico di rete si interrompe. --wait-until domstable restituisce il risultato quando il DOM smette di cambiare; è la scelta migliore per una pagina che esegue polling in background e quindi non diventa mai realmente inattiva. --wait-selector attende un selettore specificato da te. È l'unica strategia che tiene conto del contenuto della pagina richiesta, quindi è la più affidabile quando conosci l'elemento da attendere.

Gli screenshot e i PDF richiedono un layout reale, disabilitato per impostazione predefinita:

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

Il README indica come criterio di layout predefinito LayoutPolicy::Mock: la geometria viene simulata e non viene eseguito alcun rendering, perché layout e rendering costituiscono la parte più onerosa di un browser. Questa impostazione predefinita spiega i valori di memoria riportati sopra. Significa anche che un PNG vuoto dipende di solito dall'assenza del flag --layout, non da un problema della pagina.

Per gli URL trovati dall'agent, anziché scelti da te, aggiungi --block-private-networks. Un agent che segue i link letti in una pagina potrebbe essere indotto a recuperare http://169.254.169.254/ per ottenere credenziali di un'istanza cloud o a raggiungere una porta di database su localhost che non doveva essere esposta sul web. Questo flag blocca gli indirizzi privati per le richieste connesse direttamente e --block-cidrs aggiunge intervalli specifici da bloccare; gli indirizzi risolti dal proxy devono essere filtrati dal proxy. Quando il job consiste nel crawling anziché nella lettura di una singola pagina, la struttura di questa pipeline è descritta in alternative self-hosted a Firecrawl, mentre il passaggio precedente, cioè trovare gli URL, è descritto in una skill di ricerca per agent basata su SearXNG.

Fai puntare un agent a Moli tramite CDP

Per un agent che esegue molte operazioni di navigazione e clic, avvia invece il server.

moli serve --host 127.0.0.1 --port 9222

127.0.0.1 e la porta 9222 sono i valori predefiniti, quindi un semplice moli serve è già in ascolto soltanto sull'interfaccia loopback. Tuttavia, nelle configurazioni permanenti indica sempre entrambi i valori, così chi leggerà in seguito il file del servizio non dovrà ricordare quali fossero i valori predefiniti.

Verifica il server prima di collegarvi un client:

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

Un server funzionante risponde con un oggetto JSON che contiene un campo webSocketDebuggerUrl. Il relativo URL è quello a cui si collega un client CDP. curl: (7) Failed to connect to 127.0.0.1 port 9222: Connection refused indica che non è in ascolto alcun processo, quindi controlla il terminale da cui hai avviato il server oppure esegui journalctl -u moli -n 50 se il server è un servizio. /json/list elenca le destinazioni aperte e /json/protocol elenca i domini implementati da questa build. In questo modo puoi verificare se esiste un metodo CDP da cui dipendi.

Playwright si collega a quell'endpoint invece di avviare un browser autonomamente:

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 riga importante è connectOverCDP, non chromium.launch(). In questo caso non esiste alcun processo Chromium figlio, quindi executablePath e i consueti flag dei container, come --no-sandbox, non hanno alcun effetto. Per lo stesso motivo, le impostazioni di proxy, cookie e user agent vanno passate al server Moli tramite i relativi flag. La copertura CDP è parziale, non equivalente all'intero protocollo Chrome: un errore esplicito relativo a un metodo non supportato indica un limite del motore, non un bug del codice.

Due flag del server determinano le operazioni che l'agent può eseguire. --layout abilita la geometria reale, necessaria per i clic basati sulle coordinate e per gli screenshot. --resource scarica immagini, font e contenuti multimediali opzionali. Questa opzione consuma banda e memoria a ogni caricamento di pagina, quindi lasciala disattivata finché una pagina non dimostra di averne bisogno. --profile-dir conserva cookie e storage tra un'esecuzione e l'altra. Senza questo flag, ogni esecuzione è temporanea.

GraficoOne agent episode, Moli against Chromium, figures published by the Moli project
I dati alla base di questo grafico
[
  {
    "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
  }
]

Nel carico di lavoro dell'agent di esempio del progetto, Moli ha accettato una connessione CDP dopo 34.85 ms, rispetto a 169.37 ms per Chromium, con un PSS di picco (proportional set size, cioè la memoria con le pagine condivise ripartita tra i processi che le condividono) di 102.46 MiB, rispetto a 348.82 MiB. La differenza strutturale è nell'ultima colonna: 1 processo rispetto a 11. Un solo processo corrisponde a un'unica unità che systemd deve supervisionare e a un unico cgroup a cui applicare un limite. Per questo la sezione successiva è breve.

Eseguire moli come servizio systemd su loopback

Eseguire il server come servizio quando un agente ha bisogno di un browser in attesa di connessioni. Continuare a usare moli fetch per URL quando non serve, perché un server inattivo continua comunque a occupare memoria.

Non associare la porta 9222 a un'interfaccia pubblica. CDP non prevede alcun tipo di autenticazione. Chiunque possa raggiungere quella porta può controllare il browser e leggere tutto ciò che il browser può raggiungere, inclusi eventuali cookie nella directory del profilo. Mantenerla su 127.0.0.1. Raggiungerla da un altro computer tramite un tunnel SSH (ssh -L 9222:127.0.0.1:9222 user@your-vps) o tramite un'interfaccia VPN privata, quindi fare in modo che l'agente si connetta a http://127.0.0.1:9222 sul proprio lato del tunnel.

Creare un utente di servizio, quindi il file dell'unità:

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

Scrivere /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 dovrebbe mostrare active (running), mentre curl dovrebbe restituire il JSON di rilevamento. ProtectSystem=strict rende il filesystem di sola lettura, ad eccezione dei filesystem API e delle eccezioni configurate; StateDirectory=moli crea /var/lib/moli, assegnandola all'utente di servizio, e la mantiene scrivibile. Con PrivateTmp=yes, anche /tmp e /var/tmp privati dell'unità sono scrivibili. Un'unità che si avvia e poi termina con un errore di autorizzazione in journalctl -u moli sta quasi sempre tentando di scrivere in un percorso che ProtectSystem ha appena reso di sola lettura; spostare quindi quel percorso nella directory di stato.

MemoryMax=768M limita l'uso della memoria dell'unità. L'unità dispone di un cgroup dedicato e, quando l'uso raggiunge il limite, il kernel tenta di recuperare memoria. Se non è possibile ridurre l'uso, l'OOM killer viene invocato all'interno di quel cgroup e non termina i processi esterni. Il journal registra una terminazione:

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

Interpretare quella riga come un'indicazione per il dimensionamento. Le pagine possono essere più pesanti del previsto oppure il limite può essere troppo basso. Impostare il valore sulla base di una misurazione delle proprie pagine; questa è l'argomento della sezione successiva. Il conteggio misura l'uso; controlli separati come MemoryMax e CPUQuota impongono limiti ad altri servizi, mentre limitare memoria e CPU con systemd opera insieme a questi controlli.

Misura direttamente il picco di memoria

I valori pubblicati provengono dall'hardware e dalle pagine di qualcun altro. Il picco di memoria determina se il server riesce a rimanere operativo e dipende interamente da ciò che carichi. Esegui le misurazioni prima di dimensionare il sistema.

Per un'acquisizione singola, usa il binario time, che restituisce molte più informazioni rispetto al builtin della shell con lo stesso nome:

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

L'output termina con un blocco di statistiche sulle risorse che include Maximum resident set size (kbytes). Dividilo per 1024 per ottenere i MiB. Esegui il test su dieci pagine che il tuo agent visita realmente, invece che su example.com, e conserva il risultato peggiore anziché la media, perché l'OOM killer reagisce ai picchi.

Per il servizio, leggi il contatore che il kernel mantiene già per il relativo cgroup:

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

memory.peak è un conteggio in byte e rappresenta il valore massimo raggiunto dall'utilizzo dall'istanziazione del cgroup; il riavvio del servizio lo reimposta solo se il cgroup viene ricreato. Questo valore deve essere inferiore a MemoryMax, lasciando ulteriore margine per la pagina più pesante che non hai ancora visitato. systemd-cgtop -m mostra l'utilizzo corrente per unità ed è il modo più rapido per vedere quale servizio sul server sta consumando più risorse oggi.

Dove fallisce Moli e quando serve ancora Chrome?

Il progetto esegue anche un benchmark su 1,308 attività comparabili di automazione del browser e pubblica il punteggio ottenuto da diversi engine.

GraficoLexbench headless browser suite, 1,308 tasks, figures published by the Moli project
I dati alla base di questo grafico
[
  {
    "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
  }
]

Tra questi 5 engine, Moli 0.1.1 ha completato il 81.88 percento delle attività, mentre Chrome, l'engine di riferimento, ha completato il 99.85 percento. Il progetto valuta se stesso sulla propria suite, quindi questo dato va interpretato come un'affermazione del progetto e non come un risultato indipendente.

L'interpretazione pratica è semplice. Moli 0.1.1 ha fallito 237 delle 1,308 attività selezionate, cioè circa una su cinque. Se l'agente visita un insieme fisso di pagine che controllate, questo rapporto fornisce poche informazioni, perché le vostre pagine funzionano oppure non funzionano e potete verificarlo già oggi. Il report descrive osservazioni, non i limiti massimi delle funzionalità, quindi questi errori non dimostrano che alcune funzioni non siano supportate né indicano un tasso di errore sul web aperto.

L'ambito dichiarato dal progetto indica quali carichi di lavoro verificare con Chrome.

  • Applicazioni che richiedono un rendering Canvas ad alta fedeltà; Moli implementa le operazioni di disegno Canvas, quindi Canvas da solo non dimostra la necessità di usare Chrome
  • Qualsiasi applicazione che richieda WebGL ad alta fedeltà o compositing GPU, perché non è disponibile un compositor GPU
  • Riproduzione di contenuti multimediali impegnativa
  • Test visivi che verificano screenshot identici a livello di pixel rispetto a Chrome, perché la parità con Chrome non è un obiettivo

L'altro dato citato dal progetto, ovvero il superamento di 1.612 milioni di test della piattaforma web in un'esecuzione completa, riguarda la copertura degli standard. Non garantisce il funzionamento sui siti visitati dall'agente. Una pagina può usare esclusivamente standard ben supportati e fallire comunque un controllo anti-bot; inoltre nessun punteggio dell'engine copre questo caso.

Quindi mantenete il fallback nella progettazione. Inviate ogni URL prima a Moli. Se una pagina restituisce contenuto vuoto o un selettore non compare mai, riprovate quell'URL con Playwright che controlla Chrome reale, su una macchina più potente oppure in una pianificazione in cui un processo da 773 MiB sia sostenibile. La maggior parte degli agenti trascorre la maggior parte del tempo su pagine ordinarie, quindi l'engine leggero gestisce il volume e quello più costoso gestisce i casi residuali.

FAQ

Moli può sostituire Chrome headless per il mio agent?

Per leggere le pagine, estrarre testo ed eseguire clic ordinari, in genere sì. Nel benchmark del progetto, su 1,308 attività ha completato il 81.88 percento, contro il 99.85 percento di Chrome, lasciando 237 attività non riuscite su Moli 0.1.1; queste osservazioni non dimostrano che ogni errore richieda una funzionalità non supportata. Il rendering ad alta fedeltà di Canvas/WebGL e la riproduzione dei contenuti multimediali non rientrano nell'ambito dichiarato dal progetto, ma il solo utilizzo di Canvas non rende un'applicazione incompatibile. Invia gli URL che non superano i tuoi controlli a Chrome reale, invece di tornare a utilizzarlo per tutto.

Quanta RAM richiede Moli su un VPS?

Il progetto riporta un RSS mediano di 73 MiB durante una scansione di 192 URL e un PSS massimo di 102.46 MiB in un episodio di esempio dell'agent, contro un valore mediano di 773 MiB per Chrome headless. Questi sono i valori riportati dal progetto nelle relative pagine. Misura il tuo consumo con /usr/bin/time -v intorno a una chiamata moli fetch per l'uso una tantum, oppure leggi /sys/fs/cgroup/system.slice/moli.service/memory.peak per il servizio; quindi imposta MemoryMax al di sopra del valore massimo osservato.

È sicuro esporre la porta 9222 su Internet?

No. CDP non dispone di autenticazione, quindi chiunque possa raggiungere quella porta può controllare il browser e leggere qualsiasi contenuto accessibile dal browser. Mantieni --host 127.0.0.1 e raggiungi l'endpoint da un altro computer tramite un tunnel SSH o attraverso un'interfaccia VPN privata. Se devi associare il servizio a un altro indirizzo, utilizza un'interfaccia privata e controlla l'accesso con il firewall.

Perché lo screenshot è vuoto o il clic non si posiziona su nulla?

Il layout è disabilitato per impostazione predefinita. Il README indica come criterio predefinito LayoutPolicy::Mock, quindi la geometria degli elementi non è reale e tutto ciò che dipende da un riquadro nella pagina non può funzionare. Avvia il server con moli serve --layout oppure aggiungi --layout a moli fetch; lo screenshot e le operazioni basate sulle coordinate inizieranno così a funzionare. Le immagini mancanti dipendono da un flag diverso: --resource.

Quale versione di Moli devo installare?

Fissa una versione e annota quale hai scelto. Al 16 novembre 2026, la release più recente è 1.1.25; i comandi di questa guida restano fissati alla versione 1.1.18. Il punteggio Lexbench del progetto è stato misurato sulla versione 0.1.1, quindi confronta le versioni prima di confrontare i risultati con quelli di un'altra persona. Scarica il moli-x86_64-unknown-linux-gnu.tar.gz di quel tag e installa manualmente il binario, invece di affidarti allo shell installer, che risolve la release più recente anziché il tag da cui l'hai scaricato; quindi verifica con moli --version.

Questo articolo ti è stato utile?