SSD Nodes Learn Hosting plans →
Guide Matt ConnorDi Matt Connor

Paritok riduce davvero i costi del coding agent?

Paritok comprime file, output e contesto inviati dal coding agent: il progetto dichiara il 74% di token in meno. Ecco il meccanismo e il punto di pareggio.

Cosa fa Paritok a una richiesta

Paritok è un token gateway: un proxy che si interpone tra il coding agent e l’API del modello e comprime ogni richiesta prima di inoltrarla. Il tuo agent comunica con http://127.0.0.1:8080 invece che con il provider. Il proxy riduce gli schemi degli strumenti, le letture dei file, l’output degli strumenti e i turni precedenti, invia a monte un payload più piccolo e restituisce la risposta senza modificarla.

Il provider ti addebita ciò che riceve, ma la fattura dipende dai token rimossi, dal relativo prezzo di caching e dal numero di turni eseguiti dall’agent. Questo è il concetto centrale. Si tratta di un’affermazione diversa da «il tuo contesto dura più a lungo» ed è il motivo per cui questo strumento è interessante, non soltanto ordinato.

Il progetto è recente. Il gateway è stato pubblicato come open source il 15 July 2026; su PyPI, v1.3.14 risale al 6 October 2026 e v1.3.0 al 5 August. I pesi e il codice del gateway sono distribuiti con licenza Apache 2.0. Il modello di compressione è un adapter LoRA (low-rank adaptation) basato su Qwen3-4B-Instruct-2507, distillato da un insieme di 45,000 segmenti estratti da traiettorie reali di coding agent; 40,606 di questi hanno superato la validazione del teacher e sono diventati esempi di addestramento.

Perché questo non è il trimming del contesto

Il trimming elimina definitivamente i contenuti. Quando un agent si avvicina al limite del contesto e scarta i turni più vecchi, il file letto al turno 3 non è più disponibile. Se serve di nuovo al turno 20, l'agent deve rileggere il file e paghi nuovamente quei token. Il risparmio era solo temporaneo.

Paritok sostituisce un segmento con una forma più breve e un tag, [REF:id], mantenendo il testo completo sul proxy. Il modello recupera un segmento chiamando read_original o expand_context. Questo cambia la modalità di errore. Un trimmer fallisce dimenticando il contenuto, senza informarti. Un compressor fallisce fornendo al modello un estratto con perdita di informazioni; quando l'estratto non basta, il modello può richiedere l'originale.

Gli schema filtrati dei tool restano recuperabili, ma il filtro adattivo predefinito rimuove i tool standard non selezionati e i tool MCP non selezionati, salvo che si attivi il relativo segnale di pertinenza MCP. Quando il segnale si attiva, i tool MCP non selezionati vengono sostituiti da stub. gateway_search_tools supporta il recupero e il gateway rileva inoltre i messaggi relativi a tool mancanti, quindi inserisce i tool corrispondenti prima di riprovare. Questo è importante perché un filtro che nasconde definitivamente un tool modifica ciò che l'agent può fare, e te ne accorgeresti solo tramite un'attività con esito errato senza segnali evidenti.

I tre meccanismi e quello gratuito

Il primo meccanismo è il filtro dello schema degli strumenti. Ogni richiesta contiene l'intero array tools. In un turno di Claude Code senza server MCP (model context protocol) collegati, il progetto misura questo blocco in circa 29,000 token; con MCP collegato, riporta da 44,000 a 65,000 token. Il filtro incorpora la richiesta dell'utente e la descrizione di ogni strumento con BAAI/bge-small-en-v1.5, un modello di embedding da 130 MB, mantiene gli strumenti pertinenti, rimuove gli strumenti standard non selezionati e crea stub per gli strumenti MCP non selezionati solo quando si attiva il relativo segnale di pertinenza MCP. In caso contrario, rimuove anche questi strumenti MCP. Nell'esempio del progetto con 29,000 token, il blocco si riduce a circa 8,000 token. Il modello di embedding viene eseguito sulla CPU.

