SSD Nodes Learn Hosting plans →
गाइड Matt Connorलेखक: Matt Connor

Paritok token gateway: क्या इससे agent bills कम होंगे?

Paritok आपके coding agent के file reads और tool output को compress करता है। यह 74% तक tokens कम करने का दावा करता है। यहाँ इसका कार्य करने का तरीका और लागत का गणित समझें।

Paritok एक request के साथ क्या करता है

Paritok एक token gateway है: यह एक ऐसा proxy है जो आपके coding agent और model API के बीच स्थित होता है और आगे भेजने से पहले प्रत्येक request को compress करता है। आपका agent provider के बजाय http://127.0.0.1:8080 से बात करता है। यह proxy tool schemas, file reads, tool output और पुराने turns को छोटा कर देता है, छोटे payload को upstream भेजता है, और reply को बिना किसी बदलाव के वापस सौंप देता है।

Provider आपसे उस डेटा के लिए शुल्क लेता है जो उस तक पहुँचता है, लेकिन invoice इस बात पर निर्भर करती है कि कौन से tokens हटाए गए, उनकी cache pricing क्या है और agent कितने turns लेता है। यही इसका मुख्य उद्देश्य है। यह "आपका context अधिक समय तक चलता है" वाले दावे से अलग है, और यही कारण है कि यह tool केवल व्यवस्थित होने के बजाय दिलचस्प है।

यह project अभी नया है। इस gateway को 15 July 2026 को open-source किया गया था, और PyPI के अनुसार v1.3.14 की तारीख 6 October 2026 है और v1.3.0 की तारीख 5 August है। इसके weights और gateway code Apache 2.0 लाइसेंस के अंतर्गत हैं। इसका compression model Qwen3-4B-Instruct-2507 पर आधारित एक LoRA (low-rank adaptation) adapter है, जिसे वास्तविक coding-agent trajectories से लिए गए 45,000 segments के pool से तैयार किया गया है, जिनमें से 40,606 ने teacher validation पास किया और training examples बने।

यह कॉन्टेक्स्ट ट्रिमिंग क्यों नहीं है

ट्रिमिंग डेटा को हमेशा के लिए हटा देती है। जब कोई एजेंट अपनी कॉन्टेक्स्ट सीमा के करीब पहुँचता है और सबसे पुराने टर्न्स को हटा देता है, तो टर्न 3 पर पढ़ी गई फाइल गायब हो जाती है। यदि उसे टर्न 20 पर उस फाइल की आवश्यकता होती है, तो वह उसे फिर से पढ़ता है, इसलिए आप उन टोकन्स के लिए दूसरी बार भुगतान करते हैं। वह बचत एक ऋण की तरह थी।

Paritok एक सेगमेंट को एक छोटे रूप और एक टैग, [REF:id], से बदल देता है और पूर्ण टेक्स्ट को प्रॉक्सी पर सुरक्षित रखता है। मॉडल read_original या expand_context को कॉल करके सेगमेंट को पुनः प्राप्त कर लेता है। यह विफलता के तरीके (failure mode) को बदल देता है। एक ट्रिमर भूलकर विफल होता है, और वह आपको कभी नहीं बताता। एक कंप्रेसर मॉडल को एक लॉस-युक्त (lossy) अंश देकर विफल होता है, और यदि वह अंश पर्याप्त नहीं है तो मॉडल मूल टेक्स्ट की मांग कर सकता है।

फिल्टर किए गए टूल स्कीमा पुनः प्राप्त करने योग्य बने रहते हैं, लेकिन डिफ़ॉल्ट एडेप्टिव फिल्टर अचयनित मानक टूल्स को हटा देता है और अचयनित MCP टूल्स को तब तक हटा देता है जब तक कि उसका MCP प्रासंगिकता सिग्नल सक्रिय न हो जाए। जब वह सिग्नल सक्रिय होता है, तो अचयनित MCP टूल्स को स्टब (stub) कर दिया जाता है। gateway_search_tools रिकवरी का समर्थन करता है, और गेटवे गायब-टूल संदेशों का पता लगाता है और पुनः प्रयास करने से पहले मिलान वाले टूल्स को इंजेक्ट करता है। यह महत्वपूर्ण है क्योंकि एक फिल्टर जो स्थायी रूप से किसी टूल को छिपा देता है, वह आपके एजेंट की कार्यक्षमता को बदल देता है, और आपको इसके बारे में तब पता चलेगा जब कोई कार्य चुपचाप विफल हो जाएगा।

