Skip to content

साइटेशन सत्यापन: हैल्यूसिनेटेड साइटेशन रोकें ​

💡 एक वाक्य में सार: Jev से AI साइटेशन सत्यापन पाइपलाइन बनाएँ —— स्ट्रिंग मैचिंग से बनाए गए साइटेशन रोकें, एक Choice प्रश्न से जाँचें कि संदर्भ दावे को समर्थन देता है या नहीं, कम confidence वाले निर्णय अपने आप मानव हस्तक्षेप पर जाएँ।

LLM प्रश्नों के उत्तर देते समय साइटेशन जोड़ना पसंद करता है: हर दावे के साथ स्रोत दस्तावेज़ का एक अंश, साथ ही वह साइटेशन जिस पर वह आधारित है। पर उनमें से कुछ गलत होते हैं, यहाँ तक कि बनाए हुए भी: साइटेशन शायद दस्तावेज़ में होता ही नहीं; या शब्दशः दस्तावेज़ में मौजूद हो, पर उसका संदर्भ पूरी तरह कुछ और कह रहा हो।

एक साइटेशन की मैन्युअल जाँच कितनी थकाऊ है, आधिकारिक cookbook में तीन चरण गिनाए गए हैं: दस्तावेज़ ढूँढें, दस्तावेज़ में साइटेशन ढूँढें, फिर पर्याप्त संदर्भ पढ़कर तय करें कि वह दावे को सहारा देता है या नहीं। एक के लिए भी ऐसा है, तो 8, 80, 800 साइटेशनों के लिए कैसे?

इस आधिकारिक cookbook (Double-checking citations) का स्वचालित समाधान दो द्वार हैं: पहले साधारण स्ट्रिंग मैचिंग से「मूल पाठ में नहीं हैं」ऐसे साइटेशन ढूँढें——ये बनाए हुए (fabricated) होते हैं, मॉडल की बारी ही नहीं आती; बचे हुए साइटेशनों को फिर एक Choice प्रश्न से संदर्भ पढ़कर उनका दावे से संबंध जाँचा जाता है।

पिछले पाठ LLM गार्डरेल में「न कही जाने वाली बातें」रोकी गईं, इस पाठ में「न दिए जाने वाले साइटेशन」रोके जाएँगे——वही「प्रायिकता + थ्रेशोल्ड + कोड से रूटिंग」वाला विचार, इस बार पहरा「हर दावे का कोई स्रोत है या नहीं」का। यह पाठ लगभग 12 मिनट का है, आधिकारिक डेटा पैकेज के साथ पूरा चलाता है: स्रोत दस्तावेज़ RFC 7519 (JSON Web Token, 2015年 5月) है, 8 साइटेशन एक LLM ने उसे देखकर लिखे हैं——4 सही, 4 आधिकारिक रूप से बदले गए, सभी आधिकारिक रूप से जारी आँकड़ों से सत्यापित (jev-1.12, 2026-08-16 सैंपलिंग)।

text
एक साइटेशन (claim + quote + section)
        │
        ▼
द्वार 1: स्ट्रिंग मैचिंग——साइटेशन स्रोत दस्तावेज़ में है या नहीं?
        │                    │
     नहीं मिला              मिला (अनुभाग दर्ज) / केवल अनुभाग बताया
        │                    │
        ▼                    ▼
    fabricated        द्वार 2: एक Choice प्रश्न
   (बनाया हुआ, शून्य अनुरोध)      संदर्भ और दावे का संबंध क्या है?
                         supports      → verified
                         contradicts   → contradicted
                         says_nothing  → unsupported
                              │
                              ▼
                    confidence ≥ 0.8 → निर्णय लागू
                    confidence < 0.8 → मानव पुष्टि

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

  • AI आउटपुट के हर साइटेशन को अपने आप चार में से एक निर्णय दें: verified जारी, fabricated / contradicted अस्वीकृत, unsupported मानव हस्तक्षेप पर
  • शून्य API लागत वाली स्ट्रिंग मैचिंग से पहले वे हैल्यूसिनेटेड साइटेशन रोकें जो「मूल पाठ में हैं ही नहीं」
  • एक Choice प्रश्न से साइटेशन का संदर्भ पढ़ें, जाँचें कि वह दावे को supports / contradicts / says_nothing करता है
  • confidence थ्रेशोल्ड से अपने आप रूटिंग: उच्च confidence निर्णय सीधे लागू, कम confidence मानव कतार में (आधिकारिक शुरुआत 0.8)

Jev क्यों, मैन्युअल एक-एक जाँच क्यों नहीं? ​

क्षमतामैन्युअल एक-एक जाँचJev साइटेशन सत्यापन
एक साइटेशन में समय❌ दस्तावेज़ ढूँढें, साइटेशन ढूँढें, पर्याप्त संदर्भ पढ़ें, एक-एक करके✅ आधिकारिक कैश से परीक्षित: एक निर्णय 0.08–0.25 सेकंड
निर्णय का मानदंड❌ व्यक्ति और समय के साथ बदलता है,「मूल पाठ में नहीं कहा」और「मूल पाठ उल्टा कहता है」अक्सर एक ही श्रेणी में मिल जाते हैं✅ तीन संबंध criteria में परिभाषित, चार निश्चित निर्णयों में वलित
बनाए हुए साइटेशन❌ पहले मूल पाठ में संबंधित स्थान तक पहुँचना पड़ता है तभी पता चलता है✅ स्ट्रिंग मैचिंग पहले रोकती है, एक भी अनुरोध नहीं भेजना पड़ता
भरोसे को कैसे व्यक्त करें❌「दिखने में ठीक है」——प्रक्रिया में नहीं आ सकता✅ कैलिब्रेटेड प्रायिकता + confidence, 0.8 से नीचे अपने आप मानव हस्तक्षेप पर
बैच और ऑडिट❌ सत्यापन रिकॉर्ड दिमाग में, चैट इतिहास में रह जाते हैं✅ हर निर्णय के साथ प्रायिकता, confidence, token संख्या, संग्रह और पुनः चलाने योग्य

