मान निष्कर्षण: तारीख, ईमेल, फ़ोन, राशि
💡 एक वाक्य में सार: Jev जानकारी निष्कर्षण से एक फ़ील्ड पाइपलाइन बनाएँ—तारीख को भागों में तोड़कर कोड से जोड़ें, ईमेल/फ़ोन/राशि के लिए पहले regex से उम्मीदवार खोजें, Jev सही वाला चुनें, मान केवल मूल पाठ से ही आ सकता है।
दस्तावेज़ के फ़ील्ड डेटाबेस को देने के लिए, आपको चाहिए «जवाब जैसा दिखने वाला एक पाठ» नहीं। आधिकारिक तौर पर इसके लिए दो cookbook दिए गए हैं: Date extraction (तारीख निष्कर्षण) तारीख केभागों के बारे में पूछता है—कौन सा महीना, कौन सी तारीख, वर्ष लिखा है या नहीं, निरपेक्ष तारीख है या «अगले गुरुवार» जैसी सापेक्ष तारीख; कैलेंडर गणित पूरी तरह कोड पर छोड़ा जाता है; Pre-parsed value extraction (पूर्व-पार्स्ड मान निष्कर्षण) मेंregex से उम्मीदवार खोजे जाते हैं, Jev सही वाला चुना जाता है, कोड अक्षरशः प्रतिलिपि बनाता है। बँटवारे का एक ही नियम है: मॉडल पाठ पढ़ता है, गणित और मानकीकरण कोड में होते हैं।
यह लाइन अलग पाठ के लायक क्यों है? आधिकारिक तौर पर Pre-parsed में बिल्कुल स्पष्ट कहा गया है: TypeSafe केवल regex द्वारा पहले से मिले उम्मीदवारों में से चुनता है, इसलिए यह कोई मान गढ़ नहीं सकता, और न ही संख्या को विस्थापित करके लिख सकता है। आधिकारिक वास्तविक परीक्षण परिणाम: छह तारीख उदाहरण सभी सही (इनमें एक ऐसी तारीख भी शामिल है जो दस्तावेज़ में लिखी ही नहीं थी, उसे सही ढंग से «तारीख नहीं दी जा सकती» माना गया, 0.46 पर मानव समीक्षा); ईमेल के चार पतों में से प्राप्तकर्ता ईमेल सही चुना गया 0.97; तीन फ़ोन में मोबाइल नंबर सही चुनकर +14155550177 में मानकीकृत किया गया; इनवॉइस की चार राशियों में कुल योग और छूट सही चुनी गईं, credit / charge की संभावना एक ओर 0.03 दूसरी ओर 0.98। यह पाठ लगभग 15 मिनट में पूरा चलाया जा सकता है—इसमें ईमेल/फ़ोन/राशि वाले हिस्से में, आधिकारिक कैश डाउनलोड करने के बादशून्य Key के साथ आधिकारिक सभी आँकड़े पुनरुत्पन्न (इस पृष्ठ पर वास्तविक परीक्षण सफल; तारीख वाला हिस्सा क्यों नहीं चल सकता, चरण 1 में समझाया जाएगा)।
सीखने के बाद आप क्या कर सकेंगे
extract_date(document, role)लिखें: इसे एक दस्तावेज़ और एक वाक्य «फ़ॉर्म लौटाने की अंतिम तारीख क्या है» दें, वापस पाएँ एकdateसाथ में confidence; वर्ष न लिखा हो तो वर्ष जोड़ें, «अगले गुरुवार» को ठोस तारीख में पार्स करें, जोड़ी न जा सकने वाली तारीख पर त्रुटि देंfind+pickजोड़ी से मान निकालें: regex से ईमेल/फ़ोन/राशि के उम्मीदवार पकड़ें, Jev सही वाला चुनें, जवाब उम्मीदवार कीअक्षरशः प्रतिलिपि होता है—कोई मनगढ़ंत नहीं, कोई विस्थापित ट्रांसक्रिप्शन नहीं- चुने गए मानों को मानकीकृत करें: ईमेल लोअरकेस में, फ़ोन E.164 अंतरराष्ट्रीय प्रारूप में, राशि
Decimalमें और साथ में credit / charge चिह्नित करें - एक पैसा खर्च किए बिना आधिकारिक मान निष्कर्षण आँकड़े पुनरुत्पन्न करें: आधिकारिक
json_cache.jsonकैश रीप्ले, पुनः चलाने पर शून्य अनुरोध
Jev का उपयोग क्यों करें, और LLM से सीधे निकालवाने के बजाय?
«LLM से अनुबंध से तारीख निकलवा लो»—बहुत से लोगों की पहली प्रतिक्रिया यही है—चल जाता है, लेकिन हर अक्षर वह फिर से खुद टाइप करता है।
| क्षमता | LLM से सीधे निकालवाना | Jev जानकारी निष्कर्षण |
|---|---|---|
| मान का स्रोत | ❌ मॉडल फिर से जनरेट करता है, कोई मान गढ़ सकता है, 14 को 41 लिख सकता है | ✅ विकल्प वही उम्मीदवार हैं जो regex से मिले, जवाब उनमें से किसी एक कीमूल प्रतिलिपिया none है—आधिकारिक शब्द: invent नहीं कर सकता, transpose नहीं कर सकता |
| कैलेंडर गणित | ❌ «अगले गुरुवार को कौन सी तारीख है», «2 महीने में 30 तारीख है या नहीं» मॉडल से करवाना अविश्वसनीय है | ✅ मॉडल केवल भाग पढ़ता है (अगस्त / 14 / वर्ष नहीं लिखा), जोड़ना, अनुमान, सत्यापन सब कोड में |
| दस्तावेज़ में न लिखा मान | ❌ फिर भी कोई तारीख दे देने की प्रवृत्ति | ✅ mode=none, year=none, pick=none तीन आपात द्वार—आधिकारिक पक्ष: गायब भाग को रिपोर्ट किया जाना चाहिए, अनुमान लगाया नहीं जाना चाहिए |
| भरोसे का स्तर | ❌ पूछना पड़ता है «क्या आप निश्चित हैं», जवाब फिर भी स्थिर नहीं | ✅ हर भाग के साथ confidence, तारीख मेंप्रयुक्त भागों में सबसे कमज़ोर लिया जाता है, 0.60 से कम होने पर मानव समीक्षा |
| जवाब का रूप | ❌ मुक्त पाठ या JSON, डाउनस्ट्रीम पार्सिंग विफल होगी | ✅ टाइप्ड जवाब + संभावना वितरण, कोड सीधे उपयोग करता है |
एक वाक्य में: LLM दस्तावेज़ आपके लिए फिर से लिखता है, Jev दस्तावेज़आपके लिए केवल पढ़ता है—लिखी गई संख्या हमेशा मूल पाठ से आती है।
आपकी वर्तमान दुविधा
- «LLM से इनवॉइस का कुल योग निकलवाते हैं, तो वह कभी-कभी
$1,315.50को$1,351.50लिख देता है—एक स्थान की गड़बड़ी, डाउनस्ट्रीम बिल सब गलत, और पता भी नहीं चलता कि किस चरण में गलती हुई» - «अनुबंध में डिलीवरी की तारीख लिखी ही नहीं है, फिर भी मॉडल ढंग से एक तारीख गढ़कर दे देता है; मुझे उसके हैल्यूसिनेशन पकड़ने के लिए एक और सत्यापन परत लिखनी पड़ती है»
- 『「अगले शुक्रवार तक लौटाएँ』 जैसी सापेक्ष तारीखें मॉडल से कैलेंडर गणित करवाती हैं, और हर बार चलाने पर जवाब अलग आता है」
इस तरकीब का उपयोग कब करें
जब आपको चाहिए:
- अनुबंध, ईमेल, इनवॉइस, फ़ॉर्म से संरचित फ़ील्ड निकालना: तारीख, ईमेल, फ़ोन, राशि — सीधे डेटाबेस या बिलिंग प्रवाह में
- मान शब्दशः दस्तावेज़ से आने चाहिए — मनगढ़ंत नहीं, गलत जगह से ट्रांसक्रिप्ट नहीं, और गायब होने पर स्पष्ट रूप से गायब बताना हो
- सापेक्ष तारीखें (「आज」「अगले गुरुवार」) को ठोस तारीख में पार्स करना, और पार्सिंग नियम आपके कोड में लिखे हों — नियम बदलें, सवाल नहीं
और जब आप नहीं चाहते:
- LLM के थूके JSON को पार्स करना और फिर 「क्या इसने फिर से बना दिया」 जैसी एक और सत्यापन परत लिखना
- जनरेटिव मॉडल से कैलेंडर गणित करवाना
- हर नए दस्तावेज़ पर prompt फिर से ट्यून करना
🎒 शुरू करने से पहले की तैयारी
- पूरा किया Noul हाँ-नहीं प्रश्न: राशि की credit / charge पहचान Noul पर टिकी है, 0.5 = पचास-पचास
- पूरा किया Choice बहुविकल्पीय प्रश्न: तारीख के सात सवाल सब Choice हैं —
criteriaविकल्प map लिखना औरchoiceवconfidenceपढ़ पाना आना चाहिए - पढ़ने की सलाह Confidence विश्वास स्तर: पता हो कि 0.60 यह पुनःजाँच रेखा जोखिम के अनुसार कैसे एडजस्ट होती है
- चला लियाइंस्टॉल और पहला अनुरोध:
.venvउपलब्ध है। मान निष्कर्षण वाला हिस्सा बिना Key भी चलेगा(चरण 1 में ऑफ़िशियल कैश दिया गया है); तारीख वाले हिस्से के लिएTYPESAFE_API_KEYचाहिए - एक कप पानी ☕ — यह पाठ एक पूर्ण लघु प्रोजेक्ट है: एक तारीख फ़ंक्शन + तीन तरह के मान परिदृश्य; मॉडल केवल टेक्स्ट पढ़ता है, गणित और सामान्यीकरण पूरे कोड में
मेरे साथ करें
पहले तय कर लें कि कैसे चलाना है: नया value_extraction.py बनाएँ, और नीचे हर चरण के कोड ब्लॉक क्रम से उसी एक फ़ाइल में चिपकाएँ। इस पाठ के दो हिस्से हैं, दो तरीके से चलते हैं:
- चरण 2–4 (तारीख): ऑफ़िशियल कैश और मौजूदा कोड की कैश की मेल नहीं खाती (चरण 1 में विस्तार से),
TYPESAFE_API_KEYसेट करके वास्तव में चलाएँ — छह उदाहरणों में कुल 6 अनुरोध, जवाब लोकल कैश में, दोबारा चलाने पर दोहरा खर्च नहीं - चरण 5–6 (ईमेल/फ़ोन/राशि): ऑफ़िशियल
json_cache.jsonडाउनलोड करकेबिना Key ऑफ़िशियल के सारे आँकड़े पुनरुत्पन्न करें
अभी Key नहीं है? सीधे चरण 5 पर जाकर पहले मान निष्कर्षण चला लें; तारीख वाला हिस्सा पेज पर दिए गए ऑफ़िशियल रिकॉर्डेड आँकड़ों के मुकाबले पढ़ें — हर चरण पर अंकित है।
चरण 1: एनवायरनमेंट इंस्टॉल करें, ऑफ़िशियल कैश डाउनलोड करें, दो सेट निष्कर्षण उदाहरण तैयार रखें
क्यों: ऑफ़िशियल दोनों उदाहरणों में एक-एक रिकॉर्डेड जवाब कैश json_cache.json आती है — मान निष्कर्षण वाली व्यवहार में परखकर शब्दशः रीप्ले होती है, बिना Key; तारीख वाली कैश की कुंजी मौजूदा कोड से मेल नहीं खाती, वह केवल live चल सकती है। पहले सामग्री जुटा लें, तभी आगे हर चरण पर जवाब से मिलान हो पाएगा।
डिपेंडेंसी इंस्टॉल करें (ऑफ़िशियल दोनों cookbook की इंस्टॉल कमांड मिलाकर; typesafe-sdk का वर्शन रेंज cooksafe 0.2.0 की डिपेंडेंसी घोषणा typesafe-sdk<0.8.0,>=0.7.0 के अनुसार स्पष्ट रूप से पिन की गई है; cooksafe ऑफ़िशियल cookbook का साथी टूल लाइब्रेरी है, PyPI विवरण 「Shared helpers for the TypeSafe cookbooks」 — इस पेज पर इसकी JsonCache कैश का उपयोग होता है):
pip install 'typesafe-sdk>=0.7.0,<0.8.0' ipython phonenumbers 'cooksafe>=0.2.0,<0.3.0'मान निष्कर्षण की ऑफ़िशियल कैश डाउनलोड करें (raw सीधा लिंक, परखकर काम करता है):
curl -sL -o values_cache.json https://raw.githubusercontent.com/typesafe-ai/typesafe-public-examples/main/cookbooks/pre_parsed_value_extraction_cookbook/json_cache.jsonनया value_extraction.py बनाएँ, फ़ाइल हेडर चिपकाएँ — क्लाइंट पर दो कैश लगी हैं, तारीख और मान अपनी-अपनी:
import os
import re
from datetime import date, timedelta
from decimal import Decimal
from pathlib import Path
import phonenumbers
from cooksafe import JsonCache
from typesafe_sdk import Choice, Noul, TypeSafeClient
# 官方录制版本:Date extraction 用 jev-1.12,
# Pre-parsed value extraction 用 jev-1.14.0。
# live 跑日期部分时换成你锁定的版本 ID;jev-latest 别名会随版本漂移。
DATE_MODEL = "jev-1.14.0"
VALUE_MODEL = "jev-1.14.0"
client = TypeSafeClient(
api_key=os.environ.get("TYPESAFE_API_KEY", "cache-only"), # cached re-renders need no key
base_url=os.environ.get("TYPESAFE_BASE_URL"),
timeout=30.0,
)
# 日期:缓存你自己 live 跑的答案(官方那份对不上,见下方提示框)
date_cache = JsonCache(Path("date_cache.json"))
# 值:官方缓存,零 Key 重放第 5、6 步全部官方数字
values_cache = JsonCache(Path("values_cache.json"))
print("setup ok")python value_extraction.py चलाएँ।
आपको यह दिखना चाहिए: setup ok — यह चरण केवल असेंबली है, अभी अनुरोध नहीं भेजा गया।
⚠️ तारीख कैश ऑफ़िशियल वाली क्यों नहीं डाउनलोड करते
ऑफ़िशियल रिपॉज़िटरी मेंतारीख वाले हिस्से की कैश भी जारी है, लेकिन मेरी व्यवहारिक जाँच में: इस पेज के कोड (यानी ऑफ़िशियल दस्तावेज़ी का वर्तमान कोड) और cooksafe 0.2.0 से रीप्ले करने पर छहों कॉलसभी मिस — कैश कुंजी मेल नहीं खाती (संभवतः रिकॉर्डिंग स्क्रिप्ट और वर्तमान दस्तावेज़ी कोड सिंक में नहीं), SDK फिर वास्तविक अनुरोध की कोशिश करता है, और Key न होने पर 401। इसलिए तारीख वाले हिस्से के लिए अपनी date_cache.json इस्तेमाल करें; ऑफ़िशियल आँकड़े इस पेज पर जस के तस दिए हैं, जवाब मिलाने के लिए। मान निष्कर्षण की ऑफ़िशियल कैश व्यवहार मेंशब्दशः रीप्ले होती है, निश्चिंत रहें।
setup okछप गया,values_cache.jsonरन डायरेक्टरी में है
चरण 2: तारीख के सात सवाल — Jev सूचना निष्कर्षण पहले भाग पढ़ता है, गणित नहीं करता
क्यों: मॉडल से सीधे 「आख़िरी तारीख कौन सी है」 पूछना, उससे कैलेंडर गणित करवाने जैसा है। ऑफ़िशियल तरीका है कि तारीख का हर भागछोटे बंद सेट में रहे: बारह महीने, 1–31 तारीख, एक वर्ष विंडो — इस तरह हर भाग एक Choice है, और एक ही अनुरोध में समानांतर पूछ लिए जाते हैं (एक अनुरोध में कई सवालों की प्रणाली देखेंसमानांतर प्रश्न और स्पेकुलेटिव फैन-आउट)। मॉडल टेक्स्ट पढ़ता है, कोड कैलेंडर गिनता है।
पहले ऑफ़िशियल चार उदाहरण दस्तावेज़ तैयार करें, फिर सात सवालों की परिभाषाएँ चिपकाएँ:
CONTRACT = "This agreement is effective January 1, 2025 and expires December 31, 2027."
FORM = "Please return the signed form by August 14."
SURVEY = "Heads up - the customer survey closes today at 5pm."
REVIEW = "Let's schedule the design review for next Thursday."
MONTHS = {
"January": 1, "February": 2, "March": 3, "April": 4,
"May": 5, "June": 6, "July": 7, "August": 8,
"September": 9, "October": 10, "November": 11, "December": 12,
}
WEEKDAYS = ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"]
YEAR_WINDOW = list(range(1900, 2051)) # 1900..2050
def date_questions(role: str) -> dict[str, Choice]:
"""Seven typed choices that read a date's shape and parts off the text -- no math."""
absent = "The document does not state this, or it is not this kind of date."
return {
"mode": Choice(
instructions=(
f"How is {role} written? 'absolute' = a calendar date naming a month (e.g. "
"'August 14', 'the 3rd of March'); 'relative' = given relative to today (today, "
"tomorrow, the day after tomorrow, or a named weekday such as 'next Thursday'); "
"'none' = the document does not state this date."
),
criteria={"absolute": None, "relative": None, "none": None},
),
"month": Choice(
instructions=f"If {role} is an absolute calendar date, which month is it in?",
criteria={m: None for m in MONTHS} | {"none": absent},
),
"day": Choice(
instructions=f"If {role} is an absolute calendar date, which day of the month (1-31)?",
criteria={str(d): None for d in range(1, 32)} | {"none": absent},
),
"year": Choice(
instructions=(
f"If {role} is an absolute calendar date, which year? Pick 'none' if the document "
"states no year (code infers it), or 'out_of_range' if a year is stated but not "
"in the list."
),
criteria={str(y): None for y in YEAR_WINDOW}
| {
"out_of_range": "A year is stated for this date but is outside the listed range.",
"none": "No year is stated for this date.",
},
),
"day_anchor": Choice(
instructions=(
f"If {role} is relative to today, which day is it? 'today', 'tomorrow', "
"'day_after' (the day after tomorrow), or 'weekday' (a named day of the week)."
),
criteria={
"today": None, "tomorrow": None, "day_after": None,
"weekday": None, "none": absent,
},
),
"weekday": Choice(
instructions=f"If {role} names a day of the week, which one?",
criteria={w: None for w in WEEKDAYS} | {"none": absent},
),
"week_offset": Choice(
instructions=(
f"If {role} names a weekday, which week is it in? 'next' for 'next Thursday' or "
"'Thursday next week'; 'current' for 'this Thursday'; 'none' for a bare weekday "
"with no qualifier (just 'Thursday' / 'on Thursday')."
),
criteria={"current": None, "next": None, "none": absent},
),
}सात सवालों का बँटवारा — mode बताता है कि यह तारीखकैसे लिखी है (पूर्ण / सापेक्ष / लिखी ही नहीं), बाकी छहभाग पढ़ते हैं: पूर्ण तारीख के लिए month + day + year, सापेक्ष तारीख के लिए day_anchor (आज / कल / परसों / कोई सप्ताह-दिन), और सप्ताह-दिन नाम लेने पर weekday व week_offset बताते हैंकौन सा औरकौन सा सप्ताह। कोड केवल mode वाले उन्हीं सवालों को पढ़ता है जो काम आते हैं।
year के दो एमरजेंसी रास्ते नोट करें: none = टेक्स्ट में वर्ष लिखा नहीं, कोड भरेगा; out_of_range = लिखा है पर 1900–2050 में नहीं — अंदाज़ा लगाने के बजाय रिपोर्ट करें। ऑफ़िशियल ने विकल्प सूची बहुत लंबी होने पर एक वैकल्पिक तरीका भी दिया है, देखेंउन्नत तरकीबें।
फिर अनुरोध भेजने वाला फ़ंक्शन चिपकाएँ, और अनुबंध की प्रभावी तारीख वाली पंक्ति चला लें:
@date_cache
def read_parts(document: str, role: str) -> dict:
"""One TypeSafe call -> {part: {choice, confidence}} for the seven questions."""
answers = client.system_one(
state=document, questions=date_questions(role), model=DATE_MODEL
).answers
return {
part: {"choice": ans.choice, "confidence": ans.confidence}
for part, ans in answers.items()
}
parts = read_parts(CONTRACT, "the date the agreement takes effect")
for name, part in sorted(parts.items()):
print(f"{name:<12}{part['choice']:<11}(conf {part['confidence']:.2f})")python value_extraction.py चलाएँ। Key सेट हो तो एक वास्तविक अनुरोध जाएगा (jev-1.14.0), जवाब date_cache.json में जाएगा।
आपको यह दिखना चाहिए (ऑफ़िशियल jev-1.12 रिकॉर्डेड आँकड़े; आपके live चलाने पर भाग चुनाव वही होना चाहिए, विश्वास स्तर में छोटा अंतर हो सकता है):
day 1 (conf 0.98)
day_anchor none (conf 0.89)
mode absolute (conf 1.00)
month January (conf 1.00)
week_offset none (conf 0.99)
weekday none (conf 0.86)
year 2025 (conf 0.97)तीन पढ़ने के तरीके:
मॉडल ने गणित नहीं किया: उसने केवल 「January」「1」「2025」 कहा — यह सप्ताह का कौन सा दिन है या आज से कितनी दूर है, नहीं कहा — वह काम चरण 3 के कोड का है
लागू न होने वाले भागों का जवाब
none: पूर्ण तारीख कोday_anchor/weekdayनहीं चाहिए, सबnoneउच्च विश्वास के साथहर भाग के साथ confidence आता है: यह मशीन जानती है कि उसका हर पढ़ा हुआ मान कितना भरोसेमंद है — चरण 4 इनसे पूरी तारीख का विश्वास स्तर निकालेगा
मैं बता सकता हूँ कि सातों सवाल क्या पढ़ते हैं, और
modeतय करता है कि कोड कौन से सवाल पढ़ेगा
चरण 3: कोड तारीख जोड़ता है — कैलेंडर गणित मॉडल तक नहीं जाता
क्यों: घटक मिल गए, बाकी सब निश्चित (deterministic) काम है: जो वर्ष नहीं लिखा है वह आज के अनुसार भर जाएगा, "next Thursday" आपकी घोषित परिपाटी के अनुसार पार्स होगा, और February 30 जैसे जोड़े जो बन ही नहीं सकते, वे error देंगे। अधिकारीक रूप से इस हिस्से को शुद्ध फ़ंक्शन (pure function) के रूप में लिखा गया है — कोई request नहीं भेजता, कोई log नहीं लिखता, इसे अलग से unit test किया जा सकता है।
जोड़ने वाला (assembly) कोड पेस्ट करें:
TODAY = date(2026, 7, 30) # fixed reference "today" so relative dates resolve reproducibly
REVIEW_BELOW = 0.60 # gate: a date below this confidence is flagged for a human
def resolve_weekday(today: date, weekday: str, week_offset: str) -> date:
"""Which date a named weekday points to, by our stated convention: a bare weekday is the next
occurrence on or after today; 'next' is the following calendar week; 'current' is this week."""
w = WEEKDAYS.index(weekday)
this_monday = today - timedelta(days=today.weekday())
if week_offset == "next":
return this_monday + timedelta(days=7 + w)
if week_offset == "current":
return this_monday + timedelta(days=w)
return today + timedelta(days=(w - today.weekday()) % 7)
def assemble(parts: dict, today: date = TODAY) -> dict:
"""Resolve the parts TypeSafe read into a concrete date, in code. Confidence is the weakest of
the parts the shape actually used."""
mode = parts["mode"]["choice"]
confs = [parts["mode"]["confidence"]]
def result(resolved: date | None, note: str) -> dict:
usable = [c for c in confs if c is not None]
confidence = min(usable) if usable else None
needs_review = resolved is None or confidence is None or confidence < REVIEW_BELOW
return {
"date": resolved,
"confidence": confidence,
"needs_review": needs_review,
"note": note,
}
if mode == "none":
return result(None, "no such date stated")
if mode == "absolute":
month, day, year = (
parts["month"]["choice"],
parts["day"]["choice"],
parts["year"]["choice"],
)
confs += [
parts["month"]["confidence"],
parts["day"]["confidence"],
parts["year"]["confidence"],
]
if "none" in (month, day) or not day.isdigit() or month not in MONTHS:
return result(None, "absolute date incomplete")
if year == "out_of_range": # a year is stated but off the list -> flag, don't guess
return result(None, f"year outside {YEAR_WINDOW[0]}-{YEAR_WINDOW[-1]}")
if year == "none": # no year stated -> infer this year, bumped to next if well past
try:
resolved = date(today.year, MONTHS[month], int(day))
except ValueError: # e.g. February 30 -- an inconsistent read, not a real date
return result(None, f"impossible date: {month} {day}")
if resolved < today - timedelta(days=31):
resolved = date(today.year + 1, MONTHS[month], int(day))
return result(resolved, "")
try: # a stated, in-range year
return result(date(int(year), MONTHS[month], int(day)), "")
except ValueError:
return result(None, f"impossible date: {year}-{month}-{day}")
if mode == "relative":
anchor = parts["day_anchor"]["choice"]
confs.append(parts["day_anchor"]["confidence"])
if anchor == "today":
return result(today, "")
if anchor == "tomorrow":
return result(today + timedelta(days=1), "")
if anchor == "day_after":
return result(today + timedelta(days=2), "")
if anchor == "weekday":
weekday, offset = parts["weekday"]["choice"], parts["week_offset"]["choice"]
confs += [parts["weekday"]["confidence"], parts["week_offset"]["confidence"]]
if weekday not in WEEKDAYS:
return result(None, "relative weekday not read")
return result(resolve_weekday(today, weekday, offset), "")
return result(None, "relative day not read")
return result(None, f"unrecognized mode: {mode}")
def extract_date(document: str, role: str) -> dict:
return assemble(read_parts(document, role))
print(extract_date(CONTRACT, "the date the agreement takes effect"))चलाएँ।
आपको यह दिखना चाहिए (आधिकारिक रिकॉर्डिंग: तीन उपयोग किए गए घटक 1.00 / 0.98 / 0.97, सबसे कमज़ोर लिया जाता है):
{'date': datetime.date(2025, 1, 1), 'confidence': 0.97, 'needs_review': False, 'note': ''}तीनों तर्क-खंडों को एक बार पढ़ें, हर खंड का अपना निकास (exit) है:
- "next Thursday" की अस्पष्टता का फ़ैसला कोड करता है: आधिकारिक रूप से घोषित परिपाटी — बिना किसी विशेषण के weekday = आज से (आज सहित) अगला;
next= अगला calendar week;current= इसी हफ़्ते। आप इसे अपनी टीम की परिपाटी के अनुसार बदल सकते हैं, बदलता है कोड है, समस्या नहीं - वर्ष न लिखा हो तो अनुमान लगाया जाता है: पहले इसी साल से जोड़ा जाता है; अगर** 31 दिन से अधिक** बीत चुके हों तभी अगले साल पर जाता है — 8 अगस्त की 14 तारीख़ वाला फ़ॉर्म 7 जुलाई की 30 तारीख़ को देखने पर इसी साल का है
- जो तारीख़ बन नहीं सकती उसे impossible कहा जाता है, जबरन नहीं जोड़ी जाती: February 30 जैसे विरोधाभासी पढ़ावट सीधे
Noneसाथ note लौटाती है, चरण 4 इसे मानव समीक्षा को भेज देगा
💡 यही Jev का अनन्य मूल्य है
विश्वास स्तर (confidence) उपयोग किए गए घटकों में सबसे कमज़ोर वाला होता है — पूर्णतः निरपेक्ष तारीख़ के लिए केवल mode + महीना + दिन + वर्ष चार चीज़ें देखी जाती हैं, day_anchor ने क्या जवाब दिया, इससे कोई फ़र्क़ नहीं पड़ता। कौन-सा घटक पीछे खींच रहा है, एक नज़र में साफ़ है, समीक्षक को पता होता है कि मूल पाठ का कौन-सा आधा वाक्य देखना है। साधारण LLM यह नहीं दे सकता: वह एक ही बार में तैयार तारीख़ थूक देता है, आपको पता नहीं होता कि कौन-सी कड़ी अनुमान पर थी।
- मैं
year=noneहोने पर लागू अनुमान नियम बता सकता/सकती हूँ (इसी साल से शुरू, 31 दिन से अधिक पहले होने पर ही अगले साल पर जाना), और बिना विशेषण वाले weekday की पार्सिंग परिपाटी
चरण 4: छह आधिकारिक उदाहरणों से जवाब मिलाना, 0.60 से कम होने पर मानव समीक्षा को भेजना
क्यों: कोई एक्स्ट्रैक्शन सिस्टम प्रोडक्शन में जा सकता है या नहीं, यह देखना होता है कि वह "दस्तावेज़ में यह तारीख़ नहीं लिखी" होने पर कैसा व्यवहार करता है। आधिकारिक छह उदाहरण चार तरह की लेखन-शैलियों और एक जाल को कवर करते हैं: अनुबंध में वर्ष लिखी हुई दो तारीख़ें, बिना वर्ष वाली फ़ॉर्म की अंतिम तिथि, "आज" बंद होने वाला सर्वे, "अगले गुरुवार" का डिज़ाइन रिव्यू, और साथ ही एक kickoff call जिसका** ज़िक्र फ़ॉर्म में** है ही नहीं (फ़ॉर्म में तारीख़ है, बस यह तारीख़ नहीं — "तारीख़ दिखे तो निकाल लो" वाली आदत के लिए खास)।
उदाहरण और स्कोरबोर्ड पेस्ट करें:
# (document, question phrase, expected date) -- the expected value is only for the scorecard.
EXAMPLES = [
(CONTRACT, "the date the agreement takes effect", date(2025, 1, 1)),
(CONTRACT, "the date the agreement expires", date(2027, 12, 31)),
(FORM, "the deadline to return the form", date(2026, 8, 14)),
(FORM, "the date of the kickoff call", None),
(SURVEY, "the date the survey closes", date(2026, 7, 30)),
(REVIEW, "the date of the design review", date(2026, 8, 6)),
]
print(f"{'':3}{'question':<38}{'expected':<12}{'got':<12}{'conf':>6} flags")
print("-" * 84)
for document, role, expected in EXAMPLES:
r = extract_date(document, role)
got = r["date"].isoformat() if r["date"] else "none"
exp = expected.isoformat() if expected else "none"
mark = "OK" if r["date"] == expected else "XX"
conf = f"{r['confidence']:.2f}" if r["confidence"] is not None else " n/a"
flags = " <== review" if r["needs_review"] else ""
if r["note"]:
flags += f" ({r['note']})"
print(f"{mark:<3}{role:<38}{exp:<12}{got:<12}{conf:>6}{flags}")
print()
confident = [(doc, role) for doc, role, _ in EXAMPLES if not extract_date(doc, role)["needs_review"]]
review = [(doc, role) for doc, role, _ in EXAMPLES if extract_date(doc, role)["needs_review"]]
print(f"auto-accept ({len(confident)}):")
for _doc, role in confident:
print(f" - {role}")
print(f"\nsend to review ({len(review)}):")
for _doc, role in review:
r = extract_date(_doc, role)
print(f" - {role} (conf {r['confidence']:.2f} / {r['note'] or 'low confidence'})")चलाएँ। छह उदाहरणों में कुल 6 कॉल — चरण 2 वाली पहले से cache में है, पहले रन में 5 नए request जाते हैं; बाद के auto-accept / review दो हिस्सों में extract_date फिर कॉल होता है, सब cache से।
आपको यह दिखना चाहिए (आधिकारिक jev-1.12 रिकॉर्डिंग, TODAY = 2026-07-30, एक गुरुवार; live आँकड़ों में थोड़ा अंतर होगा):
question expected got conf flags
------------------------------------------------------------------------------------
OK the date the agreement takes effect 2025-01-01 2025-01-01 0.97
OK the date the agreement expires 2027-12-31 2027-12-31 0.91
OK the deadline to return the form 2026-08-14 2026-08-14 0.95
OK the date of the kickoff call none none 0.46 <== review (absolute date incomplete)
OK the date the survey closes 2026-07-30 2026-07-30 0.94
OK the date of the design review 2026-08-06 2026-08-06 0.92
auto-accept (5):
- the date the agreement takes effect
- the date the agreement expires
- the deadline to return the form
- the date the survey closes
- the date of the design review
send to review (1):
- the date of the kickoff call (conf 0.46 / absolute date incomplete)तीन चीज़ें रुककर देखने लायक़ हैं:
- न लिखी गई तारीख़ रिपोर्ट की जाती है, अनुमान से नहीं गढ़ी जाती: kickoff call वाली पंक्ति में
modeनेabsoluteजवाब दिया परmonthथाnone— code "absolute date incomplete" का फ़ैसला करता है, तारीख़ खाली, confidence 0.46, needs_review। यही घटकों मेंnoneescape hatch जोड़ने का आधिकारिक उद्देश्य है: जो घटक गायब है वह रिपोर्ट होता है, मनगढ़ंत नहीं - बिना वर्ष वाला फ़ॉर्म स्वयं भर देता है: August 14 → 2026-08-14 (
TODAYहै 2026-07-30, 8 महीना अभी बीता नहीं, साल छलांगने की ज़रूरत नहीं) - "आज" और "अगले गुरुवार" दोनों ठिकाने लगे: survey closes → 2026-07-30 (उसी दिन); design review → 2026-08-06 (7 जुलाई की 30 तारीख़ गुरुवार है, "next" = अगले calendar week का 4वाँ दिन)। सापेक्ष तारीख़ें पुनरुत्पादन योग्य तभी होती हैं जब
TODAYनिश्चित हो — आप ख़ुद चलाएँ तोTODAYकी जगहdate.today()रखें, या batch चलाने से पहले एक बार पिन कर दें
प्रोडक्शन में जाने का निर्णय needs_review एकमात्र फ़ील्ड से होता है: False सीधे डेटाबेस में, True मानव समीक्षा को — जोखिम के अनुसार confidence की सीमा कैसे बदलें, देखें Confidence विश्वास स्तर।
- छह पंक्तियों का स्कोरबोर्ड और auto-accept 5 / send to review 1 सब मेल खाता है; मैं बता सकता/सकती हूँ कि kickoff call वाली पंक्ति 2026-08-14 क्यों नहीं होनी चाहिए
चरण 5: ईमेल एक्स्ट्रैक्शन — regex उम्मीदवार ढूँढता है, Jev सही वाला चुनता है
क्यों: इस चरण से बिना Key चलता है। ईमेल की असली कठिनाई "सारे पते ढूँढना" नहीं है — regex एक घंटे में लिखा जा सकता है — बल्किचार उम्मीदवारों में से कौन-सा वही है जो आपको चाहिए: रसीद किस ईमेल पर जाए, यह इस पर निर्भर करता है कि मुख्य पाठ का वह वाक्य समझा गया या नहीं — "बिल वाला उपनाम मत इस्तेमाल करना, मेरे निजी ईमेल पर भेजना"। यही आधिकारिक तीन-चरणीय तरीक़ा है: regex उम्मीदवार ढूँढता है (ज़्यादा पकड़ने में हर्ज नहीं) → Jev सही चुनता है → कोड अक्षरशः प्रतिलिपि करके normalize करता है।
चार सहायक फ़ंक्शन और ईमेल उदाहरण पेस्ट करें:
NONE = "none" # the escape hatch on every selection: "none of the candidates fits"
EMAIL_RE = re.compile(r"[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}")
PHONE_RE = re.compile(r"\(?\+?\d[\d\s()\-.]{6,}\d")
MONEY_RE = re.compile(r"[$€£¥]\s?\d[\d,]*(?:\.\d{2})?")
def find(pattern: re.Pattern, text: str) -> list[str]:
"""Code-side candidate finder: recall-tuned regex, deduped, in document order."""
seen: set[str] = set()
out: list[str] = []
for match in pattern.findall(text):
span = match.strip()
if span and span not in seen:
seen.add(span)
out.append(span)
return out
@values_cache
def pick(document: str, candidates: list[str], question: str) -> dict:
"""TypeSafe selects which found span plays the role. Returns {choice, confidence}.
The options ARE the candidate spans, so ``choice`` is a verbatim copy of one of them (or the
``none`` hatch). The model chooses; code owns the string."""
criteria = {c: None for c in candidates} | {NONE: "None of these is the requested value."}
answer = client.system_one(
state=document,
questions={"pick": Choice(instructions=question, criteria=criteria)},
model=VALUE_MODEL,
).answers["pick"]
return {"choice": answer.choice, "confidence": answer.confidence}
@values_cache
def classify(document: str, question: str, options: list[str]) -> dict:
"""A small Choice over a fixed label set (currency, country, ...). Returns {choice, confidence}."""
answer = client.system_one(
state=document,
questions={"q": Choice(instructions=question, criteria={o: None for o in options})},
model=VALUE_MODEL,
).answers["q"]
return {"choice": answer.choice, "confidence": answer.confidence}
@values_cache
def is_true(document: str, question: str) -> float:
"""A yes/no Noul. Returns P(yes)."""
return (
client.system_one(
state=document,
questions={"q": Noul(instructions=question)},
model=VALUE_MODEL,
)
.answers["q"]
.noul
)
EMAIL_DOC = """From: Jane Doe <jane.doe@example.com>
To: billing@example.com
Cc: orders@example.com
Reply-To: jane.personal@example.net
Hi team - please don't use the billing alias for this one. Send my receipt to my
personal address instead. Thanks, Jane."""
emails = find(EMAIL_RE, EMAIL_DOC)
receipt = pick(EMAIL_DOC, emails, "Which email address does the sender want their receipt sent to?")
sender = pick(EMAIL_DOC, emails, "Which email address did this message come from (the From line)?")
print("candidates :", emails)
# code copies the picked value verbatim and normalizes (lowercase); it never re-types it
print(f"receipt -> : {receipt['choice'].lower():<28} (conf {receipt['confidence']:.2f})")
print(f"sender -> : {sender['choice'].lower():<28} (conf {sender['confidence']:.2f})")python value_extraction.py चलाएँ — सब आधिकारिक cache में hit, एक भी request नहीं जाता।
आपको यह दिखना चाहिए (आधिकारिक jev-1.14.0 रिकॉर्डिंग; इस पृष्ठ पर वास्तविक परीक्षण में अक्षरशः पुनरुत्पादित):
candidates : ['jane.doe@example.com', 'billing@example.com', 'orders@example.com', 'jane.personal@example.net']
receipt -> : jane.personal@example.net (conf 0.97)
sender -> : jane.doe@example.com (conf 1.00)दो डिज़ाइन बिंदु:
pickके विकल्प स्वयं उम्मीदवार होते हैं:criteriaचार पतों की strings और एकnoneहै, इसलिएchoiceउनमें से किसी एक कीअक्षरशः समान प्रतिलिपि ही हो सकता है — पाँचवाँ पता गढ़ना असंभव है, ग़लत ट्रांसक्रिप्शन भी संभव नहीं, क्योंकि "दोबारा टाइप करना" वाला कदम है ही नहीं- चुन न सके तो कहता है कि चुन नहीं सका: जब कोई उम्मीदवार मेल नहीं खाता तो जवाब
noneहोता है, कोड इसे "नहीं मिला" मानकर संभालता है, जबरन कोई चुनता नहीं - दो सवाल, दो request, वही उम्मीदवार: प्राप्तकर्ता का पता मुख्य पाठ से (निजी ईमेल चाहिए), प्रेषक
Fromपंक्ति से — निर्णय पंक्तियों के बीच छिपा है, यही वह हिस्सा है जो regex नहीं कर सकता
💡 यही Jev का अनन्य मूल्य है
regex recall संभालता है (जो हो सकते हैं सब पकड़ लेना, ज़्यादा पकड़ने में हर्ज नहीं), Jev चयन संभालता है (मुख्य पाठ पढ़कर सही वाला चुनना), कोड शुद्धता संभालता है (अक्षरशः प्रतिलिपि + lowercase normalization)। तीनों खंड अपना-अपना काम करते हैं, कोई भी ख़राब हो तो अलग से ठीक हो सकता है — LLM का सीधा एक्स्ट्रैक्शन तीनों काम एक ही generation में मिला देता है, ग़लती हो तो पता नहीं चलता कि किस खंड में हुई।
- बिना Key receipt 0.97 / sender 1.00 निकाला; मैं बता सकता/सकती हूँ कि
pickउम्मीदवारों में न होने वाला पता लौटाना असंभव क्यों है
चरण 6: फ़ोन और राशि — E.164 और Decimal में normalize करना
क्यों: सही वैल्यू चुनना सिर्फ़ आधा खेल है, उसे सिस्टम में इस्तेमाल होने लायक़ रूप में भी बदलना पड़ता है। फ़ोन की मुश्किल: तीन नंबर बिल्कुल एक जैसे दिखते हैं, कौन-सा मोबाइल है, किस देश में है—** अंकों में यह जानकारी नहीं होती, यह आसपास के शब्दों में होती है**। राशि की मुश्किल: कुल राशि चुनना काफ़ी नहीं, यह भी पता होना चाहिए कि वह charge है या credit, वरना Decimal चिह्न तक नहीं तय कर पाएगा।
फ़ोन का उदाहरण पेस्ट करें:
PHONE_DOC = """Reach our San Francisco office at these numbers: main desk (415) 555-0199,
billing fax (415) 555-0142, and my direct cell (415) 555-0177. Call the cell if it's urgent."""
phones = find(PHONE_RE, PHONE_DOC)
mobile = pick(PHONE_DOC, phones, "Which of these is the direct mobile / cell number?")
region = classify(PHONE_DOC, "In what country is this office located?", ["US", "GB", "DE", "FR", "CA", "AU"])
# code copies the picked value and normalizes it with the model-supplied country
parsed = phonenumbers.parse(mobile["choice"], region["choice"])
e164 = phonenumbers.format_number(parsed, phonenumbers.PhoneNumberFormat.E164)
print("candidates :", phones)
print(f"mobile -> : {mobile['choice']} (conf {mobile['confidence']:.2f})")
print(f"country -> : {region['choice']} (conf {region['confidence']:.2f})")
print(f"E.164 -> : {e164}")अब राशि का उदाहरण पेस्ट करें:
MONEY_DOC = """Invoice INV-2087.
Subtotal: $1,200.00
Sales tax: $115.50
Total due: $1,315.50
A $50.00 courtesy credit from last month has already been applied."""
amounts = find(MONEY_RE, MONEY_DOC)
currency = classify(MONEY_DOC, "What currency are these amounts in?", ["USD", "EUR", "GBP", "JPY", "CAD"])
total = pick(MONEY_DOC, amounts, "Which amount is the total the customer must pay?")
credit = pick(MONEY_DOC, amounts, "Which amount is the courtesy credit that was applied?")
def to_decimal(value: str) -> Decimal:
"""Copy the picked value and parse the number in code (US grouping/decimal here)."""
return Decimal(re.sub(r"[^\d.]", "", value))
for label, chosen in [("total due", total), ("credit", credit)]:
is_credit = is_true(
MONEY_DOC,
f"Is the amount {chosen['choice']} a credit or refund to the customer, not a charge?",
)
kind = "credit" if is_credit > 0.5 else "charge"
print(
f"{label:<10}: {chosen['choice']:<10} -> {to_decimal(chosen['choice'])} {currency['choice']} "
f"({kind}, P(credit)={is_credit:.2f})"
)
print("\ncandidates :", amounts)चलाएँ।
आपको यह दिखना चाहिए (आधिकारिक jev-1.14.0 रिकॉर्डिंग; इस पृष्ठ पर वास्तविक परीक्षण में अक्षरशः पुनरुत्पादित):
candidates : ['(415) 555-0199', '(415) 555-0142', '(415) 555-0177']
mobile -> : (415) 555-0177 (conf 1.00)
country -> : US (conf 1.00)
E.164 -> : +14155550177
total due : $1,315.50 -> 1315.50 USD (charge, P(credit)=0.03)
credit : $50.00 -> 50.00 USD (credit, P(credit)=0.98)
candidates : ['$1,200.00', '$115.50', '$1,315.50', '$50.00']चार हिस्सों को अलग-अलग देखें:
- फ़ोन: Jev नंबर चुनता है + देश पढ़ता है,
phonenumbersफ़ॉर्मैटिंग का ज़िम्मेदार है—(415) 555-0177में कोई भी अंक यह नहीं कहता कि 「मैं मोबाइल हूँ」 या 「मैं अमेरिका में हूँ」, ये दोनों बातें 「my direct cell」 और 「San Francisco office」 जैसे शब्दों से आती हैं; E.164 की असेंबली शुद्ध कोड है, देश एक पैरामीटर की तरह पास होता है - राशि: एक Noul प्रश्न चिह्न तय करता है—「यह राशि ग्राहक के लिए credit है या charge」 इसके जवाब में क्रमशः 0.03 और 0.98 मिलते हैं, एकतरफ़ा संभावना
Decimalके धन/ऋण चिह्न को आधार देती है;0.5एक सीधी रेखा है, 0.5 के पास पहुँचने वाले केस मानव-समीक्षा को भेजे जाने चाहिए (Noul में confidence नहीं होता) classifyके लेबल वह बंद सेट है जो आपने चुना है: देश[US, GB, DE, FR, CA, AU], मुद्रा[USD, EUR, GBP, JPY, CAD]—अपने बिज़नेस क्षेत्र के हिसाब से बदलने के लिए बस ये दो सूचियाँ बदलें; जब आधिकारिक सुझाई गई सूची पूरी कवरेज न दे, तो एकother/none of the aboveविकल्प जोड़ें, ताकि मॉडल के पास कहने की जगह हो कि 「इनमें से कोई नहीं」pickमें confidence पहले से आता है: आधिकारिक कैश में total इस चुनाव-प्रश्न के लिए दर्ज है 0.56 (आउटपुट में छपा नहीं, कैश में दर्ज है)—जवाब सही चुना गया, लेकिन भरोसा मध्यम है। कम confidence वाले pick की दोबारा समीक्षा करें या नहीं, यह नियम चरण 4 केREVIEW_BELOWके तर्क पर लिखकर अपने कोड में रखें
आधिकारिक दस्तावेज़ पेज के अंत में दो सीमाएँ बताता है, पहले एक लाइन नोट कर लें, आगे की तकनीकें में विस्तार से:
एक Choice में ज़्यादा से ज़्यादा 255 विकल्प, उम्मीदवार ज़्यादा हों तो पहले दो चरणों में चुनें
उम्मीदवार ढूँढना ही मेहनत वाला कदम है—ईमेल, फ़ोन, राशि किस्मत से संभाले जा सकते हैं, व्यक्ति के नाम का कोई अच्छा regex नहीं है, उम्मीदवार सूची या NER से आने पड़ेंगे
बिना Key के E.164
+14155550177और P(credit) 0.03 / 0.98 निकल आए; मैं बता सकता हूँ कि मोबाइल नंबर और देश किसने तय किए, E.164 किसने जोड़ा
📋 मैजिक Prompt
इस पेज का 「Prompt」 API के लिए प्रश्न और कोड टेम्पलेट है—कॉपी करके 【】 प्लेसहोल्डर बदलें (? वाले वैकल्पिक हैं) और अपने दस्तावेज़ों से जोड़ सकते हैं। तीन चीज़ें: तारीख़ घटक प्रश्न, उम्मीदवार चुनाव प्रश्न, नॉर्मलाइज़ेशन पाइपलाइन।
📝 तारीख़ घटकों के सात सवाल (Choice संस्करण)
अपेक्षित परिणाम: 「भूमिका के हिसाब से तारीख़ पूछने」 वाली कोई भी ज़रूरत—अनुबंध प्रभाव तिथि, फ़ॉर्म की अंतिम तिथि, बैठक की नई तिथि—एक ही प्रश्न-सेट में role बदलकर काम करेगा, जवाब हमेशा घटक होंगे, तैयार तारीख़ नहीं।
# 必填项:【日期角色】换成你要问的那个日期的自然语言描述
DATE_QUESTIONS = {
"mode": Choice(
instructions="【这个日期是怎么写的?absolute=点名月份的日历日期;relative=相对今天;none=文档没写】",
criteria={"absolute": None, "relative": None, "none": None},
),
"month": Choice(
instructions="【若是绝对日期,是几月?】",
criteria={【m: None for m in 十二个月】} | {"none": "文档没写或不是这种日期"},
),
"day": Choice(
instructions="【若是绝对日期,是几号(1-31)?】",
criteria={【str(d): None for d in range(1, 32)】} | {"none": "文档没写或不是这种日期"},
),
"year": Choice(
instructions="【若是绝对日期,是哪年?没写选 none,超出范围选 out_of_range】",
criteria={【str(y): None for y in 你的年份窗口】}
| {"out_of_range": "写了年份但在列表外", "none": "没写年份,代码来补"},
),
"day_anchor": Choice(
instructions="【若是相对日期,锚在哪天?today / tomorrow / day_after / weekday】",
criteria={"today": None, "tomorrow": None, "day_after": None, "weekday": None,
"none": "文档没写或不是这种日期"},
),
"weekday": Choice(
instructions="【若点名了星期几,是哪一个?】",
criteria={【w: None for w in 七个星期】} | {"none": "文档没写或不是这种日期"},
),
"week_offset": Choice(
instructions="【若点名星期几,是哪一周?next=下一日历周;current=本周;none=光秃秃没限定】",
criteria={"current": None, "next": None, "none": "文档没写或不是这种日期"},
),
}
# 选填项:窗口按你的业务改——1950–2035 或未来十年;列表太长见进阶技巧的预筛做法?
# 输出规范:每题 answer.choice + answer.confidence;代码只读 mode 用得上的部件
# 约束条件:
# ✅ 每道不适用的部件都给 none 出口——缺的部件要被报出来,不是被猜出来
# ✅ 日历数学(补年份、解析「下周四」、校验 2 月 30)全放代码
# ❌ 不要问「截止日期是几月几号」——那是让模型做数学+回答二合一✅ उम्मीदवार चुनाव प्रश्न (pick संस्करण)
अपेक्षित परिणाम: जो भी फ़ील्ड ऐसी हो कि 「regex उम्मीदवार ढूँढ सकता है, लेकिन सही चुनने के लिए संदर्भ समझना पड़ता है」—प्राप्तकर्ता ईमेल, मोबाइल नंबर, इनवॉइस की कुल राशि, सपोर्ट टिकट नंबर—सब पर यही एक टेम्पलेट लागू होता है।
from typesafe_sdk import Choice
# 必填项:candidates 传正则抓出的候选(去重、按文档序),问题问「角色」不问「形状」
picked = client.system_one(
state=【整份文档原文】,
questions={
"pick": Choice(
instructions="【哪个候选是……?例如:寄件人希望收据寄到的那个邮箱】",
criteria={c: None for c in 【candidates】}
| {"none": "None of these is the requested value."},
)
},
).answers["pick"]
# 选填项:同一批候选换一个 role 再问一次(发件人 vs 收件人)——两次请求、同一副选项?
# 输出规范:answer.choice 是某个候选的逐字拷贝或 "none";answer.confidence 可接复核线
# 约束条件:
# ✅ 选项就是候选字符串本身——答案是拷贝,不是重新生成
# ✅ 正则调召回不调精度:多抓的让 Jev 挑掉,漏抓的谁也救不回来
# ❌ 候选超过 255 个别硬塞——先分区块挑,再挑区块内的 span(见 C4)🔧 नॉर्मलाइज़ेशन और समीक्षा (कोड संस्करण)
अपेक्षित परिणाम: चुनी हुई वैल्यू सिस्टम में सीधे इस्तेमाल होने लायक़ रूप में बदल जाती है, हर कदम शुद्ध कोड है, यूनिट-टेस्ट करने योग्य, बिना खर्च।
# 必填项:按字段类型选规范化器
normalized = {
"email": lambda v: v.lower(), # 逐字拷贝 + 小写
"phone": lambda v: phonenumbers.format_number( # 读国家 + E.164
phonenumbers.parse(v, region["choice"]),
phonenumbers.PhoneNumberFormat.E164),
"amount": lambda v: Decimal(re.sub(r"[^\d.]", "", v)), # $1,315.50 -> 1315.50
"date": assemble, # 部件 -> date,见第 3 步
}
# 选填项:credit/charge 用一道 Noul 定符号——P(credit) > 0.5 是 credit,贴着 0.5 转人工?
# 输出规范:值 + provenance(来自哪个候选/哪些部件)+ confidence + needs_review
# 约束条件:
# ✅ 规范化只处理「选中的那个字符串」,绝不重新生成
# ✅ 复核线(日期 0.60 起步)按风险调:进账单的金额从严,进统计报表的可松
# ❌ 别假设逗号一定是千分位——欧式格式 €1.315,50 正相反,先问一道 Noul「这份文档用逗号当小数点吗」再分支चेकपॉइंट ✅
- चरण 5, 6 बिना Key के आधिकारिक सारे आँकड़े दोहराए: receipt 0.97 / sender 1.00 / E.164
+14155550177/ total P(credit)=0.03 / credit P(credit)=0.98 - मैं बता सकता हूँ कि सातों तारीख़-प्रश्न क्या पढ़ते हैं, और
modeतय करता है कि कोड कौन-से घटक पढ़ेगा - मुझे पता है कि तारीख़ का confidence इस्तेमाल हुए घटकों में सबसे कमज़ोर वाला होता है; 0.60 से कम हो तो मानव-समीक्षा को भेजें; दस्तावेज़ में न लिखी तारीख़ पर
none+ note रिपोर्ट करें, बनाना नहीं - मैं समझा सकता हूँ कि
pickवैल्यू गढ़ना या ग़लत जगह लिखना क्यों असंभव है: विकल्प खुद उम्मीदवार ही हैं, जवाब अक्षरशः कॉपी है - मुझे दोनों सीमाएँ पता हैं: Choice में ज़्यादा से ज़्यादा 255 विकल्प (ज़्यादा हों तो दो चरणों में चुनें); व्यक्ति के नाम जैसी वैल्यू जिनका अच्छा regex नहीं है, उनके उम्मीदवार सूची, NER या LLM के सुझाव से आने चाहिए
ख़ाक-चूक चेतावनी
❌ LLM से वैल्यू 「दोबारा टाइप」 करवाना
LLM से सीधे निकालवाने का असली मतलब है उसे $1,315.50 दोबारा टाइप करके आउटपुट देना—एक जगह ग़लत लिखना ($1,351.50), या दस्तावेज़ में न होती वैल्यू की अफ़वाह गढ़ना, दोनों 「दोबारा जनरेट」 इसी कदम में होते हैं। आधिकारिक तीन-कदम विधि इस कदम को पूरा हटा देती है: regex उम्मीदवार ढूँढता है → Jev उम्मीदवारों में से चुनता है → कोड अक्षरशः कॉपी करके नॉर्मलाइज़ करता है। आधिकारिक मूल शब्दों की सबसे कड़ी लाइन: TypeSafe सिर्फ़ regex से मिले उम्मीदवारों में से चुनता है, इसलिए वह न कोई वैल्यू ईजाद कर सकता है, न अंक ग़लत जगह लिख सकता है।
❌ regex बहुत सख़्त ट्यून करना, असली वैल्यू उम्मीदवारों के बाहर छूट जाना
pick के विकल्प वही उम्मीदवार हैं जो आप उसे देते हैं—उम्मीदवारों में न हो, तो वह कितना भी समझदार हो, चुन नहीं सकता। आधिकारिक दस्तावेज़ पहले कदम का काम रिकॉल बताता है: regex ट्यून करते समय ज़्यादा पकड़ने में जाना बेहतर है (ऑर्डर नंबर, फ़ैक्स नंबर, उप-योग साथ में आ जाएँ तो कोई हर्ज नहीं, Jev छाँट देगा), पर असली वैल्यू छूटने न दें। ज़्यादा पकड़ने की कीमत एक रिक्वेस्ट में कुछ ज़्यादा विकल्प हैं; छूटने की कीमत यह कि यह रिकॉर्ड हमेशा के लिए ग़लत।
❌ तारीख़ कैश से बिना Key रीप्ले की उम्मीद करना
आधिकारिक रिपॉज़िटरी में जारी तारीख़ json_cache.json और मौजूदा दस्तावेज़ कोड की कैश-की मेल नहीं खाती (इस पेज पर परखा गया: छह कॉल सब miss, SDK असली रिक्वेस्ट करने लगा, बिना Key 401)—सबसे संभावना यह कि रिकॉर्डिंग के समय का फ़ंक्शन सिग्नेचर मौजूदा कोड से असिंक्रोनस है। तारीख़ हिस्से के लिए TYPESAFE_API_KEY सेट करके अपना कैश चलाएँ; आधिकारिक आँकड़ों से मिलान करते समय इस पेज पर दर्ज स्कोरबोर्ड को आधार मानें। वैल्यू निकालने का आधिकारिक कैश अछूता है, परखा गया—अक्षरशः रीप्ले होता है।
❌ राशि दिखते ही to_decimal, चीनी दस्तावेज़ दिखते ही सीधे उसे लागू करें
दोनों बातों में फिसलना आसान है। पहला: Decimal(re.sub(r"[^\d.]", "", value)) मान लेता है 「कॉमा=हज़ार का चिह्न, बिंदु=दशमलव」—$1,315.50 पर सही, €1.315,50 पर उल्टा; आधिकारिक सलाह पहले एक Noul पूछे 「क्या इस दस्तावेज़ में कॉमा दशमलव की तरह इस्तेमाल हुआ है」, और जवाब के हिसाब से शाखा बनाए। दूसरा: आधिकारिक दस्तावेज़ बताता है कि Jev मुख्यतः अंग्रेज़ी पर ट्रेन हुआ है, अन्य भाषाएँ (चीनी समेत) चलती हैं पर सटीकता कम है—चीनी अनुबंध और इनवॉइस लॉन्च करने से पहले अपने दस्तावेज़ों पर एक बैच चलाकर संभावना-वितरण देखें, भाषा समर्थन का विवरण मॉडल और मूल्य में।
आगे की तकनीकें (वैकल्पिक)
**साल की सूची बहुत लंबी? पहले छाँटें। ** year का 1900–2050 151 विकल्प है, आधिकारिक दस्तावेज़ ख़ुद कहता है 「अगर यह परेशान करता है, तो पहले टेक्स्ट में साल जैसे दिखने वाले अंक निकालो, सिर्फ़ उन्हीं को मॉडल को विकल्प दो」—उम्मीदवार विंडो छोटी हुई, प्रश्न भी ज़्यादा केंद्रित। यह चरण 5 जैसा ही विचार है: जो उम्मीदवार-निर्माण कोड संभाल सके, मॉडल को न झंझोड़ें।
**उम्मीदवार 255 से ज़्यादा: दो चरणों में चुनें। ** आधिकारिक तरीका: पहले ब्लॉक चुनें (कौन-सा पैराग्राफ़/कौन-सी टेबल), फिर ब्लॉक के भीतर span चुनें—हर Choice 255 के भीतर रहे। खोज और मिलान की लाइन-दर-लाइन खोज पहले चरण का ही उदाहरण है: हर लाइन को ID दें, Choice को मैच होती लाइन की ओर इशारा करने दें।
**व्यक्ति के नाम का अच्छा regex नहीं है। ** आधिकारिक दस्तावेज़ साफ़ कहता है: उम्मीदवार ढूँढना ही मेहनत वाला कदम है—ईमेल, फ़ोन, राशि के तैयार regex हैं, नाम के नहीं। उम्मीदवार आपकी मौजूदा सूची से (HR सिस्टम, ग्राहक सूची) आ सकते हैं, या NER / LLM से सुझाए जा सकते हैं, Jev आख़िरी चुनाव संभालता है।
आधिकारिक उदाहरण मुफ़्त में आज़माएँ। आधिकारिक cookbook पेज के निचले भाग में बने हुए Playground शेयर लिंक हैं — ईमेल बॉडी + चार उम्मीदवार पते वाला वह pick प्रश्न, उसे खोलकर (https://console.typesafe.ai/playground) आप ब्राउज़र में ही शब्दावली बदल सकते हैं और प्रायिकता वितरण देख सकते हैं। अपना खुद का लिंक बनाना चाहते हैं तो:
from cooksafe import make_playground_link
link = make_playground_link(EMAIL_DOC, {
"receipt": Choice(
instructions="Which email address does the sender want their receipt sent to?",
criteria={c: None for c in emails} | {"none": "None of these is the requested value."},
),
})
print(link) # 链接里带着完整 state 和问题,别放敏感数据इसे अपने दस्तावेज़ प्रवाह में जोड़ें। प्रश्न निश्चित रहते हैं, केवल state बदलें — EMAIL_DOC की जगह आपका पार्स किया हुआ ईमेल बॉडी और MONEY_DOC की जगह OCR से निकला इनवॉइस टेक्स्ट रखें, सात दिनांक प्रश्न और तीन मान प्रश्न जस के तस पुनः उपयोग हो जाएँगे। कैश कुंजी की रचना दोनों ओर अलग है, इसे ठीक से याद रखने से काफ़ी डिबगिंग समय बचता है: मान भाग की कुंजी में दस्तावेज़, उम्मीदवार और प्रश्न (pick / classify / is_true के सभी पैरामीटर) शामिल हैं — दस्तावेज़ बदलने, regex बदलने या प्रश्न बदलने पर miss होगा और अपने आप वास्तविक अनुरोध जाएगा; दिनांक भाग की कुंजी में केवल दस्तावेज़ और role हैं — date_questions के भीतर का प्रश्न बदलने पर कोई miss नहीं होगा (प्रश्न फ़ंक्शन बॉडी में है, cooksafe दस्तावेज़ स्पष्ट कहता है कि फ़ंक्शन बॉडी बदलने से कैश अमान्य नहीं होता), पुराना उत्तर वैसे ही चलता रहेगा; प्रश्न बदलने के बाद वास्तव में चलाना चाहें तो date_cache.json हटा दें। निकालने की मात्रा बड़ी हो तो कैस्केड निष्कर्षण देखें: सस्ता मॉडल पहले भारी काम करता है, Jev केवल फ़ील्ड-दर-फ़ील्ड सत्यापन करता है।
इस पाठ का सारांश
✅ Jev सूचना निष्कर्षण, दिनांक इस तरह हल होती है: सात Choice प्रश्न एक ही अनुरोध में आकृति और घटक पढ़ते हैं, कैलेंडर गणित (वर्ष भरना, «अगले गुरुवार» का पार्सिंग, 2 महीने 30 का सत्यापन) सब assemble() में; confidence = उपयोग किए गए घटकों में सबसे कमज़ोर, 0.60 से नीचे हो तो मानव समीक्षा पर भेजें।
✅ मान = regex उम्मीदवार + Jev चयन + अक्षरशः प्रतिलिपि: find रिकॉल संभालता है, pick चयन संभालता है (विकल्प ही उम्मीदवार हैं, उत्तर केवल मूल पाठ की प्रतिलिपि या none हो सकता है), कोड सामान्यीकरण संभालता है — कोई गढ़ंत नहीं, कोई विचलित लिप्यंतरण नहीं।
✅ तीनों प्रकार के मान पूरी तरह सामान्यीकृत होकर लागू: ईमेल लोअरकेस 0.97 / 1.00, फ़ोन E.164 +14155550177 (देश classify से पढ़ा जाता है), राशि Decimal पर credit/charge चिह्न (Noul 0.03 / 0.98)।
✅ आधिकारिक आँकड़ों का बिना Key पुनरुत्पादन: मान निष्कर्षण भाग में आधिकारिक कैश का परीक्षण अक्षरशः रीप्ले होता है; दिनांक भाग में परीक्षण में कैश कुंजी मेल नहीं खाती, अपने कैश से live चलाएँ (6 अनुरोध), स्कोरबोर्ड आधिकारिक रिकॉर्डिंग को मान्य मानें।
मुख्य कॉन्फ़िगरेशन फ़ील्ड की समीक्षा:
| फ़ील्ड | इस पेज पर मान | विवरण |
|---|---|---|
DATE_MODEL / VALUE_MODEL | jev-1.14.0 | आधिकारिक रिकॉर्डिंग: दिनांक jev-1.12, मान jev-1.14.0; live चलाने पर अपना ही वर्शन ID लॉक करें, ड्रिफ़्ट होने वाला jev-latest न लें |
TODAY | date(2026, 7, 30) | «आज» निश्चित रखने से सापेक्ष दिनांक पुनरुत्पादन योग्य होती है; खुद चलाने पर date.today() बदलें या बैच से पहले एक साथ पिन कर दें |
REVIEW_BELOW | 0.60 | दिनांक विश्वास स्तर की पुनःजाँच रेखा; जोखिम के अनुसार स्तर बदलें |
YEAR_WINDOW | 1900–2050 + none / out_of_range | वर्ष विकल्प विंडो में दो आपात निकास |
| तीन regex | EMAIL_RE / PHONE_RE / MONEY_RE | रिकॉल को प्राथमिकता; उम्मीदवार डुप्लिकेट हटाए जाते हैं, दस्तावेज़ क्रम में |
| Choice विकल्प सीमा | 255 | सीमा पार होने पर पहले ब्लॉक चुनें फिर span (देखें C4) |
| प्रति दस्तावेज़ अनुरोध | दिनांक 1 बार (सात प्रश्न समानांतर); प्रत्येक मान 1–3 बार (pick / classify / is_true) | सब कैश से चलते हैं, दस्तावेज़ बदलने/प्रश्न बदलने पर ही miss |
संबंधित ट्यूटोरियल:
- कैस्केड निष्कर्षण: सस्ता मॉडल काम करता है, Jev सत्यापन करता है, महँगा मॉडल अंतिम सहारा — इस पेज के पाइपलाइन का औद्योगिक संस्करण: फ़ील्ड बढ़ने पर बड़े मॉडल की फ़ील्ड-दर-फ़ील्ड तर्कशीलता कैसे बचाई जाए
- खोज और मिलान: रीरैंकिंग, पंक्ति-दर-पंक्ति खोज, एंटिटी अलाइनमेंट — उम्मीदवार 255 से अधिक होने पर दो-चरणीय संकुचन का व्यावहारिक उदाहरण, 218 पंक्ति वाले दस्तावेज़ की पंक्ति-दर-पंक्ति सिमेंटिक खोज
- Confidence विश्वास स्तर — 0.60 इस पुनःजाँच रेखा का सिद्धांत, और «उच्च स्वचालित निष्पादन / मध्यम चिह्नित / निम्न मानव हस्तांतरण» वाले तीन स्तरों का उपयोग
अगले पाठ की झलक
फ़ील्ड निकाल लिए गए, अगला प्रश्न है कि फ़ॉर्मेट खो चुके टेक्स्ट का क्या करें। अगला पाठ: संरचना पुनर्स्थापन: शुद्ध टेक्स्ट को वापस Markdown में बदलना।
आप सीखेंगे:
- दो अनुरोधों में फ़ॉर्मेट खो चुके शुद्ध टेक्स्ट को वापस Markdown में बदलना: पहली बार में हर आसन्न पंक्ति-जोड़े के लिए एक Noul, कठोर लाइन-ब्रेक से कटी वाक्य वापस जोड़े जाते हैं; दूसरी बार में हर ब्लॉक के लिए एक Choice, जिससे शीर्षक / पैराग्राफ़ / सूची / उद्धरण / कोड / नोटिस बॉक्स में विभाजन होता है
- क्यों आउटपुट काहर अक्षर इनपुट से आता है — मॉडल केवल निर्णय करता है, रेंडरिंग पूरी तरह कोड करता है, टेक्स्ट रीराइट करने वाला मॉडल आपके शब्द बदल देगा
- इस पेज की तरह ही श्रम-विभाजन: मॉडल टेक्स्ट पढ़ता है, कोड काम करता है, बस इस बार वापस लानी होने वाली चीज़ मान नहीं बल्कि संरचना है