Skip to content

सरल मेमोरी सिस्टम: Jev को तय करने दें कि क्या याद रखना है ​

💡 एक वाक्य में सारांश: Jev से एक AI मेमोरी सिस्टम बनाएं — एक Noul गेट तय करता है कि क्या याद रखना है, मेमोरी एक साधारण Python डिक्शनरी में सेव होती है, और कॉल से पहले अपने आप state में मिल जाती है।

हर Jev अनुरोध केवल वही state देखता है जो आप उसे भेजते हैं। ग्राहक ने पिछले महीने आपको जो बताया था — कौन सा वर्शन, कौन सा प्लान, कॉन्ट्रैक्ट हुआ या नहीं — वह अगले अनुरोध में नहीं होता, जब तक आपका कोड उसे वहां न डाले।

आधिकारिक cookbook (Simple memory system) का तरीका बिल्कुल सीधा है: हर कॉल पर एक अतिरिक्त Jev अनुरोध, और एक Python डिक्शनरी।

इसका उदाहरण परिदृश्य सपोर्ट टिकट रूटिंग है। 8वें महीने, ग्राहक कहता है कि वे Windows Server पर सेल्फ-होस्टेड हैं; 9वें महीने, वे लिखते हैं «Dashboards have been really slow since this morning»। मेमोरी के बिना, Jev यह टिकट क्लाउड टीम को भेजता है; मेमोरी के साथ, छह बाद के टिकट सभी अपेक्षित टीम पर रूट होते हैं — हर टिकट अलग से रूट होता है, जिनमें केवल तीन में मेमोरी काम आती है।

यह AI मेमोरी सिस्टम केवल दो हिस्सों का है:

  • कॉल के बाद: Jev मूल अनुरोध और अपना उत्तर देखकर एक Noul का उत्तर देता है — आधिकारिक रूप से इसे the gate (गेट) कहते हैं: क्या इस अनुरोध ने याद रखने लायक कोई ग्राहक तथ्य बताया है? P(yes) ≥ 0.5 होने पर, टिकट अपने उत्तर समेत उस ग्राहक की मेमोरी के रूप में सेव हो जाता है
  • कॉल से पहले: उस ग्राहक के सेव किए गए टिकट (Jev उत्तरों सहित) state में जोड़े जाते हैं — ask_with_memory() में लिपटे हुए, पैरामीटर और रिटर्न वैल्यू ask() जैसे ही
text
ask_with_memory(state, questions)
      │
      ▼  ① state + उस ग्राहक की सेव की गई मेमोरी (न हो तो वैसा ही भेजें)
  Jev अनुरोध 1: आपके सवालों के उत्तर देता है (इस उदाहरण में: यह टिकट कौन सी टीम लेगी)
      │  ② मूल अनुरोध + Jev का उत्तर, एक जोड़ी में
      ▼
  Jev अनुरोध 2: गेट (एक Noul) — क्या इस अनुरोध ने याद रखने लायक कोई ग्राहक तथ्य बताया है?
      │
      ▼  ③ P(yes) ≥ REMEMBER_AT (0.5)? — यह आपका कोड तय करता है
 हां ──┤── नहीं ──┐
 ▼               │
 MEMORIES में सेव    │
 (हर ग्राहक ID के लिए एक सूची)
 └──────┬────────┘
        ▼
  ④ अनुरोध 1 का उत्तर वैसा ही लौटाया जाता है, आपका कोड हमेशा की तरह काम करता है
        ↺  सेव की गई मेमोरी उस ग्राहक के अगले अनुरोध में जाती है (① पर वापस)

ask_with_memory() यह रैपर फंक्शन ही एक न्यूनतम agent harness है। आधिकारिक परिभाषा: harness मॉडल के चारों ओर ऐसा कोड है जो उसे अतिरिक्त क्षमताएं (tool calls, लूप में चलाना) देता है। इस पेज का harness केवल मेमोरी देता है — साधारण Python डिक्शनरी, हर ग्राहक ID के लिए एक सूची। मॉडल को tool calls देने वाला harness देखने के लिए पिछला पाठ Agent निर्णय देखें।

यह पाठ लगभग 15 मिनट का है। पेज के सभी आंकड़े आधिकारिक cookbook की रिकॉर्ड की गई डेटा से हैं (jev-1.14.0, 2026-10-29): आधिकारिक रिकॉर्डिंग फाइल में डुप्लिकेट हटाने के बाद 31 कॉल, कुल 21,456 इनपुट टोकन — $42/Btok और आउटपुट मुफ्त के हिसाब से लगभग $0.0009। रिकॉर्डिंग फाइल आधिकारिक रिपॉजिटरी के साथ जारी होती है, बिना key के भी रिप्ले करके जांची जा सकती है।

सीखने के बाद आप क्या कर सकेंगे ​

  • किसी भी «Jev निर्णय + ग्राहक इतिहास» वाले सिस्टम में मेमोरी जोड़ें: कॉल के बाद एक Noul गेट तय करता है कि याद रखना है या नहीं, कॉल से पहले सेव की गई मेमोरी state में मिलती है — ask_with_memory() और ask() समान पैरामीटर, समान रिटर्न वैल्यू, बदलने पर बाकी कोड में कुछ बदलने की जरूरत नहीं
  • «क्या याद रखना है» को बिखरे हुए नियमों की जगह एक स्पष्ट प्रश्न (GATE) बनाएं: वर्शन, प्लान, कॉन्ट्रैक्ट जैसे स्थायी तथ्य 0.96–0.98 पर सेव होते हैं; एयरपोर्ट फोन, पब्लिक हॉलिडे 0.02, 0.03 सेव नहीं होते
  • आधिकारिक टेस्ट खुद दोहराएं: एक ही «डैशबोर्ड बहुत धीमा है», बिना मेमोरी Jev इसे क्लाउड टीम को रूट करता है 0.55, मेमोरी के साथ यह Windows सेल्फ-होस्टेड टीम पर पहुंचता है 0.98 — छह बाद के टिकट 3/6 से 6/6
  • इस सिस्टम की पांच सीमाएं समझाएं (हर कॉल पर दो क्रमिक अनुरोध, मेमोरी केवल बढ़ती है घटती नहीं……), और जानें मेमोरी अपग्रेड के लिए आधिकारिक अगला कदम (प्रासंगिकता से चुनना, पुरानी मेमोरी बदलना, डेटाबेस बदलना)

Jev का उपयोग क्यों करें, न कि पूरा इतिहास prompt में भरने का? ​

क्षमतापूरा इतिहास prompt में भरना / चैट मॉडल को खुद याद रखने देनाJev गेट मेमोरी
क्या याद रखना है, इसका फैसला कौन करता है❌ पूरा इतिहास स्टोर में डालना: एयरपोर्ट वाला फ़ोन, सार्वजनिक छुट्टियाँ भी context पर कब्ज़ा करती हैं; चैट मॉडल की याददाश्त: क्या याद रखना है मॉडल के मूड पर निर्भर, और आउटपुट की समीक्षा भी नहीं हो सकती✅ एक Noul गेट प्रायिकता देता है: जो याद रखने योग्य है वह 0.96–0.98, जो नहीं है वह ≤ 0.04, और थ्रेशोल्ड आपके कोड में रहता है
क्या प्रायिकता पर भरोसा किया जा सकता है❌ मॉडल से अपनी निश्चितता को टेक्स्ट में लिखवाना, फिर parsing में गलती न होने की प्रार्थना करना✅ RLCD कैलिब्रेशन ट्रेनिंग: प्रायिकता वास्तविक परिणामों के साथ अलाइन है, इसीलिए P ≥ 0.5 वाली यह रेखा अर्थपूर्ण है
इतिहास लंबा होने के बाद❌ हर अनुरोध पूरा इतिहास ढोता है, token टिकटों की संख्या के साथ रैखिक रूप से बढ़ते हैं✅ केवल गेट पार करने वाले टिकट ही मेमोरी में जाते हैं, state «याद रखने लायक तथ्यों» के साथ बढ़ता है; हर कॉल में ठीक एक अतिरिक्त गेट अनुरोध जुड़ता है
मौजूदा कोड में जोड़ना❌ prompt टेम्पलेट बदलना, कॉल चेन बदलना✅ ask_with_memory() के पैरामीटर और रिटर्न वैल्यू ask() जैसे ही हैं——आधिकारिक शब्दों में: इसे लगाने के लिए बाकी कोड बदलने की ज़रूरत नहीं
गेट क्या देखता है❌ मॉडल के उत्तर को भी याद रखना: सामान्य उत्तर अनुरोध के असली तथ्यों को दबा देंगे✅ केवल अनुरोध में ग्राहक/सहायता कर्मी द्वारा लिखे गए शब्द गिने जाते हैं; केवल उत्तर में आने वाले तथ्य स्टोर नहीं होते