आपकी वर्तमान दुविधा ​

  • 「AI की लिखी रिपोर्ट के साइटेशन एक-एक सच जैसे लगते हैं, हर एक के लिए मूल पाठ नहीं खंगाल सकते——पर पिछली बार एक बनाया हुआ छूट ही गया」
  • 「और भी धोखेबाज़ वह साइटेशन: शब्दशः सचमुच मूल पाठ में है, पर संदर्भ उल्टी बात कह रहा है, आँखों से देखकर कतई नहीं पता चलता」
  • 「बैच में सत्यापन करना चाहता हूँ, पर फिर से एक LLM को न्यायाधीश नहीं बना सकता——उसकी गलती करने का तरीका, साइटेशन हैल्यूसिनेशन की तरह ही दिखता है」

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

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

  • RAG प्रश्नोत्तर, AI लेखन सहायक, साहित्य समीक्षा जैसे「साइटेशन युक्त AI आउटपुट」की बैच गुणवत्ता जाँच
  • हर साइटेशन को चार में से एक निर्णय देना, हर एक अपनी प्रक्रिया में जाए: जारी, अस्वीकृत, मानव हस्तक्षेप
  • बनाए हुए साइटेशन शून्य लागत में रोकना, कम confidence निर्णयों के लिए मानव सहारा

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

  • एक-एक करके मैन्युअल रूप से मूल पाठ में साइटेशन ढूँढना, संदर्भ पढ़ना
  • सत्यापन परिणाम फिर वही एक ऐसा मुक्त पाठ जो प्रक्रिया में नहीं आ सकता
  • असली साइटेशन से झूठी बात कहने वाले साइटेशन गुणवत्ता जाँच में फिसलकर औपचारिक मसौदे में पहुँच जाना

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

  • पूरा कर लिया Choice प्रश्न — पता है कि criteria एक options map है और उत्तर में probabilities और confidence आते हैं — इस पेज की पूरी निर्णय-रेखा एक ही Choice पर टिकी है
  • (वैकल्पिक लेकिन अनुशंसित) पढ़ लिया Confidence 置信度 — तीन स्तरों के उपयोग में से「कम confidence पर मानव-हस्तांतरण」(低置信मानव से जोड़ें) इसी पेज के AUTO_ACCEPT थ्रेशोल्ड का विचार है
  • सफलतापूर्वक चला लिया इंस्टॉल और पहला रिक्वेस्ट — .venv में typesafe-sdk है और TYPESAFE_API_KEY पर्यावरण चर में मौजूद है
  • पता है कि आधिकारिक डेटा पैक में परिणाम कैश आता है — दोबारा चलाने पर प्रकाशित आंकड़े रीप्ले होते हैं, कोई रिक्वेस्ट नहीं जाती; कैश मिटाने पर ही असली कॉल होती है (7 बार — 8वाँ citation स्ट्रिंग-मैचिंग चरण में ही बाहर हो गया)। बिलिंग इनपुट token पर होती है, आउटपुट मुफ़्त है; दरें देखें मॉडल और कीमतें

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

चरण 1: आधिकारिक डेटा पैक लें (RFC 7519 + 8 citations + परिणाम कैश) ​

क्यों: citations की जाँच के लिए असली दस्तावेज़ और असली citations चाहिए। आधिकारिक cookbook तीनों चीज़ें तैयार रखता है: rfc7519.txt (RFC 7519 का मूल पाठ, rfc-editor.org से लिया गया), citations.json (एक LLM द्वारा RFC देखकर लिखे 8 citations — 4 सटीक हैं, 4 को आधिकारिक रूप से छेड़ा गया है और वे निश्चित रूप से पास नहीं होंगे), json_cache.json (आधिकारिक रूप से चलाए गए परिणामों का कैश)। ये सब typesafe-public-examples रिपॉज़िटरी के cookbooks/citation_check डायरेक्टरी में रखे हैं।

उस डायरेक्टरी में जहाँ आपने इंस्टॉलेशन पाठ पूरा किया था (.venv वाली जगह), तीन फ़ाइलें डाउनलोड करें और फिर आधिकारिक notebook के दो पैकेज इंस्टॉल करें:

bash
curl -sfLO https://raw.githubusercontent.com/typesafe-ai/typesafe-public-examples/main/cookbooks/citation_check/rfc7519.txt
curl -sfLO https://raw.githubusercontent.com/typesafe-ai/typesafe-public-examples/main/cookbooks/citation_check/citations.json
curl -sfLO https://raw.githubusercontent.com/typesafe-ai/typesafe-public-examples/main/cookbooks/citation_check/json_cache.json
.venv/bin/pip install ipython 'cooksafe>=0.2.0,<0.3.0'

फिर इस पाठ की मुख्य स्क्रिप्ट citation_check.py बनाएँ, पहले स्केलेटन लिखें (क्लाइंट और कैश आधिकारिक cookbook से शब्दशः):

python
# citation_check.py —— 引用核查:拦住幻觉引文
# 依赖:.venv 里已有 typesafe-sdk(安装课装过),本课另装 ipython 和 cooksafe
import json
import os
import re
from pathlib import Path
from time import perf_counter

from cooksafe import JsonCache
from typesafe_sdk import Choice, TypeSafeClient

