SSD Nodes Learn Hosting plans →

Paritok తో AI కోడింగ్ ఏజెంట్ ఖర్చులను తగ్గించుకోవడం ఎలా?

Paritok టోకెన్ గేట్‌వే ఫైల్ రీడ్స్ మరియు టూల్ అవుట్‌పుట్‌ను ఎలా కుదిస్తుందో తెలుసుకోండి. ఇది 74% టోకెన్లను ఆదా చేస్తుందని చెబుతోంది. దీని పనితీరు మరియు ఖర్చుల లెక్కలను ఇక్కడ చూడండి.

Paritok ఒక అభ్యర్థనపై ఏమి చేస్తుంది

Paritok ఒక token gateway: ఇది మీ coding agent మరియు model API మధ్య ఉండి, ప్రతి అభ్యర్థనను ఫార్వార్డ్ చేసే ముందు కుదిస్తుంది (compress). మీ agent ప్రొవైడర్‌కు బదులుగా http://127.0.0.1:8080 తో మాట్లాడుతుంది. ఈ proxy టూల్ స్కీమాలు, ఫైల్ రీడ్స్, టూల్ అవుట్‌పుట్ మరియు పాత సంభాషణలను కుదించి, చిన్న payload ను upstream కు పంపుతుంది, మరియు వచ్చిన సమాధానాన్ని మార్పు లేకుండా తిరిగి ఇస్తుంది.

ప్రొవైడర్ వద్దకు చేరిన డేటాకు వారు మీకు బిల్లు వేస్తారు, కానీ బిల్లు అనేది ఏ tokens తొలగించబడ్డాయి, వాటి cache ధర మరియు agent ఎన్ని సార్లు సంభాషణ జరిపింది అనే అంశాలపై ఆధారపడి ఉంటుంది. ఇదే దీని ముఖ్య ఉద్దేశ్యం. ఇది "మీ context ఎక్కువ కాలం ఉంటుంది" అనే వాదన కంటే భిన్నమైనది, మరియు ఈ సాధనం కేవలం శుభ్రంగా ఉండటమే కాకుండా ఆసక్తికరంగా ఉండటానికి కారణం ఇదే.

ఈ ప్రాజెక్ట్ కొత్తది. ఈ gateway 15 July 2026 న open-source చేయబడింది, మరియు PyPI లో v1.3.14 తేదీ 6 October 2026 గా, v1.3.0 తేదీ 5 August గా ఉన్నాయి. Weights మరియు gateway కోడ్ Apache 2.0 లైసెన్స్‌లో ఉన్నాయి. ఈ compression model అనేది Qwen3-4B-Instruct-2507 పై ఉన్న LoRA (low-rank adaptation) అడాప్టర్. ఇది నిజమైన coding-agent trajectories నుండి సేకరించిన 45,000 విభాగాల పూల్ నుండి డిస్టిల్ చేయబడింది, అందులో 40,606 టీచర్ వాలిడేషన్‌ను దాటి శిక్షణ ఉదాహరణలుగా మారాయి.

ఇది కాంటెక్స్ట్ ట్రిమ్మింగ్ (context trimming) ఎందుకు కాదు

ట్రిమ్మింగ్ సమాచారాన్ని శాశ్వతంగా తొలగిస్తుంది. ఒక ఏజెంట్ తన కాంటెక్స్ట్ పరిమితికి చేరుకున్నప్పుడు పాత సంభాషణలను తొలగిస్తే, అది మూడవ టర్న్ (turn) లో చదివిన ఫైల్ ఇక ఉండదు. ఒకవేళ 20వ టర్న్ వద్ద ఆ ఫైల్ అవసరమైతే, అది మళ్ళీ ఆ ఫైల్‌ను చదవాల్సి వస్తుంది, కాబట్టి మీరు ఆ టోకెన్ల కోసం రెండోసారి చెల్లించాల్సి ఉంటుంది. ఆ పొదుపు కేవలం అప్పు మాత్రమే.

