लागत कम करने के लिए चैट इतिहास ट्रिम करें: स्लाइडिंग विंडो या सारांश

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

DeepSeek की मल्टी-राउंड चैट गाइड (api-docs.deepseek.com, 1 नवंबर 2026 को जाँचा गया) स्पष्ट रूप से कहती है: सर्वर पिछले अनुरोधों का संदर्भ रिकॉर्ड नहीं करता, इसलिए क्लाइंट हर कॉल पर पूरी messages सूची भेजता है। CheapTokens पर OpenAI-संगत प्रारूप उसी तरह काम करता है। यदि यह आपके लिए नया है, तो लंबी चैट अधिक महंगी क्यों होती है और messages ऐरे कैसे काम करता है से शुरू करें।

टर्न 50 वास्तव में क्या भेजता है#

मान लें कि आप 400-टोकन सिस्टम प्रॉम्प्ट वाला सपोर्ट बॉट चलाते हैं। एक सामान्य टर्न में उपयोगकर्ता लगभग 60 टोकन लिखता है और बॉट लगभग 190 टोकन का उत्तर देता है। एक पूरा टर्न इतिहास में 250 टोकन जोड़ता है। ये अनुमान हैं: इन्हें अपने स्वयं के प्रतिक्रियाओं के usage फ़ील्ड की संख्याओं से बदलें।

टर्न 50 पर अनुरोध में सिस्टम प्रॉम्प्ट, 49 पिछले टर्न और नया संदेश होता है: 400 + 49 × 250 + 60 = 12,710 इनपुट टोकन, 190-टोकन उत्तर पाने के लिए। पूरी चैट जोड़ें। सिस्टम प्रॉम्प्ट और नया संदेश हर बार भेजे जाते हैं: 50 × 460 = 23,000। दोहराया गया इतिहास 250 × 1,225 = 306,250 जोड़ता है। कुल मिलाकर: 23,000 + 306,250 = 329,250 इनपुट टोकन, बनाम 50 × 190 = 9,500 आउटपुट टोकन।

प्रत्येक अनुरोध में इतिहास एक टर्न बढ़ता है, इसलिए कुल चैट लंबाई के वर्ग के साथ बढ़ता है। 50 से 100 टर्न पर जाएँ और दोहराया-इतिहास वाला हिस्सा लगभग चार गुना हो जाता है।

विकल्प 1: एक स्लाइडिंग विंडो#

विचार: हमेशा सिस्टम प्रॉम्प्ट भेजें, अंतिम N टर्न को छोड़कर सब कुछ हटा दें। आप अपने स्वयं के स्टोरेज में पूरा इतिहास रखते हैं और केवल भेजी जाने वाली प्रति को ट्रिम करते हैं।

def trim_history(messages, keep_pairs=4):
    """System prompt + the last keep_pairs turns + the new user message."""
    system = [m for m in messages if m["role"] == "system"]
    rest = [m for m in messages if m["role"] != "system"]
    return system + rest[-(keep_pairs * 2 + 1):]

उपयोगकर्ता का नया संदेश जोड़ने के बाद इसे कॉल करें। keep_pairs=4 के साथ यह 4 उपयोगकर्ता/सहायक जोड़े और नया संदेश, 9 संदेश हैं, और स्लाइस हमेशा एक उपयोगकर्ता संदेश से शुरू होता है। यहाँ इसे एक वास्तविक कॉल में जोड़ा गया है:

import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.cheaptokens.dev/v1",
    api_key=os.environ["CHEAPTOKENS_API_KEY"],
)
MODEL = "deepseek-ai/DeepSeek-V4-Flash-0731"

history = [{"role": "system", "content": "You are a concise support assistant."}]

def ask(text):
    history.append({"role": "user", "content": text})
    resp = client.chat.completions.create(
        model=MODEL,
        messages=trim_history(history),
        max_tokens=500,
    )
    answer = resp.choices[0].message.content
    history.append({"role": "assistant", "content": answer})
    print(resp.usage.prompt_tokens, resp.usage.completion_tokens)
    return answer

print पंक्ति उपयोगी है: पहली संख्या देखें। ट्रिमिंग के बिना यह हर टर्न बढ़ती है। विंडो के साथ यह चैट के टर्न 4 पार करने के बाद बढ़ना बंद कर देती है।

संख्याओं में: टर्न 5 से, प्रत्येक अनुरोध 400 + 4 × 250 + 60 = 1,460 इनपुट टोकन है। पहले चार टर्न सामान्य रूप से बढ़ते हैं और 3,340 तक जोड़ते हैं। पूरी चैट: 3,340 + 46 × 1,460 = 70,500 इनपुट टोकन, पूर्ण इतिहास के साथ भेजे गए 329,250 का लगभग पाँचवाँ हिस्सा। आउटपुट 50 × 190 = 9,500 रहता है।

कोड में, पूरा परिवर्तन कॉल में एक तर्क है:

messages=history

messages=trim_history(history)