# 官方 cookbook 锁定的版本:本页核对的所有数字出自 jev-1.12(2026-08-16 采样)。
# 阈值是对着具体版本调的——jev-latest 别名会随新版本漂移,调过阈值的系统要锁版本 ID。
TYPESAFE_MODEL = "jev-1.12"
AUTO_ACCEPT = 0.8  # 官方注释:起步设高,多转人工;对模型的信任建立起来再往下调

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

जाँचें कि सभी फ़ाइलें जगह पर हैं:

bash
.venv/bin/python -c "from pathlib import Path; import json; print(Path('rfc7519.txt').stat().st_size, 'bytes'); print(len(json.loads(Path('citations.json').read_text())), 'citations')"

आपको यह दिखना चाहिए:

text
63039 bytes
8 citations

एक सुविधाजनक बात: आधिकारिक रूप से api_key का डिफ़ॉल्ट मान "cache-only" लिखा गया है — जब तक json_cache.json मौजूद है, दोबारा चलाने पर पूरी तरह आधिकारिक आंकड़े रीप्ले होते हैं और एक भी रिक्वेस्ट नहीं जाती, इसलिए अभी API Key न होने पर भी यह पाठ पूरा चलाया जा सकता है; कैश फ़ाइल मिटाकर असली कॉल चलाते समय ही Key ज़रूरी होती है।

  • तीनों फ़ाइलें सफलतापूर्वक डाउनलोड हुईं, ऊपर के कमांड 63039 bytes और 8 citations प्रिंट करते हैं

चरण 2: सोर्स दस्तावेज़ लोड करें और क्रमांकित सेक्शनों में काटें ​

क्यों: मॉडल को पूरा 58k-अक्षरों वाला RFC नहीं पढ़ना चाहिए। आधिकारिक तरीका: load_source() पहले हर पेज का हेडर-फ़ुटर हटाता है (वरना पैराग्राफ टुकड़ों में बँट जाते हैं), split_sections() फिर क्रमांकित सेक्शन शीर्षकों के हिसाब से 45 सेक्शनों में काटता है; आगे हर citation के लिए केवल उसका अपना सेक्शन state में जाता है। 「बड़ा state अप्रासंगिक विवरणों से भरा」— यह Jev की ज्ञात समस्या है, और यही चरण अप्रासंगिक विवरणों को पहले से बाहर रखता है।

फिर citation_check.py में नीचे लिखते जाएँ (पार्सिंग फ़ंक्शन आधिकारिक cookbook से शब्दशः):

python
def load_source() -> str:
    """RFC 7519 verbatim, minus the page headers and footers that interrupt its paragraphs."""
    lines = []
    for line in Path("rfc7519.txt").read_text().splitlines():
        bare = line.lstrip("\f")
        if re.match(r"Jones, et al\.\s.*\[Page \d+\]$", bare):
            continue
        if re.match(r"RFC 7519\s+JSON Web Token \(JWT\)\s+May 2015$", bare):
            continue
        lines.append(bare)
    return re.sub(r"\n{3,}", "\n\n", "\n".join(lines))


def split_sections(source: str) -> dict[str, str]:
    """Map each numbered section ("4.1.3") to its text, split on the RFC's header lines."""
    boundary = re.compile(r"(?m)^(?:(\d+(?:\.\d+)*)\.  .+|Appendix [A-Z]\..*)$")
    marks = list(boundary.finditer(source))
    sections = {}
    for mark, nxt in zip(marks, marks[1:] + [None]):
        if mark.group(1) is None:  # an appendix header only terminates the section before it
            continue
        sections[mark.group(1)] = source[mark.start() : nxt.start() if nxt else len(source)].strip()
    return sections


SOURCE = load_source()
SECTIONS = split_sections(SOURCE)
CITATIONS = json.loads(Path("citations.json").read_text())

देखें कि लोड का परिणाम और citations कैसे दिखते हैं:

bash
.venv/bin/python -c "from citation_check import SOURCE, SECTIONS, CITATIONS; print(f'{len(SOURCE):,} characters, {len(SECTIONS)} numbered sections, {len(CITATIONS)} citations')"

आपको यह दिखना चाहिए:

text
58,365 characters, 45 numbered sections, 8 citations

अब दो citations का रूप देखें (एक quote के साथ, एक केवल सेक्शन की ओर इशारा करता हुआ):

bash
.venv/bin/python -c "import json; from citation_check import CITATIONS; print(json.dumps(CITATIONS[1], indent=2)); print(json.dumps(next(c for c in CITATIONS if c['quote'] is None), indent=2))"

आपको यह दिखना चाहिए:

text
{
  "id": "aud_reject",
  "claim": "If a validator does not find itself in a token's audience list, it has to reject the token.",
  "quote": "If the principal processing the claim does not identify itself with a value in the \"aud\" claim when this claim is present, then the JWT MUST be rejected.",
  "section": "4.1.3"
}
{
  "id": "iat_future",
  "claim": "The \"iat\" claim requires validators to reject tokens whose issue time is in the future.",
  "quote": null,
  "section": "4.1.6"
}

हर citation के चार फ़ील्ड हैं: id (आपका दिया पहचानकर्ता), claim (AI आउटपुट का वह दावा), quote (जिस मूल पाठ के अंश का वह हवाला देता है), section (सेक्शन संख्या)। quote का null होना यह बताता है कि 「केवल सेक्शन बताया गया, quote नहीं दिया गया」 — मैच करने लायक कोई स्ट्रिंग नहीं है, नाम लिया सेक्शन सीधे मॉडल को भेजा जाता है।

  • दोनों प्रिंट मेल खाते हैं: 58,365 characters, 45 numbered sections, 8 citations, और aud_reject (quote के साथ) तथा iat_future (quote null)