Paritok ఒక విభాగాన్ని చిన్న రూపంతో మరియు ఒక ట్యాగ్‌తో భర్తీ చేస్తుంది, [REF:id], మరియు పూర్తి పాఠ్యాన్ని ప్రాక్సీ (proxy) వద్ద ఉంచుతుంది. మోడల్ read_original లేదా expand_contextని పిలవడం ద్వారా ఆ విభాగాన్ని తిరిగి పొందుతుంది. ఇది వైఫల్య విధానాన్ని (failure mode) మారుస్తుంది. ట్రిమ్మర్ మర్చిపోవడం ద్వారా విఫలమవుతుంది, మరియు అది మీకు ఎప్పటికీ తెలియజేయదు. కంప్రెసర్ మోడల్‌కు నష్టంతో కూడిన సారాంశాన్ని అందించడం ద్వారా విఫలమవుతుంది, మరియు సారాంశం సరిపోనప్పుడు మోడల్ అసలు సమాచారం కోసం అడగగలదు.

ఫిల్టర్ చేసిన టూల్ స్కీమాలు (tool schemas) తిరిగి పొందగలిగేలా ఉంటాయి, కానీ డిఫాల్ట్ అడాప్టివ్ ఫిల్టర్ ఎంచుకోని ప్రామాణిక టూల్స్‌ను తొలగిస్తుంది మరియు దాని MCP relevance సిగ్నల్ ఫైర్ కాకపోతే ఎంచుకోని MCP టూల్స్‌ను కూడా తొలగిస్తుంది. ఆ సిగ్నల్ ఫైర్ అయినప్పుడు, ఎంచుకోని MCP టూల్స్ స్టబ్ (stub) చేయబడతాయి. gateway_search_tools రికవరీకి మద్దతు ఇస్తుంది, మరియు గేట్‌వే కూడా మిస్సింగ్-టూల్ సందేశాలను గుర్తిస్తుంది మరియు మళ్ళీ ప్రయత్నించే ముందు సరిపోలే టూల్స్‌ను ఇంజెక్ట్ చేస్తుంది. ఇది చాలా ముఖ్యం, ఎందుకంటే ఒక టూల్‌ను శాశ్వతంగా దాచిపెట్టే ఫిల్టర్ మీ ఏజెంట్ చేయగలిగే పనులను మారుస్తుంది, మరియు అది నిశ్శబ్దంగా విఫలమైన పని ద్వారా మీకు తెలుస్తుంది.

మూడు నియంత్రణలు, వాటిలో ఉచితమైనది ఏది

మొదటి నియంత్రణ tool-schema filter. ప్రతి అభ్యర్థనలో మొత్తం tools array ఉంటుంది. MCP (model context protocol) servers ఏవీ అనుసంధానించని Claude Code turn లో, ఆ block పరిమాణం సుమారు 29,000 tokens గా project కొలుస్తుంది; MCP అనుసంధానించినప్పుడు 44,000 నుంచి 65,000 tokens గా నివేదిస్తుంది. ఈ filter వినియోగదారు అభ్యర్థనను మరియు ప్రతి tool description ను BAAI/bge-small-en-v1.5 అనే 130 MB embedding model తో embed చేస్తుంది, సరిపోలే tools ను ఉంచుతుంది, ఎంపిక చేయని standard tools ను తొలగిస్తుంది, అలాగే దాని MCP relevance signal పనిచేసినప్పుడు మాత్రమే ఎంపిక చేయని MCP tools కు stubs ఉంచుతుంది. లేకపోతే ఆ MCP tools ను కూడా తొలగిస్తుంది. Project యొక్క 29,000-token ఉదాహరణలో, ఆ block సుమారు 8,000 tokens కు తగ్గుతుంది. ఆ embedding model CPUపై నడుస్తుంది.