आपकी मौजूदा दुविधा ​

  • «ग्राहक ने 8 महीने यानी अगस्त में साफ़ कह दिया था कि वे Windows Server पर self-hosted हैं, 9 महीने यानी सितंबर में डैशबोर्ड धीमा हुआ तो टिकट फिर क्लाउड टीम को भेज दिया गया——ग्राहक को हर बार अपना environment शुरू से दोहराना पड़ता है»
  • «चैट मॉडल से «ग्राहक की जानकारी याद रखने» में मदद मांगी, लेकिन वह जो याद रखकर लाता है उसकी समीक्षा नहीं हो सकती: कभी «आज एयरपोर्ट पर फ़ोन से किया गया» को भी दीर्घकालिक तथ्य मान लेता है, कभी अपने पिछले राउंड के अनुमान को फिर से याद रख लेता है»
  • «पूरा ऐतिहासिक टिकट इतिहास हर अनुरोध में ठूँसने की कोशिश की: token लगातार जलते गए, और राउटिंग बिल्कुल अप्रासंगिक पुराने टिकटों से भटक गई»

यह तरीका कब अपनाएँ ​

जब आपको चाहिए:

  • आपका सिस्टम पहले से Jev से निर्णय लेता है (राउटिंग, वर्गीकरण, सत्यापन), और निर्णय की गुणवत्ता इस पर निर्भर है कि «यह ग्राहक कौन है»——संस्करण, ऑपरेटिंग सिस्टम, पैकेज, अनुबंध, दीर्घकालिक प्राथमिकताएँ
  • «क्या याद रखना है» एक स्पष्ट लिखित प्रश्न और एक स्पष्ट थ्रेशोल्ड है——इंसान समीक्षा कर सकता है, वर्ज़न कंट्रोल में रख सकता है, कभी भी दोबारा तय कर सकता है
  • हर ग्राहक की अपनी अलग मेमोरी, नए कॉल में अपने आप जुड़ जाती है, प्रश्न में एक शब्द भी बदलने की ज़रूरत नहीं

और आप नहीं चाहते:

  • पूरा इतिहास हर अनुरोध में ठूँसना, token इतिहास के साथ रैखिक रूप से बढ़ते जाएँ
  • चैट मॉडल को «याद रखने» के लिए स्वतंत्र छूट देना, फिर उसके थूके गए टेक्स्ट को parse करना
  • इसके लिए एक पूरा embedding-retrieval पाइपलाइन घुसाना——मेमोरी बड़ी होने पर ही ज़रूरत होती है (एडवांस्ड टिप्स देखें)

🎒 शुरू करने से पहले की तैयारी ​

  • पूरा कर लिया Noul हाँ/ना प्रश्न: गेट एक Noul है——0–1 प्रायिकता कैसे पढ़ें, थ्रेशोल्ड कैसे सेट करें, इस पेज पर सीधे उपयोग होता है
  • जानते हैं कि state वह सब है जो Jev देखता है: मेमोरी केवल state में जुड़ी एक कुंजी है, प्रश्न को उसके साथ बदलने की ज़रूरत नहीं
  • सफलतापूर्वक चला लियाइंस्टॉलेशन और पहला अनुरोध: .venv में typesafe-sdk है, TYPESAFE_API_KEY environment variables में है
  • आधिकारिक रिकॉर्डेड कैश डाउनलोड करें: typesafe-public-examples रिपॉज़िटरी के cookbooks/basic_memory डायरेक्टरी के नीचे json_cache.json, इसे रन डायरेक्टरी में रखें——आधिकारिक कोड को जस का तस चलाएँ, एक key भी नहीं चाहिए; इसे हटा दें तो सब वास्तविक कॉल से चलेगा
  • लागत की ऊपरी सीमा जानें: आधिकारिक रिकॉर्डिंग में डुप्लिकेट हटाने के बाद 31 कॉल, 21,456 इनपुट token, $42/Btok के हिसाब से लगभग $0.0009, आउटपुट मुफ़्त——दरें देखेंमॉडल और कीमतें

मेरे साथ करें ​

चरण 1: environment, आधिकारिक कैश और पाँच शुरुआती टिकट तैयार करें ​

क्यों: मेमोरी सिस्टम को दो तरह के टिकट चाहिए——स्थायी तथ्य बताने वाले शुरुआती टिकट (याद रखने योग्य), और केवल तात्कालिक बातें कहने वाले बाद के संदेश (मेमोरी काम आती है)। आधिकारिक डेटा पूरी तरह इस उदाहरण के लिए हाथ से लिखा गया है: 2 ग्राहक, 5 शुरुआती टिकट, 3 बाद के संदेश।

डायरेक्टरी बनाएँ, आधिकारिक रिकॉर्डेड कैश डाउनलोड करें, dependencies इंस्टॉल करें:

bash
mkdir jev-memory && cd jev-memory
curl -sLO https://raw.githubusercontent.com/typesafe-ai/typesafe-public-examples/main/cookbooks/basic_memory/json_cache.json
pip install ipython 'cooksafe>=0.2.0,<0.3.0' typesafe-sdk

आधिकारिक pip लाइन में मूल रूप से typesafe-sdk नहीं था (डॉक्यूमेंटेशन प्लेटफ़ॉर्म पर पहले से इंस्टॉल है), यहाँ जोड़ दिया गया है।

Setup सेल (आधिकारिक रूप में; make_playground_link और display केवल अंतिम Playground सेल में उपयोग होते हैं):

python
import json
import os
from pathlib import Path

from cooksafe import JsonCache, make_playground_link
from IPython.display import Markdown, display
from typesafe_sdk import Choice, Noul, NoulCriteria, SystemOneResponse, TypeSafeClient

TYPESAFE_MODEL = "jev-1.14.0"
REMEMBER_AT = 0.5  # save when P(lasting customer fact) reaches this starting threshold
MEMORY_KEY = "earlier_tickets_from_this_customer"  # where saved tickets go in the state

client = TypeSafeClient(
    api_key=os.environ.get("TYPESAFE_API_KEY", "cache-only"),  # keyless kernels replay the cache
    base_url=os.environ.get("TYPESAFE_ENDPOINT"),
    timeout=120.0,
)
json_cache = JsonCache(Path("json_cache.json"))

तीन constants अलग-अलग काम संभालते हैं: TYPESAFE_MODEL संस्करण पिन करता है (आधिकारिक रिकॉर्डेड आँकड़े jev-1.14.0 का उपयोग करते हैं); REMEMBER_AT = 0.5 गेट का वह शुरुआती थ्रेशोल्ड है जिससे ऊपर मेमोरी स्टोर होती है; MEMORY_KEY वह कुंजी का नाम है जिसके तहत मेमोरी state में रखी जाती है। "cache-only" key के लिए आधिकारिक डिफ़ॉल्ट मान है——कैश हिट होने पर कोई अनुरोध भेजा ही नहीं जाता, बिना key के भी इस पेज के सारे आँकड़े पुन:प्रस्तुत किए जा सकते हैं।