चरण 3: स्ट्रिंग-मैचिंग से पहले 「मूल पाठ में नहीं मौजूद」 citations को रोकें ​

क्यों: अगर citation दस्तावेज़ में ही नहीं है, तो वह गढ़ा हुआ है — इसके लिए मॉडल नहीं चाहिए, साधारण स्ट्रिंग-मैचिंग काफ़ी है, एक भी API कॉल नहीं जाती। मैचिंग से पहले नॉर्मलाइज़ करें: RFC पाठ की हर पंक्ति लगभग 72 अक्षरों पर लपेटी जाती है, जबकि citation में लाइन-ब्रेक जस का तस रहते हैं तो मैच नहीं होता; व्हाइटस्पेस को एक स्पेस में समेटें और घुमे उद्धरण-चिह्नों को सीधे करें, तो पंक्तियों के आर-पार फैले citations भी मेल खा जाते हैं।

फिर नीचे लिखते जाएँ (आधिकारिक cookbook से शब्दशः):

python
def normalize(text: str) -> str:
    """Collapse whitespace and fold curly quotes, so a quote matches across line wraps."""
    table = str.maketrans({"“": '"', "”": '"', "‘": "'", "’": "'"})
    return re.sub(r"\s+", " ", text.translate(table)).strip()


def find_quote(sections: dict[str, str], quote: str) -> str | None:
    """The number of the section that contains the quote verbatim, or None."""
    needle = normalize(quote)
    for number in sorted(sections, key=lambda n: [int(p) for p in n.split(".")]):
        if needle in normalize(sections[number]):
            return number
    return None


def locate(sections: dict[str, str], citation: dict) -> tuple[str, str | None]:
    """Step 1 for one citation: a status, plus the section step 2 will read."""
    if citation["quote"] is None:
        return "section-only", sections[citation["section"]]
    number = find_quote(sections, citation["quote"])
    if number is None:
        return "missing", None
    return "found", sections[number]

locate() दो चीज़ें लौटाता है: एक स्थिति (found मिला / missing नहीं मिला / section-only केवल सेक्शन), और वह सेक्शन-पाठ जो अगले चरण में मॉडल को पढ़ने भेजा जाएगा। नया locate_report.py बनाकर 8 citations के मैच के परिणाम देखें:

python
# locate_report.py —— 第 3 步检查:8 条引文的字符串匹配结果
from citation_check import CITATIONS, SECTIONS, locate

for citation in CITATIONS:
    status, section = locate(SECTIONS, citation)
    where = f"section of {len(section):,} chars" if section else "not in the source"
    print(f"{citation['id']:<18}{status:<14}{where}")
bash
.venv/bin/python locate_report.py

आपको यह दिखना चाहिए (आधिकारिक रूप से प्रकाशित आंकड़े):

text
epoch_seconds     found         section of 3,122 chars
aud_reject        found         section of 761 chars
sig_reporting     missing       not in the source
clock_skew        found         section of 529 chars
exp_required      found         section of 529 chars
pii_encryption    found         section of 1,653 chars
iat_future        section-only  section of 270 chars
duplicate_names   found         section of 918 chars

sig_reporting यहीं बाहर हो जाता है: उसका 「citation」 RFC में कभी था ही नहीं — आधिकारिक डेटा लाइसेंस (DATA_LICENSE.md) में भी लिखा है कि यह quote उन्होंने खुद लिखा था, RFC का मूल पाठ नहीं है। आगे इस पर एक भी रिक्वेस्ट खर्च नहीं होगी। iat_future दूसरी श्रेणी है: केवल 4.1.6 सेक्शन बताया, quote नहीं दिया, मैच करने लायक स्ट्रिंग नहीं है, वही सेक्शन लेकर आगे बढ़ते हैं।

  • 8 पंक्तियों की स्थिति में एक पंक्ति missing (sig_reporting), एक पंक्ति section-only (iat_future), बाकी 6 पंक्तियाँ found

चरण 4: एक Choice प्रश्न से तय करें कि संदर्भ दावे का समर्थन करता है या नहीं ​

क्यों: इस चरण तक पहुँचे citations मूल पाठ में शब्दशः मौजूद हैं — लेकिन बस इतना काफ़ी नहीं: citation सटीक हो, फिर भी उस पर टिका दावा गलत हो सकता है। यह तय करने के लिए citation का संदर्भ पढ़ना पड़ता है (चरण 3 में मिला वह सेक्शन)। आधिकारिक तरीका सेक्शन और दावे के तीन रिश्तों को एक ही Choice प्रश्न में समेटता है; सबसे अधिक संभावना वाला विकल्प ही निर्णय है, confidence ≥ 0.8 होने पर निर्णय सीधे लागू होता है, 0.8 से कम होने पर मानव-पुष्टि पर जाता है।

फिर नीचे लिखते जाएँ (प्रश्न-परिभाषा और निर्णय-फोल्डिंग आधिकारिक cookbook से शब्दशः):

python
QUESTIONS = {
    "relation": Choice(
        instructions="How does the section relate to the claim?",
        criteria={
            "supports": "The section states the claim or directly implies that it is true",
            "contradicts": "The section states the opposite of the claim or implies it is false",
            "says_nothing": "The section does not address what the claim asserts, either way",
        },
    ),
}

RELATION_TO_VERDICT = {
    "supports": "verified",
    "contradicts": "contradicted",
    "says_nothing": "unsupported",
}


