pjandro/OmniRoute
1
0
Fork 0
mirror of https://github.com/diegosouzapw/OmniRoute.git synced 2026-09-20 13:52:28 +03:00
Code Issues Packages Projects Releases Wiki Activity
Files
7975ce99ff4ea88547b8331f40175dfce11412a5
OmniRoute/docs/i18n/te/docs/compression/COMPRESSION_GUIDE.md
Diego Rodrigues de Sa e Souza 8feea123bb feat(docs): mirror every docs/ page in all 65 locales (#14106) 
* feat(docs): mirror every docs/ page in all 65 locales

Extends the documentation mirrors from the 22-page core set (#13940) to
every Markdown page under docs/: 152 sources x 65 locales = 9,880 mirrors
(6,208 new), language bars rewritten for the full locale list, state
adopted so the blocking drift gate now covers all 152 pages.

run-translation.mjs: an oversized block made only of table rows or list
items (PROVIDER_REFERENCE.md 244-row table, FREE_TIERS.md 71-item list) is
cut at item boundaries and rejoined without a blank line — the single
16-40 KB request outlived the backend socket for verbose scripts. 48
older mirrors whose tables had lost rows were retranslated with --force.

* docs(i18n): refresh mirrors for the sources the base changed since the branch cut

Section-level retranslation of the 29 docs (and README.md) whose source
or mirrors moved on release/v3.8.51 during the run, then state adoption;
the drift gate is green again on the merged tree.
2026-09-18 13:16:46 -03:00

61 KiB
Raw Blame History

🗜️ Prompt Compression Guide — OmniRoute (తెలుగు)

🌐 Languages: 🇺🇸 English · 🇪🇹 am · 🇸🇦 ar · 🇦🇿 az · 🇧🇬 bg · 🇧🇩 bn · 🇨🇿 cs · 🇩🇰 da · 🇩🇪 de · 🇬🇷 el · 🇪🇸 es · 🇪🇪 et · 🇮🇷 fa · 🇫🇮 fi · 🇫🇷 fr · 🇮🇪 ga · 🇮🇳 gu · 🇳🇬 ha · 🇮🇱 he · 🇮🇳 hi · 🇭🇷 hr · 🇭🇺 hu · 🇦🇲 hy · 🇮🇩 id · 🇳🇬 ig · 🇮🇹 it · 🇯🇵 ja · 🇬🇪 ka · 🇰🇭 km · 🇮🇳 kn · 🇰🇷 ko · 🇱🇹 lt · 🇱🇻 lv · 🇮🇳 ml · 🇮🇳 mr · 🇲🇾 ms · 🇲🇹 mt · 🇲🇲 my · 🇳🇵 ne · 🇳🇱 nl · 🇳🇴 no · 🇮🇳 or · 🇮🇳 pa · 🇵🇭 phi · 🇵🇱 pl · 🇵🇹 pt · 🇧🇷 pt-BR · 🇷🇴 ro · 🇷🇺 ru · 🇱🇰 si · 🇸🇰 sk · 🇸🇮 sl · 🇷🇸 sr · 🇸🇪 sv · 🇰🇪 sw · 🇮🇳 ta · 🇹🇭 th · 🇹🇷 tr · 🇺🇦 uk-UA · 🇵🇰 ur · 🇺🇿 uz · 🇻🇳 vi · 🇳🇬 yo · 🇨🇳 zh-CN · 🇹🇼 zh-TW

అర్హమైన సందర్భంపై స్వయంచాలకంగా 15-95% ఆదా చేయండి. త్వరిత అవలోకనం కోసం, README Compression విభాగం చూడండి.

అవలోకనం

OmniRoute, అభ్యర్థనలు అప్స్ట్రీమ్ ప్రొవైడర్లను చేరకముందే ముందస్తుగా అమలయ్యే మాడ్యులర్ ప్రాంప్ట్ కంప్రెషన్ పైప్లైన్ను అమలు చేస్తుంది. అంటే, మీ టోకెన్ ఆదా పారదర్శకంగా జరుగుతుంది — మీ వర్క్ఫ్లోలో ఎలాంటి మార్పులూ అవసరం లేదు.

క్లయింట్ అభ్యర్థన
  → కంప్రెషన్ వ్యూహ ఎంపిక సాధనం
    → Combo ఓవర్రైడ్ ఉందా? → Combo సెట్టింగ్ను ఉపయోగించు
    → స్వయంచాలక-ట్రిగ్గర్ థ్రెషోల్డ్ ఉందా? → స్వయంచాలక మోడ్ను ఉపయోగించు
    → డిఫాల్ట్ మోడ్ ఉందా? → గ్లోబల్ సెట్టింగ్ను ఉపయోగించు
    → Offలో ఉందా? → కంప్రెషన్ను దాటవేయి
  → ఎంచుకున్న కంప్రెషన్ మోడ్
    → Off: కంప్రెషన్ లేదు
    → Lite: సురక్షిత వైట్స్పేస్/ఫార్మాటింగ్ శుభ్రపరచడం (~15%)
    → Standard: Caveman-శైలి అనవసర పదాల తొలగింపు (~30%)
    → Aggressive: చరిత్ర ఏజింగ్ + సారాంశీకరణ (~50%)
    → Ultra: హ్యూరిస్టిక్ ప్రూనింగ్ + కోడ్-బ్లాక్ సంక్షిప్తీకరణ (~75%)
    → RTK: కమాండ్-అవగాహనతో టెర్మినల్/టూల్-అవుట్పుట్ ఫిల్టరింగ్ (అప్స్ట్రీమ్ పరిధి 60-90%)
    → Stacked: క్రమబద్ధమైన బహుళ-ఇంజిన్ పైప్లైన్, సాధారణంగా RTK తర్వాత Caveman (అర్హమైన పరిధి 78-95%)
  → కంప్రెస్ చేసిన అభ్యర్థన → ప్రొవైడర్

కంప్రెషన్ మోడ్లు

Off

కంప్రెషన్ వర్తించదు. అన్ని సందేశాలు మార్పు లేకుండా పంపబడతాయి.

Lite మోడ్ (~15% ఆదా, <1ms లేటెన్సీ)

అత్యంత సురక్షితమైన మోడ్ — అర్థంలో ఎలాంటి మార్పూ ఉండదు, కేవలం ఫార్మాటింగ్ మాత్రమే శుభ్రపరుస్తుంది:

సాంకేతికత వివరణ
collapseWhitespace వరుసగా ఉన్న ఖాళీ పంక్తులు మరియు చివరలోని స్పేస్లను విలీనం చేస్తుంది
dedupSystemPrompt నకిలీ సిస్టమ్ సందేశాలను తొలగిస్తుంది
compressToolResults సుదీర్ఘమైన టూల్/ఫంక్షన్ అవుట్పుట్లను కంప్రెస్ చేస్తుంది
removeRedundantContent పునరావృత సూచనలను తొలగిస్తుంది
replaceImageUrls base64 ఇమేజ్ డేటా URIలను సంక్షిప్తం చేస్తుంది

అత్యుత్తమంగా సరిపడేది: ఎల్లప్పుడూ ఆన్లో ఉండే వినియోగం, భద్రత-కీలకమైన వర్క్ఫ్లోలు.

Standard మోడ్ (~30% ఆదా)

Caveman నుండి ప్రేరణ పొందింది — అర్థాన్ని కాపాడుతూ అనవసర పదాలు మరియు సుదీర్ఘ పదబంధాలను తొలగిస్తుంది:

  • అనవసర పదాలను తొలగిస్తుంది ("దయచేసి", "నా అభిప్రాయం ప్రకారం", "ప్రాథమికంగా", "నిజానికి")
  • సుదీర్ఘ పదబంధాలను సంక్షిప్తం చేస్తుంది ("చేయడం కోసం" → "చేయడానికి", "ఫలితంగా" → "కారణంగా")
  • మర్యాదపూర్వక సందిగ్ధతను తొలగిస్తుంది ("మీకు అభ్యంతరం లేకపోతే...", "మీరు వీలైతే...")
  • కోడింగ్ ప్రాంప్ట్ల కోసం సర్దుబాటు చేసిన 30+ regex నియమాలు

అత్యుత్తమంగా సరిపడేది: రోజువారీ కోడింగ్ వర్క్ఫ్లోలు, ఖర్చుపై శ్రద్ధగల బృందాలు.

Aggressive మోడ్ (~50% ఆదా)

సుదీర్ఘ సెషన్ల కోసం తెలివైన చరిత్ర నిర్వహణ:

  • సందేశ ఏజింగ్ — పాత సందేశాలు క్రమంగా మరింత కంప్రెస్ అవుతాయి
  • టూల్ ఫలితాల సారాంశీకరణ — సుదీర్ఘమైన టూల్ అవుట్పుట్ల స్థానంలో సారాంశాలను ఉంచుతుంది
  • నిర్మాణ సమగ్రత రక్షణలు — tool_use + tool_result జంటలు స్థిరంగా ఉండేలా చూస్తాయి
  • కాంటెక్స్ట్ విండో అవగాహన — ప్రతి మోడల్కు సంబంధించిన టోకెన్ పరిమితులను గౌరవిస్తుంది

అత్యుత్తమంగా సరిపడేది: సుదీర్ఘ డీబగ్గింగ్ సెషన్లు, పెద్ద కోడ్బేస్లు.

Ultra మోడ్ (~75% ఆదా)

టోకెన్-కీలక పరిస్థితుల కోసం గరిష్ఠ కంప్రెషన్:

  • హ్యూరిస్టిక్ ప్రూనింగ్ — సంబంధితత థ్రెషోల్డ్ కంటే దిగువన ఉన్న సందేశాలను తొలగిస్తుంది
  • కోడ్ బ్లాక్ సంక్షిప్తీకరణ — పునరావృత కోడ్ ఉదాహరణలను కంప్రెస్ చేస్తుంది
  • బైనరీ సెర్చ్ ట్రంకేషన్ — కాంటెక్స్ట్ విండో కోసం అనుకూలమైన కట్ పాయింట్ను కనుగొంటుంది
  • Aggressive మోడ్లోని అన్ని ఫీచర్లు చేర్చబడ్డాయి

అత్యుత్తమంగా సరిపడేది: మీరు కాంటెక్స్ట్ పరిమితులను పదేపదే చేరుకుంటున్నప్పుడు.

RTK మోడ్ (అప్స్ట్రీమ్ పరిధి 60-90%)

కోడింగ్-ఏజెంట్ సెషన్లలో కనిపించే సుదీర్ఘమైన టూల్ అవుట్పుట్ల కోసం RTK మోడ్ ఆప్టిమైజ్ చేయబడింది:

  • git status, git diff, git log, టెస్ట్ రన్నర్లు, TypeScript/Vite/Webpack బిల్డ్లు, ESLint/Biome/Prettier, npm ఆడిట్లు/ఇన్స్టాల్లు, Docker లాగ్లు, ఇన్ఫ్రా అవుట్పుట్ మరియు సాధారణ షెల్ అవుట్పుట్ వంటి కమాండ్/అవుట్పుట్ తరగతులను గుర్తిస్తుంది
  • open-sse/services/compression/engines/rtk/filters/ నుండి JSON ఫిల్టర్ ప్యాక్లను వర్తింపజేస్తుంది
  • ఇన్లైన్-టెస్ట్ ధ్రువీకరణ మరియు ప్రాజెక్ట్ ఫైళ్ల కోసం ట్రస్ట్-గేటింగ్తో, ప్రాజెక్ట్ లేదా గ్లోబల్ filters.toml ఫైళ్ల నుండి RTK TOML schema v1 ఫిల్టర్లను దిగుమతి చేస్తుంది
  • ఇన్లైన్ ధ్రువీకరణ నమూనాలతో 49 అంతర్నిర్మిత ఫిల్టర్లను అందిస్తుంది
  • ANSI నియంత్రణ క్రమాలు, ప్రోగ్రెస్ బార్లు, పునరావృత పంక్తులు మరియు చర్యకు ఉపయోగపడని అనవసర సమాచారాన్ని తొలగిస్తుంది
  • వైఫల్యాలు, ఎర్రర్లు, హెచ్చరికలు, మారిన ఫైళ్లు, సారాంశాలు మరియు సుదీర్ఘ అవుట్పుట్ చివరి భాగాన్ని సంరక్షిస్తుంది
  • ట్రస్ట్-గేటెడ్ ప్రాజెక్ట్ ఫిల్టర్లు, గ్లోబల్ ఫిల్టర్లు మరియు ఐచ్ఛికంగా సవరించిన ముడి అవుట్పుట్ రికవరీకి మద్దతు ఇస్తుంది

అత్యుత్తమంగా సరిపడేది: షెల్, బిల్డ్, టెస్ట్, git, grep మరియు ఫైల్-అవుట్పుట్ ట్రాన్స్క్రిప్ట్లతో కూడిన ఏజెంట్ సెషన్లు.

Stacked మోడ్ (అర్హమైన పరిధి 78-95%)

Stacked మోడ్ అనేక కంప్రెషన్ ఇంజిన్లను నిర్ణీత క్రమంలో అమలు చేస్తుంది. డిఫాల్ట్ పైప్లైన్:

RTK -> Caveman

ఆ క్రమం ముందుగా టెర్మినల్/టూల్ అవుట్పుట్ను సంక్షిప్తంగా ఉంచి, తర్వాత మిగిలిన సహజ-భాషా ప్రాంప్ట్పై Caveman సెమాంటిక్ సంక్షిప్తీకరణను వర్తింపజేస్తుంది. Stacked పైప్లైన్లను గ్లోబల్గా లేదా రౌటింగ్ comboలకు కేటాయించిన కంప్రెషన్ comboల ద్వారా కాన్ఫిగర్ చేయవచ్చు.

అత్యుత్తమంగా సరిపడేది: పెద్ద టూల్ లాగ్లతో పాటు మానవ సూచనలు లేదా అసిస్టెంట్ సారాంశాలు కలిగిన మిశ్రమ కాంటెక్స్ట్.

అప్స్ట్రీమ్ ఆదా గణితం

OmniRoute రెండు మూలాల నుండి లభించే కంప్రెషన్ ఆదాను డాక్యుమెంట్ చేస్తుంది: అప్స్ట్రీమ్ ప్రాజెక్ట్ బెంచ్మార్క్లు మరియు OmniRoute యొక్క స్వంత ఇంజిన్ కూర్పు.

మూలం ఇక్కడ ఉపయోగించిన అప్స్ట్రీమ్ README సంఖ్య
Caveman ~75% తక్కువ అవుట్పుట్ టోకెన్లు, 65% బెంచ్మార్క్ సగటు అవుట్పుట్ ఆదా, 22-87% పరిధి మరియు ~46% ఇన్పుట్ కంప్రెషన్ సాధనం
RTK 60-90% కమాండ్-అవుట్పుట్ ఆదా; నమూనా సెషన్లో ~118,000 -> ~23,900 టోకెన్లు లేదా 79.7% ఆదా (~80%)

ఒకదానితో ఒకటి అతివ్యాప్తి చెందే టూల్/కాంటెక్స్ట్ పేలోడ్ల కోసం, డిఫాల్ట్ OmniRoute కాంబో ఇంజిన్లను ఇలా వరుసగా అమర్చుతుంది:

RTK -> Caveman

సంయుక్త ఆదా గుణాత్మకంగా ఉంటుంది, సంకలనాత్మకంగా కాదు:

combined = 1 - (1 - RTK savings) * (1 - Caveman input savings)
average  = 1 - (1 - 0.80) * (1 - 0.46) = 89.2%
range    = 1 - (1 - 0.60..0.90) * (1 - 0.46) = 78.4-94.6%

RTK మరియు Caveman రెండూ ఒకే ఇన్పుట్/కాంటెక్స్ట్ పేలోడ్ను తగ్గించగలిగినప్పుడు ఆ 78-95% సంఖ్య వర్తిస్తుంది. Caveman రెస్పాన్స్ అవుట్పుట్ మోడ్ వేరుగా ఉంటుంది: దాన్ని ప్రారంభించినప్పుడు, Caveman యొక్క స్వంత అవుట్పుట్ ఆదాను (65% సగటు, ~75% ప్రధాన సంఖ్య, 22-87% పరిధి) ఉపయోగించండి. మొత్తం బిల్లింగ్ ఆదా మీ ప్రాంప్ట్/అవుట్పుట్ నిష్పత్తిపై ఆధారపడి ఉంటుంది.

"అర్హమైనది" అంటే వాస్తవంగా ఏమిటి

15-95% ప్రధాన పరిధి వాస్తవమైనదే, కానీ అది పునరావృతమైన లేదా అతిగా వివరమైన కంటెంట్కు మాత్రమే వర్తిస్తుంది — పదేపదే వచ్చే ఎర్రర్ లైన్లు, ఒకే వార్నింగ్ను వరుసగా చూపించే బిల్డ్ లాగ్, అవసరానికి మించిన grep/ఫైల్-రీడ్ డంప్. దీని అర్థం ప్రతి రిక్వెస్ట్లోనూ అంత ఆదా అవుతుందని కాదు.

ప్రయోగపూర్వకంగా ధృవీకరించబడింది (tests/unit/compression/stacked-compression-tool-result-savings.test.ts): 300 ఒకే విధమైన ఎర్రర్ లైన్లను కలిగిన Anthropic-ఆకృతి tool_result బ్లాక్పై అమలు చేసిన stacked (RTK + Caveman) రన్లో 95.93% టోకెన్ ఆదా / 96.26% అక్షర ఆదా లభించింది — ఇది ప్రకటించిన పరిధిలో స్పష్టంగా ఉంది. అయితే, అదే పైప్లైన్ను సాధారణమైన, పునరావృతం కాని టూల్ అవుట్పుట్పై (శుభ్రమైన grep మ్యాచ్ జాబితా, చిన్న ఫైల్ రీడ్, సాధారణ సంభాషణ టెక్స్ట్) అమలు చేసినప్పుడు సరిగ్గా దాదాపు సున్నా ఆదా వస్తుంది, ఎందుకంటే తొలగించడానికి పునరావృతమైనది ఏదీ ఉండదు మరియు కోడ్ బ్లాక్లు, URLలు, హెడ్డింగ్లు, వెర్షన్లు లేదా ALL-CAPS స్థిరాంక ఐడెంటిఫైయర్లను తొలగించే లేదా మార్చే రీరైట్ను పంపడానికి validateCompression() (validation.ts) నిరాకరిస్తుంది.

ఇది ఊహించిన, సురక్షితమైన ప్రవర్తనే తప్ప బగ్ కాదు: ఎక్కువగా శుభ్రమైన ఫైల్లను రీడ్/గ్రెప్ చేసే కోడింగ్ సెషన్లో కంప్రెషన్ పూర్తిగా ప్రారంభించబడి ఉన్నప్పటికీ మొత్తం ఆదా పరిమితంగానే ఉంటుంది; విఫలమవుతున్న లూప్ లేదా అతిగా సందేశాలు ఇచ్చే లింటర్ను ఎదుర్కొనే సెషన్లో మాత్రం ఆ ట్రాఫిక్పై పూర్తి 78-95% పరిధి ఆదా కనిపిస్తుంది. కంప్రెషన్ తప్పుగా కాన్ఫిగర్ చేయబడిందనడానికి ఒకే సెషన్లోని తక్కువ సమగ్ర ఆదా శాతాన్ని సాక్ష్యంగా ఉపయోగించవద్దు — ముందుగా అంతర్లీన టూల్ అవుట్పుట్ నిజంగా పునరావృతమైనదో లేదో తనిఖీ చేయండి.

టోకెన్ ఆదా విజువలైజేషన్

కంప్రెషన్ లేకుండా:         LLMకు 47K టోకెన్లు పంపబడ్డాయి
Liteతో:                    40K టోకెన్లు పంపబడ్డాయి          (15% ఆదా — సురక్షితం, ఎల్లప్పుడూ ఆన్లో ఉంటుంది)
Standardతో:                33K టోకెన్లు పంపబడ్డాయి          (30% ఆదా — caveman-శైలి నియమాలు)
Aggressiveతో:              24K టోకెన్లు పంపబడ్డాయి          (50% ఆదా — ఏజింగ్ + సమ్మరైజేషన్)
Ultraతో:                   12K టోకెన్లు పంపబడ్డాయి          (75% ఆదా — హ్యూరిస్టిక్ ప్రూనింగ్)
RTKతో:                     19K-5K టోకెన్లు పంపబడ్డాయి       (కమాండ్/టూల్ అవుట్పుట్పై 60-90% ఆదా)
Stackedతో:                 10K-2.5K టోకెన్లు పంపబడ్డాయి     (అర్హమైన RTK+Caveman కంటెంట్పై 78-95% పరిధి)

కాన్ఫిగరేషన్

డ్యాష్బోర్డ్

Dashboard → Context & Cacheకు వెళ్లండి:

  • Caveman — మోడ్ ఎంపిక, భాషా ప్యాక్లు, ప్రివ్యూ మరియు గ్లోబల్ డిఫాల్ట్లు
  • RTK — కమాండ్-ఫిల్టర్ ప్రివ్యూ, RTK భద్రతా సెట్టింగ్లు మరియు ఫిల్టర్ కేటలాగ్
  • Compression Combos — రూటింగ్ కాంబోలకు కేటాయించిన, పేర్లు గల ఇంజిన్ పైప్లైన్లు
  • Auto-Trigger Threshold — టోకెన్ల సంఖ్య థ్రెషోల్డ్ను మించినప్పుడు కంప్రెషన్ను స్వయంచాలకంగా ప్రారంభిస్తుంది

ఒక్కో కాంబోకు ఓవర్రైడ్

Dashboard → Context & Cache → Compression Combosలో, ఒక రూటింగ్ కాంబోకు కంప్రెషన్ కాంబోను కేటాయించండి:

Combo: "free-tier-fallback"
  Compression Combo: "coding-agent-stack"
  Pipeline: RTK -> Caveman
  Targets:
    1. if/kimi-k2.7-code
    2. if/qwen3.8-max-preview

చెల్లింపు సబ్స్క్రిప్షన్లలో లైట్ మోడ్ను కొనసాగిస్తూనే, ఉచిత/కోడింగ్ ప్రొవైడర్లపై స్టాక్డ్ కంప్రెషన్ను ఉపయోగించడానికి ఇది మిమ్మల్ని అనుమతిస్తుంది.

ఈ "Per-Combo Override" కేటాయింపు, routing-combo compression mode ఓవర్రైడ్ (Default/Off/Lite/Standard/Aggressive/Ultra)కు భిన్నమైన నియంత్రణ — ఆ ఓవర్రైడ్ పేరున్న కంప్రెషన్-కాంబో పైప్లైన్ను ఎంచుకోదు; అది resolveCompressionPlan పరిశీలించే compressionMode ఫీల్డ్ను మాత్రమే సెట్ చేస్తుంది. దీన్ని కాంబో కార్డ్లో (Dashboard → Combos) లేదా, #6760 నుండి, పైన డాక్యుమెంట్ చేసిన పైప్లైన్-కేటాయింపు చెక్బాక్స్ పక్కనే ఉన్న Dashboard → Context & Cache → Compression Combosలోని "Assign to routing" జాబితాలో ఒక్కో రూటింగ్ కాంబోకు సెట్ చేయవచ్చు. రెండు ఇంటర్ఫేస్లలో చేసిన మార్పులూ ఒకే PUT /api/combos/{id} ఎండ్పాయింట్ ద్వారా నిల్వ చేయబడతాయి.

ఒక్కో రిక్వెస్ట్కు ఓవర్రైడ్

ఒకే రిక్వెస్ట్కు కంప్రెషన్ ప్లాన్ను ఓవర్రైడ్ చేయడానికి x-omniroute-compression రిక్వెస్ట్ హెడర్ను పంపండి. దీనికే అత్యధిక ప్రాధాన్యత ఉంటుంది — ఇది రూటింగ్-కాంబో ఓవర్రైడ్, సక్రియ ప్రొఫైల్, ఆటో-ట్రిగ్గర్ మరియు ప్యానెల్ Default కంటే ప్రాధాన్యత పొందుతుంది. తెలియని విలువలు విస్మరించబడతాయి (రిక్వెస్ట్ ఎప్పటికీ తిరస్కరించబడదు), అలాగే గ్లోబల్ మాస్టర్ స్విచ్ ఇప్పటికీ అన్నింటినీ నియంత్రిస్తుంది: కంప్రెషన్ గ్లోబల్గా ఆఫ్లో ఉన్నప్పుడు, హెడర్ దాన్ని ఆన్ చేయలేదు. విలువలు:

విలువ ప్రభావం
off ఈ రిక్వెస్ట్కు కంప్రెషన్ ఉండదు.
default ప్యానెల్ నుండి ఉత్పన్నమైన Default ప్రొఫైల్ (సక్రియ ప్రొఫైల్ను విస్మరిస్తుంది).
engine:<id> ప్రారంభించబడి ఉన్నప్పుడు ఒకే ఇంజిన్, ఉదా. engine:rtk.
<combo> పేరుతో సరిపోల్చబడే పేరున్న కాంబో (కేస్-ఇన్సెన్సిటివ్గా), ఆపై idతో సరిపోల్చబడుతుంది.

వర్తింపజేసిన ప్లాన్ X-OmniRoute-Compression: <mode>; source=<source> రెస్పాన్స్ హెడర్లో తిరిగి పంపబడుతుంది, ఇక్కడ <source> అనేది request-header, routing-override, active-profile, auto-trigger, default లేదా offలో ఒకటి.

API

# కంప్రెషన్ సెట్టింగ్లను పొందండి
curl http://localhost:20128/api/settings/compression

# కంప్రెషన్ సెట్టింగ్లను అప్డేట్ చేయండి
curl -X PUT http://localhost:20128/api/settings/compression \
  -H "Content-Type: application/json" \
  -d '{"defaultMode":"stacked","autoTriggerMode":"stacked","autoTriggerTokens":32000}'

# నిర్దిష్ట RTK/stacked పేలోడ్ను ప్రివ్యూ చేయండి
curl -X POST http://localhost:20128/api/compression/preview \
  -H "Content-Type: application/json" \
  -d '{"mode":"rtk","messages":[{"role":"tool","content":"npm test output here"}]}'

# RTK ఫిల్టర్ ప్యాక్లను జాబితా చేయండి
curl http://localhost:20128/api/context/rtk/filters

# ఐచ్ఛిక కమాండ్ మెటాడేటాతో RTKను నేరుగా పరీక్షించండి
curl -X POST http://localhost:20128/api/context/rtk/test \
  -H "Content-Type: application/json" \
  -d '{"command":"npm test","text":"FAIL tests/example.test.ts\nError: boom"}'

ఏవి రక్షించబడతాయి

కంప్రెషన్ ఇంజిన్ ఎల్లప్పుడూ వీటిని యథాతథంగా ఉంచుతుంది:

  • ✅ కోడ్ బ్లాక్లు (ఫెన్స్డ్ మరియు ఇన్లైన్)
  • ✅ URLలు మరియు ఫైల్ పాత్లు
  • ✅ JSON నిర్మాణాలు మరియు నిర్మిత డేటా
  • ✅ ఐడెంటిఫైయర్లు మరియు రక్షిత సాంకేతిక టోకెన్లు
  • ✅ గణిత వ్యక్తీకరణలు
  • ✅ టూల్/ఫంక్షన్ కాల్ నిర్వచనాలు
  • ✅ సిస్టమ్ ప్రాంప్ట్లు (lite మోడ్లో)

ఏదైనా డేటా నిల్వ చేయబడటానికి ముందు, RTK రా-అవుట్పుట్ రికవరీ సాధారణ API కీలు, బేరర్ టోకెన్లు, Slack టోకెన్లు, AWS యాక్సెస్ కీలు, పాస్వర్డ్లు, టోకెన్లు మరియు రహస్యాలను రీడాక్ట్ చేస్తుంది.

కంప్రెషన్ గణాంకాలు

కంప్రెస్ చేసిన ప్రతి అభ్యర్థనకు సంబంధించిన గణాంకాలు సర్వర్ లాగ్లలో ఉంటాయి:

{
  "originalTokens": 47200,
  "compressedTokens": 40120,
  "savingsPercent": 15.0,
  "techniquesUsed": ["collapseWhitespace", "dedupSystemPrompt"],
  "mode": "lite",
  "engine": "caveman",
  "compressionComboId": "coding-agent-stack",
  "durationMs": 0.8,
  "rtkRawOutputPointers": []
}

దశల రోడ్మ్యాప్

దశ మోడ్లు స్థితి
దశ 1 Off, Lite ✅ విడుదలైంది
దశ 2 Standard, Aggressive, Ultra ✅ విడుదలైంది
దశ 3 RTK, Stacked, Compression Combos ✅ విడుదలైంది
దశ 4 Output Styles, SLM-tier Ultra, eval harness ✅ విడుదలైంది
దశ 4C అనుకూల సందర్భ-బడ్జెట్ ("dial") — కంప్యూట్ ఇంజిన్ + API (PUT /api/settings/compressionలో contextBudget) + డ్యాష్బోర్డ్ మోడ్/పాలసీ నియంత్రణలు ✅ విడుదలైంది

కృతజ్ఞతలు

Standard మోడ్ కంప్రెషన్ నియమాలు JuliusBrussee రూపొందించిన Caveman (⭐ 51K+) నుండి ప్రేరణ పొందాయి — ఇది వైరల్ అయిన "ఎక్కువ టోకెన్లు ఎందుకు వాడాలి, కొన్ని టోకెన్లతోనే పని పూర్తవుతుంటే" అనే ప్రాజెక్ట్. Caveman నివేదిక ప్రకారం, అవుట్పుట్ టోకెన్లు ~75% తక్కువగా ఉంటాయి, బెంచ్మార్క్ సగటు అవుట్పుట్ ఆదా 65%, అవుట్పుట్ పరిధి 22-87%, అలాగే ఇన్పుట్-కంప్రెషన్ టూల్ ~46% ఆదా చేస్తుంది.

RTK మోడ్ RTK AI రూపొందించిన RTK - Rust Token Killer నుండి ప్రేరణ పొందింది — ఇది టెర్మినల్, బిల్డ్, టెస్ట్, git మరియు టూల్-అవుట్పుట్ ఫిల్టరింగ్ కోసం రూపొందించిన అధిక-పనితీరు గల కమాండ్-అవుట్పుట్ కంప్రెషన్ ప్రాజెక్ట్. RTK నివేదిక ప్రకారం 60-90% ఆదా అవుతుంది; దాని README నమూనా సెషన్లో ~80% ఆదా చూపబడింది.

అధునాతన కంప్రెషన్ సిస్టమ్లు

7 ప్రామాణిక మోడ్లకు అదనంగా, సందర్భం ఆధారంగా స్వయంచాలకంగా పనిచేసే పలు అధునాతన కంప్రెషన్ సిస్టమ్లను OmniRoute కలిగి ఉంది.

క్యాష్-అవేర్ కంప్రెషన్

కొన్ని ప్రొవైడర్లు (ప్రాంప్ట్ క్యాషింగ్తో కూడిన Anthropic వంటివి) ప్రాంప్ట్ క్యాషింగ్కు మద్దతు ఇస్తాయి, ఇది ఖర్చులు మరియు లేటెన్సీని తగ్గించడానికి ప్రాంప్ట్లోని భాగాలను క్యాష్ చేసుకునే వీలు కల్పిస్తుంది. క్యాషింగ్ ప్రారంభించబడినప్పుడు, దూకుడైన కంప్రెషన్ క్యాష్ చేసిన టోకెన్లను మార్చి, క్యాష్ను చెల్లనిదిగా చేస్తుంది కాబట్టి వాస్తవానికి పనితీరును దెబ్బతీయవచ్చు.

cachingAware.ts మాడ్యూల్ క్యాషింగ్ సందర్భాన్ని గుర్తించడం మరియు దానికి అనుగుణంగా కంప్రెషన్ వ్యూహాన్ని సర్దుబాటు చేయడం ద్వారా ఈ సమస్యను పరిష్కరిస్తుంది.

ఇది ఎలా పనిచేస్తుంది

  1. క్యాషింగ్ సందర్భాన్ని గుర్తిస్తుంది — cache_control మార్కర్ల కోసం అభ్యర్థన బాడీని స్కాన్ చేస్తుంది
  2. క్యాషింగ్ ప్రొవైడర్లను గుర్తిస్తుంది — లక్ష్య ప్రొవైడర్ క్యాషింగ్కు మద్దతు ఇస్తుందో లేదో తనిఖీ చేస్తుంది
  3. వ్యూహాన్ని సర్దుబాటు చేస్తుంది — క్యాషింగ్ ప్రొవైడర్ల కోసం aggressive/ultraను standardకు తగ్గిస్తుంది
  4. సిస్టమ్ ప్రాంప్ట్ను దాటవేస్తుంది — సిస్టమ్ ప్రాంప్ట్లు సాధారణంగా క్యాష్ చేయబడతాయి, కాబట్టి వాటిని కంప్రెస్ చేయదు
  5. నిర్ణీత రూపాంతరాలను ఉపయోగిస్తుంది — స్థిరమైన అవుట్పుట్ను ఉత్పత్తి చేసే రూపాంతరాలను మాత్రమే ఉపయోగిస్తుంది

కోడ్ ఉదాహరణ

import {
  detectCachingContext,
  getCacheAwareStrategy,
} from "@omniroute/open-sse/services/compression/cachingAware";

const body = {
  model: "anthropic/claude-sonnet-4.5",
  messages: [{ role: "user", content: "Hello" }],
  cache_control: { type: "ephemeral" }, // ← క్యాష్ మార్కర్
};

const ctx = detectCachingContext(body, { provider: "anthropic" });
// → { hasCacheControl: true, provider: "anthropic", isCachingProvider: true }

const strategy = getCacheAwareStrategy("aggressive", ctx);
// → { strategy: "standard", skipSystemPrompt: true, deterministicOnly: true }

ఎప్పుడు ఉపయోగించాలి

క్యాష్-అవేర్ కంప్రెషన్ ఎల్లప్పుడూ ఆన్లో ఉంటుంది — ఎలాంటి కాన్ఫిగరేషన్ అవసరం లేదు. ఇది కింది సందర్భాల్లో మాత్రమే అమలవుతుంది:

  • అభ్యర్థనలో cache_control మార్కర్లు ఉన్నప్పుడు
  • లక్ష్య ప్రొవైడర్ ప్రాంప్ట్ క్యాషింగ్కు మద్దతు ఇచ్చినప్పుడు (Anthropic, OpenAI మొదలైనవి)

ప్రోగ్రెసివ్ ఏజింగ్

దీర్ఘ సంభాషణల్లో అనేక సందేశ టర్న్లు పేరుకుపోతాయి, అయితే పాత టర్న్ల ప్రాసంగికత తగ్గిపోతుంది. progressiveAging.ts మాడ్యూల్ టర్న్ దూరం ఆధారంగా సందేశాల వివరాలను తగ్గిస్తుంది:

  • ఇటీవలి టర్న్లు (0-3): యథాతథంగా ఉంచబడతాయి (పూర్తి వివరాలతో)
  • మధ్యస్థ టర్న్లు (4-8): Lite కంప్రెషన్ (వైట్స్పేస్, ఫార్మాటింగ్ శుభ్రపరచడం)
  • పాత టర్న్లు (9+): Caveman కంప్రెషన్ (అనవసర పదాల తొలగింపు, సారాంశీకరణ)
  • చాలా పాత టర్న్లు (20+): విస్తృతంగా సారాంశీకరించబడతాయి లేదా తొలగించబడతాయి

కోడ్ ఉదాహరణ

import { applyAging } from "@omniroute/open-sse/services/compression/progressiveAging";

const messages = [
  { role: "system", content: "You are a helpful assistant" },
  { role: "user", content: "What is 2+2?" },
  { role: "assistant", content: "4" },
  // ... మరో 50 టర్న్లు ...
];

const { messages: aged, saved } = applyAging(messages, {
  verbatim: 3, // మొదటి 3 టర్న్లు: యథాతథంగా
  light: 8, // 4-8 టర్న్లు: lite కంప్రెషన్
  moderate: 20, // 9-20 టర్న్లు: caveman కంప్రెషన్
  // 21+ టర్న్లు: విస్తృత సారాంశీకరణ
});

// saved = ఆదా అయిన టోకెన్ల సంఖ్య

ఎప్పుడు ఉపయోగించాలి

ప్రోగ్రెసివ్ ఏజింగ్ aggressive మరియు ultra మోడ్లలో ఎల్లప్పుడూ ఆన్లో ఉంటుంది. ఇది ప్రత్యేకంగా వీటికి ప్రభావవంతంగా ఉంటుంది:

  • దీర్ఘకాలం కొనసాగే కోడింగ్ సెషన్లు
  • అనేక రోజుల సంభాషణలు
  • అనేక టూల్ కాల్లతో కూడిన ఏజెంటిక్ వర్క్ఫ్లోలు

కేవ్మ్యాన్ అవుట్పుట్ మోడ్

మోడల్ స్వయంగా సంక్షిప్తమైన, క్లుప్తమైన అవుట్పుట్ను ("కేవ్మ్యాన్" శైలి) ఉత్పత్తి చేసేలా outputMode.ts మాడ్యూల్ సిస్టమ్ ప్రాంప్ట్ సూచనలను చొప్పిస్తుంది.

ఇది ఎలా పనిచేస్తుంది

ఇన్పుట్ను కుదించడానికి బదులుగా, ఈ మోడ్ ఇలాంటి సిస్టమ్ ప్రాంప్ట్ను జోడిస్తుంది:

"కనిష్ఠ పదాలతో సమాధానమివ్వండి. మర్యాదపూర్వక మాటలను వదిలేయండి. చిన్న వాక్యాలను ఉపయోగించండి."

ఇది ప్రత్యేకంగా వీటికి బాగా పనిచేస్తుంది:

  • కోడ్ జనరేషన్ (మరింత క్లుప్తమైన అవుట్పుట్ = తక్కువ టోకెన్లు)
  • త్వరిత ప్రశ్నోత్తరాలు (వివరణాత్మక సమాధానాలు అవసరం లేదు)
  • బ్యాచ్ ప్రాసెసింగ్ (త్రూపుట్ను గరిష్ఠీకరించండి)

ఎప్పుడు ఉపయోగించాలి

కేవ్మ్యాన్ అవుట్పుట్ మోడ్ ఎంపిక చేసుకుంటేనే అమలవుతుంది — కాంబో కాన్ఫిగ్ ద్వారా దీన్ని సెట్ చేయండి:

{
  "strategy": "auto",
  "config": {
    "auto": {
      "outputMode": "caveman"
    }
  }
}

అవుట్పుట్ శైలులు (కేటలాగ్)

పైన ఉన్న కేవ్మ్యాన్ అవుట్పుట్ మోడ్ లెగసీ సింగిల్-స్టైల్ మార్గం. Phase 4 దీన్ని కలిపి ఉపయోగించగల అవుట్పుట్ శైలుల కేటలాగ్గా విస్తరించింది: open-sse/services/compression/outputStyles/catalog.tsలోని OUTPUT_STYLE_CATALOG. ప్రతి శైలి మోడల్ స్వయంగా తక్కువ ఖర్చుతో కూడిన అవుట్పుట్ను ఉత్పత్తి చేసేలా చేసే సిస్టమ్-ప్రాంప్ట్ సూచన; శైలులను కలిపి ప్రారంభించవచ్చు, అవి కేటలాగ్ క్రమంలో చొప్పించబడతాయి.

శైలి id ఇది చేసే పని సూచనల భాషలు
క్లుప్త గద్యం terse-prose అనవసర పదాలు/ఆర్టికల్స్/సందిగ్ధ వ్యక్తీకరణలను తొలగిస్తుంది; సాంకేతిక సారాంశాన్ని ఖచ్చితంగా ఉంచుతుంది. లెగసీ కేవ్మ్యాన్ అవుట్పుట్ మోడ్లోని అదే టెక్స్ట్ను తిరిగి టైప్ చేయకుండా సూచిస్తుంది. en, pt-BR, es, de, fr, it, ru, zh, ja, id, vi
తక్కువ కోడ్ less-code YAGNI శ్రేణి: పనిచేసే అతి చిన్న మార్పు, అభ్యర్థించని అబ్స్ట్రాక్షన్లు ఉండవు. en, pt-BR, es, de, fr, it, ru, zh, ja, id, vi
పోనీటెయిల్ (బద్ధకస్తుడైన సీనియర్ డెవలపర్) ponytail "ఎప్పుడూ రాయని కోడే అత్యుత్తమ కోడ్": తిరిగి ఉపయోగించడం > తిరిగి రాయడం, మూల కారణం > లక్షణం, పనిచేసే అతి చిన్న డిఫ్. en, pt-BR, es, de, fr, it, ru, zh, ja, id, vi
నాకు ADHD ఉంది (చర్య-మొదట) i-have-adhd ముందుగా చర్య (గద్యానికి ముందు కమాండ్/పాత్/స్నిపెట్), సంఖ్యలతో కూడిన పరిమిత దశలు, ఒకే నిర్దిష్ట తదుపరి దశ, ఉపోద్ఘాతం/పునశ్చరణ/ముగింపు వాక్యాలు ఉండవు. ayghri/i-have-adhd (MIT) నుండి అనుకరించబడింది. en, pt-BR, es, de, fr, it, ru, zh, ja, id, vi
క్లుప్త CJK (文言) terse-cjk సాంప్రదాయ చైనీస్ అత్యంత క్లుప్త శైలి. zh (లోకేల్-పరిమితం: పరిష్కరించబడిన భాష zh అయినప్పుడు మాత్రమే అందించబడుతుంది)

ప్రతి శైలిలో lite, full, ultra అనే మూడు తీవ్రతా స్థాయిలు ఉంటాయి — ప్రతి స్థాయి పంచుకున్న పరిమితుల క్లాజ్తో ముగుస్తుంది; ఇది కోడ్ బ్లాక్లు, ఫైల్ పాత్లు, కమాండ్లు, ఎర్రర్ స్ట్రింగ్లు, URLలు మరియు ఐడెంటిఫైయర్లను యథాతథంగా ఉంచుతుంది.

ఇంజెక్షన్ ఎలా పనిచేస్తుంది

applyOutputStyles() (open-sse/services/compression/outputStyles/apply.ts) ఎంపికను కేటలాగ్తో సరిపోల్చి పరిష్కరిస్తుంది (తెలియని idలు మరియు లోకేల్కు సరిపోని శైలులు తొలగించబడతాయి, ఎప్పుడూ ఎర్రర్ ఏర్పడదు), ఎంచుకున్న సూచనలను కేటలాగ్ క్రమంలో కలుపుతుంది, పరిమితుల క్లాజ్ను ఒక్కసారి జోడిస్తుంది, ఆపై ఫలితాన్ని ఒకే ఐడెంపొటెన్సీ మార్కర్ ([OmniRoute Output Styles]) వెనుక సిస్టమ్ ప్రాంప్ట్ ప్రారంభంలో ఉంచుతుంది — మళ్లీ వర్తింపజేయడం వల్ల ఎలాంటి మార్పూ ఉండదు. గుర్తించిన అభ్యర్థన భాషకు అనువాదం ఉన్నప్పుడు, ఇంగ్లీష్కు బదులుగా స్థానికీకరించిన సూచన చొప్పించబడుతుంది.

ఎలా ప్రారంభించాలి

డ్యాష్బోర్డ్లో: Context → Settings → Compression — ప్రతి శైలికి ఆన్/ఆఫ్ టాగుల్ మరియు స్థాయి సెలెక్టర్తో ఒక వరుస ఉంటుంది. ప్రోగ్రామేటిక్గా, కంప్రెషన్ కాన్ఫిగ్ ఎంపికను ఇలా నిల్వ చేస్తుంది:

{
  "outputStyles": [
    { "id": "i-have-adhd", "level": "full" },
    { "id": "less-code", "level": "lite" }
  ]
}

వెనుకబడిన అనుకూలత: లెగసీ outputMode: "caveman" కాంబో సెట్టింగ్ ఇప్పటికీ పనిచేస్తుంది, terse-proseకు మ్యాప్ అవుతుంది, అలాగే ప్రతి లెగసీ భాషలో పాత ఇంజెక్షన్తో బైట్-స్థాయిలో ఒకేలా ఉంటుంది.

భాష ఎంపిక: languageConfig.enabled ఆన్లో ఉన్నప్పుడు, autoDetect తాజా యూజర్ సందేశపు భాషను ఎంచుకుంటుంది (ఇన్పుట్ ఇంజిన్లు ఉపయోగించే అదే డిటెక్టర్); autoDetectను ఆఫ్ చేయడం ద్వారా defaultLanguage స్థిరపరచబడుతుంది. ఆఫ్ → ఇంగ్లీష్.

శైలి × భాష మ్యాట్రిక్స్ tests/unit/compression/output-styles-i18n-matrix.test.ts ద్వారా స్థిరపరచబడింది: కనీసం pt-BR అనువాదం (లేదా స్పష్టంగా ట్రాక్ చేసిన మినహాయింపు) లేకుండా కొత్త శైలిని విడుదల చేయలేరు, అలాగే ఇప్పటికే ఉన్న శైలి నిశ్శబ్దంగా ఒక లోకేల్ను కోల్పోకూడదు. శైలిని జోడించడానికి, EXTENDING_COMPRESSION.md చూడండి.

టూల్ ఫలితాల కంప్రెషన్

టూల్ ఫలితాల కోసం (ఫంక్షన్ కాల్లు, ఏజెంట్ అవుట్పుట్లు, శోధన ఫలితాలు మొదలైనవి) toolResultCompressor.ts మాడ్యూల్ 5 ప్రత్యేక కంప్రెషన్ వ్యూహాలను అందిస్తుంది:

  1. శోధన ఫలితాల కంప్రెషన్ — అనవసర పునరావృత ఫలితాలను తొలగించి, అగ్ర N ఫలితాలను ఉంచుతుంది
  2. ఫైల్ రీడ్ కంప్రెషన్ — పెద్ద ఫైల్లను కుదించి, హెడర్లు/ఇంపోర్ట్లను సంరక్షిస్తుంది
  3. కోడ్ ఎగ్జిక్యూషన్ కంప్రెషన్ — అవసరమైన stdout/stderrను మాత్రమే ఉంచుతుంది
  4. డేటాబేస్ క్వెరీ కంప్రెషన్ — వరుసలను పరిమితం చేసి, అధిక వివరణాత్మక మెటాడేటాను తొలగిస్తుంది
  5. API రెస్పాన్స్ కంప్రెషన్ — null ఫీల్డ్లను తొలగించి, అరేలను కుదిస్తుంది

ఎప్పుడు ఉపయోగించాలి

టూల్ కాల్లు ఉన్నప్పుడు టూల్ ఫలితాల కంప్రెషన్ ఎల్లప్పుడూ ఆన్లో ఉంటుంది. ఎలాంటి కాన్ఫిగరేషన్ అవసరం లేదు.

స్టాక్డ్ పైప్లైన్

స్టాక్డ్ మోడ్ అనేక ఇంజిన్లను వరుసగా అమలు చేస్తుంది — సాధారణంగా మొదట RTK (టూల్ అవుట్పుట్పై 60-90% ఆదా), ఆపై Caveman (మిగిలిన టెక్స్ట్పై అదనంగా 30% ఆదా). ఇది మొత్తంగా 78-95% ఆదాను సాధిస్తుంది.

ఇది ఎలా పనిచేస్తుంది

ఇన్పుట్ (1000 టోకెన్లు)
  → RTK (కమాండ్-అవేర్ ఫిల్టర్) → 200 టోకెన్లు
    → Caveman (అనవసర పదాల తొలగింపు) → 140 టోకెన్లు
  → అవుట్పుట్ (140 టోకెన్లు, 86% ఆదా)

ఎప్పుడు ఉపయోగించాలి

వీటి కోసం స్టాక్డ్ మోడ్ను ఉపయోగించండి:

  • టూల్లు అధికంగా ఉపయోగించే వర్క్ఫ్లోలు (ఏజెంటిక్ కోడింగ్, పరిశోధన)
  • ఖర్చుకు ప్రాధాన్యమిచ్చే బ్యాచ్ ప్రాసెసింగ్
  • మీకు గరిష్ఠ టోకెన్ ఆదా అవసరమైనప్పుడు

కాంబో ద్వారా కాన్ఫిగర్ చేయండి:

{
  "strategy": "auto",
  "config": {
    "auto": {
      "modePack": "stacked"
    }
  }
}

కాంప్రెషన్ కాంబో ఓవర్రైడ్లు

విభిన్న వినియోగ సందర్భాలకు అనుగుణంగా ప్రవర్తనను సూక్ష్మంగా సర్దుబాటు చేయడానికి గ్లోబల్ కాంప్రెషన్ మోడ్ను ప్రతి కాంబోకు ఓవర్రైడ్ చేయవచ్చు:

{
  "id": "coding-combo",
  "strategy": "priority",
  "config": {
    "auto": {
      "weights": { "taskFit": 0.5 },
      "modePack": "quality-first"
    }
  },
  "compressionOverride": {
    "mode": "aggressive",
    "stackedPipelines": ["rtk", "caveman"],
    "preserveToolDefinitions": true
  }
}

ఇది కింది వాటికి ఉపయోగకరంగా ఉంటుంది:

  • కోడింగ్ కాంబోలు: సుదీర్ఘ సెషన్ల కోసం aggressive మోడ్ను ఉపయోగించండి
  • త్వరిత ప్రశ్నోత్తర కాంబోలు: వేగవంతమైన ప్రతిస్పందనల కోసం lite మోడ్ను ఉపయోగించండి
  • టూల్-ఆధారిత కాంబోలు: గరిష్ఠ ఆదా కోసం stacked మోడ్ను ఉపయోగించండి
  • ప్రొడక్షన్ కాంబోలు: క్యాషింగ్ ప్రొవైడర్ల కోసం cache-aware మోడ్ను ఉపయోగించండి

ఇవి కూడా చూడండి

Reference in New Issue View Git Blame Copy Permalink