दो ग्राहक, पाँच शुरुआती टिकट, तीन बाद के संदेश (आधिकारिक DATA जस का तस; expected_team को मानव द्वारा ग्राहक के शुरुआती टिकटों में कहे गए शब्दों के आधार पर चिह्नित किया गया है):

python
DATA = {
    "customers": {
        "C-1042": {"id": "C-1042", "company": "Acme Corp"},
        "C-2210": {"id": "C-2210", "company": "Example Studio"},
    },
    "earlier_tickets": [
        {"id": "T-101", "customer_id": "C-1042", "received_on": "2026-08-04",
         "subject": "Adding an admin",
         "text": "Hi, we run your self-hosted edition on Windows Server 2022 in our own data "
                 "centre. How do I add a new admin user?"},
        {"id": "T-102", "customer_id": "C-2210", "received_on": "2026-08-11",
         "subject": "Exporting to PDF",
         "text": "We're a small design studio on your cloud edition, paying monthly on the "
                 "self-serve Team plan. How do I export a dashboard as a PDF?"},
        {"id": "T-103", "customer_id": "C-1042", "received_on": "2026-08-19",
         "subject": "Invoice download",
         "text": "Sorry for the typos, typing this on my phone at the airport. Where can I "
                 "download last month's invoice?"},
        {"id": "T-104", "customer_id": "C-2210", "received_on": "2026-09-02",
         "subject": "Dark mode?",
         "text": "Our whole team is out on Friday for a public holiday, so no rush on this "
                 "one. Is there a dark mode?"},
        {"id": "T-105", "customer_id": "C-1042", "received_on": "2026-09-10",
         "subject": "Sandbox environment",
         "text": "For context, we signed an Enterprise contract with you in March. Can we get "
                 "a sandbox environment for testing?"},
    ],
    "later_messages": [
        {"subject": "Slow dashboards",
         "text": "Dashboards have been really slow since this morning."},
        {"subject": "Upgrade failing",
         "text": "The upgrade to version 5.2 keeps failing halfway through."},
        {"subject": "More seats",
         "text": "We'd like to add 20 more seats before next quarter."},
    ],
    "later_received_on": "2026-09-28",
    # Labelled by hand from what each customer said in the earlier tickets.
    "expected_team": {
        "C-1042": {"Slow dashboards": "selfhosted_windows",
                   "Upgrade failing": "selfhosted_windows", "More seats": "enterprise_desk"},
        "C-2210": {"Slow dashboards": "cloud_ops", "Upgrade failing": "cloud_ops",
                   "More seats": "billing"},
    },
}
CUSTOMERS = DATA["customers"]


def ticket_state(customer_id: str, ticket_id: str, received_on: str, subject: str,
                 text: str) -> dict:
    """The state Jev sees for one ticket: a simplified ticket, like one from a helpdesk."""
    return {
        "customer": CUSTOMERS[customer_id],
        "ticket": {
            "id": ticket_id,
            "received_on": received_on,
            "subject": subject,
            "messages": [{"from": "customer", "text": text}],
        },
    }


EARLIER = [
    ticket_state(t["customer_id"], t["id"], t["received_on"], t["subject"], t["text"])
    for t in DATA["earlier_tickets"]
]
print(f"{len(CUSTOMERS)} customers, {len(EARLIER)} earlier tickets, "
      f"{len(DATA['later_messages'])} later messages. The first ticket as Jev sees it:\n")
print(json.dumps(EARLIER[0], indent=2))

आपको यह दिखना चाहिए (आधिकारिक रिलीज़):

text
2 customers, 5 earlier tickets, 3 later messages. The first ticket as Jev sees it:

{
  "customer": {
    "id": "C-1042",
    "company": "Acme Corp"
  },
  "ticket": {
    "id": "T-101",
    "received_on": "2026-08-04",
    "subject": "Adding an admin",
    "messages": [
      {
        "from": "customer",
        "text": "Hi, we run your self-hosted edition on Windows Server 2022 in our own data centre. How do I add a new admin user?"
      }
    ]
  }
}

हर टिकट के state के दो ही हिस्से हैं (ticket_state() से जुड़ा हुआ): customer कौन रिपोर्ट कर रहा है, ticket एक सरलीकृत टिकट थ्रेड है। डेटा की डिज़ाइन मंशा आधिकारिक रूप से स्पष्ट लिखी गई है: तीन शुरुआती टिकट स्थायी तथ्य बताते हैं——T-101 संस्करण (Windows Server पर self-hosted), T-102 पैकेज (क्लाउड संस्करण self-serve Team), T-105 अनुबंध (Enterprise); दो नहीं बताते——T-103 एयरपोर्ट वाला फ़ोन, T-104 सार्वजनिक छुट्टियाँ। तीनों बाद के संदेश ग्राहक के environment का उल्लेख नहीं करते, इसलिए मेमोरी न होने पर Jev केवल अनुमान लगा सकता है।

  • 2 customers, 5 earlier tickets, 3 later messages बिना त्रुटि प्रिंट होता है; मैं बता सकता हूँ कि कौन से तीन टिकट स्थायी तथ्य बताते हैं और कौन से दो नहीं बताते

चरण 2: पहले bare Jev राउटिंग चलाएँ, देखें कि मेमोरी न होने पर गलती कहाँ होती है ​

क्यों: पहले बेसलाइन बनाएँ——मेमोरी न होने पर यह «डैशबोर्ड धीमा है» वाला टिकट कहाँ राउट होगा।

राउटिंग प्रश्न एक Choice है, 7 विकल्प 7 सहायता टीमों को कवर करते हैं। none_suitable पर ध्यान दें: आधिकारिक रूप से इसका उपयोग टिप्पणी में लिखा है——जब कोई टीम उपयुक्त न हो तो इसका गंतव्य, context की कमी वाले टिकट यहाँ आ जाते हैं:

python
ROUTE = {
    "team": Choice(
        instructions="Which support team should handle `ticket`?",
        criteria={
            "cloud_ops": "Cloud team: problems with the hosted cloud edition, run by us",
            "selfhosted_linux": "Self-hosted team, Linux: installs, upgrades and "
            "performance of the self-hosted edition on Linux servers",
            "selfhosted_windows": "Self-hosted team, Windows: installs, upgrades and "
            "performance of the self-hosted edition on Windows Server",
            "billing": "Billing: invoices, payments, seats and plan changes for "
            "self-serve plans",
            "enterprise_desk": "Enterprise desk: seats, contracts and account changes for "
            "customers on an Enterprise contract (their technical problems go to the "
            "technical teams)",
            "general": "General product questions: features, how-to, settings",
            "none_suitable": "None of these teams fits the ticket",
        },
    ),
}


@json_cache
def _system_one(model: str, state: str, questions: str) -> dict:
    response = client.system_one(
        state=json.loads(state), questions=json.loads(questions), model=model
    )
    return response.model_dump(mode="json")


def ask(state: dict, questions: dict) -> SystemOneResponse:
    """client.system_one, with the model pinned and the call cached."""
    as_json = {qid: q.model_dump(mode="json", exclude_none=True) for qid, q in questions.items()}
    raw = _system_one(TYPESAFE_MODEL, json.dumps(state), json.dumps(as_json))
    return SystemOneResponse.model_validate(raw)


