Jev के साथ हार्नेस बनाना

एजेंट्स एक लूप में चलते हैं: एक LLM तय करता है कि क्या करना है, एक टूल उसे निष्पादित करता है, मॉडल परिणामों का आकलन करता है, और फिर कार्य पूरा होने तक उसी लूप में जारी रहता है।

शुरुआत में एजेंट्स और LLMs को सॉफ्टवेयर एप्लिकेशन के साथ एकीकृत करना कठिन था, क्योंकि ये संरचित डेटा और पूर्वानुमानित इंटरफेस पर निर्भर करते हैं। दो प्रमुख बुनियादी तत्वों (primitives) ने इसे बहुत आसान बना दिया:

• Tool calling ने मॉडल्स को संरचित अनुरोध करने और संरचित परिणाम प्राप्त करने की अनुमति दी।
• Structured outputs ने मॉडल्स को संरचित परिणाम लौटाने की सुविधा प्रदान की।

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

यहाँ आता है Jev। Jev TypeSafe AI द्वारा रिलीज़ किया गया एक नया मॉडल है released from TypeSafe AI। कंपनी का दावा है कि वर्गीकरण कार्यों (classification tasks) में तुलनीय LLMs की तुलना में इसका इन्फरेंस 200x तेज़ और लागत 400x कम है।

https://x.com/CompleteSkeptic/status/2099925682726002904

यह पोस्ट बताती है कि Jev कैसे काम करता है, यह एजेंट लूप में कहाँ फिट होता है, और LangChain के साथ इसका उपयोग कैसे किया जाता है।

Jev के बारे में सब कुछ

Jev वास्तव में एक पारंपरिक LLM नहीं है, यह टेक्स्ट जनरेट नहीं करता है। इसे TypeSafe AI टीम "System One model" कहती है:

📖 System One models AI मॉडल्स की एक श्रेणी हैं जो तेज़, संरचित निर्णय लेने के लिए बनाई गई हैं जिन्हें सॉफ्टवेयर सीधे उपयोग कर सकता है। एक System One model एक

state का आकलन करता है और टाइप्ड उत्तर तथा संभावनाएं (probabilities) लौटाता है।

इसे कैलिब्रेटेड निर्णयों के लिए रिइनफोर्समेंट लर्निंग (reinforcement learning for calibrated decisions (RLCD)) का उपयोग करके प्रशिक्षित किया गया है। आपका कोड उन परिणामों का उपयोग यह मार्गदर्शन करने के लिए करता है कि एजेंट आगे क्या करेगा, बिना हर निर्णय के लिए पूरी चैट LLM कॉल किए।

Jev मॉडल को कॉल करने के लिए, आप इसे एक state (संदर्भ) और उस state के बारे में questions भेजते हैं। यहाँ उनके docs में दिए गए सपोर्ट-टिकट उदाहरण का एकल-प्रश्न संस्करण है:

1{
2  "model": "jev-latest",
3  "state": "Hi, I've been trying to connect my Stripe account for 3 days and it keeps failing. I'm losing sales. Please help ASAP.",
4  "questions": {
5    "is_urgent": {
6      "type": "noul",
7      "instructions": "The message conveys urgency or time-sensitivity"
8    }
9  }
10}

Docs के उदाहरण में यह अर्जेंसी उत्तर मिलता है, जो यहाँ शेष प्रतिक्रिया के बिना दिखाया गया है:

1{
2  "is_urgent": {
3    "type": "noul",
4    "noul": 0.999
5  }
6}

यह इस बात की 99.9% संभावना है कि संदेश अर्जेंट है, जिसका उपयोग आपका एप्लिकेशन टिकट को प्राथमिकता देने के लिए कर सकता है।

समर्थित questions के तीन प्रकार हैं:

• Choice: विकल्पों के सेट में से चुनें। यह प्रत्येक विकल्प के लिए एक संभावना और एक समग्र विश्वास स्कोर (confidence score) लौटाता है।
• Score: इनपुट को क्रमबद्ध स्तरों (जैसे low, medium, और high) के विरुद्ध रेट करें। यह एक निरंतर स्कोर, अंतर्निहित वितरण, और एक विश्वास मान (confidence value) लौटाता है।
• Noul: हाँ या नहीं वाले प्रश्नों का उत्तर दें। यह किसी कथन के सत्य होने की संभावना लौटाता है।

यहाँ एक मुख्य विशेषता यह है कि आप एक ही अनुरोध में एक ही state के बारे में कई प्रश्न पूछ सकते हैं।

💡 System One models एक अनुरोध में सभी प्रश्नों का समांतर रूप से (in parallel) आकलन करते हैं। प्रश्न जोड़ने से प्रतिक्रिया समय लगभग नहीं बदलता है और इसकी लागत केवल अतिरिक्त प्रश्नों के टोकन्स जितनी होती है, जो कि सस्ती होती है।

सपोर्ट टिकट के बारे में कई प्रश्न पूछने का उदाहरण देखने के लिए, TypeSafe Quickstart देखें।

संक्षेप में, पारंपरिक LLMs के विपरीत, Jev न तो टेक्स्ट जनरेशन से प्रतिबंधित है और न ही अनुक्रमिक निर्णय लेने (sequential decision making) से!

LangChain के साथ Jev का उपयोग कैसे करें

LangChain का प्रोवाइडर-अग्नोस्टिक मॉडल Jev को हजारों अन्य इंटीग्रेशन और मॉडल प्रोवाइडर्स के साथ समर्थित करने के लिए उपयुक्त है।

LangChain integration Jev को TypeSafeClassifier के माध्यम से एक्सपोज़ करती है। आप अपना state और questions .invoke() में पास करते हैं, और आपको चैट प्रतिक्रिया के बजाय वर्गीकरण परिणाम मिलते हैं।

langchain-typesafe इंस्टॉल करें और अपना TYPESAFE_API_KEY सेट करें, फिर एक कॉल करें:

1from langchain_typesafe import Noul, TypeSafeClassifier
2
3classifier = TypeSafeClassifier()
4
5response = classifier.invoke(
6    state=(
7        "The deploy failed twice and customers are seeing 500s. "
8        "Can someone look now?"
9    ),
10    questions={
11        "urgent": Noul(
12            instructions="Does this need attention right now?"
13        ),
14    },
15)
16
17urgency = response.nouls["urgent"].noul

State टेक्स्ट, संरचित डेटा, या LangChain messages हो सकता है। इससे आपके एजेंट के पास पहले से मौजूद संदर्भ का उपयोग करके एक नोड या मिडलवेयर हुक से Jev को कॉल करना आसान हो जाता है।

आप इसे कस्टम मिडलवेयर या टूल्स में शामिल कर सकते हैं!

उपयोग के मामले (Use Cases)

Jev किसी LLM का सीधा विकल्प (drop-in replacement) नहीं है। यह टेक्स्ट जनरेट नहीं करता, लेकिन यह उन वर्गीकरण कार्यों को संभाल सकता है जिनके लिए हम आज अक्सर LLMs का उपयोग करते हैं, बिना उसी लेटेंसी और लागत के। यह आपके एजेंट को चलाने वाले मॉडल के लिए एक आशाजनक पूरक (complement) बनाता है: खुले-सिर वाले तर्क और जनरेशन के लिए एक LLM का उपयोग करें, और रास्ते में तेज़, संरचित निर्णयों के लिए Jev का उपयोग करें।

Model routing

एक साधारण लुकअप को किसी कठिन डिबगिंग कार्य के समान मॉडल की आवश्यकता नहीं होती है। Model-routing middleware Jev को अनुरोध का आकलन करने और आपके द्वारा परिभाषित मानदंडों के आधार पर एक मॉडल चुनने देता है, ताकि सरल कार्यों के लिए तेज़ और सस्ता हो, और जटिल कार्यों के लिए अधिक सक्षम हो।