రెండవ నియంత్రణ content compression. 4B model ను ఉపయోగించే భాగం ఇదే; ఇది GPUపై లేదా CPUపై Ollama ద్వారా నడుస్తుంది. File reads, tool output మరియు history వాటి అసలు పరిమాణంలో 25.7% కు తగ్గించబడతాయి. Model ప్రధానంగా spans ను తిరిగి రాయడం కంటే ఎంపిక చేస్తుంది. Reasoning summaries మరియు tool-call framing వంటి content కు మాత్రమే పరిమిత rewriting అనుమతించబడుతుంది. Teacher-generated training corpus లో, ఉత్పత్తి చేసిన identifiers, paths మరియు numbers లో 96.0% input లో ఉన్నట్టుగానే కనిపించాయని project paper కొలిచింది; trained model యొక్క held-out SWE-bench Lite output ఇదే audit లో 96.2% స్కోర్ సాధించింది. 74% అనే headline అక్కడి నుంచే వచ్చింది. దీన్ని జాగ్రత్తగా అర్థం చేసుకోండి: 74% అనేది compression కు లోనయ్యే content పై compression rate, మీ bill పై తగ్గింపు కాదు.

మూడవ నియంత్రణ history summarization. Default గా, context configured window లో 80% ను మించినప్పుడు పాత turns ను summarize చేస్తుంది. నాలుగు ఇటీవలి turns మాత్రం యథాతథంగా ఉంటాయి. అందువల్ల long session limit ను తాకకుండా కొనసాగుతుంది.

Self-hosting కోసం GPU తప్పనిసరి కాదు. ఈ page లో అత్యంత ఉపయోగకరమైన వాక్యం ఇదే. pip install "paritok[toolselect]" సాధారణ CPU VPSపై, ప్రతి token కు fee లేకుండా tool filter అందిస్తుంది. Card అద్దెకు తీసుకునే ముందు దీన్ని ప్రయత్నించండి.

ప్రాజెక్ట్ ఏమి కొలిచింది, ఏ harness పై కొలిచింది

చార్ట్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 పై ప్రాజెక్ట్ స్వంత harness తో వీటిని కొలిచారు. Paritok-4B-v1 కంటెంట్‌ను అసలు పరిమాణంలో 25.7% కు కుదిస్తూ, కుదించని solve rate లో 86.5% ను నిలుపుతుంది. gpt-5 ను compressor గా ఉపయోగిస్తే మరింత నాణ్యత నిలుస్తుంది: 93.6%. అయితే కంటెంట్ 61.9% కు మాత్రమే కుదుస్తుంది. అంటే frontier ధరలు ఆదా చేయడానికి frontier ధరలకే చెల్లించాల్సి ఉంటుంది.

Quality column ను వాస్తవికంగా చదవాలి. Quality retained అనేది compressor solve rate ను uncompressed baseline solve rate తో భాగించిన నిష్పత్తి. 86.5% నిలుపుకోవడం అంటే ఆ baseline తో పోలిస్తే solves లో నికరంగా 13.5% తగ్గుదల ఉందని అర్థం. Baseline లో solve అయిన సమస్యల్లో ఎన్ని కోల్పోయాయో మాత్రమే ఇది లెక్కించదు, ఎందుకంటే compressed runs వేర్వేరు సమస్యలను కూడా solve చేయవచ్చు. ఈ గణాంకం recall నిలిపి, production edit recovery ప్రారంభించి, raw source ను compress చేసిన దాని single-shot comprehension ను కొలుస్తుంది. CPU tool-schema filter లేదా పూర్తి multi-turn gateway ను ఇది కొలవదు.

చార్ట్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
  }
]

Session కొనసాగుతున్న కొద్దీ end-to-end saving పెరుగుతుంది, ఎందుకంటే history పేరుకుపోతుంది. Compress చేసేది history నే. Single turn లో సుమారు 25%, turn 5 నాటికి 39%, turn 20 నాటికి 63% saving ఉందని ప్రాజెక్ట్ నివేదిస్తుంది. Turns 1 నుంచి 5 వరకు మాత్రమే కొలిచారు. తరువాతి rows ను README projections గా పేర్కొంటుంది. Saving ఎక్కడ ఆగిపోతుందో కూడా README వివరిస్తుంది. 200,000 token budget లో per-turn content saving సుమారు 48,000 tokens వద్ద, దాదాపు turn 8 నుంచి 12 మధ్య flatten అవుతుంది. Context నిండిన తరువాత history పెరగడం ఆగిపోవడమే దీనికి కారణం. ప్రత్యేకమైన tool-filter saving ప్రతి turn కు సుమారు 21,000 tokens జోడిస్తుంది. అందువల్ల projected combined plateau ప్రతి turn కు సుమారు 69,000 tokens అవుతుంది. విస్తృతంగా ఉటంకించే "past 85%" గణాంకం context-saturated sessions ను సూచిస్తుంది. అది ఉత్తమ పరిస్థితి. అదే README default settings కింద saving సుమారు 72% ceiling వైపు plateau అవుతుందని చెబుతుంది. కాబట్టి మీ ప్రణాళికను దానిపై ఆధారపరచవద్దు.