तीन लीवर, और कौन सा मुफ्त है

पहला लीवर tool-schema फ़िल्टर है। प्रत्येक request में पूरा tools array शामिल होता है। बिना किसी MCP (model context protocol) सर्वर के Claude Code टर्न पर, प्रोजेक्ट इस ब्लॉक को लगभग 29,000 tokens मापता है; MCP के साथ, यह 44,000 से 65,000 tokens तक रिपोर्ट करता है। फ़िल्टर उपयोगकर्ता की request और प्रत्येक tool description को BAAI/bge-small-en-v1.5 (एक 130 MB embedding model) के साथ एम्बेड करता है, मेल खाने वाले tools को रखता है, अनचाहे standard tools को हटा देता है, और अनचाहे MCP tools को केवल तभी स्टब करता है जब उसका MCP relevance signal सक्रिय होता है। अन्यथा, यह उन MCP tools को भी हटा देता है। प्रोजेक्ट के 29,000-token वाले उदाहरण में, यह ब्लॉक घटकर लगभग 8,000 tokens रह जाता है। वह embedding model CPU पर चलता है।

दूसरा लीवर content compression है, और यह वह हिस्सा है जो 4B model का उपयोग करता है, GPU पर या Ollama के माध्यम से CPU पर। File reads, tool output और history को उनके मूल आकार के 25.7% तक कम कर दिया जाता है। model मुख्य रूप से spans को फिर से लिखने के बजाय उनका चयन करता है, जिसमें reasoning summaries और tool-call framing जैसी सामग्री के लिए सीमित rewriting की अनुमति होती है। प्रोजेक्ट का पेपर मापता है कि 96.0% emitted identifiers, paths और numbers teacher-generated training corpus में इनपुट के रूप में verbatim दिखाई देते हैं; प्रशिक्षित model का held-out SWE-bench Lite आउटपुट उसी ऑडिट पर 96.2% स्कोर करता है। 74% की मुख्य बात यहीं से आती है। इसे ध्यान से पढ़ें: 74% उस सामग्री पर compression rate है जिसे compress किया जाता है, न कि आपके बिल में कटौती।

तीसरा लीवर history summarization है। डिफ़ॉल्ट रूप से, एक बार जब context कॉन्फ़िगर की गई window के 80% से अधिक हो जाता है, तो पुराने turns को summarize कर दिया जाता है जबकि चार हालिया turns बरकरार रहते हैं ताकि limit तक पहुँचने के बजाय एक लंबा session चलता रहे।

Self-hosting के लिए GPU वैकल्पिक है। यह इस पेज का सबसे उपयोगी वाक्य है। pip install "paritok[toolselect]" आपको एक साधारण CPU VPS पर tool फ़िल्टर देता है, बिना किसी per-token शुल्क के। कार्ड किराए पर लेने से पहले इसे आज़माएँ।

परियोजना ने क्या मापा, और किस हार्नेस पर