पकड़: एक विंडो भूल जाती है। यदि उपयोगकर्ता टर्न 40 पर पूछता है "मेरा ऑर्डर नंबर क्या था?" और नंबर टर्न 3 में था, तो मॉडल ने इसे कभी नहीं देखा है। दो सस्ते समाधान। स्थिर तथ्यों (नाम, ऑर्डर नंबर, योजना) को अपने कोड में चैट से निकालें और उन्हें सिस्टम प्रॉम्प्ट में जोड़ें, जहाँ विंडो उन्हें कभी नहीं काटती। या एक सारांश जोड़ें, जो अगला विकल्प है।

विकल्प 2: पुराने टर्न का सारांश#

पुराने टर्न को छोड़ने के बजाय, आप उन्हें संपीड़ित करते हैं। हर कुछ टर्न पर, विंडो से बाहर निकले टर्न और वर्तमान सारांश को मॉडल को भेजें और एक नया, संक्षिप्त सारांश माँगें। फिर उस सारांश को सिस्टम संदेश में डालें।

def summarize(summary, old_messages):
    transcript = "\n".join(f"{m['role']}: {m['content']}" for m in old_messages)
    prompt = (
        f"Summary so far:\n{summary}\n\nNew turns:\n{transcript}\n\n"
        "Rewrite the summary in under 200 words. "
        "Keep names, numbers, decisions and open questions."
    )
    resp = client.chat.completions.create(
        model=MODEL,
        messages=[{"role": "user", "content": prompt}],
        max_tokens=400,
    )
    return resp.choices[0].message.content

def build_messages(history, summary, keep_pairs=4):
    system = history[0]["content"]
    if summary:
        system += "\n\nEarlier in this chat: " + summary
    recent = history[1:][-(keep_pairs * 2 + 1):]
    return [{"role": "system", "content": system}] + recent

सारांश मुफ़्त नहीं है: यह एक अतिरिक्त मॉडल कॉल है। मान लें कि सारांश लगभग 300 टोकन का है, हर 5 टर्न पर रीफ़्रेश होता है (50 टर्न में 9 बार), प्रत्येक रीफ़्रेश लगभग 1,600 टोकन पढ़ता है (पुराना सारांश प्लस पाँच टर्न प्लस निर्देश) और 300 लिखता है। सुरक्षित पक्ष पर रहने के लिए, टर्न 5 से प्रत्येक अनुरोध में सारांश गिनें (वास्तव में यह पहले रीफ़्रेश के बाद दिखाई देता है, इसलिए यह थोड़ा अधिक अनुमान है): 400 + 300 + 4 × 250 + 60 = 1,760 इनपुट टोकन।

चैट के लिए कुल: मुख्य अनुरोध 3,340 + 46 × 1,760 = 84,300 इनपुट टोकन, सारांश कॉल 9 × 1,600 = 14,400 इनपुट और 9 × 300 = 2,700 आउटपुट। कुल मिलाकर 84,300 + 14,400 = 98,700 इनपुट और 9,500 + 2,700 = 12,200 आउटपुट टोकन।

सारांश खाली विंडो से थोड़ा अधिक खर्च करता है, और बदले में मॉडल अभी भी जानता है कि टर्न 3 में क्या हुआ था।

तीनों सेटअप की लागत#

यहाँ DeepSeek-V4-Flash पर वही 50-टर्न चैट है, ऊपर के योगों से लाइव मूल्य निर्धारित:

कीमतें लाइव मूल्य सूची से आती हैं, इसलिए टैरिफ बदलने पर संख्याएँ अपडेट होती हैं। क्रम नहीं बदलेगा: विंडो सबसे कम भेजती है, सारांश बीच में है, पूर्ण इतिहास सबसे महंगा है।

इस तरह की चैट के लिए, शुरू करने के लिए CheapTokens मॉडल DeepSeek-V4-Flash है। इसमें 380K संदर्भ विंडो है (50-टर्न चैट बिना ट्रिम किए भी फिट हो जाती है), प्रति उत्तर अधिकतम 32,768 आउटपुट टोकन, दिन के किसी भी समय एक निश्चित मूल्य, और कुल मिलाकर, इनपुट और आउटपुट को एक साथ गिनते हुए, यह OpenRouter से सस्ता है। मॉडल आईडी deepseek-ai/DeepSeek-V4-Flash-0731 है। यदि आप विंडो सेटअप पर मॉडल की तुलना करना चाहते हैं (प्रति अनुरोध औसतन 1,410 इनपुट टोकन, 190 आउटपुट, 50 अनुरोध), तो यहाँ लाइव तालिका है:

GLM-5.3-Flash में 390K संदर्भ है और MiniMax-M2.7 में 180K है, जो ट्रिम की गई चैट के लिए पर्याप्त है। वर्तमान कीमतें मूल्य निर्धारण पृष्ठ पर हैं, और दस्तावेज़ दिखाते हैं कि पहला अनुरोध कैसे भेजें।

किसे चुनें#

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