100k विंडो में कन्वर्सेशन मेमोरी: बजटिंग, ट्राइमिंग और सारांश
100,000-टोकन विंडो एक लंबे रोलेप्ले या कहानी से भरने तक विशाल लगती है। यह लेख कॉन्टेक्स्ट को एक लेजर के रूप में देखता है: आप जवाब के लिए जगह आरक्षित करते हैं, तथ्यों के एक छोटे से सेट को सुरक्षित रखते हैं, पुराने टर्न्स को एक रोलिंग सारांश में जोड़ते हैं और शेष को काटते हैं। हर कदम के साथ छोटा Python कोड आता है जिसे आप अनुकूलित कर सकते हैं।

अपडेटेडUnfiltered AI
मुख्य बिंदु
- Unfiltered AI जैसे समर्पित इन्फ्रास्ट्रक्चर प्रदाता एकल मॉडल पर बिना सेंसर व्यवस्थापन प्रदान करते हैं, जो एग्रीगेटर रूटिंग की यादृच्छिकता से बचाते हैं।
- OpenRouter जैसे एग्रीगेटर कई मॉडल तक पहुंच प्रदान करते हैं, लेकिन विशिष्ट मॉडल संस्करण के आधार पर वे सामग्री फिल्टर को कितनी सख्ती से लागू करते हैं, इसमें भिन्नता हो सकती है।
- Unfiltered AI एक ओपन-वेट मॉडल का उपयोग करता है जो समर्पित हार्डवेयर पर 100k कॉन्टेक्स्ट विंडो के साथ चलता है, जिसका मूल्य $0.15/$0.50 प्रति मिलियन टोकन है।
- कठोर NSFW या रोलप्ले स्थिरता के लिए, एक समर्पित बिना सेंसर LLM API सामान्य फिल्टर को बायपास करने के लिए जटिल प्रॉम्प्ट इंजीनियरिंग की आवश्यकता समाप्त कर देता है।
विंडो को एक लेजर की तरह सोचें
मॉडल कॉल के बीच कोई मेमोरी नहीं रखता। जो याद करने जैसा लगता है वह आपका टेक्स्ट फिर से भेजना है, और हर रीसेंट टोकन एक लेजर में एक लाइन है जिसका एक कठोर सीलिंग है: 100,000 टोकन, जो प्रॉम्प्ट and जवाब द्वारा साझा की जाती है। प्रॉम्प्ट पर अधिक खर्च करें तो जवाब के लिए कम जगह बचती है; दोनों के लिए बहुत अधिक मांगें तो अनुरोध 400 के साथ अस्वीकृत हो जाता है।
एक काम करने वाला लेजर इस तरह दिखता है। जवाब के लिए 1,500 टोकन रिजर्व करें, क्योंकि वही आप max_tokens के रूप में पास करेंगे। एक अतिरिक्त 3,000 मार्जिन के रूप में रिजर्व करें, क्योंकि कोई भी स्थानीय टोकन गणना एक अनुमान है। इससे प्रॉम्प्ट के लिए बजट के 59,500 टोकन बचते हैं। उस बजट के भीतर, चार प्रकार की सामग्री प्रतिस्पर्धा करती हैं: सिस्टम प्रॉम्प्ट, पिन्ड किए तथ्य, एक रोलिंग सारांश, और वर्बेटो हालिया टर्न्स। इस आर्टिकल का शेष भाग यह तय करने के बारे में है कि कौन जीतता है।
प्राथमिकता क्रम बयान करने के लिए सरल है। सिस्टम और पिन की गई सामग्री कभी काटी नहीं जाती। सारांश काटा नहीं जाता बल्कि बदला जाता है। हाल के टर्न्स पुराने-पहले काटे जाते हैं। हाल के टर्न्स से जो कुछ भी गिरता है वह खोया नहीं जाता, क्योंकि इसे पहले सारांश में फोल्ड किया जाता है।
टोकनाइजर के बिना गिनती
usage गणना का उपयोग करके अपने अनुमानों की जांच करें। अक्षर-प्रति-टोकन शॉर्टकट भाषा, विराम चिह्नों और कोड के साथ बदल सकता है। आउटपुट के लिए जगह छोड़ें और जब अनुमान संयुक्त संदर्भ सीमा के करीब पहुंचें तो इनपुट कम करें।
इसीलिए मार्जिन मौजूद है, और कैलिब्रेट करना फायदेमंद है। प्रत्येक कॉल के बाद, अपने द्वारा भेजे गए अक्षरों की तुलना usage.prompt_tokens से करें और अपने अनुपात को अवलोकित मान की ओर बढ़ाएं। एक छोटा स्मूथिंग फैक्टर एक अजीब संदेश को इसे बाहर नहीं फेंकने देता।
class Calibrator:
"""Learns the real chars-per-token ratio from the usage block."""
def __init__(self):
self.ratio = 4.0
def update(self, sent_messages, prompt_tokens):
chars = sum(len(m["content"]) for m in sent_messages)
if prompt_tokens > 0 and chars > 2000:
observed = chars / prompt_tokens
self.ratio = 0.8 * self.ratio + 0.2 * observed # smooth it
def est(self, text):
return int(len(text) / self.ratio) + 4यदि आप कैलिब्रेटर के est को ट्राइमर में बदलते हैं, तो बजत संवाद के वास्तविक स्वरूप के रूप में उभरने के साथ स्वतः सख्त या ढीला हो जाता है। संवाद और छोटे शब्दों में भारी कहानी वर्णों प्रति टोकन अधिक लागत आती है, इसलिए अवलोकित अनुपात देखने योग्य है।
ट्राइमिंग: नवीनतम पहले, कभी भी मध्य-पेयर में नहीं
हालिया इतिहास को पीछे की ओर देखें और केवल उन संदेशों को जोड़ें जो बजट में फिट बैठते हैं। यदि नवीनतम आदान-प्रदान भी बहुत बड़ा है, तो उसे जानबूझकर ट्रंक करें या अस्वीकार करें। आवश्यक संदर्भ और अनुमत भूमिकाओं को एक मान्य क्रम में रखें; हाल के टर्न चुनना सुसंगत उत्तरों की गारंटी नहीं देता।
# memory.py
WINDOW = 64_000 # prompt + completion share this
MAX_OUT = 1_500 # what we ask for in max_tokens
MARGIN = 3_000 # slack for estimation error
BUDGET = WINDOW - MAX_OUT - MARGIN # 59,500 tokens for the prompt
def est_tokens(text: str) -> int:
# Rough heuristic: about 4 characters per token for English prose.
return len(text) // 4 + 4
def build_messages(system, pinned, summary, turns):
"""Return (messages_to_send, dropped_turns). turns is oldest-first."""
head = [{"role": "system", "content": system}]
if pinned:
head.append({"role": "system", "content": "Pinned facts (always true):\n- " + "\n- ".join(pinned)})
if summary:
head.append({"role": "system", "content": "Story so far: " + summary})
used = sum(est_tokens(m["content"]) for m in head)
kept = []
for m in reversed(turns): # walk from the newest turn backwards
cost = est_tokens(m["content"])
if used + cost > BUDGET:
break
kept.append(m)
used += cost
kept.reverse()
while kept and kept[0]["role"] != "user": # never start on an orphaned assistant turn
kept.pop(0)
dropped = turns[: len(turns) - len(kept)]
return head + kept, droppedफ़ंक्शन दो चीजें लौटाता है: भेजने के लिए संदेश और बाहर निकल गए टर्न्स। गिरे हुए टर्न्स को लौटाना, उन्हें फेंकने के बजाय, वह डिज़ाइन निर्णय है जो सारांशों को संभव बनाता है। कुछ भी चुपचाप डिलीट नहीं होता।
पिन करना तथ्यों को जो टिके रहना चाहिए
सारांश प्रकृति से हानिपूर्ण होता है। अक्षर तथ्य जो कभी विचलित नहीं होने चाहिए, जैसे कोई नाम, कोई रहस्य, कोई वादा या दुनिया का नियम, इस बात पर निर्भर नहीं होने चाहिए कि सारांशकार उन्हें रखना चुनता है या नहीं। इन्हें इतिहास के बाहर एक छोटी सूची के रूप में स्टोर करें और प्रत्येक कॉल पर एक समर्पित सिस्टम संदेश के रूप में इंजेक्ट करें।
- पहचान पिन करें: नाम, रिश्ते, प्रजाति, आयु (केवल वयस्क), व्यवसाय।
- सीमाएं पिन करें: बातें जो नैरेटर को नहीं करनी चाहिए या अभी तक नहीं बतानी चाहिए।
- स्थिति पिन करें जो दुर्लभ बदलती है: स्थान, मौसम, कब क्या रखता है।
- वातावरण पिन न करें। मूड सारांश में होता है, जहां यह विकसित हो सकता है।
पिन किए गए ब्लॉक को लगभग 400 टोकन से नीचे रखें। यदि यह उससे बढ़ जाता है, तो यह एक दूसरा सिस्टम प्रॉम्प्ट की तरह व्यवहार करने लगता है और मॉडल हर पिन की गई पंक्ति को समान रूप से ज़रूरी मानने लगता है। सूची की समीक्षा कभी-कभी करें और उन तथ्यों को सेवानिवृत्त करें जो सत्य नहीं रहे हैं।
रोलिंग सारांश
जब टर्न्स विंडो से बाहर निकलते हैं, तो मॉडल से उनमें से एक मौजूदा सारांश में फोल्ड करने के लिए कहें। प्रॉम्प्ट कोड से अधिक मायने रखता है: इसे बताएं कि क्या रखना है (कौन उपस्थित है, क्या बदला, वादे, अनसुलझे धागे, वर्तमान स्थान) और क्या छोड़ना है (अनावश्यक शब्द, दोहराई गई विवरण), और शब्दों में लंबाई को कैप करें। एक कैप सारांश को धीरे-धीरे उसी समस्या में नहीं बढ़ने देता है जिसे यह हल करता है।
import os
from openai import OpenAI
client = OpenAI(base_url="https://api.unfilteredaiapi.com/v1", api_key=os.environ["API_KEY"])
SUMMARY_PROMPT = (
"Compress the material below into a running summary of at most 250 words. "
"Keep: who is present, what changed, promises and secrets, unresolved threads, "
"the current location and mood. Drop: filler and repeated description. "
"Write plain past-tense prose, no bullet points."
)
def fold_into_summary(old_summary, dropped_turns):
transcript = "\n".join(f"{m['role']}: {m['content']}" for m in dropped_turns)
user = f"Existing summary:\n{old_summary or '(none)'}\n\nNew material:\n{transcript}"
r = client.chat.completions.create(
model="uncensored",
messages=[{"role": "system", "content": SUMMARY_PROMPT}, {"role": "user", "content": user}],
temperature=0.2,
max_tokens=450,
)
return r.choices[0].message.content.strip()एक कम तापमान का उपयोग करें। एक सारांश वफादार होना चाहिए, आविष्कारक नहीं। एक सस्ता सुरक्षा कवच हर बीस या इससे अधिक फोल्ड्स के दौरान स्वयं सारांश पढ़ना है; त्रुटियां संचित होती हैं क्योंकि प्रत्येक नया सारांश पिछले पर बनाया गया है।
टुकड़ों को एक साथ रखना
नीचे दी गई क्लास ट्रिमिंग, पिनिंग और सारांश को एक लूप में जोड़ती है। प्रत्येक कॉल प्रॉम्प्ट बनाती है, जांचती है कि क्या कुछ छोड़ा गया था, यदि ऐसा होता है तो उसे सारांश में फोल्ड करती है, और फिर से बनाती है। नियम जानबूझकर लेज़ी है: यह केवल तभी सारांश बनाता है जब विंडो उसे फोर्स करती है, इसलिए छोटी बातचीत कभी सारांश कॉल के लिए भुगतान नहीं करती।
from memory import build_messages, fold_into_summary, client, MAX_OUT
class Conversation:
def __init__(self, system, pinned):
self.system, self.pinned = system, pinned
self.summary, self.turns = "", []
def say(self, text):
self.turns.append({"role": "user", "content": text})
messages, dropped = build_messages(self.system, self.pinned, self.summary, self.turns)
if dropped: # something fell out of the window
self.summary = fold_into_summary(self.summary, dropped)
self.turns = self.turns[len(dropped):]
messages, _ = build_messages(self.system, self.pinned, self.summary, self.turns)
r = client.chat.completions.create(
model="uncensored", messages=messages, max_tokens=MAX_OUT, temperature=0.8
)
answer = r.choices[0].message.content
self.turns.append({"role": "assistant", "content": answer})
return answer
convo = Conversation(
system="You narrate a slow-burn adult mystery set in a mountain hotel.",
pinned=["Ines Duarte is the night manager and is lying about the ledger.",
"It is the third night of the blizzard; the road is closed.",
"The narrator never reveals the culprit before the player accuses someone."],
)
print(convo.say("I ask Ines why the guest book has a page missing."))यह FastAPI बैकएंड आर्टिकल में स्ट्रीमिंग रिले के साथ स्वाभाविक रूप से जुड़ता है, जहाँ सेशन स्टोर summary, pinned और turns को एक समतल सूची के बजाय संग्रहीत करेगा। उसी पैटर्न पर संरचित NPC स्थिति के लिए, गेम डायलॉग गाइड देखें।
याद रखने की लागत
लंबी मेमोरी मुफ़्त नहीं है, क्योंकि पूरा प्रॉम्प्ट हर कॉल पर फिर से बिल किया जाता है। दो सेटअप मानें। पहले में, इतिहास 50,000 प्रॉम्प्ट टोकन भरने की अनुमति देता है और प्रत्येक जवाब 500 टोकन है। इनपुट लागत 50,000 x $0.15 / 1,000,000 = $0.0075, आउटपुट लागत 500 x $0.50 / 1,000,000 = $0.00025, इसलिए प्रत्येक टर्न की लागत लगभग $0.00775 है। दूसरे में, आप हाल के टर्न्स के 8,000 टोकन plus एक 600-टोकन सारांश और 400 पिन्ड टोकन रखते हैं, कुल मिलाकर लगभग 9,000। इनपुट $0.00225, आउटपुट $0.00025, इसलिए प्रत्येक टर्न लगभग $0.0028 है।
1,000 से अधिक टर्न्स, यानी लगभग $13 बनाम $2.75 इन मान्यताओं के तहत। सारांश दृष्टिकोण का भी कभी-कभी एक अतिरिक्त कॉल लगता है, शायद 3,000 इनपुट टोकन और 450 आउटपुट टोकन, जो लगभग $0.0012 है, जो बचत के मुकाबले नगण्य है। दरें मूल्य निर्धारण पृष्ठ पर हैं।
व्यावहारिक सलाह: विंडो को भरें नहीं क्योंकि वह वहां है। विंडो को एक बीमा के रूप में उपयोग करें उन क्षणों के लिए जहां एक दृश्य वास्तव में लंबे वर्बेटो कॉन्टेक्स्ट की आवश्यकता होती है, और शेष को सारांशों को लेने दें।
जहां मेमोरी स्कीम धीरे-धीरे विफल होती हैं
तीन विफलता पैटर्न बार-बार सामने आते हैं। पहला है summary drift: एक विवरण को पुनर्लिखित किया जाता है, उस पुनर्लेखन का सारांश फिर से बनाया जाता है, और एक दर्जन बार इस प्रक्रिया को दोहराने के बाद मूल तथ्य पहचानने योग्य नहीं रहता। पिन करना उस हर चीज़ के लिए समाधान है जिसे आप खो नहीं सकते, और एक कठोर शब्द सीमा यह सुनिश्चित करती है कि सारांश सब कुछ अवशोषित न कर ले।
दूसरा है the cliff। शुद्ध ट्रिम और बिना सारांश के, सबसे पुराना टर्न बस गायब हो जाता है और किरदार अचानक कुछ ऐसा भूल जाता है जिसे वह एक पल पहले जानता था। उपयोगकर्ता इसे नोटिस करते हैं। विंडो के पास पहुँचने से एक कदम पहले सारांशकर्ता को चलाना, उदाहरण के लिए जब प्रॉम्प्ट बजट का 80 प्रतिशत से अधिक हो जाता है, संक्रमण को सहज बनाता है।
तीसरा है role confusion after trimming, जब इतिहास आदान-प्रदान के बीच में शुरू हो जाता है। ट्रिम्मर में लीडिंग-एसिस्टेंट चेक इसी के लिए मौजूद है। एक परीक्षण जोड़ें जो एक लंबी नकली बातचीत बनाता है, उसे ट्रिम करता है, और पुष्टि करता है कि पहला संरक्षित संदेश उपयोगकर्ता का है और अनुमानित कुल बजट से कम रहता है। इसमें पाँच मिनट लगते हैं और यह एक बग की श्रेणी को रोकते हैं जो मैनुअल प्ले में खोजना मुश्किल होता है।
प्रश्न और उत्तर
यदि प्रॉम्प्ट plus max_tokens 100,000 से अधिक हो जाता है तो क्या होता है?
अनुरोध अस्वीकृत नहीं होता: max_tokens विंडो में उपलब्ध स्थान के अनुसार कम कर दिया जाता है, और उत्तर विंडो के अंत पर समाप्त हो जाता है। केवल 100,000 टोकन से अधिक लंबा प्रॉम्प्ट 400 bad request लौटाता है।
क्या मैं अनुरोध से पहले टोकन को सटीक रूप से गिन सकता हूँ?
अग्रिम रूप से सटीक रूप से नहीं। स्थानीय रूप से अनुमान लगाएँ, सुरक्षा मार्जिन रखें और प्रत्येक प्रतिक्रिया के साथ लौटाए गए usage.prompt_tokens मान के विरुद्ध कैलिब्रेट करें।
मुझे कितनी बार सारांश बनाना चाहिए?
केवल तब जब बातचीत की टर्न्स कॉन्टेक्स्ट विंडो से बाहर निकल जाएं। इससे छोटी बातचीत अतिरिक्त कॉल से मुक्त रहती है।
पिन किए गए तथ्य और सारांश के लिए शुल्क लगता है?
हाँ। प्रॉम्प्ट टोकन के रूप में भेजी गई हर चीज़ पर प्रत्येक अनुरोध के लिए प्रति मिलियन इनपुट टोकन $0.15 की दर से शुल्क लगता है, इसलिए दोनों को संक्षिप्त रखें।
आपकी कुंजी बस एक फ़ॉर्म दूर है
एक खाता बनाएं, कुंजी कॉपी करें, बेस URL बदलें। यही पूरी सेटअप है।