चार्टSWE-bench Lite: compression rate against solve quality retained (project's published figures)
इस चार्ट के पीछे का डेटा
[
  {
    "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
  }
]

ये परियोजना के स्वयं के प्रकाशित आंकड़े हैं, जिन्हें SWE-bench Lite के विरुद्ध इसके अपने हार्नेस पर मापा गया है। Paritok-4B-v1 सामग्री को मूल आकार के 25.7% तक संकुचित (compress) करता है, जबकि यह असंकुचित (uncompressed) सॉल्व रेट का 86.5% बनाए रखता है। कंप्रेसर के रूप में gpt-5 का उपयोग करने पर अधिक गुणवत्ता बनी रहती है, जो कि 93.6% है, लेकिन यह केवल 61.9% तक ही संकुचित होता है, और आप फ्रंटियर कीमतों को बचाने के लिए फ्रंटियर कीमतें ही चुका रहे होंगे।

गुणवत्ता कॉलम को ईमानदारी से पढ़ें। 'रिटेन्ड क्वालिटी' (Quality retained) का अर्थ है कंप्रेसर सॉल्व रेट को असंकुचित बेसलाइन सॉल्व रेट से विभाजित करना। 86.5% बनाए रखने का मतलब है उस बेसलाइन के सापेक्ष सॉल्व्स में 13.5% की शुद्ध कमी; इसमें बेसलाइन-सॉल्व समस्याओं के उस अंश की गणना नहीं होती जो खो गए हैं, क्योंकि संकुचित रन अलग-अलग समस्याओं को भी हल कर सकते हैं। यह आंकड़ा संकुचित रॉ सोर्स की सिंगल-शॉट समझ को मापता है, जिसमें रिकॉल (recall) अक्षम है और प्रोडक्शन एडिट रिकवरी सक्षम है; यह CPU टूल-स्कीमा फिल्टर या पूर्ण मल्टी-टर्न गेटवे को नहीं मापता है।

चार्टReported input-token saving as a session grows (project's own harness)
इस चार्ट के पीछे का डेटा
[
  {
    "label": "Turn 1",
    "saved_pct": 25
  },
  {
    "label": "Turn 5",
    "saved_pct": 39
  },
  {
    "label": "Turn 12",
    "saved_pct": 57
  },
  {
    "label": "Turn 20",
    "saved_pct": 63
  }
]

एंड-टू-एंड बचत सत्र चलने के साथ बढ़ती है, क्योंकि हिस्ट्री जमा होती है और हिस्ट्री ही वह चीज है जिसे संकुचित किया जा रहा है। परियोजना एक टर्न पर लगभग 25%, टर्न 5 तक 39% और टर्न 20 तक 63% की रिपोर्ट करती है। केवल टर्न 1 से 5 तक को मापा गया है; README बाद की पंक्तियों को अनुमान (projections) के रूप में लेबल करता है। यह यह भी बताता है कि विकास कहाँ रुकता है: 200,000 टोकन बजट पर प्रति-टर्न सामग्री की बचत लगभग 48,000 टोकन पर स्थिर हो जाती है, जो टर्न 8 से 12 के आसपास कहीं होती है, क्योंकि एक बार कॉन्टेक्स्ट भर जाने पर हिस्ट्री बढ़ना बंद हो जाती है। अलग टूल-फिल्टर बचत प्रति टर्न लगभग 21,000 टोकन जोड़ती है, जिससे अनुमानित संयुक्त पठार (plateau) लगभग 69,000 टोकन प्रति टर्न हो जाता है। व्यापक रूप से उद्धृत "85% से अधिक" का आंकड़ा कॉन्टेक्स्ट-सैचुरेटेड सत्रों का वर्णन करता है। यह सबसे अच्छा मामला है, और वही README कहता है कि डिफ़ॉल्ट सेटिंग्स के तहत बचत लगभग 72% की सीमा (ceiling) की ओर स्थिर हो जाती है, इसलिए इसके आधार पर योजना न बनाएं।

क्या 24GB GPU, Paritok के लिए किफायती है?

GPU वैकल्पिक है, और मॉडल 24 GB से छोटे कार्ड पर भी चल सकता है। रेंटल की गणना के उदाहरण के लिए, 24 GB कार्ड के लिए $0.44 प्रति घंटा मान लें। यदि इसे पूरे महीने चलाया जाए, तो यह 730 घंटे होते हैं, यानी $321। यदि इसे केवल काम के घंटों के दौरान, 22 दिनों तक प्रतिदिन 8 घंटे चलाया जाए, तो यह 176 घंटे होते हैं, यानी $77।

अब टोकन कटौती को डॉलर की बचत में बदलें। यह कटौती इनपुट टोकन पर लागू होती है। आउटपुट टोकन प्रॉक्सी से बिना किसी बदलाव के गुजरते हैं, इसलिए प्रॉक्सी उन्हें कंप्रेस नहीं करती है। अपने प्रदाता की दरों का उपयोग करके नए इनपुट, कैश राइट्स और कैश रीड्स की कीमतों का अलग-अलग आकलन करें, फिर बदलाव से पहले और बाद की कुल API लागत की तुलना करें। भले ही इनपुट आपके कुल खर्च का 80% हो, टोकन कटौती को 0.8 से गुणा करने से आपकी बिल बचत का सटीक पता नहीं चलता है।

चार्टMonthly API saving needed to cover an illustrative $0.44/hour card
इस चार्ट के पीछे का डेटा
[
  {
    "label": "Always on (730 hours)",
    "required_api_saving_usd": 321.2
  },
  {
    "label": "Workday only (176 hours)",
    "required_api_saving_usd": 77.44
  }
]

यदि आपकी मापी गई मासिक API बचत $321.2 से अधिक हो जाती है, तो लगातार चलने वाला कार्ड अपनी लागत निकाल लेता है। यदि आप काम के घंटों के बाहर इंस्टेंस को बंद कर देते हैं, तो यह सीमा $77.44 हो जाती है। केवल 85% टोकन कटौती से 68% बिल बचत सुनिश्चित नहीं होती, इसलिए यह मासिक एजेंट-खर्च की सीमा निर्धारित नहीं कर सकती। उस सीमा को प्राप्त करने के लिए रेंटल लागत को अपनी मापी गई बिल-बचत के अनुपात से विभाजित करें।

दो चीजें इसे चार्ट द्वारा सुझाए गए आंकड़ों से बेहतर बनाती हैं। मॉडल को 24 GB की आवश्यकता नहीं है: q4 बिल्ड लगभग 2.5 GB का है और f16 बिल्ड लगभग 8 GB का, इसलिए एक छोटा कार्ड, या कोई ऐसा GPU बॉक्स जिसे आप पहले से ही किसी अन्य कार्य के लिए चला रहे हैं, चार्ट के हर आंकड़े को कम कर देता है। और जब कोई कोडिंग नहीं कर रहा हो तब इंस्टेंस को बंद करना यहाँ सबसे बड़ा बचत का जरिया है, क्योंकि यह रेंटल लागत को लगभग तीन-चौथाई कम कर देता है।

एक चीज इसे खराब बनाती है। कंप्रेशन प्रक्रिया में वास्तविक काम होता है। 4B मॉडल जिस हर टोकन को कंप्रेस करता है, उसे उसे पढ़ना पड़ता है, और जिस हर स्पैन को वह रखता है, उसे उसे वापस लिखना पड़ता है, जिससे प्रत्येक एजेंट टर्न में लेटेंसी बढ़ जाती है। प्रति घंटा किराए पर लिए गए कार्ड पर यह लागत प्रतीक्षा समय के रूप में दिखाई देती है, न कि इनवॉइस पर एक लाइन के रूप में, इसलिए जब तक आप इसे महसूस नहीं करते, तब तक इसे नजरअंदाज करना आसान है।

यदि आप सामान्य रूप से किराए के GPU घंटों की तुलना API टोकन से कर रहे हैं, तो GPU VPS और API टोकन के बीच ब्रेक-ईवन इन्फरेंस के लिए भी यही गणित अपनाता है।

VPS पर Paritok gateway चलाना

PyPI पर पैकेज मेटाडेटा Python 3.10 या उससे नए वर्ज़न को स्वीकार करता है, हालाँकि README बैज 3.11+ बताता है। Ubuntu 24.04 में Python 3.12 आता है, इसलिए CPU टूल फिल्टर के लिए एक साधारण VPS इमेज पर्याप्त है।

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"

वर्ज़न को पिन करें। PyPI के अनुसार v1.3.0 का समय 5 August 2026 और v1.3.14 का 6 October 2026 है। इतनी तेज़ी से आगे बढ़ने वाले प्रोजेक्ट releases के बीच चीजों का नाम बदल देते हैं: v1.3.0 ने अपने API में expand_context का नाम बदलकर read_original कर दिया था। एक साधारण pip install paritok, या main का git clone, आपको अगले सप्ताह एक अलग gateway दे देगा और इस बात का कोई रिकॉर्ड नहीं रहेगा कि आपने जो आंकड़े मापे थे, वे किस वर्ज़न से आए थे।

डिफ़ॉल्ट बैकएंड Ollama है। मॉडल को pull करें, फिर उसे वह छोटा नाम दें जिसे प्रॉक्सी खोजता है।

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

चूंकि लोकल मॉडल हर उस सेगमेंट के लिए स्पैन लिखता है जिसे वह कंप्रेस करता है, इसलिए एक लंबा चलने वाला कंप्रेशन पास एक रुके हुए एजेंट टर्न के रूप में दिखाई देता है, और Ollama's num_predict cap on output length वह सेटिंग है जो इसे सीमित करती है।

इसके बगल में paritok.yaml लिखें। use_gpu_server: false वह है जो कंप्रेशन को आपके अपने हार्डवेयर पर रखता है।

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

यदि मॉडल गायब है तो उसे pull करने और प्रॉक्सी को पोर्ट 8080 पर शुरू करने के लिए paritok up शॉर्टकट है; Ollama पहले से इंस्टॉल होना चाहिए। एजेंट को पॉइंट करने से पहले प्रॉक्सी की जाँच करें।

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

/health एक छोटा JSON ऑब्जेक्ट लौटाता है जिसमें "status":"ok" और एक वर्ज़न स्ट्रिंग होती है। /stats कंप्रेशन का कुल योग और प्रॉक्सी का अपना अनुमान लौटाता है कि उसने क्या बचाया। उस अनुमान को प्रॉक्सी द्वारा अपने काम को ग्रेड देने के रूप में मानें, और अपने प्रोवाइडर के यूसेज पेज से इसकी पुष्टि करें।

सुविधा के बजाय थ्रूपुट के लिए, vLLM बेस मॉडल के ऊपर एडेप्टर को सर्व करता है।

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

--max-lora-rank 32 फ्लैग प्रोजेक्ट के अपने कमांड में है क्योंकि एडेप्टर रैंक 32 है। फिर paritok.yaml में local_model.base_url को http://localhost:8000/v1 पर सेट करें ताकि प्रॉक्सी Ollama के बजाय vLLM से बात करे।

Ollama को सेटअप करना तेज़ है। vLLM समवर्ती अनुरोधों (concurrent requests) को बेहतर तरीके से संभालता है, जो तब मायने रखता है जब एक से अधिक एजेंट बॉक्स साझा करते हैं। The practical difference between Ollama and vLLM ही वह है जो आपके लिए यह निर्णय तय करता है।

बेस URL एनवायरनमेंट वेरिएबल्स के साथ एजेंट को प्रॉक्सी पर पॉइंट करें।

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

Codex CLI OPENAI_BASE_URL को अनदेखा करता है, इसलिए जब paritok.yaml में codex.enabled: true सेट होता है, तो paritok up आपके लिए ~/.codex/config.toml लिखता है। वेरिएबल को अकेले एक्सपोर्ट करने पर Codex सीधे प्रोवाइडर से बात करता है, और इसका संकेत यह है कि काम करते समय /stats काउंटर कभी नहीं बढ़ता।

लिसनर को 127.0.0.1 पर रखें, कभी भी 0.0.0.0 पर नहीं। प्रॉक्सी प्रत्येक अनुरोध के साथ प्रदान किए गए क्रेडेंशियल्स को अपस्ट्रीम फॉरवर्ड करता है, और इसका अनऑथेंटिकेटेड /stats एंडपॉइंट मूल और कंप्रेस्ड सामग्री के नमूने उजागर करता है। इसलिए, इंटरनेट-फेसिंग लिसनर निजी संदर्भ और स्थानीय कंप्रेशन संसाधनों को उजागर करता है। पोर्ट खोलने के बजाय SSH टनल या VPN के माध्यम से लैपटॉप से इसे एक्सेस करें।

इसे systemd के तहत चलाएं ताकि यह रीबूट के बाद भी बना रहे। अपने इंस्टॉलेशन से मेल खाने के लिए पाथ को एडजस्ट करें। paritok यूजर बनाएं जिसके तहत यूनिट चलती है, और उसे इंस्टॉलेशन डायरेक्टरी दें:

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

इसे sudo systemctl enable --now paritok के साथ इनेबल करें, फिर दोबारा /health को curl करें। जो यूनिट शुरू होकर तुरंत बंद हो जाती है, उसका मतलब आमतौर पर यह होता है कि कॉन्फ़िगरेशन फ़ाइल का पाथ गलत है, और journalctl -u paritok -n 50 इसका कारण प्रिंट करता है।

Hosted विकल्प और इसकी लागत

यह प्रोजेक्ट compression को एक सेवा के रूप में भी बेचता है। paritok.com से प्राप्त API key के साथ use_gpu_server: true को set करें और 4B model उनके hardware पर चलेगा। 2 November 2026 तक की स्थिति के अनुसार, यह compression के लिए प्रति दस लाख file tokens पर $0.30 का शुल्क लेता है, जो prepaid credit से काटा जाता है। tool-schema filtering निःशुल्क है। नए accounts को $5 का मुफ्त credit मिलता है जिसके लिए किसी card की आवश्यकता नहीं है। वह launch period जिसके दौरान hosted service मुफ्त थी, 1 October 2026 को समाप्त हो गया है, इसलिए अब यह एक सशुल्क सेवा है। यह compression-model hosting के काम को हटा देता है, जबकि gateway आप स्वयं चलाते हैं।

इसका यह अर्थ भी है कि आपके prompts और वे files जिन्हें आपका agent पढ़ता है, वे आपके model provider तक पहुँचने से पहले आपकी machine से बाहर निकलकर एक third party तक पहुँचते हैं। Self-hosting का अस्तित्व ठीक इसी hop से बचने के लिए है। उस flag को set करने से पहले यह तय कर लें कि आप इन दोनों में से किसके लिए optimize कर रहे हैं, क्योंकि flag को बदलना तो एक line का काम है, लेकिन इसके परिणाम स्थायी होते हैं।

अपने परिणामों को पहले और बाद में कैसे मापें

प्रकाशित आंकड़े प्रोजेक्ट के अपने आंकड़े हैं, जो SWE-bench Lite पर प्रोजेक्ट के हार्नेस से लिए गए हैं। आपकी रिपॉजिटरी SWE-bench Lite नहीं है। इसलिए अपने आंकड़े स्वयं मापें।

  • एक सामान्य सप्ताह बिना किसी proxy के चलाएं। अपने प्रदाता के usage page से fresh input, cache-write, cache-read और output tokens को अलग-अलग लाइनों में रिकॉर्ड करें, न कि कुल डॉलर राशि के रूप में।
  • अगला सप्ताह proxy के साथ चलाएं, जिसमें उसी तरह का काम किया गया हो।
  • input श्रेणियों की वास्तविक कीमतों पर तुलना करें और output लागत में आए किसी भी बदलाव को शामिल करें। Proxy output को compress नहीं करता है, लेकिन agent के व्यवहार और turn count में बदलाव इस बात को प्रभावित करते हैं कि आप कितना output खरीदते हैं।
  • उन कार्यों की गिनती करें जिन्हें आपको दोबारा करना पड़ा। यह trade का गुणवत्ता वाला हिस्सा है, और कोई भी डैशबोर्ड इसकी रिपोर्ट नहीं देता है।
  • कुल योग की तुलना करने से पहले दूसरे सप्ताह में GPU hours को जोड़ें।

Input को output से अलग करना महत्वपूर्ण है क्योंकि दोनों की कीमत बहुत अलग होती है और compressor केवल एक को ही प्रभावित करता है। 2 November 2026 तक, Claude Sonnet 4.6 की कीमत $3 प्रति मिलियन input tokens और $15 प्रति मिलियन output tokens है, और prompt-cache read की दर input दर का 10% है, यानी $0.30 प्रति मिलियन। नया Claude Sonnet 5.5 $2 और $10 पर उपलब्ध है, और इसके cache reads की दर input दर का 5% है, यानी $0.10 प्रति मिलियन। Input और output token लागत के बीच का अंतर यह तय करता है कि input-side compressor आपके लिए फायदेमंद है या नहीं। Claude Code के tokens वास्तव में कहाँ जाते हैं आपको बताता है कि आपके context का कौन सा हिस्सा इतना बड़ा है कि उसे compress करने की आवश्यकता है।

Prompt caching विशेष रूप से tool-filter की गणना को जटिल बनाता है। Tool block request के शुरुआत में होता है, इसलिए पहले turn के बाद यह सामान्यतः cache hit होता है; Sonnet 4.6 पर इसकी लागत input मूल्य का 10% होती है। Cached block से 21,000 tokens कम करने पर $0.30 प्रति मिलियन की दर से 21,000 tokens की बचत होती है, जो प्रति turn लगभग $0.006 है, न कि $0.063 जो uncached दर के अनुसार होता। प्रोजेक्ट filtered block को session के लिए स्थिर रखता है ताकि cached prefix न बदले। यदि कोई filter हर turn पर tools को दोबारा चुनता है, तो वह उस prefix को अमान्य कर देगा और उसकी लागत बचत से अधिक हो सकती है।

क्या अभी भी अपुष्ट है

ऊपर दिए गए प्रदर्शन के सभी आंकड़े स्वयं प्रोजेक्ट से लिए गए हैं। एक स्वतंत्र सिंथेटिक-कॉर्पस कम्प्रेशन जांच मौजूद है, लेकिन यह स्पष्ट रूप से SWE-bench कार्य की सफलता का परीक्षण नहीं करती है; प्रोजेक्ट के SWE-bench Lite सॉल्व-क्वालिटी आंकड़े स्वतंत्र रूप से अपुष्ट बने हुए हैं। जुलाई 2026 में गेटवे के ओपन-सोर्स होने के साथ, इस कोड के पीछे बहुत कम परिचालन इतिहास भी है। कम्प्रेशन दर और गुणवत्ता-प्रतिधारण आंकड़े दोनों उसी पक्ष द्वारा मापे जाते हैं जिसे उनके अच्छे दिखने से लाभ होता है। यह उन्हें गलत नहीं बनाता है। यह उन्हें अपुष्ट बनाता है, और आपको उन्हें उन आंकड़ों से अलग मानना चाहिए जिन्हें आपने स्वयं तैयार किया है।

अपने सेटअप को दोष देने से पहले एक प्रलेखित व्यवहार के बारे में जानना उचित है। टूल फिल्टर द्वारा उपयोग किया जाने वाला एम्बेडिंग मॉडल स्टार्टअप के बजाय पहली रिक्वेस्ट पर लोड होता है, इसलिए प्रोजेक्ट 10 से 15 सेकंड के वार्म-अप का उल्लेख करता है, और उसके बाद प्रति कॉल लगभग 15 ms का समय लगता है। प्रॉक्सी शुरू होने के बाद एक थ्रोअवे रिक्वेस्ट भेजें, इससे आपका पहला वास्तविक एजेंट टर्न हैंग होता हुआ नहीं दिखेगा।

चार चीजें जिन्हें आप एक दोपहर में स्वयं तय कर सकते हैं: क्या प्रॉक्सी शुरू होती है और चालू रहती है, क्या काम करते समय /stats हिलता है, क्या आपके प्रदाता की इनपुट-टोकन लाइन वास्तव में गिरती है, और क्या एजेंट अभी भी काम पूरा करता है। ये किसी भी प्रकाशित बेंचमार्क की तुलना में आपके सेटअप के लिए बेहतर निर्णय लेते हैं।

यह आपके अन्य टूलिंग के साथ कहाँ स्थित है, इस पर: एक self-hosted LiteLLM gateway सामग्री को बदले बिना रिक्वेस्ट को रूट और मीटर करता है, इसलिए दोनों अलग-अलग समस्याओं को हल करते हैं और इन्हें चेन किया जा सकता है, जिसमें Paritok एजेंट के सबसे करीब रहता है। यदि वास्तविक लक्ष्य इस विशिष्ट टूल के बजाय बिल कम करना है, तो VPS पर एजेंट के लिए लागत नियंत्रण का व्यापक सेट में कई ऐसे बदलाव शामिल हैं जिन्हें आज़माने में कुछ भी खर्च नहीं होता है।

FAQ

क्या Paritok मेरे API बिल को कम करता है या केवल context usage को?

यह provider तक पहुँचने से पहले request को छोटा कर देता है; बिल में बचत हटाए गए tokens की कीमत और agent के परिणामी turn count पर निर्भर करती है। उस कमी का आकार headline में बताए गए आंकड़ों से छोटा होता है। 74% का आंकड़ा compress किए जा रहे content की compression दर है। End-to-end, यह project एक single turn पर लगभग 25% की बचत बताता है और 20वें turn तक input-token बचत के रूप में 63% का अनुमान लगाता है। Output tokens बिना किसी बदलाव के गुजरते हैं, लेकिन generate होने वाली मात्रा अभी भी agent के व्यवहार पर निर्भर करती है।

Compression model को self-host करने के लिए मुझे कितने GPU की आवश्यकता है?

GPU वैकल्पिक है: Ollama मॉडल को CPU पर भी चलाता है। q4 build लगभग 2.5 GB का है और f16 build लगभग 8 GB का है, इसलिए मॉडल 24 GB के card में काफी जगह के साथ फिट हो जाता है। एक छोटा card भी काम करेगा, और यह break-even गणित को आपके पक्ष में बदल देता है। Tool-schema filter को किसी GPU की आवश्यकता नहीं है: यह BAAI/bge-small-en-v1.5 का उपयोग करता है, जो 130 MB का embedding model है और CPU पर चलता है। paritok[toolselect] को एक सामान्य VPS पर install करें और आपको थोड़ी RAM की कीमत पर tool-block reduction मिल जाएगा।

यदि compressor ऐसी चीज़ हटा दे जिसकी agent को आवश्यकता थी, तो क्या होगा?

कुछ भी स्थायी रूप से नष्ट नहीं होता है। मॉडल forward किए जाने वाले content से spans को हटा देता है, लेकिन compressed segments में एक [REF:id] tag होता है और मॉडल read_original या expand_context के साथ पूरा text recover कर लेता है। Default tool filter unselected standard tools को हटा देता है और unselected MCP tools को भी हटा देता है, जब तक कि उसका MCP relevance signal न चल जाए; ऐसी स्थिति में वह उन MCP tools को stub कर देता है। Tool recovery gateway_search_tools और missing-tool messages की पहचान का उपयोग करती है। वास्तविक जोखिम किसी missing file की तुलना में अधिक सूक्ष्म है: मॉडल एक lossy excerpt से काम करता है और उसे कभी पता नहीं चलता कि उसे मूल जानकारी मांगनी चाहिए थी। SWE-bench Lite पर 86.5% quality-retained आंकड़ा, recall disable होने और production edit recovery enable होने पर compressed raw source की single-shot comprehension को मापता है; यह CPU tool-schema filter या पूर्ण multi-turn gateway को नहीं मापता है।

मेरी पहली request को पंद्रह सेकंड क्यों लगते हैं?

Tool filter के पीछे का embedding model startup के बजाय पहली request पर load होता है। Project 10 से 15 सेकंड के warm-up का उल्लेख करता है, और उसके बाद प्रति call लगभग 15 ms का समय लगता है। Proxy start करने के बाद curl के साथ एक throwaway request भेजें, तो पहला वास्तविक agent turn stall नहीं होगा।

क्या मुझे self-hosting के बजाय hosted GPU server का उपयोग करना चाहिए?

यह compression-model hosting और किसी भी GPU किराए को हटा देता है, जबकि आप gateway को maintain करना जारी रखते हैं। 2 November 2026 तक, इसकी कीमत प्रति मिलियन file tokens compress करने के लिए $0.30 है, जिसका भुगतान prepaid credit से किया जाता है, और नए accounts के लिए $5 का free credit मिलता है; free launch period 1 October 2026 को समाप्त हो गया। यह आपके prompts और आपके agent द्वारा पढ़ी जाने वाली files को आपके model provider तक पहुँचने से पहले एक third party को भी भेजता है। यदि आप code को अपने नियंत्रण वाले infrastructure पर रखने के लिए self-hosting कर रहे हैं, तो यह setting उस कारण को ही खत्म कर देती है जिसके लिए आपने शुरुआत की थी। Self-hosting compression को आपके अपने box पर रखती है; compressed requests और provider credentials अभी भी आपके model provider के पास upstream जाते हैं।

क्या यह लेख उपयोगी था?