Il secondo meccanismo è la compressione dei contenuti, che utilizza il modello 4B su una GPU oppure tramite Ollama sulla CPU. La lettura dei file, l'output degli strumenti e la cronologia vengono ridotti al 25.7% delle dimensioni originali. Il modello seleziona principalmente intervalli di testo, invece di riscriverli, consentendo una riscrittura limitata per contenuti come i riepiloghi del ragionamento e la struttura delle chiamate agli strumenti. Nel corpus di addestramento generato dal modello teacher, il documento del progetto misura il 96.0% degli identificatori, dei percorsi e dei numeri emessi come presenti alla lettera nell'input; l'output del modello addestrato sul set di test SWE-bench Lite raggiunge il 96.2% nella stessa verifica. È da qui che deriva il dato del 74%. Va interpretato correttamente: il 74% è il tasso di compressione dei contenuti compressi, non la riduzione del costo in fattura.

Il terzo meccanismo è il riepilogo della cronologia. Per impostazione predefinita, quando il contesto supera l'80% della finestra configurata, i turni meno recenti vengono riepilogati, mentre quattro turni recenti restano integri. In questo modo una sessione lunga può continuare senza raggiungere il limite.

Per l'hosting autonomo non è necessaria una GPU. Questa è la frase più utile di questa pagina. pip install "paritok[toolselect]" offre il filtro degli strumenti su una normale VPS con CPU, senza costi per token. Provalo prima di noleggiare una scheda.

Cosa ha misurato il progetto e su quale harness