@json_cache
def ask(claim: str, section: str) -> dict:
    started = perf_counter()
    response = client.system_one(
        state={"claim": claim, "section": section},
        questions=QUESTIONS,
        model=TYPESAFE_MODEL,
    )
    answer = response.answers["relation"]
    return {
        "choice": answer.choice,
        "probabilities": answer.probabilities,
        "confidence": answer.confidence,
        "seconds": round(perf_counter() - started, 2),
        "input_tokens": response.usage.input_tokens or 0,
        "output_tokens": response.usage.output_tokens or 0,
    }


def verdict(status: str, answer: dict | None) -> dict:
    """Fold step 1 and step 2 into one of the four labels, plus an auto-or-review flag."""
    if status == "missing":
        # confidence None: no model was called, so there is no model confidence to report
        return {"verdict": "fabricated", "confidence": None, "auto": True}
    return {
        "verdict": RELATION_TO_VERDICT[answer["choice"]],
        "confidence": answer["confidence"],
        "auto": answer["confidence"] >= AUTO_ACCEPT,
    }


def check_citation(sections: dict[str, str], citation: dict) -> dict:
    status, section = locate(sections, citation)
    answer = ask(citation["claim"], section) if section is not None else None
    return {"id": citation["id"], "status": status, "answer": answer, **verdict(status, answer)}

तीन जगहों की डिज़ाइन पर नज़र रखें:

  • state में केवल दो चीज़ें हैं: claim और section। 「कौन-सा हिस्सा पढ़ना है」 यह काम चरण 3 में ही हो चुका है, मॉडल को साफ़-सुथरा निर्णय-सामग्री मिलती है।
  • @json_cache डेकोरेटर: कैश हिट होने पर सीधे आधिकारिक आंकड़े रीप्ले होते हैं, API कॉल नहीं होती; कैश में न होने पर ही असली रिक्वेस्ट जाती है।
  • चार निर्णयों को कैसे फोल्ड किया जाता है: missing → fabricated (confidence में None दर्ज होता है — मॉडल कॉल नहीं हुआ, रिपोर्ट करने को मॉडल-confidence नहीं है); बाकी को RELATION_TO_VERDICT से verified / contradicted / unsupported में मैप किया जाता है, auto फ़्लैग AUTO_ACCEPT तय करता है।

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

「citation मूल पाठ में शब्दशः है」 इसका मतलब 「दावा सही है」 नहीं है। exp_required का citation 4.1.4 सेक्शन से एक-एक अक्षर मेल खाता हुआ लिया गया है, और दावा कहता है 「हर JWT में exp होना ज़रूरी है, exp न होने वाला token अमान्य है」 — जबकि उसी सेक्शन में लिखा है "Use of this claim is OPTIONAL"। संभावना-वितरण में contradicts=1.0, confidence 0.99 — एक ही बार में इस तरह के 「असली हवाला देकर उल्टी बात कहने」 को रोका जाता है। निर्णय संरचित फ़ील्ड + कैलिब्रेटेड संभावना है, कोड सीधे शाखा बना देता है; इसके बजाय जनरेटिव मॉडल से 「जाँच-राय」 लिखवाएँ तो पाठ पार्स करना पड़ेगा, और यह भूलिए नहीं कि वह खुद भी हैल्यूसिनेट करता है।

💡 चीनी सामग्री के लिए सावधानी

आधिकारिक विवरण: अंग्रेज़ी Jev की मुख्य ट्रेनिंग भाषा है; चीनी समेत अन्य भाषाएँ चलती हैं पर सटीकता कम होती है। चीनी दस्तावेज़ों और चीनी दावों पर citation-जाँच करने से पहले, या प्रश्नों को चीनी में अनुवाद करने से पहले, अपने असली डेटा पर एक बैच चलाएँ, संभावना-वितरण और confidence देखकर ही थ्रेशोल्ड तय करें।

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

चरण 5: पूरी तरह AI citation-जाँच चलाएँ, देखें चारों निर्णय किसे-किसे रोकते हैं ​

क्यों: एक-एक उद्धरण का लॉजिक अलग से देखें, पूरे सेट का असर कुल मिलाकर। आधिकारिक टीम ने 8 उद्धरणों को पूरा देखा: 4 सटीक उद्धरण सभी verified (confidence 0.93 या उससे ऊपर), 4 छेड़छाड़ वाले सभी रोक लिए गए—1 fabricated, 1 contradicted, 2 unsupported मैन्युअल कतार में।

citation_check.py को पूरा करने के लिए, मुख्य प्रोग्राम जोड़ें:

python
if __name__ == "__main__":
    print(f"{'citation':<18}{'quote':<14}{'relation':<14}{'conf':>6}  {'verdict':<13}{'action':>7}")
    for citation in CITATIONS:
        result = check_citation(SECTIONS, citation)
        answer = result["answer"]
        relation = answer["choice"] if answer else "-"
        conf = f"{answer['confidence']:.2f}" if answer else "-"
        action = "auto" if result["auto"] else "review"
        print(
            f"{result['id']:<18}{result['status']:<14}{relation:<14}{conf:>6}"
            f"  {result['verdict']:<13}{action:>7}"
        )

चलाएँ (कैश फ़ाइल मौजूद है, आधिकारिक आँकड़े रिप्ले होंगे, कोई अनुरोध नहीं जाएगा; कैश हटाने पर ही 7 असली कॉल होंगी):

bash
.venv/bin/python citation_check.py

आपको यह दिखना चाहिए (आधिकारिक रूप से जारी आँकड़े, jev-1.12, 2026-08-16 सैंपलिंग; कैश फ़ाइल हटाने के बाद असली कॉल):