24GB GPU, Paritok కోసం ఖర్చును భరిస్తుందా?

GPU అనేది ఐచ్ఛికం, మరియు ఈ మోడల్ 24 GB కంటే తక్కువ సామర్థ్యం ఉన్న కార్డులపై కూడా పనిచేస్తుంది. ఉదాహరణకు ఒక అద్దె లెక్కను తీసుకుంటే, 24 GB కార్డుకు గంటకు $0.44 ఖర్చవుతుంది. నెలంతా రన్ చేస్తే, అది 730 గంటలు, అంటే $321 అవుతుంది. కేవలం పని వేళల్లో, అంటే రోజుకు 8 గంటల చొప్పున 22 రోజులు రన్ చేస్తే, అది 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 ఆగస్టు 2026 నాటిది మరియు v1.3.14 వెర్షన్ 6 అక్టోబర్ 2026 నాటిది. ఇంత వేగంగా అభివృద్ధి చెందుతున్న ప్రాజెక్టులలో రిలీజ్‌ల మధ్య పేర్లు మారుతుంటాయి: 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

లోకల్ మోడల్ ప్రతి కంప్రెస్డ్ సెగ్మెంట్ యొక్క spans ను రాస్తుంది కాబట్టి, ఎక్కువ సమయం తీసుకునే కంప్రెషన్ ప్రాసెస్ ఏజెంట్ ఆగిపోయినట్లు చూపిస్తుంది. 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 అనేది "status":"ok" మరియు వెర్షన్ స్ట్రింగ్‌ను కలిగి ఉన్న చిన్న JSON ఆబ్జెక్ట్‌ను ఇస్తుంది. /stats కంప్రెషన్ మొత్తాలను మరియు ప్రాక్సీ అంచనా వేసిన ఆదాను చూపుతుంది. ఆ అంచనాను ప్రాక్సీ తన పనికి తానే ఇచ్చుకున్న గ్రేడ్‌గా భావించి, మీ ప్రొవైడర్ యొక్క usage పేజీతో సరిచూసుకోండి.

సౌలభ్యం కంటే throughput ముఖ్యం అనుకుంటే, 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

అడాప్టర్ rank 32 కాబట్టి, ప్రాజెక్ట్ కమాండ్‌లోనే --max-lora-rank 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 కౌంటర్ కదలదు.

లిజనర్‌ను ఎప్పుడూ 0.0.0.0 లో కాకుండా 127.0.0.1 లోనే ఉంచండి. ప్రాక్సీ ప్రతి అభ్యర్థనతో పాటు వచ్చిన క్రెడెన్షియల్స్‌ను అప్‌స్ట్రీమ్‌కు పంపుతుంది. దీని అన్‌అథెంటికేటెడ్ /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 కారణాన్ని ప్రింట్ చేస్తుంది.

హోస్ట్ చేసిన ఆప్షన్ మరియు దాని ఖర్చు