1from langchain.agents import create_agent
2from langchain_typesafe.experimental.middleware import (
3    ModelChoice,
4    ModelRouterMiddleware,
5)
6
7router = ModelRouterMiddleware(
8    choices={
9        "fast": ModelChoice(
10            model="openai:luna",
11            criteria="Direct lookups, extraction, and localized changes.",
12        ),
13        "powerful": ModelChoice(
14            model="openai:sol",
15            criteria="Architecture and high-stakes decisions.",
16        ),
17    },
18    instructions="Choose the least costly model that can complete the task.",
19)
20
21agent = create_agent("openai:gpt-5.6-luna", middleware=[router])

राउटर सबसे नए यूजर मैसेज से एक मॉडल चुनता है और पूरे रन में उसी का उपयोग करता है। संभावनाएं और विश्वास स्तर एजेंट स्टेट में भी उपलब्ध रहते हैं।

Auto Mode

एजेंट्स अभी भी स्वाभाविक रूप से अविश्वसनीय होते हैं। एक एजेंट खराब निर्देश प्राप्त कर सकता है (चाहे वह प्राकृतिक रूप से हों या किसी पर्याप्त रूप से प्रेरित हमलावर से), जो उसे ऐसी कार्रवाई करने के लिए प्रेरित कर सकता है जिसे हम नहीं चाहते थे।

claude, codex, cursor जैसे कोडिंग हार्नेस ने खतरनाक कार्यों को किये जाने से पहले वर्गीकृत करने का कोई न कोई तरीका पेश किया है, जिसने धीरे-धीरे एजेंट्स के प्रति विश्वास बनाने में मदद की है। अब तक, यह वर्गीकरण चरण हार्नेस के बंद स्रोत (closed source) हिस्सों में सुरक्षित रखा गया था।

अब जब एक सस्ता और उच्च-प्रदर्शन वाला वर्गीकरण मॉडल मौजूद है, हम उसी पैटर्न को अपना सकते हैं और इसे सभी एजेंट्स में लागू कर सकते हैं!

1from langchain.agents import create_agent
2from langchain_typesafe.experimental.middleware import (
3    AutoModeMiddleware,
4)
5
6guardrail = AutoModeMiddleware(tools=["bash"])
7
8agent = create_agent("openai:gpt-5.6-luna", middleware=[guardrail])

AutoModeMiddleware Jev का उपयोग टूल कॉल्स में जोखिम भरे निर्णयों की जांच करने के लिए करता है, और टूल निष्पादित होने से पहले कॉल्स को ब्लॉक कर देता है।

शुरू करें!

हम Jev और इसके साथ आने वाली संभावनाओं को लेकर बेहद उत्साहित हैं। कुछ ठंडे प्रोजेक्ट्स जो हमने पहले ही देखे हैं: Browserbase के Kyle Jeong ब्राउज़र उपयोग एजेंट्स को अंश सेंट (fractions of a cent) में संचालित कर रहे हैं, Jarrod Watts ने एक लाइव ट्रेडिंग एजेंट बनाया है, और Ryan Vogel स्केल पर ईमेल ट्रायज कर रहे हैं।

इस समय हर हफ्ते नए मॉडल आते हैं, लेकिन इसने एक बहुत बड़ी प्रतिक्रिया प्राप्त की है। हम उत्सुक हैं देखने के लिए कि आप LangChain और Jev के साथ क्या बनाते हैं।

forum पर हमें बताएं कि आप क्या सोचते हैं, X पर हमें टैग करें और साझा करें कि आप क्या बना रहे हैं, या LangChain issues के साथ जुड़ें!

स्वीकार्यता (Acknowledgements)

@huntlovell, @hwchase, @ccurme, @veryboldbagel, और Nathan Drenzer को उनके विचारशील समीक्षा और योगदान के लिए धन्यवाद।