text
citation          quote         relation        conf  verdict       action
epoch_seconds     found         supports        0.93  verified        auto
aud_reject        found         supports        0.95  verified        auto
sig_reporting     missing       -                  -  fabricated      auto
clock_skew        found         supports        0.99  verified        auto
exp_required      found         contradicts     0.99  contradicted    auto
pii_encryption    found         says_nothing    0.27  unsupported   review
iat_future        section-only  says_nothing    0.56  unsupported   review
duplicate_names   found         supports        0.99  verified        auto

इस तालिका को पंक्ति-दर-पंक्ति पढ़ें; चार बारीकियाँ आधिकारिक टीम ने जानबूझकर रखी हैं:

  • 4 सटीक उद्धरण सभी verified: epoch_seconds, aud_reject, clock_skew, duplicate_names, confidence 0.93 से ऊपर, 0.8 की लागू सीमा से कहीं ऊँचा।
  • sig_reporting ने एक भी अनुरोध नहीं खर्च किया: quote RFC में नहीं है, स्ट्रिंग मैचिंग के चरण में ही fabricated करार दे दिया गया, मॉडल तक पहुँचा ही नहीं।
  • exp_required "असली उद्धरण देकर उल्टी बात कहने" का मामला है: उद्धरण शब्दशः 4.1.4 से लिया गया, पर उसी सेक्शन में लिखा है "Use of this claim is OPTIONAL"—contradicts 1.0, confidence 0.99।
  • pii_encryption और iat_future मैन्युअल कतार में गए: says_nothing और confidence केवल 0.27 और 0.56, दोनों 0.8 से नीचे। pii_encryption ठीक "सिर्फ स्ट्रिंग मैचिंग काफ़ी नहीं" का आधिकारिक उदाहरण है—उद्धरण शब्दशः मूल पाठ में है, पर जिस सेक्शन 3 में वह है, वह "एन्क्रिप्शन अनिवार्य है" दावे पर कुछ नहीं कहता।

अब लागत पर एक नज़र: कैश में दर्ज 7 मॉडल कॉल, प्रति कॉल 0.08–0.25 सेकंड, कुल 4,420 इनपुट टोकन, 281 आउटपुट टोकन—आउटपुट मुफ़्त; इनपुट को मौजूदा दर $0.042/Mtok (देखें मॉडल और कीमतें) से बदलने पर, इस पूरे दौर की जाँच करीब $0.0002।

  • मेरी चली हुई तालिका में verified / fabricated / contradicted / unsupported चारों निर्णय आए
  • दोनों unsupported में review टैग है, बाकी सब auto

📋 मैजिक Prompt ​

इस पृष्ठ का "Prompt" API के लिए प्रश्न और निर्णय टेम्पलेट है—कॉपी करके 【】 प्लेसहोल्डर बदल दें (? वाले वैकल्पिक हैं), तभी तैयार।

📝 उद्धरण-संबंध Choice प्रश्न (तीन-विकल्प निर्णय) ​

अपेक्षित परिणाम: "यह संदर्भ और दावा का आपस में क्या रिश्ता है" को एक निश्चित तीन-विकल्प Choice प्रश्न बना देना, निर्णय का मापदंड criteria में तय लिखा जाए।

python
from typesafe_sdk import Choice

QUESTIONS = {
    "relation": Choice(
        instructions="【一句话问上下文与论断的关系,官方原文:How does the section relate to the claim?】",
        criteria={
            "supports": "【什么算支持:章节陈述了论断,或直接暗示它为真】",
            "contradicts": "【什么算相抵触:章节说的是论断的反面,或暗示它为假】",
            "says_nothing": "【什么算没提到:章节对论断的断言不置可否】",
        },
    ),
}
# 必填项:三个选项的方向要正——supports = 引文真的撑得住论断
# 选填项:需要更多判定档位(如「部分支持」)就加选项;选项数变了 confidence 的读法也跟着变?

# 输出规范:answer.choice → 最高概率选项;answer.probabilities → 每个选项的概率;answer.confidence → 0–1
# 约束条件:
# ✅ 选项定义写成可对照的情境,边界情形放进 criteria
# ❌ 不要只给 supports / not_supports 两档——「原文说了相反的话」和「原文没提」必须分开处理

✅ चार निर्णयों का फोल्ड + मैन्युअल हस्तांतरण थ्रेशोल्ड ​

अपेक्षित परिणाम: स्ट्रिंग मैचिंग परिणाम और मॉडल निर्णय को verified / unsupported / contradicted / fabricated में फोल्ड करना, कम confidence पर स्वतः मैन्युअल कतार।

python
AUTO_ACCEPT = 【0.8】  # 官方起点:先高后低,低于它就转人工

RELATION_TO_VERDICT = {
    "supports": "verified",
    "contradicts": "contradicted",
    "says_nothing": "unsupported",
}


def verdict(status: str, answer: dict | None) -> dict:
    """status: missing / found / section-only(字符串匹配那步的输出)"""
    if status == "missing":
        return {"verdict": "fabricated", "confidence": None, "auto": True}  # 没调模型,confidence 记 None
    return {
        "verdict": RELATION_TO_VERDICT[answer["choice"]],
        "confidence": answer["confidence"],
        "auto": answer["confidence"] >= AUTO_ACCEPT,
    }
# 必填项:AUTO_ACCEPT 用你自己文档上跑出的分布定,0.8 只是官方起点
# 选填项:想更严可以给 contradicted 单独设一条更低的转人工线?

# 输出规范:{"verdict": "verified|unsupported|contradicted|fabricated", "confidence": float|None, "auto": bool}
# 约束条件:
# ✅ auto=False 的一律进人工队列——官方就是这么处理 pii_encryption(0.27)和 iat_future(0.56)的
# ❌ 不要拿 confidence 改判定本身——它只决定「谁来看」,不决定「是什么」