ఈ ప్రాజెక్ట్ కంప్రెషన్‌ను ఒక సర్వీసుగా కూడా విక్రయిస్తుంది. paritok.com నుండి పొందిన API key తో use_gpu_server: true ను సెట్ చేస్తే, 4B మోడల్ వారి హార్డ్‌వేర్‌పై రన్ అవుతుంది. 2 నవంబర్ 2026 నాటికి, ఇది కంప్రెస్ చేసే ప్రతి మిలియన్ ఫైల్ టోకెన్లకు $0.30 చొప్పున ప్రీపెయిడ్ క్రెడిట్ నుండి వసూలు చేస్తుంది, మరియు tool-schema ఫిల్టరింగ్ ఉచితం. కొత్త ఖాతాలకు ఎటువంటి కార్డ్ అవసరం లేకుండా $5 ఉచిత క్రెడిట్ లభిస్తుంది. హోస్ట్ చేసిన సర్వీస్ ఉచితంగా ఉన్న లాంచ్ పీరియడ్ 1 అక్టోబర్ 2026తో ముగిసింది, కాబట్టి ఇది ఇప్పుడు పెయిడ్ సర్వీస్. ఇది కంప్రెషన్-మోడల్ హోస్టింగ్ పనిని తగ్గిస్తుంది, అయితే మీరు గేట్‌వేను మాత్రం మీరే రన్ చేయాలి.

దీని అర్థం మీ ప్రాంప్ట్‌లు మరియు మీ ఏజెంట్ చదివే ఫైల్‌లు మీ మెషీన్ నుండి బయటకు వెళ్లి, మీ మోడల్ ప్రొవైడర్‌కు చేరకముందే థర్డ్ పార్టీకి చేరుతాయి. సరిగ్గా ఆ అదనపు హోప్‌ను నివారించడానికి సెల్ఫ్-హోస్టింగ్ ఉపయోగపడుతుంది. మీరు ఆ ఫ్లాగ్‌ను సెట్ చేసే ముందు దేని కోసం ఆప్టిమైజ్ చేస్తున్నారో నిర్ణయించుకోండి, ఎందుకంటే ఫ్లాగ్ మార్చడం ఒక లైన్ పని మాత్రమే, కానీ దాని పరిణామాలు అలా ఉండవు.

మీ స్వంత 'ముందు' మరియు 'తర్వాత' గణాంకాలను ఎలా కొలవాలి

ప్రచురించబడిన సంఖ్యలు ప్రాజెక్ట్ యొక్క స్వంత గణాంకాలు, ఇవి SWE-bench Lite లోని ప్రాజెక్ట్ హార్నెస్ నుండి సేకరించినవి. మీ రిపోజిటరీ SWE-bench Lite కాదు. కాబట్టి మీ స్వంత గణాంకాలను మీరే కొలవండి.

  • ఒక సాధారణ వారాన్ని proxy లేకుండా నడపండి. మీ ప్రొవైడర్ యొక్క usage పేజీ నుండి input, cache-write, cache-read మరియు output టోకెన్లను విడివిడి వరుసలుగా నమోదు చేయండి; మొత్తం డాలర్ విలువను మాత్రమే చూడకండి.
  • తర్వాతి వారం అదే రకమైన పనిని proxy ని ముందు ఉంచి నిర్వహించండి.
  • వాస్తవ ధరల వద్ద input విభాగాలను పోల్చండి మరియు output ఖర్చులో వచ్చిన మార్పులను కూడా పరిగణనలోకి తీసుకోండి. Proxy output ను కంప్రెస్ చేయదు, కానీ ఏజెంట్ ప్రవర్తన మరియు turn count లో వచ్చే మార్పులు మీరు కొనుగోలు చేసే output పరిమాణాన్ని ప్రభావితం చేస్తాయి.
  • మీరు తిరిగి చేయవలసి వచ్చిన పనులను లెక్కించండి. ఇది నాణ్యతకు సంబంధించిన సగం భాగం, దీనిని ఏ డాష్‌బోర్డ్ కూడా చూపదు.
  • మొత్తాలను పోల్చే ముందు, రెండవ వారానికి GPU గంటలను కలపండి.