GraficoSWE-bench Lite: compression rate against solve quality retained (project's published figures)
I dati alla base di questo grafico
[
  {
    "label": "Paritok-4B-v1",
    "compressed_to_pct": 25.7,
    "quality_retained_pct": 86.5
  },
  {
    "label": "gpt-4.1-mini",
    "compressed_to_pct": 50.2,
    "quality_retained_pct": 85.6
  },
  {
    "label": "gpt-5",
    "compressed_to_pct": 61.9,
    "quality_retained_pct": 93.6
  }
]

Queste sono le metriche pubblicate dal progetto, misurate sul proprio harness rispetto a SWE-bench Lite. Paritok-4B-v1 comprime il contenuto al 25.7% delle dimensioni originali, mantenendo il 86.5% del solve rate non compresso. Usando gpt-5 come compressore si conserva una qualità maggiore, 93.6%, ma la compressione si ferma al 61.9%; in pratica si pagherebbero prezzi da modello frontier per risparmiare sui prezzi da modello frontier.

La colonna della qualità va interpretata correttamente. La qualità conservata è il solve rate del compressore diviso per il solve rate di base non compresso. Conservare l'86.5% significa una riduzione netta del 13.5% nei solve rispetto alla baseline; non indica la frazione dei problemi risolti dalla baseline che non vengono più risolti, perché le esecuzioni compresse possono risolvere anche problemi diversi. Questa metrica misura la comprensione single-shot del codice sorgente grezzo compresso, con il recall disabilitato e il recupero delle modifiche in produzione abilitato; non misura il filtro dello schema degli strumenti CPU né il gateway multi-turno completo.

GraficoReported input-token saving as a session grows (project's own harness)
I dati alla base di questo grafico
[
  {
    "label": "Turn 1",
    "saved_pct": 25
  },
  {
    "label": "Turn 5",
    "saved_pct": 39
  },
  {
    "label": "Turn 12",
    "saved_pct": 57
  },
  {
    "label": "Turn 20",
    "saved_pct": 63
  }
]

Il risparmio end-to-end aumenta con la durata della sessione, perché la cronologia si accumula ed è proprio la cronologia a essere compressa. Il progetto riporta circa il 25% su un singolo turno, 39% entro il turno 5 e 63% entro il turno 20. Sono misurati soltanto i turni da 1 a 5; il README indica le righe successive come proiezioni. Specifica inoltre dove la crescita si arresta: con un budget di 200,000 token, il risparmio di contenuto per turno si stabilizza intorno a 48,000 token tra il turno 8 e il turno 12, perché quando il contesto è pieno la cronologia smette di crescere. Il risparmio aggiuntivo del filtro degli strumenti è di circa 21,000 token per turno, portando il plateau combinato previsto a circa 69,000 token per turno. La cifra, spesso citata, di "oltre l'85%" descrive sessioni con il contesto saturo. È lo scenario migliore; lo stesso README afferma che, con le impostazioni predefinite, il risparmio tende a stabilizzarsi verso un limite di circa il 72%, quindi non va usato come riferimento per la pianificazione.

Una GPU da 24 GB si ripaga con Paritok?

La GPU è opzionale e il modello può essere eseguito su schede con meno di 24 GB. Per un calcolo indicativo del noleggio, considera un costo di $0.44 all'ora per una scheda da 24 GB. Se resta in esecuzione per tutto il mese, sono 730 ore, quindi $321. Se la esegui soltanto durante l'orario di lavoro, per 8 ore al giorno e 22 giorni, sono 176 ore, quindi $77.

Ora converti la riduzione dei token in una riduzione dei costi. La riduzione si applica ai token di input. I token di output passano invariati attraverso il proxy, quindi il proxy non li comprime. Calcola separatamente, usando le tariffe del tuo provider, il costo della modifica per i nuovi token di input, le scritture nella cache e le letture dalla cache, quindi confronta il costo API totale prima e dopo. Anche se l'input rappresenta l'80% del costo totale, moltiplicare la riduzione dei token per 0.8 non dimostra quanto risparmierai in fattura.

GraficoMonthly API saving needed to cover an illustrative $0.44/hour card
I dati alla base di questo grafico
[
  {
    "label": "Always on (730 hours)",
    "required_api_saving_usd": 321.2
  },
  {
    "label": "Workday only (176 hours)",
    "required_api_saving_usd": 77.44
  }
]

Una scheda lasciata in esecuzione si ripaga quando il risparmio API mensile misurato supera $321.2, oppure $77.44 se arresti l'istanza al di fuori dell'orario di lavoro. Una riduzione dei token dell'85% da sola non dimostra un risparmio in fattura del 68%, quindi non consente di stabilire una soglia mensile per la spesa degli agenti. Dividi il costo del noleggio per la frazione misurata di risparmio sulla fattura per ottenere tale soglia.

Due fattori rendono il risultato migliore di quanto suggerisca il grafico. Il modello non richiede 24 GB: la build q4 occupa circa 2.5 GB e la build f16 circa 8 GB. Una scheda più piccola, oppure un GPU box che utilizzi già per un altro scopo, riduce quindi tutti i valori del grafico. Inoltre, arrestare l'istanza quando nessuno sta scrivendo codice è la leva più importante, perché riduce il costo del noleggio di circa tre quarti.

Un fattore lo rende peggiore. Il passaggio di compressione richiede lavoro effettivo. Ogni token compresso dal modello 4B deve essere letto e ogni segmento mantenuto deve essere riscritto, aumentando la latenza di ogni turno dell'agente. Su una scheda noleggiata a ore, questo costo si manifesta come tempo di attesa, non come una voce in fattura, quindi è facile non accorgersene finché non lo si sperimenta.

Se stai confrontando in generale le ore di una GPU noleggiata con i token API, il punto di pareggio tra una GPU VPS e i token API esegue lo stesso calcolo per l'inferenza in sé.

Eseguire il gateway Paritok su un VPS

I metadati del pacchetto su PyPI accettano Python 3.10 o versioni successive, anche se il badge nel README indica 3.11+. Ubuntu 24.04 include Python 3.12, quindi un'immagine VPS standard è sufficiente per il filtro degli strumenti CPU.

sudo apt update && sudo apt install -y python3-venv curl
python3 -m venv /opt/paritok/venv
source /opt/paritok/venv/bin/activate
pip install "paritok[proxy]==1.3.14"
pip install "paritok[toolselect]==1.3.14"

Blocca la versione. PyPI indica il 5 agosto 2026 per v1.3.0 e il 6 ottobre 2026 per v1.3.14; un progetto che evolve a questo ritmo rinomina gli elementi tra una release e l'altra: la stessa v1.3.0 ha rinominato expand_context in read_original nella relativa API. Un pip install paritok senza versione, oppure un git clone di main, potrebbe fornirti la settimana successiva un gateway diverso, senza lasciare traccia di quale versione abbia prodotto i numeri misurati.

Il backend predefinito è Ollama. Scarica il modello, quindi assegnagli il nome breve che il proxy cerca.

ollama pull paritok/paritok-4b-v1
ollama cp paritok/paritok-4b-v1 paritok-4b-v1

Poiché il modello locale scrive gli span conservati per ogni segmento che comprime, un passaggio di compressione troppo lungo si manifesta come un turno dell'agente bloccato; il parametro num_predict di Ollama, che limita la lunghezza dell'output ne definisce il limite.

Scrivi paritok.yaml accanto a questo parametro. use_gpu_server: false mantiene la compressione sul tuo hardware.

use_gpu_server: false
local_model:
  base_url: http://localhost:11434/v1
paritok proxy --port 8080 --config-file paritok.yaml

paritok up è la scorciatoia per scaricare il modello se manca e avviare il proxy sulla porta 8080; Ollama deve essere già installato. Verifica il proxy prima di collegarvi un agente.

curl http://127.0.0.1:8080/health
curl http://127.0.0.1:8080/stats

/health restituisce un piccolo oggetto JSON contenente "status":"ok" e una stringa con la versione. /stats restituisce i totali della compressione e la stima del proxy sul risparmio ottenuto. Considera questa stima come una valutazione che il proxy fa del proprio lavoro e verificala nella pagina dei consumi del provider.

Per privilegiare il throughput rispetto alla semplicità, vLLM serve l'adapter sopra il modello di base.

vllm serve Qwen/Qwen3-4B-Instruct-2507 \
  --enable-lora \
  --lora-modules paritok-4b-v1=paritok/paritok-4b-v1 \
  --max-lora-rank 32 \
  --port 8000

Il flag --max-lora-rank 32 è presente nel comando del progetto perché l'adapter ha rank 32. Imposta quindi local_model.base_url su http://localhost:8000/v1 in paritok.yaml, così il proxy comunica con vLLM invece che con Ollama.

Ollama è più rapido da configurare. vLLM gestisce molto meglio le richieste concorrenti, aspetto che diventa importante non appena più di un agente condivide il server. La differenza pratica tra Ollama e vLLM determina quale soluzione scegliere.

Indica all'agente il proxy tramite le variabili d'ambiente dell'URL di base.

export ANTHROPIC_BASE_URL=http://127.0.0.1:8080
export OPENAI_BASE_URL=http://127.0.0.1:8080

Codex CLI ignora OPENAI_BASE_URL, quindi paritok up scrive ~/.codex/config.toml al posto tuo quando codex.enabled: true è impostato in paritok.yaml. Esportare da solo la variabile lascia Codex collegato direttamente al provider; il segnale è un contatore /stats che non cambia mentre lavori.

Mantieni il listener su 127.0.0.1, mai su 0.0.0.0. Il proxy inoltra upstream le credenziali fornite con ogni richiesta e il suo endpoint /stats non autenticato espone campioni del contenuto originale e compresso. Un listener esposto a Internet renderebbe quindi accessibili il contesto privato e le risorse locali di compressione. Raggiungilo da un laptop tramite un tunnel SSH o una VPN invece di aprire la porta.

Eseguilo tramite systemd, così continuerà a funzionare dopo un riavvio. Adatta i percorsi alla tua installazione. Crea l'utente paritok con cui viene eseguita l'unità e assegnagli la directory di installazione:

sudo useradd --system --home-dir /opt/paritok --shell /usr/sbin/nologin paritok
sudo chown -R paritok:paritok /opt/paritok
[Unit]
Description=Paritok compression proxy
After=network-online.target

[Service]
User=paritok
WorkingDirectory=/opt/paritok
ExecStart=/opt/paritok/venv/bin/paritok proxy --port 8080 --config-file /opt/paritok/paritok.yaml
Restart=on-failure

[Install]
WantedBy=multi-user.target

Abilitalo con sudo systemctl enable --now paritok, quindi esegui di nuovo curl /health. Un'unità che si avvia e termina immediatamente indica in genere un percorso errato del file di configurazione; journalctl -u paritok -n 50 mostra il motivo.

L’opzione in hosting e il relativo costo

Il progetto offre anche la compressione come servizio. Impostate use_gpu_server: true con una chiave API ottenuta da paritok.com e il modello 4B viene eseguito sulla relativa infrastruttura. Al 2 novembre 2026 il servizio addebita $0.30 per ogni milione di token dei file compressi, utilizzando il credito prepagato; il filtraggio degli schemi degli strumenti è gratuito. I nuovi account ricevono $5 di credito gratuito senza dover inserire una carta. Il periodo iniziale durante il quale il servizio in hosting era gratuito si è concluso il 1 ottobre 2026, quindi ora il servizio è a pagamento. In questo modo non dovete gestire l’hosting del modello di compressione, ma continuate a eseguire il gateway.

Questo significa anche che i prompt e i file letti dal vostro agente lasciano la vostra macchina e raggiungono un soggetto terzo prima di arrivare al vostro provider del modello. L’hosting autonomo serve proprio a evitare questo passaggio. Prima di impostare quel flag, decidete quale dei due obiettivi volete privilegiare: modificare il flag richiede una sola riga, ma le conseguenze sono diverse.

Come misurare i propri risultati prima e dopo

I numeri pubblicati sono quelli del progetto, ottenuti con il relativo harness su SWE-bench Lite. Il tuo repository non è SWE-bench Lite. Misura il tuo caso.

  • Esegui una settimana normale senza proxy nel percorso. Registra su righe separate i token di input, scrittura nella cache, lettura dalla cache e output riportati dalla pagina di utilizzo del provider, non come un unico totale in dollari.
  • Esegui la settimana successiva con il proxy davanti, svolgendo lo stesso tipo di attività.
  • Confronta le categorie di input usando i relativi prezzi effettivi e includi ogni variazione del costo dell'output. Il proxy non comprime l'output, ma le variazioni nel comportamento dell'agent e nel numero di turni incidono comunque sulla quantità di output acquistata.
  • Conta le attività che hai dovuto ripetere. Questa è la componente relativa alla qualità e nessuna dashboard la riporta.
  • Prima di confrontare i totali, aggiungi le ore GPU della seconda settimana.

Separare input e output è importante perché hanno prezzi molto diversi e un compressore interviene soltanto su uno dei due. Al 2 novembre 2026, Claude Sonnet 4.6 costa $3 per milione di token di input e $15 per milione di token di output; una lettura dalla prompt cache costa il 10% della tariffa di input, cioè $0.30 per milione. Il più recente Claude Sonnet 5.5 costa $2 e $10; le letture dalla cache costano il 5% della tariffa di input, cioè $0.10 per milione. La differenza tra il costo dei token di input e di output determina se un compressore lato input è utile nel tuo caso. Dove vengono effettivamente usati i token di Claude Code indica quale parte del contesto è abbastanza grande da giustificarne la compressione.

La prompt caching complica in particolare il calcolo del filtro degli strumenti. Il blocco degli strumenti si trova all'inizio della richiesta, quindi dopo il primo turno normalmente viene letto dalla cache; con Sonnet 4.6 questo costa il 10% del prezzo di input. Rimuovere 21,000 token da un blocco memorizzato nella cache consente di risparmiare 21,000 token a $0.30 per milione, cioè circa $0.006 per turno, invece dei $0.063 indicati dalla tariffa senza cache. Il progetto mantiene invariato il blocco filtrato per tutta la sessione, in modo che il prefisso memorizzato nella cache non cambi. Un filtro che selezionasse nuovamente gli strumenti a ogni turno invaliderebbe quel prefisso e potrebbe costare più del risparmio ottenuto.

Cosa non è ancora verificato

Tutti i dati sulle prestazioni riportati sopra provengono dal progetto stesso. Esiste una verifica indipendente della compressione su un corpus sintetico, ma non misura esplicitamente il successo delle attività SWE-bench; i dati sulla qualità delle soluzioni per SWE-bench Lite pubblicati dal progetto restano quindi privi di conferma indipendente. Inoltre, poiché il gateway è stato reso open source a luglio 2026, il codice ha alle spalle una storia operativa molto limitata. Sia il tasso di compressione sia il dato sulla qualità conservata sono misurati dalla parte che trae vantaggio dal fatto che risultino elevati. Questo non significa che siano errati. Significa che non sono confermati e che vanno valutati diversamente da un dato prodotto direttamente da te.

Prima di attribuire un problema alla tua configurazione, è utile conoscere un comportamento documentato. Il modello di embedding usato dal filtro degli strumenti viene caricato alla prima richiesta, non all'avvio. Per questo il progetto documenta un riscaldamento iniziale di 10-15 secondi, seguito da circa 15 ms per chiamata. Invia una richiesta di prova dopo l'avvio del proxy: il primo turno reale dell'agente non sembrerà bloccato.

In un pomeriggio puoi verificare direttamente quattro aspetti: se il proxy si avvia e rimane attivo, se /stats cambia mentre lavori, se la voce relativa agli input token del tuo provider diminuisce davvero e se l'agente completa comunque il lavoro. Per la tua configurazione, questi elementi sono molto più determinanti di qualsiasi benchmark pubblicato.

Per quanto riguarda l'integrazione con gli altri strumenti: un gateway LiteLLM self-hosted instrada e contabilizza le richieste senza modificarne il contenuto. Le due soluzioni risolvono quindi problemi diversi e possono essere concatenate, con Paritok posizionato più vicino all'agente. Se l'obiettivo reale è ridurre la spesa, anziché usare proprio questo strumento, l'insieme più ampio dei controlli dei costi per un agente su un VPS include diverse modifiche che puoi provare subito senza costi.

FAQ

Paritok riduce i costi della mia API o soltanto l'utilizzo del contesto?

Riduce la richiesta prima che raggiunga il provider; il risparmio dipende dai prezzi dei token rimossi e dal numero di turni risultante dell'agent. L'entità della riduzione è inferiore a quanto suggerisca il dato principale. Il valore del 74% indica il tasso di compressione sul contenuto compresso. Considerando l'intero percorso, il progetto dichiara un risparmio di circa il 25% su un singolo turno e prevede un risparmio del 63% sui token di input entro il turno 20. I token di output passano invariati, ma la quantità generata dipende comunque dal comportamento dell'agent.

Quanta GPU serve per eseguire autonomamente il modello di compressione?

Una GPU è facoltativa: Ollama esegue il modello anche sulla CPU. La build q4 occupa circa 2.5 GB e la build f16 circa 8 GB, quindi il modello entra in una scheda da 24 GB con molto spazio libero. È possibile usare una scheda più piccola, modificando a proprio favore il calcolo del punto di pareggio. Il filtro dello schema degli strumenti non richiede alcuna GPU: usa BAAI/bge-small-en-v1.5, un modello di embedding da 130 MB che viene eseguito sulla CPU. Installa paritok[toolselect] su un VPS ordinario per ottenere la riduzione dei blocchi degli strumenti con un consumo limitato di RAM.

Cosa succede se il compressore rimuove qualcosa di cui l'agent aveva bisogno?

Non viene perso nulla in modo permanente. Il modello elimina porzioni del contenuto inoltrato, ma i segmenti compressi includono il tag [REF:id] e il modello recupera il testo completo con read_original o expand_context. Il filtro predefinito degli strumenti rimuove gli strumenti standard non selezionati e gli strumenti MCP non selezionati, a meno che non si attivi il relativo segnale di rilevanza MCP; in quel caso crea degli stub per tali strumenti MCP. Il recupero degli strumenti usa gateway_search_tools e il rilevamento dei messaggi relativi agli strumenti mancanti. Il rischio reale è più difficile da rilevare di un file mancante: il modello opera su un estratto con perdita di informazioni e non si accorge di dover richiedere l'originale. Il valore dell'86.5% relativo alla qualità mantenuta su SWE-bench Lite misura la comprensione one-shot del codice sorgente grezzo compresso, con il recupero disattivato e il recupero delle modifiche in produzione attivato; non misura il filtro degli schemi degli strumenti basato sulla CPU né il gateway completo su più turni.

Perché la prima richiesta richiede quindici secondi?

Il modello di embedding usato dal filtro degli strumenti viene caricato alla prima richiesta, non all'avvio. Il progetto documenta un tempo di inizializzazione da 10 a 15 secondi e successivamente circa 15 ms per chiamata. Dopo aver avviato il proxy, invia una richiesta usa e getta con curl; il primo turno reale dell'agent non subirà quindi un'attesa.

Devo usare il server GPU in hosting invece di eseguire il servizio autonomamente?

Elimina la necessità di ospitare il modello di compressione e di sostenere il costo di una GPU, mentre continui a gestire il gateway. Al 2 novembre 2026 costa $0.30 per milione di token di file compressi, con addebito sul credito prepagato e $5 di credito gratuito per i nuovi account; il periodo di lancio gratuito è terminato il 1 ottobre 2026. Inoltre, invia a terzi i prompt e i file letti dall'agent prima che raggiungano il provider del modello. Se esegui il servizio autonomamente per mantenere il codice su un'infrastruttura sotto il tuo controllo, questa configurazione annulla il motivo per cui hai iniziato. L'esecuzione autonoma mantiene la compressione sul tuo server; le richieste compresse e le credenziali del provider vengono comunque inoltrate al provider del modello.

Questo articolo ti è stato utile?