def later_state(customer_id: str, message_index: int) -> dict:
    """One of the later messages, sent by this customer, with a fixed ticket ID."""
    n = 201 + 3 * list(CUSTOMERS).index(customer_id) + message_index
    message = DATA["later_messages"][message_index]
    return ticket_state(customer_id, f"T-{n}", DATA["later_received_on"], message["subject"],
                        message["text"])


slow = later_state("C-1042", 0)
team = ask(slow, ROUTE).answers["team"]
print(f"C-1042: {slow['ticket']['messages'][0]['text']!r}")
print(f"  plain Jev -> {team.choice} {team.probabilities[team.choice]:.2f}")

ask() ही client.system_one है जिसमें मॉडल पिन किया गया है और @json_cache कैश जुड़ा है; later_state() बाद के संदेशों को निश्चित टिकट नंबर देता है (T-201 से शुरू)।

आपको यह दिखना चाहिए (आधिकारिक रिलीज़):

text
C-1042: 'Dashboards have been really slow since this morning.'
  plain Jev -> cloud_ops 0.55

इस टिकट को अकेले देखें तो, «डैशबोर्ड धीमा है» क्लाउड संस्करण की समस्या लगती है——Jev इसे क्लाउड टीम को भेजता है, प्रायिकता 0.55। यह कि C-1042 Windows Server पर self-hosted है, टिकट में एक शब्द भी नहीं है।

चरण 3: मेमोरी गेट लिखें——एक Noul जो तय करे «याद रखने लायक है या नहीं» ​

क्यों: «क्या याद रखना है» एक स्पष्ट लिखित प्रश्न होना चाहिए, कोड में बिखरे if-else नहीं। पहले देखें कि स्टोर की जाने वाली चीज़ कैसी दिखती है——as_memory() मूल state और Jev के उत्तर को एक जोड़ी में रखता है:

python
def answer_text(question, answer):
    """The readable part of an answer: the chosen option's description, or the number."""
    if answer.type == "choice":
        return question.criteria[answer.choice]
    return answer.noul if answer.type == "noul" else answer.score


def as_memory(state: dict, questions: dict, response: SystemOneResponse) -> dict:
    return {
        "request": state,
        "jev_answered": {
            q.instructions: answer_text(q, response.answers[qid])
            for qid, q in questions.items()
        },
    }


def remember_probability(memory: dict) -> float:
    """P(the request states an important fact about the customer), with the answer as context."""
    return ask(memory, GATE).answers["remember"].noul

दोनों कुंजी नामों का विशेष अर्थ है: request मेंमेमोरी जोड़ने से पहलेका मूल state रहता है——पुरानी मेमोरी कभी भी नई मेमोरी में नेस्ट नहीं होती; jev_answered हर प्रश्न को उत्तर टेक्स्ट से मैप करता है (Choice उत्तर में चुने गए विकल्प का विवरण स्टोर होता है)।

गेट का मूल रूप एक Noul है (आधिकारिक GATE मूल पाठ)। instructions में लिखी उन दो सीमाओं पर नज़र रखें——केवल request.ticket में ग्राहक/सहायता कर्मी द्वारा लिखे शब्द गिने जाते हैं; jev_answered केवल context है, जो वह कहता या संकेत करता है वह नहीं गिना जाता:

python
GATE = {
    "remember": Noul(
        instructions=(
            "In `request.ticket`, does the thread state a lasting fact about the customer that "
            "should change how their future, unrelated tickets are handled? Count what the "
            "customer or our support staff wrote in `request.ticket`. `jev_answered` shows how "
            "the ticket was routed, which may rely on things learned earlier: do not count "
            "anything it says or implies."
        ),
        criteria=NoulCriteria(
            true=(
                "Yes: in `request.ticket` the customer or our support staff state something "
                "about the customer that stays true after this ticket, such as the product "
                "edition or operating system they run, their plan or contract, or a standing "
                "preference."
            ),
            false=(
                "No: `request.ticket` only contains things specific to this one ticket or "
                "moment, such as a one-off request, today's schedule, or the device they "
                "happen to be typing on; or the lasting fact appears only in `jev_answered`."
            ),
        ),
    ),
}

उत्तर गिने क्यों नहीं जाते? आधिकारिक रूप से दो कारण दिए गए हैं: पहला, सामान्य उत्तर——जैसे «General product questions: features, how-to, settings» जैसा कोई भी दे सकने वाला उत्तर——अनुरोध के असली ग्राहक तथ्यों को दबा देंगे; दूसरा, पुरानी मेमोरी से निकले उत्तर नए तथ्य मानकर फिर से स्टोर हो जाएँगे, मेमोरी स्वयं की प्रतिकृति बनाती है।

💡 चीनी टिकटों को पहले टेस्ट करें, फिर लाइव करें

आधिकारिक बात: अंग्रेज़ी Jev की मुख्य ट्रेनिंग भाषा है; चीनी सहित अन्य भाषाएँ काम करती हैं लेकिन सटीकता कम होती है। GATE और ROUTE को चीनी में बदलने से पहले, या चीनी टिकटों पर गेट लगाने से पहले, अपने ही टिकटों की एक बैच चलाएँ और देखें कि «याद रखने योग्य / न रखने योग्य» दोनों समूहों की प्रायिकताएँ अलग-अलग खुलती हैं या नहीं, फिर REMEMBER_AT तय करें।

Noul का कोई अलग confidence नहीं है——दूसरे प्रश्न-प्रकारों के साथ थ्रेशोल्ड एकरूप करना हो तो आधिकारिक सूत्र से |2p − 1| स्वयं निकालें (देखें Confidence कॉन्फिडेंस)।

आपको दिखना चाहिए: इस चरण में कोई आउटपुट नहीं है——remember_probability() अगले सेक्शन में ही वास्तव में कॉल होता है।

चरण 4: ask_with_memory() की एक परत लपेटें——AI मेमोरी सिस्टम का केंद्र ​

क्यों: तीन छोटे फ़ंक्शन गेट और state को सीने का काम करते हैं——यही पूरा AI मेमोरी सिस्टम है, आधिकारिक कोड कुल 18 पंक्तियों का है:

python
MEMORIES: dict[str, list[dict]] = {}  # customer ID -> that customer's saved memories


def customer_id(state: dict) -> str:
    return state["customer"]["id"]


def ask_with_memory(state: dict, questions: dict) -> SystemOneResponse:
    """ask(), plus memory: same arguments, same return value."""
    # 1. Answer the call with this customer's existing memories.
    saved = MEMORIES.get(customer_id(state), [])
    response = ask({**state, MEMORY_KEY: saved} if saved else state, questions)

    # 2. Ask Jev whether the original request states an important fact worth keeping.
    memory = as_memory(state, questions, response)
    if remember_probability(memory) >= REMEMBER_AT:
        MEMORIES.setdefault(customer_id(state), []).append(memory)
    return response

इन 18 पंक्तियों को तीन बार पढ़ें: ①मेमोरी होने पर {**state, MEMORY_KEY: saved} भेजें, न होने पर वैसा ही भेजें; ②गेट पार होने पर और P ≥ 0.5 होने पर ही append करें; ③रिटर्न वैल्यू ask() से बिल्कुल वैसी ही है——मेमोरी सेव हुई या नहीं, कॉलर को जानने की ज़रूरत नहीं।

आधिकारिक स्रोत ने इस डिज़ाइन के पाँच परिणाम गिनाए हैं, हर एक याद रखने लायक है:

#परिणामविवरण
1हर कॉल पर दो सीरियल रिक्वेस्टपहले रूट, फिर गेट——गेट को उत्तर देखना है, इसलिए वह रूटिंग रिक्वेस्ट के बाद ही चल सकता है; अगर आपका गेट उत्तर नहीं देखता, तो उसे रूटिंग रिक्वेस्ट में दूसरे सवाल की तरह जोड़ा जा सकता है (समानांतर प्रश्न और स्पेक्युलेटिव फैन-आउट)
2मेमोरी केवल बढ़ती है, घटती नहींहर मेमोरी उस ग्राहक में आने के बाद की हर कॉल में जाती है; कोई साइज़ लिमिट नहीं, कोई रिलेवेंस जाँच नहीं, कोई एक्सपायरी नहीं
3प्रश्न कभी मेमोरी का ज़िक्र नहीं करतेमेमोरी state की earlier_tickets_from_this_customer कुंजी में जाती है, Jev पूरा state पढ़ता है——ROUTE में एक शब्द बदलने की ज़रूरत नहीं
4state में customer.id होना ही चाहिएनंगा Jev स्ट्रिंग state भी स्वीकार करता है, लेकिन रैपर फ़ंक्शन को उस ग्राहक की लिस्ट ID से खोजनी होती है
5सेव किए गए उत्तर ग़लतियाँ दोहराते हैंगेट उत्तर नहीं गिनता, उत्तर अकेले किसी टिकट को सेव नहीं करा सकते; लेकिन सेव हुआ टिकट उत्तर के साथ जुड़ा रहता है और बाद की हर कॉल उसे पढ़ती है——ग़लत निष्कर्ष चलता रहता है

💡 यही Jev का अनन्य मूल्य है

«क्या याद रखें» न तो prompt में बिखरी हुई सलाह है, न ही सब कुछ डेटाबेस में डालने की समझौता——यह कैलिब्रेटेड प्रायिकता वाला एक Noul है: आधिकारिक रिकॉर्डिंग में याद रखने योग्य तीन टिकट 0.96–0.98, न रखने योग्य सब ≤ 0.04, दोनों समूह बहुत दूर हैं, इसीलिए REMEMBER_AT = 0.5 यह रेखा बीच में खिंचने का साहस करती है। «क्या याद रखें» बदलना = GATE की भाषा बदलना; «कितना निश्चित हों तो याद रखें» बदलना = एक कॉन्स्टेंट बदलना——दोनों में कॉल चेन छेड़ने की ज़रूरत नहीं।

आपको दिखना चाहिए: इस चरण में भी कोई नया आउटपुट नहीं है——अगला सेक्शन इसे चलाएगा।

चरण 5: पाँच शुरुआती टिकट भेजें, देखें हर मेमोरी उत्तर कैसे बदलती है ​

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

python
PROBES = {"Slow dashboards": 0, "More seats": 2}  # later messages to send after each ticket


def memory_ids(cid: str) -> str:
    return ", ".join(m["request"]["ticket"]["id"] for m in MEMORIES.get(cid, [])) or "none"


def send_probes(cid: str) -> None:
    for subject, i in PROBES.items():
        team = ask_with_memory(later_state(cid, i), ROUTE).answers["team"]
        print(f"      {subject:<16} -> {team.choice:<19} {team.probabilities[team.choice]:.2f}")


for cid in CUSTOMERS:
    print(f"{cid}, memories: {memory_ids(cid)}")
    send_probes(cid)

for state in EARLIER:
    cid = customer_id(state)
    response = ask_with_memory(state, ROUTE)
    p = remember_probability(as_memory(state, ROUTE, response))  # cached: the wrapper's call
    verdict = "saved" if p >= REMEMBER_AT else "not saved"
    text = state["ticket"]["messages"][0]["text"]
    print(f"\n{cid} {state['ticket']['id']}  {response.answers['team'].choice:<19} "
          f"P(remember) {p:.2f}  {verdict}")
    print(f"    {text[:84]}")
    print(f"{cid}, memories: {memory_ids(cid)}")
    send_probes(cid)

# cached: the wrapper's call वाली टिप्पणी ध्यान देने लायक है: रैपर फ़ंक्शन में गेट एक बार पहले ही पूछा जा चुका है, यहाँ दुबारा पूछने पर कैश हिट होगा, नई रिक्वेस्ट नहीं लगेगी।

आपको दिखना चाहिए (आधिकारिक रिलीज़, पूरी प्रोबिंग तालिका):

text
C-1042, memories: none
      Slow dashboards  -> cloud_ops           0.55
      More seats       -> enterprise_desk     0.53
C-2210, memories: none
      Slow dashboards  -> cloud_ops           0.68
      More seats       -> billing             0.58

C-1042 T-101  selfhosted_windows  P(remember) 0.97  saved
    Hi, we run your self-hosted edition on Windows Server 2022 in our own data centre. H
C-1042, memories: T-101
      Slow dashboards  -> selfhosted_windows  0.99
      More seats       -> enterprise_desk     0.53

C-2210 T-102  general             P(remember) 0.98  saved
    We're a small design studio on your cloud edition, paying monthly on the self-serve
C-2210, memories: T-102
      Slow dashboards  -> cloud_ops           0.98
      More seats       -> billing             0.98

C-1042 T-103  billing             P(remember) 0.02  not saved
    Sorry for the typos, typing this on my phone at the airport. Where can I download la
C-1042, memories: T-101
      Slow dashboards  -> selfhosted_windows  0.99
      More seats       -> enterprise_desk     0.53

C-2210 T-104  general             P(remember) 0.03  not saved
    Our whole team is out on Friday for a public holiday, so no rush on this one. Is the
C-2210, memories: T-102
      Slow dashboards  -> cloud_ops           0.98
      More seats       -> billing             0.98

C-1042 T-105  enterprise_desk     P(remember) 0.96  saved
    For context, we signed an Enterprise contract with you in March. Can we get a sandbo
C-1042, memories: T-101, T-105
      Slow dashboards  -> selfhosted_windows  0.98
      More seats       -> enterprise_desk     1.00

यह तालिका पढ़ें (आधिकारिक व्याख्या से एक-एक मिलती है):

  • सेव होने योग्य तीनों 0.96–0.98 से सेव हुए: T-101 संस्करण 0.97, T-102 प्लान 0.98, T-105 अनुबंध 0.96
  • T-102 general टीम को रूट हुआ, फिर भी सेव हुआ——गेट ग्राहक के लिखे शब्द गिनता है, रूटिंग उत्तर नहीं; पर इसकी वजह से «20 सीटें जोड़ें» का निर्णय billing 0.58 से 0.98 पर कूद गया
  • एयरपोर्ट 0.02, सार्वजनिक अवकाश 0.03 सेव नहीं हुए——उनके बाद के प्रोब उत्तरों में से एक भी नहीं बदला
  • हर मेमोरी केवल अपने से संबंधित उत्तर बदलती है: C-1042 का Windows टिकट धीमे डैशबोर्ड को क्लाउड टीम 0.55 से Windows टीम 0.99 पर ले गया, Enterprise अनुबंध ने सीटें जोड़ने का enterprise_desk 0.53 से 1.00 तक उठाया; C-2210 के Team प्लान ने क्लाउड टीम 0.68 को 0.98 तक, billing 0.58 को 0.98 तक उठाया
  • गेट ने दोहराए गए संदेशों में से एक भी सेव नहीं किया——एक ही प्रोब टिकट दो बार भेजने पर गेट का निर्णय नहीं बदलता

आपको दिखना चाहिए: आपका आउटपुट ऊपर की तालिका से पंक्ति-दर-पंक्ति मेल खाता है (कैश रीप्ले पर बिल्कुल मेल; live चलाने पर प्रायिकताओं में अंतर होगा, दिशा आपके लॉक किए संस्करण के अनुसार मान्य है)।

  • यह तालिका चलकर निकलती है; मैं बता सकता हूँ कि T-102 general को रूट होकर भी सेव क्यों हुआ

चरण 6: मिलान——एक ही संदेश, नंगे Jev और मेमोरी सहित एक-एक बार रूट ​