Input మరియు output లను విడదీయడం ముఖ్యం, ఎందుకంటే రెండింటి ధరలు చాలా భిన్నంగా ఉంటాయి మరియు కంప్రెసర్ వాటిలో ఒకదానిపై మాత్రమే పనిచేస్తుంది. 2 November 2026 నాటికి, Claude Sonnet 4.6 ధర మిలియన్ input టోకెన్లకు $3 మరియు మిలియన్ output టోకెన్లకు $15, అలాగే prompt-cache read ధర input రేటులో 10%, అంటే మిలియన్ టోకెన్లకు $0.30. కొత్త Claude Sonnet 5.5 ధరలు వరుసగా $2 మరియు $10, దీని cache read ధర input రేటులో 5%, అంటే మిలియన్ టోకెన్లకు $0.10. Input మరియు output టోకెన్ ధరల మధ్య వ్యత్యాసం అనేది input-side కంప్రెసర్ మీకు లాభదాయకమా కాదా అని నిర్ణయిస్తుంది. Claude Code టోకెన్లు వాస్తవానికి ఎక్కడికి వెళ్తాయి అనేది మీ కాంటెక్స్ట్‌లో ఏ భాగం కంప్రెస్ చేయడానికి తగినంత పెద్దదిగా ఉందో తెలియజేస్తుంది.

Prompt caching ముఖ్యంగా tool-filter గణనను క్లిష్టతరం చేస్తుంది. Tool బ్లాక్ అభ్యర్థన (request) ప్రారంభంలో ఉంటుంది, కాబట్టి మొదటి turn తర్వాత అది సాధారణంగా cache hit అవుతుంది; Sonnet 4.6 లో దీని ధర input ధరలో 10% ఉంటుంది. Cached బ్లాక్ నుండి 21,000 టోకెన్లను తగ్గించడం వల్ల మిలియన్ టోకెన్లకు $0.30 చొప్పున 21,000 టోకెన్లకు ఆదా అవుతుంది, అంటే ప్రతి turn కు సుమారు $0.006 ఆదా అవుతుంది, ఇది uncached రేటు ప్రకారం వచ్చే $0.063 కంటే భిన్నమైనది. ప్రాజెక్ట్ ఫిల్టర్ చేసిన బ్లాక్‌ను సెషన్ కోసం అలాగే ఉంచుతుంది, తద్వారా cached ప్రిఫిక్స్ మారదు. ప్రతి turn కు టూల్స్‌ను మళ్ళీ ఎంచుకునే ఫిల్టర్ ఆ ప్రిఫిక్స్‌ను చెల్లుబాటు కాకుండా చేస్తుంది మరియు అది ఆదా చేసే దానికంటే ఎక్కువ ఖర్చు చేయవచ్చు.

ఇంకా ధృవీకరించబడని అంశాలు

పైన పేర్కొన్న ప్రతి పనితీరు సంఖ్య ప్రాజెక్ట్ బృందం అందించినదే. స్వతంత్ర సింథటిక్-కార్పస్ కంప్రెషన్ పరీక్ష అందుబాటులో ఉన్నప్పటికీ, అది SWE-bench టాస్క్ సక్సెస్‌ను పరీక్షించదు; ప్రాజెక్ట్ యొక్క SWE-bench Lite సాల్వ్-క్వాలిటీ గణాంకాలు ఇంకా స్వతంత్రంగా ధృవీకరించబడలేదు. జూలై 2026లో గేట్‌వే ఓపెన్-సోర్స్ చేయబడినందున, ఈ కోడ్‌కు సంబంధించి ఆపరేషనల్ చరిత్ర చాలా తక్కువగా ఉంది. కంప్రెషన్ రేటు మరియు క్వాలిటీ-రిటైన్డ్ గణాంకాలు రెండింటినీ వాటి వల్ల ప్రయోజనం పొందే వారే కొలిచారు. అంత మాత్రాన అవి తప్పు అని కాదు. అవి ఇంకా ధృవీకరించబడలేదని అర్థం, కాబట్టి మీరు స్వయంగా పొందిన ఫలితాలతో పోలిస్తే వీటిని భిన్నంగా చూడాలి.