🔧 citations.json: अपने दस्तावेज़ और उद्धरण से बदलें ​

अपेक्षित परिणाम: जाँच को अपने RAG / राइटिंग प्रोडक्ट की ओर मोड़ना: सोर्स दस्तावेज़ बदलें, उद्धरण सूची बदलें, निर्णय पाइपलाइन में एक लाइन बदलने की ज़रूरत नहीं।

json
[
  {
    "id": "【引文 id,用你产品里的引文主键,判定结果好回写】",
    "claim": "【AI 输出里的那句论断,原文照抄】",
    "quote": "【它引用的原文片段;只指章节不给引文时填 null】",
    "section": "【章节号,如 4.1.4;quote 为 null 时必填,模型读这一节】"
  }
]
  • अनिवार्य फ़ील्ड: claim + quote (या quote: null के साथ section)
  • वैकल्पिक फ़ील्ड: id प्रोडक्ट की प्राइमरी की के रूप में, निर्णय को मूल दस्तावेज़ में वापस लिखना आसान?
  • आउटपुट विनिर्देश: हर उद्धरण → चार निर्णयों में से एक + confidence + auto टैग
  • बाध्यकारी शर्तें:
    • ✅ quote सोर्स दस्तावेज़ से शब्दशः लें—आधिकारिक मैचिंग सामान्यीकरण के बाद कीसटीक मैचिंग है
    • ❌ "लगभग सही" उद्धरण सहने की उम्मीद न रखें—काटे-छाँटे या बदले हुए quote found नहीं माने जाते, fabricated करार दिए जाएँगे; प्रोडक्शन में लापरवाह उद्धरण सहने हों तो फ़ज़ी मैचिंग अपनानी होगी (आधिकारिक मूल शब्द)

चेकपॉइंट ✅ ​

  • citation_check.py से 8 पंक्तियों की निर्णय तालिका, verified / fabricated / contradicted / unsupported चारों निर्णय दिखे
  • मैं बता सकता हूँ कि sig_reporting एक भी अनुरोध खर्च किए बिना fabricated क्यों हुआ—स्ट्रिंग मैचिंग को RFC में वह "उद्धरण" नहीं मिला
  • मुझे पता है exp_required का उद्धरण शब्दशः 4.1.4 में है, फिर भी निर्णय contradicted क्यों—उसी सेक्शन में लिखा है "Use of this claim is OPTIONAL"
  • मुझे पता है pii_encryption (0.27) और iat_future (0.56) मैन्युअल कतार में क्यों गए—दोनों 0.8 के AUTO_ACCEPT से नीचे
  • मुझे पता है आधिकारिक आँकड़े jev-1.12 (2026-08-16 सैंपलिंग) से हैं: कैश फ़ाइल मौजूद हो तो यही रिप्ले होता है, हटाने पर ही असली अनुरोध जाते हैं

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

❌ समझना कि "उद्धरण मूल पाठ में है" बराबर है "दावा सही है" ​

pii_encryption आधिकारिक टीम का जानबूझकर रखा गया प्रति-उदाहरण है: इसका उद्धरण शब्दशः RFC के सेक्शन 3 में है, स्ट्रिंग मैचिंग पक्का found—पर वह सेक्शन JWT की संरचना की बात करता है (claims को JWS/JWE में एन्कोड करना), "व्यक्तिगत डेटा हो तो एन्क्रिप्शन अनिवार्य" दावे पर कुछ नहीं कहता; मॉडल ने says_nothing कहा, confidence केवल 0.27। स्ट्रिंग मैचिंग सिर्फ "मनगढ़ंत" रोक सकती है, "असली उद्धरण से झूठ बोलना" नहीं—इसीलिए चरण 4 में वह Choice प्रश्न है।

❌ सटीक मैचिंग को फ़ज़ी मैचिंग की तरह इस्तेमाल करना ​

आधिकारिक मूल कथन: सामान्यीकरण के बाद मिलान सटीक होता है——उद्धरण कटा हुआ हो, या एक शब्द हल्के से बदला गया हो, तो परिणाम missing → fabricated है। यदि आपका सिस्टम लापरवाह उद्धरणों को सहन करना चाहता है, तो फ़ज़ी मैचिंग पर स्विच करना होगा। लॉन्च से पहले सोच लें: आपके प्रोडक्ट में「उद्धरण」कैसे बनते हैं, कटान और पुनर्लेखन कितने आम हैं।

❌ सिर्फ "पास / फेल" दो स्तर रखना ​

चारों निर्णयों का अपना-अपना इस्तेमाल है: verified सीधे आगे बढ़ेगा; fabricated और contradicted को दोबारा लिखवाना होगा—एक मनगढ़ंत है, दूसरे में मूल पाठ ने उल्टा कहा है; unsupported परिस्थिति देखकर—हो सकता है स्रोत जोड़ना हो, हो सकता है दावा ही बदलना हो। दो स्तरों में निचोड़ दें तो आगे एक ही कटौती बचेगी, exp_required (मूल पाठ ने उल्टा कहा) और pii_encryption (मूल पाठ ने कुछ नहीं कहा) एक जैसा व्यवहार पाएँगे।

❌ थ्रेशोल्ड सेट करके दोबारा न देखना ​