क्यों: अंतिम मिलान। हर ग्राहक को तीनों फ़ॉलोअप संदेश भेजें, वही state, वही सवाल, अलग-अलग ask() और ask_with_memory() से। अपेक्षित टीम अंदाज़े से नहीं आई——DATA की टिप्पणी साफ़ कहती है: मानव ने ग्राहकों के शुरुआती टिकटों में कहे गए शब्दों के आधार पर चिह्नित किया (C-1042 का सेल्फ-होस्टेड संस्करण + Enterprise अनुबंध, C-2210 का क्लाउड संस्करण Team प्लान):

python
EXPECTED = DATA["expected_team"]
plain_correct = memory_correct = total = 0
example_state = None


def cell(answer, expected: str) -> str:
    mark = "✓" if answer.choice == expected else "✗"
    return f"{mark} {answer.choice} {answer.probabilities[answer.choice]:.2f}"


print(f"{'customer':<9}{'message':<17}{'expected':<20}{'plain Jev':<27}{'with memory':<27}")
for cid in CUSTOMERS:
    for i, message in enumerate(DATA["later_messages"]):
        state = later_state(cid, i)
        expected = EXPECTED[cid][message["subject"]]
        plain = ask(state, ROUTE).answers["team"]
        if example_state is None:
            # Keep the exact state used for this call for the playground link.
            saved = MEMORIES.get(cid, [])
            example_state = json.loads(json.dumps({**state, MEMORY_KEY: saved} if saved else state))
        response = ask_with_memory(state, ROUTE)
        remembered = response.answers["team"]
        plain_correct += plain.choice == expected
        memory_correct += remembered.choice == expected
        total += 1
        print(f"{cid:<9}{message['subject']:<17}{expected:<20}{cell(plain, expected):<27}"
              f"{cell(remembered, expected):<27}")

print(f"\nExpected routes: {plain_correct}/{total} without memory, "
      f"{memory_correct}/{total} with memory.")

example_state वे पंक्तियाँ अंतिम Playground लिंक के लिए रखी गई हैं——C-1042 के पहले धीमे डैशबोर्ड कॉल के समय का सटीक state उठाएँ (तब तक सेव हुई मेमोरी सहित)।

आपको यह दिखना चाहिए (आधिकारिक रिलीज़):

text
customer message          expected            plain Jev                  with memory
C-1042   Slow dashboards  selfhosted_windows  ✗ cloud_ops 0.55           ✓ selfhosted_windows 0.98
C-1042   Upgrade failing  selfhosted_windows  ✗ none_suitable 0.64       ✓ selfhosted_windows 1.00
C-1042   More seats       enterprise_desk     ✓ enterprise_desk 0.53     ✓ enterprise_desk 1.00
C-2210   Slow dashboards  cloud_ops           ✓ cloud_ops 0.68           ✓ cloud_ops 0.98
C-2210   Upgrade failing  cloud_ops           ✗ none_suitable 0.58       ✓ cloud_ops 0.95
C-2210   More seats       billing             ✓ billing 0.58             ✓ billing 0.98

Expected routes: 3/6 without memory, 6/6 with memory.

3/6 बनाम 6/6। चार पंक्तियाँ ध्यान से देखने लायक हैं:

  • एक ही वाक्य अलग-अलग टीमों को जाता है: धीमा डैशबोर्ड, C-1042 Windows टीम को जाता है, C-2210 क्लाउड टीम में रहता है; सीटें जोड़ें, C-1042 enterprise_desk को जाता है, C-2210 billing को——मेमोरी «कैसे रूट हो» को ग्राहक के साथ चलाती है, केवल इस वाक्य के साथ नहीं
  • दोनों none_suitable बचा लिए गए: एस्केलेशन विफल टिकट परिवेश का ज़िक्र नहीं करते, संदर्भ कम है, नंगा Jev केवल «कोई टीम उपयुक्त नहीं» जवाब दे सकता है; मेमोरी के साथ दोनों क्रमशः Windows टीम 1.00, क्लाउड टीम 0.95 को जाते हैं
  • नंगे Jev की मूल रूप से सही तीन पंक्तियाँ, मेमोरी ने प्रायिकता ऊपर उठाई: C-1042 की सीटें जोड़ें 0.53 से 1.00 तक——मेमोरी केवल सही-ग़लत नहीं बदलती, भरोसा भी बदलती है
  • गेट ने इन छह बाद के संदेशों में से एक भी सेव नहीं किया—वे कोई स्थायी तथ्य नहीं कहते, मेमोरी में कुछ नया जुड़ा नहीं

📋 मैजिकल Prompt ​

इस पेज का 「Prompt」 API के लिए दिए गए प्रश्न और रैपर टेम्पलेट है—इसे कॉपी करके 【】 प्लेसहोल्डर बदल दें (? वाले वैकल्पिक हैं), और यह उपयोग के लिए तैयार है।

📝 मेमोरी गेट (Noul संस्करण) ​

अपेक्षित परिणाम: 「क्या याद रखना है」 को एक स्पष्ट हाँ/ना प्रश्न के रूप में लिखें, 0–1 प्रायिकता मिलती है, सेव करना या नहीं कोड में दिए थ्रेशोल्ड से तय होता है।

python
GATE = {
    "remember": Noul(
        instructions=(
            "【在 `request.ticket` 里,这个线程是否陈述了关于客户的一条持久事实——"
            "它应该改变客户未来、与这张工单无关的工单的处理方式?只数客户或支持人员"
            "在 `request.ticket` 里写下的话。`jev_answered` 显示这张工单被如何路由,"
            "可能依赖早先学到的东西:它说的或暗示的任何内容都不要数。】"
        ),
        criteria=NoulCriteria(
            true="【是:客户或支持人员在 `request.ticket` 里陈述了这张工单之后仍然为真的东西——如产品版本、操作系统、套餐、合同、长期偏好】",
            false="【否:`request.ticket` 只有属于这张工单或这一刻的内容——如一次性请求、当天日程、碰巧在用的设备;或持久事实只出现在 `jev_answered` 里】",
        ),
    ),
}
# 必填项:state = as_memory() 配好的 {"request": 加记忆前的原始 state, "jev_answered": {问题 instructions: 答案文本}}
# 选填项:true/false 里的例子换成你领域「值得记 / 不值得记」的清单?
# 输出规范:response.answers["remember"].noul → 0–1 概率(Noul 无单独 confidence)
# 约束条件:
# ✅ 一道 Noul 只问「该不该记」;记多久、给谁看,是代码的事
# ✅ 官方英文原文最稳(见第 3 步);中文化先用你自己的数据验证再上线
# ❌ 不要数 `jev_answered`——通用答案会压过真事实,靠旧记忆得出的答案会被当新事实再存

✅ मेमोरी रैपर और थ्रेशोल्ड (ask_with_memory संस्करण) ​

अपेक्षित परिणाम: कॉल से पहले मेमोरी अपने आप जुड़ती है, कॉल के बाद गेट अपने आप चलता है; ask() के समान पैरामीटर और समान रिटर्न वैल्यू, मौजूदा कोड में शून्य बदलाव के साथ बदला जा सकता है।

python
REMEMBER_AT = 【0.5】  # 多确定才记:官方给这道闸门的起点阈值
MEMORY_KEY = "【earlier_tickets_from_this_customer】"  # 记忆放进 state 用的键名
MEMORIES: dict[str, list[dict]] = {}  # 客户 ID -> 该客户的记忆列表


def ask_with_memory(state: dict, questions: dict) -> SystemOneResponse:
    """ask(), plus memory: same arguments, same return value."""
    saved = MEMORIES.get(customer_id(state), [])
    response = ask({**state, MEMORY_KEY: saved} if saved else state, questions)
    memory = as_memory(state, questions, response)
    if remember_probability(memory) >= REMEMBER_AT:
        MEMORIES.setdefault(customer_id(state), []).append(memory)
    return response