మీ సెటప్‌ను తప్పుబట్టే ముందు ఒక డాక్యుమెంట్ చేయబడిన ప్రవర్తనను తెలుసుకోవడం మంచిది. టూల్ ఫిల్టర్ ఉపయోగించే ఎంబెడ్డింగ్ మోడల్ స్టార్టప్ సమయంలో కాకుండా, మొదటి అభ్యర్థన (request) వచ్చినప్పుడు లోడ్ అవుతుంది. కాబట్టి, ప్రాజెక్ట్ డాక్యుమెంటేషన్ ప్రకారం 10 నుండి 15 సెకన్ల వార్మ్-అప్ సమయం పడుతుంది, ఆ తర్వాత ప్రతి కాల్‌కు సుమారు 15 ms సమయం పడుతుంది. ప్రాక్సీ ప్రారంభమైన తర్వాత ఒక డమ్మీ అభ్యర్థనను పంపండి, దీనివల్ల మీ మొదటి అసలు ఏజెంట్ టర్న్ హ్యాంగ్ అయినట్లు అనిపించదు.

ఒక మధ్యాహ్న సమయంలో మీరు స్వయంగా పరీక్షించుకోగల నాలుగు విషయాలు: ప్రాక్సీ ప్రారంభమై స్థిరంగా ఉంటుందా, మీరు పని చేస్తున్నప్పుడు /stats మారుతుందా, మీ ప్రొవైడర్ యొక్క ఇన్‌పుట్-టోకెన్ లైన్ నిజంగా తగ్గుతుందా, మరియు ఏజెంట్ పనిని పూర్తి చేయగలదా అనేది. ఏదైనా ప్రచురించబడిన బెంచ్‌మార్క్ కంటే, మీ సెటప్ కోసం ఇవే సరైన నిర్ణయాలను తీసుకుంటాయి.

ఇది మీ ఇతర టూలింగ్‌తో ఎక్కడ సరిపోతుందంటే: self-hosted LiteLLM gateway అభ్యర్థనల కంటెంట్‌ను మార్చకుండానే వాటిని రూట్ చేస్తుంది మరియు మీటర్ చేస్తుంది. కాబట్టి ఈ రెండు వేర్వేరు సమస్యలను పరిష్కరిస్తాయి మరియు వీటిని ఒకదాని తర్వాత ఒకటి (chained) ఉపయోగించవచ్చు, ఇందులో Paritok ఏజెంట్‌కు అత్యంత దగ్గరగా ఉంటుంది. మీ అసలు లక్ష్యం ఈ నిర్దిష్ట టూల్ కంటే బిల్లును తగ్గించుకోవడమే అయితే, VPSపై ఏజెంట్ కోసం విస్తృతమైన ఖర్చు నియంత్రణలు అనే విభాగంలో ఖర్చు లేని అనేక మార్పులు ఉన్నాయి, వాటిని ముందుగా ప్రయత్నించవచ్చు.

FAQ

Paritok నా API ఖర్చును తగ్గిస్తుందా, లేక context వినియోగాన్ని మాత్రమే తగ్గిస్తుందా?

అభ్యర్థన provider కు చేరకముందే దానిని సంక్షిప్తం చేస్తుంది. బిల్లు తగ్గింపు తొలగించిన tokens ధరలు మరియు agent కు అవసరమైన మొత్తం turns పై ఆధారపడి ఉంటుంది. ఈ తగ్గింపు పరిమాణం శీర్షికలో కనిపించే సంఖ్యకన్నా తక్కువగా ఉంటుంది. 74% సంఖ్య సంక్షిప్తం చేసిన content పై compression rate ను సూచిస్తుంది. End to end గా, ఒకే turn లో సుమారు 25% మరియు turn 20 నాటికి input-token savings గా 63% ఉంటుందని project నివేదిస్తుంది. Output tokens మార్పు లేకుండా పంపబడతాయి. అయితే ఉత్పత్తి అయ్యే మొత్తం agent ప్రవర్తనపై ఆధారపడి ఉంటుంది.

Compression model ను self-host చేయడానికి నాకు ఎంత GPU అవసరం?