आधिकारिक टिप्पणी साफ़ कहती है: AUTO_ACCEPT = 0.8 "शुरुआत में ऊँचा रखें, ज़्यादा मैन्युअल कतार" का आरंभिक बिंदु है; कुछ समय चलाएँ, मॉडल के अपने दस्तावेज़ों पर प्रदर्शन को देखकर नीचे लाएँ। साथ ही आधिकारिक टीम ने TYPESAFE_MODEL को jev-1.12 पर बाँधा है, यह बिना सोचे नहीं—jev-latest उपनाम नए वर्शन के साथ खिसकता रहता है; पुराने वर्शन पर छाँटा थ्रेशोल्ड वर्शन बदलने पर कुछ और ही हो सकता है (देखें मॉडल और कीमतें)।

उन्नत तरीके (वैकल्पिक) ​

ब्राउज़र में पहले आज़माएँ (कोड से मुक्त)। आधिकारिक cookbook cooksafe के make_playground_link() से exp_required के claim + section और प्रश्न को शेयर लिंक में बदलता है; खोलते ही Playground में वही अनुरोध चलता है:

exp_required का playground उदाहरण खोलें →

लिंक बनाने वाला कोड बहुत छोटा है (आधिकारिक notebook में चलाया गया, example और example_section exp_required वाले citation से लिए गए हैं):

python
from cooksafe import make_playground_link
from IPython.display import Markdown, display

playground_link = make_playground_link(
    {"claim": example["claim"], "section": example_section}, QUESTIONS
)

अपने डेटा की ओर इशारा करें। आधिकारिक निष्कर्ष सीधा कहता है: rfc7519.txt और citations.json बदल दें बस—लेकिन load_source() और split_sections() RFC के प्रारूप के हिसाब से लिखे गए हैं (हेडर-फुटर हटाना, क्रमांकित अनुभाग शीर्षकों के अनुसार विभाजित करना), दूसरे दस्तावेज़ों के आकार के लिए अपना parsing लिखना होगा। वेबपेज, PDF से टेक्स्ट, Markdown मैनुअल—इनका «अनुभाग» काटने का तर्क अलग-अलग है, लेकिन «हर citation के लिए केवल वही हिस्सा भेजें जिसमें वह है» यह सिद्धांत नहीं बदलता।

कैश रीप्ले बनाम वास्तविक कॉल। json_cache.json मौजूद है तो दोबारा चलाने पर आधिकारिक आंकड़े रीप्ले होते हैं (api_key का डिफ़ॉल्ट "cache-only" है, Key के बिना भी reproduce होता है); इसे हटा दें तो 7 वास्तविक कॉल input token के हिसाब से बिल होते हैं, output मुफ़्त है। अपने प्रोजेक्ट में भी ऐसे «पहले रीप्ले, फिर वास्तविक चलाना» चाहते हैं तो cooksafe का JsonCache decorator इसी काम के लिए है।

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

✅ AI citation सत्यापन के दो द्वार: string matching उन citations को रोकती है जो «मूल पाठ में नहीं हैं» (fabricated, शून्य API लागत); एक Choice प्रश्न यह तय करता है कि संदर्भ दावे को समर्थन देता है या नहीं।

✅ चार निर्णय अपनी-अपनी जगह पर: verified जाने दें, contradicted वापस भेजें (मूल पाठ ने उल्टा कहा), unsupported मानव के पास भेजें (मूल पाठ ने उल्लेख नहीं किया), fabricated वापस भेजें (citation बनावटी है)—«असली पाठ उद्धृत करके झूठ बोलना» और «मूल पाठ ने कुछ नहीं कहा» को अलग-अलग संभाला जाता है।

✅ confidence गेटिंग: ≥ 0.8 पर निर्णय लागू होता है, उससे कम पर मानव के पास जाता है—आधिकारिक 8 में से ठीक 2 (0.27, 0.56) मानव कतार में गए।

✅ आधिकारिक वास्तविक परीक्षण: 4 सटीक citations सभी verified (0.93 से ऊपर), 4 समस्याग्रस्त citations सभी रोके गए; 7 मॉडल कॉलों में कुल लगभग 4.4k input token, वर्तमान दरों से लगभग $0.0002।

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

फ़ील्डइस पेज पर मानविवरण
TYPESAFE_MODELjev-1.12आधिकारिक cookbook में लॉक संस्करण; alias drift करते हैं, threshold ट्यून करते समय ID लॉक करें
AUTO_ACCEPT0.8निर्णय लागू होने की रेखा, इससे कम पर मानव के पास; शुरुआत ऊँची रखें, नीचे घटाएँ
QUESTIONS["relation"]Choice के तीन विकल्पsupports / contradicts / says_nothing
निर्णय मैपिंगsupports→verified आदिmissing→fabricated मॉडल से नहीं गुज़रता, confidence में None दर्ज
state{"claim": …, "section": …}मॉडल केवल दावा + संबंधित अनुभाग पढ़ता है, असंबंधित विवरण संदर्भ में नहीं आते
कैशjson_cache.jsonआधिकारिक आंकड़े रीप्ले करता है; हटाने पर वास्तविक कॉल

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

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

Citation सत्यापन «उद्धृत की गई बात» की रखवाली करता है, अगला पाठ «संदर्भ में डाले गए अनुच्छेद» की: RAG अनुच्छेद जाँच: केवल संबंधित सामग्री संदर्भ में जाए।

आप सीखेंगे:

  • हर retrieval अनुच्छेद के लिए एक अनुरोध से प्रासंगिकता स्कोर, कोड तय करता है कि कौन से अनुच्छेद answering model तक पहुँचेंगे
  • हर अनुच्छेद को Noul हाँ-ना प्रश्न से 0–1 प्रायिकता स्कोर—इस पेज के Choice निर्णय का ठीक पूरक
  • असंबंधित अनुच्छेदों को संदर्भ से बाहर रखें, उत्तर की गुणवत्ता अब retrieval की गुणवत्ता के साथ drift नहीं करती
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.