# 必填项:state 里必须有 customer.id——包装函数靠它找该客户的记忆列表
# 选填项:记忆长了加一道相关性问题,只挑子集并进 state?
# 输出规范:返回值与 ask() 完全相同——存没存记忆,调用方都不用管
# 约束条件:
# ✅ 先路由后闸门——闸门要看答案,只能在路由请求之后跑
# ✅ as_memory() 的 request 键存加记忆前的原始 state——旧记忆不会嵌套进新记忆
# ❌ 别把 MEMORIES 直接上线——内存字典进程退出就没了,官方 Next steps:换按客户 ID 键的数据库

🔧 आपका अपना राउटिंग प्रश्न (Choice संस्करण) ​

अपेक्षित परिणाम: एक Choice टिकट को एक निश्चित टीम सेट में भेजता है; none_suitable संदर्भ अपर्याप्त टिकट को एक जगह देता है।

python
ROUTE = {
    "team": Choice(
        instructions="【这张工单该哪个支持团队接?判断 `ticket`】",
        criteria={
            "【选项 ID】": "【选项描述:什么情况归这个团队】",
            "none_suitable": "【以上团队都不适合这张工单】",
        },
    ),
}
# 必填项:选项 map——ID 是代码读的,描述是 Jev 读的
# 选填项:官方 7 选项全集见第 2 步(cloud_ops / selfhosted_linux / selfhosted_windows / billing / enterprise_desk / general / none_suitable)?
# 输出规范:answers["team"].choice + probabilities(每个选项)+ confidence
# 约束条件:
# ✅ 列表可能不全时留 none_suitable(或 other)——上下文不足的工单有地方去
# ✅ 记忆进 state 后,这道题一个字不用改——Jev 读整个 state
# ❌ 不要在 instructions 里提「记忆」——记忆是 state 的事,不是问题的事

चेकपॉइंट ✅ ​

  • मैं इस AI मेमोरी सिस्टम के दो हिस्से बता सकता हूँ: कॉल के बाद एक Noul गेट तय करता है कि याद रखना है या नहीं (P ≥ 0.5 होने पर ही सेव), कॉल से पहले उस ग्राहक के सेव किए गए टिकट उत्तर समेत state में जुड़ते हैं
  • मैं जानता हूँ कि गेट केवल request.ticket में लिखी बातें ही क्यों गिनता है: सामान्य उत्तर असली तथ्यों को दबा देंगे, पुरानी मेमोरी से निकला उत्तर नया तथ्य समझकर दोबारा सेव हो जाएगा
  • पाँच शुरुआती टिकट में तीन सेव हुए दो नहीं: वर्शन / प्लान / कॉन्ट्रैक्ट 0.96–0.98 सेव हुए, एयरपोर्ट फोन 0.02, सार्वजनिक छुट्टी 0.03 सेव नहीं हुए—T-102 जो general में राउट हुआ वह फिर भी सेव हुआ
  • मिलान प्रयोग 3/6 → 6/6: वही 「डैशबोर्ड धीमा है」 वाक्य, C-1042 Windows टीम को गया, C-2210 क्लाउड टीम में रहा; बिना मेमोरी वाले Jev के तीन सही पंक्तियाँ, मेमोरी ने प्रायिकता 0.53 से बढ़ाकर 1.00 कर दी
  • पाँच परिणामों में से मैं तीन बता सकता हूँ: हर कॉल में दो क्रमिक रिक्वेस्ट, मेमोरी केवल बढ़ती है घटती नहीं, state को customer.id चाहिए (बाकी दो: प्रश्न कभी मेमोरी का जिक्र नहीं करते, सेव किए उत्तर गलतियाँ दोहराते हैं)

सावधानी की याद दिलाना ​

❌ गेट Jev के उत्तर को भी साथ गिने ​

jev_answered को भी 「याद रखने योग्य」 के निर्णय में शामिल करने पर दो बातें होती हैं जिन्हें आधिकारिक रूप से नाम दिया गया है: सामान्य उत्तर (「General product questions: features, how-to, settings」) रिक्वेस्ट के असली ग्राहक तथ्यों को दबा देंगे—T-102 सेव ही नहीं हो सकता; पुरानी मेमोरी से निकला उत्तर नया तथ्य समझकर दोबारा सेव होगा, मेमोरी खुद बढ़ती जाएगी।

आधिकारिक समाधान GATE की instructions में तय है: केवल ग्राहक/सपोर्ट कर्मियों द्वारा request.ticket में लिखी बातें गिनें, jev_answered केवल संदर्भ है, जो वह कहता है या संकेत देता है उसे नहीं गिनते।

❌ एक रिक्वेस्ट बचाने के चक्कर में गेट को राउटिंग रिक्वेस्ट में मिला देना ​

गेट को 「टिकट + Jev का उत्तर」 देखना होता है, उत्तर राउटिंग रिक्वेस्ट के बाद ही आता है—इसीलिए चरण 4 के पाँच परिणामों में पहला ही 「हर कॉल में दो क्रमिक रिक्वेस्ट」 है। आधिकारिक रूप से कहा गया अपवाद: अगर आपका गेट उत्तर नहीं देखता, तो उसे राउटिंग रिक्वेस्ट का दूसरा प्रश्न बनाया जा सकता है (स्पेकुलेटिव फैनआउट, देखें समानांतर प्रश्न और स्पेकुलेटिव फैनआउट)।

पहले सोच लें कि आपका गेट उत्तर देखेगा या नहीं, फिर तय करें कि मिलाना है या नहीं।

❌ state में customer.id न होते हुए भी रैपर फंक्शन लगा देना ​

बिना रैपर वाला Jev स्ट्रिंग state स्वीकार करता है, कोई भी आकार चलता है; ask_with_memory() को state["customer"]["id"] से उस ग्राहक की मेमोरी सूची ढूँढनी होती है। रैपर फंक्शन लगाने से पहले पुष्टि करें कि आपके state में ग्राहक ID है।

❌ 「केवल बढ़ने वाली」 डेमो मेमोरी को सीधे प्रोडक्शन में ले जाना ​

तीन 「नहीं」 आधिकारिक रूप से साफ लिखे हैं: कोई साइज़ सीमा नहीं, कोई प्रासंगिकता जाँच नहीं, कोई समाप्ति नहीं। हर मेमोरी उस ग्राहक की उसके बाद की हर कॉल में जाती है—और 「बड़ा state अप्रासंगिक विवरणों से भरा」 ही Jev 1.13 सावधानी मैनुअल में दर्ज ज्ञात विफलता मोड है।

दो और जोखिम आधिकारिक रूप से नामित हैं: सेव किए टिकट उत्तर समेत जुड़ते हैं, गलत निष्कर्ष साथ चलता रहता है; MEMORIES एक इन-मेमोरी डिक्शनरी है, प्रोसेस बंद होते ही चली जाती है। आधिकारिक Next steps का समाधान एडवांस्ट तकनीकों में है।

एडवांस्ड तकनीकें (वैकल्पिक) ​

REMEMBER_AT को कैलिब्रेट करना: आधिकारिक कैलिब्रेशन विधि। आधिकारिक Next steps की पहली बात यही है: अपने ट्रैफ़िक से 「रिक्वेस्ट + उत्तर」 जोड़ियों का एक सेट चुनें, मैन्युअल रूप से 「याद रखने योग्य / अयोग्य」 दो ढेर बाँटें, सबसे अलग दिखने वाली प्रायिकता को थ्रेशोल्ड चुनें, फिर चयन में न आए सेट से जाँचें। भ्रामक मेमोरी का खर्च बड़ा हो तो ऊपर बढ़ाएँ।