GPU తప్పనిసరి కాదు. Ollama model ను CPU పై కూడా నడుపుతుంది. q4 build పరిమాణం సుమారు 2.5 GB, f16 build పరిమాణం సుమారు 8 GB. అందువల్ల model 24 GB card లో చాలా ఖాళీతో సరిపోతుంది. చిన్న card కూడా పనిచేస్తుంది. ఇది break-even లెక్కలను మీకు అనుకూలంగా మారుస్తుంది. Tool-schema filter కు GPU అవసరం లేదు. ఇది 130 MB పరిమాణం గల embedding model అయిన BAAI/bge-small-en-v1.5 ను ఉపయోగిస్తుంది. ఇది CPU పై నడుస్తుంది. సాధారణ VPS పై paritok[toolselect] ను install చేస్తే, కొద్దిపాటి RAM ఖర్చుతో tool-block reduction లభిస్తుంది.

Compressor agent కు అవసరమైనదాన్ని తొలగిస్తే ఏమవుతుంది?

ఏదీ శాశ్వతంగా కోల్పోదు. Forward చేసే content నుంచి model కొన్ని spans ను తొలగిస్తుంది. అయితే compressed segments లో [REF:id] tag ఉంటుంది. Model read_original లేదా expand_context తో పూర్తి text ను తిరిగి పొందుతుంది. Default tool filter ఎంపిక చేయని standard tools ను తొలగిస్తుంది. MCP relevance signal సక్రియం కాకపోతే ఎంపిక చేయని MCP tools ను కూడా తొలగిస్తుంది. ఆ signal సక్రియమైతే, ఆ MCP tools కు stubs ఉంచుతుంది. Tool recovery కోసం gateway_search_tools మరియు missing-tool messages గుర్తింపును ఉపయోగిస్తుంది. అసలు ప్రమాదం missing file కంటే నిశ్శబ్దంగా ఉంటుంది. Model lossily తీసుకున్న excerpt ఆధారంగా పనిచేస్తుంది. Original text అడగాల్సిన అవసరం ఉందని అది గుర్తించకపోవచ్చు. SWE-bench Lite పై నివేదించిన 86.5% quality-retained సంఖ్య, recall disabled మరియు production edit recovery enabled ఉన్నప్పుడు compressed raw source ను ఒకే ప్రయత్నంలో అర్థం చేసుకునే సామర్థ్యాన్ని కొలుస్తుంది. ఇది CPU tool-schema filter ను లేదా పూర్తి multi-turn gateway ను కొలవదు.

నా మొదటి అభ్యర్థనకు పదిహేను సెకన్లు ఎందుకు పడుతున్నాయి?

Tool filter వెనుక ఉన్న embedding model startup సమయంలో కాకుండా మొదటి request సమయంలో load అవుతుంది. Project 10 నుంచి 15 seconds warm-up సమయాన్ని document చేస్తుంది. ఆ తరువాత ప్రతి call కు సుమారు 15 ms పడుతుంది. Proxy ప్రారంభించిన తరువాత curl తో ఒక throwaway request పంపండి. అప్పుడు మొదటి నిజమైన agent turn ఆలస్యం కాదు.

Self-hosting కు బదులుగా hosted GPU server ఉపయోగించాలా?

దీనివల్ల compression-model hosting మరియు GPU rent అవసరం ఉండదు. అయితే gateway నిర్వహణను మీరు కొనసాగించాలి. 2 November 2026 నాటికి, compressed ప్రతి million file tokens కు $0.30 ఖర్చవుతుంది. ఈ మొత్తాన్ని prepaid credit నుంచి చెల్లించాలి. కొత్త accounts కు $5 free credit లభిస్తుంది. Free launch period 1 October 2026 న ముగిసింది. Model provider కు చేరకముందే ఇది మీ prompts మరియు agent చదివే files ను third party కు పంపుతుంది. మీరు నియంత్రించే infrastructure పై code ఉంచడానికి self-hosting ఎంచుకుంటే, ఈ setting మీరు self-hosting ప్రారంభించిన కారణాన్నే తొలగిస్తుంది. Self-hosting compression ను మీ స్వంత box పై ఉంచుతుంది. అయితే compressed requests మరియు provider credentials పైకి మీ model provider కు పంపబడతాయి.

ఈ వ్యాసం ఉపయోగకరంగా ఉందా?