आधिकारिक शुरुआती बिंदु 0.5 ही क्यों है, Noul सामान्य शुरुआती बिंदु के 「yes ≥ 0.7」 से ढीला? कोड की टिप्पणी केवल इतना कहती है कि यह starting threshold (शुरुआती थ्रेशोल्ड) है; Confidence का सिद्धांत है कि थ्रेशोल्ड जोखिम के साथ स्केल होता है—एक मेमोरी सेव करना वापस लेने योग्य कम जोखिम वाला काम है, 0.5 काफ़ी है, खर्च असंतुलित हो तो ऊपर करें। आधिकारिक रूप से संदर्भ भी दिया गया: confidence-based routing पैटर्न।

मेमोरी बढ़ने पर आधिकारिक चार-चरण अपग्रेड पथ। Next steps में बाकी चार बातें हैं, ज़रूरत के अनुसार लगाएँ: ① एक प्रासंगिकता प्रश्न जोड़ें, लंबी मेमोरी से सबसेट चुनकर state में जोड़े; ② पूछें कि नई मेमोरी पुरानी की जगह लेगी या नहीं, कोड में बदली हुई प्रविष्टियाँ हटाएँ; ③ MEMORIES को ग्राहक ID से की गई डेटाबेस से बदलें; ④ अपने ऐप के उत्तरों को भी टिकट थ्रेड में सपोर्ट संदेश के रूप में जोड़ें, गेट उसे भी साथ जाँचे।

बिना key रीप्ले और लागत का हिसाब। सभी कॉल आधिकारिक रूप से जारी json_cache.json में दर्ज हैं: डुप्लिकेट हटाने के बाद 31 कॉल (दोहराए गए प्रोब रिक्वेस्ट एक ही कैश प्रविष्टि पर पड़ते हैं, इसीलिए प्रविष्टियाँ लॉजिकल कॉल से कम हैं)—19 राउटिंग, 12 गेट; कुल 21,456 इनपुट टोकन, 1,752 आउटपुट टोकन। $42/Btok इनपुट बिलिंग और आउटपुट मुफ़्त के हिसाब से पूरा पेज लगभग $0.0009 में चलता है।

मेमोरी के साथ राउटिंग कॉल केवल एक बार अनुभव करना चाहते हैं: आधिकारिक cookbook पेज के नीचे बना हुआ Playground शेयर लिंक है—उसमें C-1042 के पहले धीमे डैशबोर्ड कॉल के समय का state (उस समय सेव की गई T-101, T-105 दो मेमोरी समेत) + राउटिंग प्रश्न है, खोलते ही ब्राउज़र में बदल सकते हैं:

TypeSafe playground में C-1042 का टिकट और उसकी मेमोरी खोलें →

यह आधिकारिक आख़िरी सेल से बना है: make_playground_link(example_state, ROUTE)—चरण 6 में पकड़ा गया वही सटीक state।

अपने ऐप में जोड़ना। GATE और ROUTE अब आपके हैं, रैपर फंक्शन जस का तस कॉपी करें। अगर आप Claude Code उपयोग करते हैं, तो TypeSafe Agent Skill लगाकर यह पेज उसे सौंप दें:

bash
claude plugin marketplace add typesafe-ai/skills
claude plugin install typesafe@typesafe-ai

आधिकारिक सलाह है कि प्रश्न और थ्रेशोल्ड स्थिरांकों को एक फ़ाइल में रखें ताकि मानव समीक्षा आसान हो—GATE का शब्द चयन और REMEMBER_AT ही आपकी दो 「नीतियाँ」 हैं, हर बदलाव कोड समीक्षा से गुज़रना चाहिए।

इस पाठ का सारांश ​

✅ एक AI मेमोरी सिस्टम = दो हिस्से: कॉल के बाद एक Noul गेट (P ≥ 0.5 होने पर ही सेव), कॉल से पहले उस ग्राहक के सेव किए गए टिकट उत्तर समेत state में जुड़ते हैं—ask_with_memory() और ask() समान पैरामीटर, समान रिटर्न वैल्यू, बदलने पर बाकी कोड में कोई बदलाव नहीं।

✅ 「क्या याद रखना है」 एक स्पष्ट प्रश्न है: GATE केवल रिक्वेस्ट में ग्राहक/सपोर्ट कर्मियों द्वारा लिखी बातें गिनता है; याद रखने योग्य 0.96–0.98, अयोग्य ≤ 0.04—दोनों समूह दूर हैं, तभी 0.5 यह रेखा खिंचने का साहस होता है।

✅ आधिकारिक परीक्षण: बिना मेमोरी वाला (bare) Jev बाद के टिकट 3/6 जोड़े; मेमोरी के साथ 6/6 सभी अपेक्षित टीम तक पहुँचे। धीमे डैशबोर्ड 0.55 क्लाउड टीम → 0.98 Windows टीम; सीटें जोड़ना 0.53 → 1.00; दोनों none_suitable बचा लिए गए।

✅ सीमाएँ स्पष्ट: हर कॉल में दो क्रमिक अनुरोध; मेमोरी केवल बढ़ती है, घटती नहीं; प्रश्न कभी मेमोरी का उल्लेख नहीं करते; state को customer.id चाहिए; सहेजे गए उत्तर गलतियाँ दोहराते हैं।

मुख्य कॉन्फ़िगरेशन फ़ील्ड की समीक्षा:

फ़ील्डइस पृष्ठ का मानविवरण
REMEMBER_AT0.5मेमोरी सहेजने के शुरुआती दहलीज़ का मान, आधिकारिक टिप्पणी का मूल शब्द starting threshold
MEMORY_KEYearlier_tickets_from_this_customerमेमोरी state की कुंजी में जाती है; Jev पूरा state पढ़ता है, प्रश्नों को बदलने की ज़रूरत नहीं
TYPESAFE_MODELjev-1.14.0आधिकारिक रिकॉर्डिंग संख्याओं वाला संस्करण; live चलाने पर अपना संस्करण ID
MEMORIESdict[str, list[dict]], ग्राहक ID के अनुसारमेमोरी डिक्शनरी, प्रक्रिया बंद होने पर मिट जाती है; प्रोडक्शन में डेटाबेस पर स्विच करें
दहलीज़ का प्रश्न-प्रकारNoul (कोई अलग confidence नहीं)दहलीज़ सीधे P(yes) पर सेट है; अन्य प्रश्न-प्रकारों के समान पैमाने के लिए स्वयं "2p − 1 का निरपेक्ष मान" निकालें
state का आकारcustomer (सहित id) + ticketरैपर फ़ंक्शन customer.id से मेमोरी सूची ढूँढता है

संबंधित ट्यूटोरियल:

अगले पाठ की झलक ​

B रेखा (LLM और Agent अनुप्रयोग) यहीं पूरी होती है। अगले पाठ से C रेखा (दस्तावेज़ और डेटा) शुरू: मान निष्कर्षण: तारीख़, ईमेल, फ़ोन, राशि।

आप सीखेंगे:

  • तारीख़: दस्तावेज़ से घटक पूछें (निरपेक्ष या सापेक्ष), कोड पार्स और सत्यापित करे, confidence से पुनः जाँच
  • ईमेल, फ़ोन, राशि: regex से पहले उम्मीदवार निकालें, Jev सही वाला चुने, कोड फिर मानक रूप दे
  • इस पृष्ठ जैसी ही आदत: निष्कर्षण की सही-गलती मॉडल की ईमानदारी पर नहीं, टाइप किए गए प्रश्न + कोड सत्यापन पर टिकी है
gaodong.aiAboutPrivacyContact

Independent tutorials, not affiliated with any product mentioned. Product names and trademarks belong to their owners. Check official pages for prices and policies.