Evals का उपयोग करके WebMCP का परीक्षण करें

Kasper Kulikowski

पब्लिश होने की तारीख: 19 मई, 2026, पिछली बार अपडेट किए जाने की तारीख: 28 मई, 2026

ज़्यादा जानकारी देने वाला वीडियो	वेब	एक्सटेंशन	Chrome स्टेटस	मकसद
GitHub	ऑरिजिन ट्रायल		देखें	एक्सपेरिमेंट करने का इरादा

WebMCP, जनरेटिव एआई मॉडल का इस्तेमाल करने वाले एजेंट के साथ काम करता है. जनरेटिव एआई का इस्तेमाल करके किसी भी सिस्टम की जांच करने के लिए, आपके टेस्ट में संभावित नतीजों का समर्थन होना चाहिए: एक इनपुट से, अलग-अलग सटीक जवाब मिल सकते हैं. इस टेस्टिंग तकनीक को आकलन या इवैल कहा जाता है.

टूल को प्रोडक्शन में रिलीज़ करने से पहले, आपको यह पुष्टि करनी होगी कि एजेंट को यह पता हो कि टूल को कब कॉल करना है, इसे कैसे लागू करना है, और कौनसे जवाब स्वीकार किए जा सकते हैं. समस्याएं होने से पहले ही उन्हें ठीक करें.

अपने सिस्टम के टचपॉइंट की जांच करने के लिए, लार्ज लैंग्वेज मॉडल (एलएलएम) के साथ आकलन लिखें:

• देखें कि मॉडल को टूल के मकसद के बारे में पता हो. इसके लिए, टूल के ब्यौरे और स्कीमा की जांच करें.
• पुष्टि करें कि मॉडल, उपयोगकर्ता के मकसद को पूरा करने के लिए सही पैरामीटर के साथ सही टूल चुनता हो.
• पुष्टि करें कि मॉडल को मिली जानकारी के आधार पर कार्रवाई की जा रही है. उदाहरण के लिए, किसी अन्य टूल को कॉल करने के लिए जानकारी का इस्तेमाल करना.
• उपयोगकर्ता की गतिविधियों के सही तरीके से पूरा होने की पुष्टि करें. उपयोगकर्ता के इरादे को देखते हुए, क्या एजेंट दिए गए टूल की मदद से मेरी वेबसाइट पर उपयोगकर्ता की गतिविधि को पूरा कर सकता है?

आपको ऐसे किसी भी सिस्टम इंटरैक्शन के लिए क्लासिक डिटरमिनिस्टिक टेस्ट लिखना जारी रखना चाहिए जो मॉडल के साथ कम्यूनिकेट नहीं करता है.

फ़ेल होने के मोड

डेवलपर को अपने सिस्टम की जांच करनी चाहिए, ताकि गड़बड़ियां होने से पहले ही उन्हें ठीक किया जा सके. इसके लिए, आपको यह समझना होगा कि सिस्टम कब काम नहीं कर सकता. ऐसा, सिस्टम के अपने फ़ैसलों और बाहरी फ़ैक्टर के साथ इंटरैक्ट करने के दौरान हो सकता है. WebMCP के लिए, टूल खुद काम नहीं कर सकता. साथ ही, एजेंट शायद टूल का इस्तेमाल उम्मीद के मुताबिक न कर पाएं.

WebMCP टूल काम नहीं कर सकते और एजेंट, WebMCP टूल के साथ काम नहीं कर सकता. उदाहरण के लिए, मान लें कि आपके उपयोगकर्ता को अपने कार्ट में एक टी-शर्ट जोड़नी है.

अपलोड नहीं हुआ	उदाहरण	समस्या हल करें
एजेंट सही टूल नहीं चुन पाता या सीधे तौर पर गलत टूल को कॉल करता है.	एजेंट, addToCart को छोड़कर सीधे checkout पर जाता है.	क्या टूल का description साफ़ तौर पर बताया गया है, पूरी जानकारी दी गई है, और टूल के काम करने के तरीके के बारे में सटीक जानकारी दी गई है? क्या functionName को इस्तेमाल करना आसान है और इसमें पूरी जानकारी दी गई है? क्या टूल को मौजूदा स्थिति/संदर्भ में एलएलएम के लिए सही तरीके से उपलब्ध कराया गया है? क्या इस टूल का स्कीमा, किसी दूसरे टूल के स्कीमा से काफ़ी मिलता-जुलता है? इस वजह से, क्या कॉल के बारे में साफ़ तौर पर पता नहीं चल पा रहा है?
एजेंट, टूल को गलत क्रम में कॉल करता है	एजेंट, checkout और फिर addToCart को कॉल करता है.	क्या टूल के ब्यौरे एक-दूसरे से मिलते-जुलते हैं, जिससे एलएलएम को ज़रूरी क्रम के बारे में भ्रम हो रहा है? क्या पिछले टूल के आउटपुट में, अगले टूल को कॉल करने के लिए ज़रूरी कॉन्टेक्स्ट मौजूद है? क्या स्थिति को सही तरीके से अपडेट किया गया है और क्या एलएलएम को उम्मीद के मुताबिक कोई नया टूल दिखाया गया है? अगर कुछ टूल को अलग-अलग क्रम में कॉल किया जाता है, तो क्या एंड-टू-एंड यूज़ केस अब भी सही है? क्या आपने टूल कॉल की चेन को अलग से टेस्ट किया है? इसके लिए, पिछले कॉल को फ़ोर्स करके यह पुष्टि की जाती है कि एलएलएम सही अगला चरण चुनता है.
एजेंट ने टूल को गलत आर्ग्युमेंट के साथ कॉल किया	एजेंट addToCart को कॉल करता है, लेकिन टी-शर्ट के बजाय जूते जोड़ देता है.	क्या inputSchema को साफ़ तौर पर बताया गया है? इसमें enum की वैल्यू और हर प्रॉपर्टी के लिए description की जानकारी शामिल है? क्या सभी ज़रूरी पैरामीटर साफ़ तौर पर मार्क किए गए हैं और उनकी जांच की गई है? क्या जवाब के ब्यौरे में, एलएलएम को साफ़ तौर पर यह बताया गया है कि उपयोगकर्ता के इनपुट को, अनुमानित स्ट्रक्चर्ड डेटा (जैसे, कोई खास आईडी या फ़ॉर्मैट) से कैसे मैप किया जाए?

अगर उपयोगकर्ता को यह देखना है कि उसकी कार्ट में क्या-क्या है, तो क्या होगा?

अपलोड नहीं हुआ	उदाहरण	समस्या हल करें
टूल का आउटपुट गलत है या टूल में कोई जानकारी मौजूद नहीं है.	उपयोगकर्ता ने viewCart के बारे में पूछा है, लेकिन एजेंट ने प्रॉडक्ट के नाम और उनकी अलग-अलग कीमतों के बजाय, कार्ट में मौजूद प्रॉडक्ट की कुल कीमत बताई है.	क्या टूल के लॉजिक में गड़बड़ियां हैं? इसकी जांच, डिटरमिनिस्टिक टेस्ट की मदद से करें. क्या यूज़र इंटरफ़ेस (यूआई) की स्थिति को सही तरीके से अपडेट किया गया था और क्या एजेंट को साइड इफ़ेक्ट के बारे में सही जानकारी मिली थी? अगर एलएलएम, आउटपुट का इस्तेमाल बाद के कॉल के लिए करता है, तो क्या एलएलएम के इस्तेमाल के लिए आउटपुट को साफ़ तौर पर फ़ॉर्मैट किया गया है? क्या जवाब में बहुत ज़्यादा जानकारी दी गई है? क्या इसमें सिर्फ़ वह ज़रूरी जानकारी शामिल है जो एलएलएम को आगे की कार्रवाई के लिए चाहिए?

आखिर में, कोई टूल किसी भी तरह से काम नहीं कर सकता, जैसा कि JavaScript नहीं कर सकता. समस्या हल करने के लिए, यहां दी गई जानकारी देखें:

• क्या टूल का कोड, रनटाइम के दौरान होने वाली सभी संभावित गड़बड़ियों और अपवादों को सही तरीके से हैंडल करता है?
• क्या एजेंट और मॉडल को गड़बड़ी की जानकारी सही तरीके से दी गई है?
• क्या टूल के लिए ज़रूरी बाहरी एपीआई या सेवाएं ठीक से काम कर रही हैं?
• क्या गड़बड़ी का स्ट्रक्चर इतना साफ़ है कि मॉडल, कुछ समय के लिए होने वाली समस्या (फिर से कोशिश करें) और गंभीर गड़बड़ी के बीच अंतर कर सके?

आइसोलेशन में टेस्टिंग टूल

अगर कोई एजेंट, "मुझे एक छोटा पिज़्ज़ा चाहिए" जैसे अनुरोध के लिए, यह पता नहीं लगा पाता कि किस टूल को कॉल करना है, तो वह उपयोगकर्ता के मुश्किल सफ़र में मदद नहीं कर पाएगा.

जांच करने वाले टूल का इस्तेमाल अलग-अलग करके, ब्राउज़र सिम्युलेशन चलाने से पहले ही अपने स्कीमा और ब्यौरों को ऑप्टिमाइज़ किया जा सकता है.

कॉल की सटीक जानकारी मेज़र करना

हमारे डेमो, WebMCP zaMaker को देखें. जब उपयोगकर्ता प्रॉम्प्ट करता है, "मुझे एक छोटा पिज़्ज़ा चाहिए," तो आपको मॉडल से ऐसा जवाब मिल सकता है जिसमें set_pizza_size कॉल करने का इरादा बताया गया हो. साथ ही, "size":"Small" आर्ग्युमेंट के बारे में बताया गया हो.

expectedCall फ़ंक्शन, अनुमानित फ़ंक्शन और आर्ग्युमेंट को तय करता है. इस अप्रोच से यह पुष्टि होती है कि एजेंट, दिए गए स्कीमा के आधार पर उपयोगकर्ता के मकसद को पूरा करने के लिए सही टूल चुनेगा.

{
  "messages": [
    {
      "role": "user",
      "content": "I'd like a small pizza."
    }
  ],
  "expectedCall": [
    {
      "functionName": "set_pizza_size",
      "arguments": { "size": "Small" }
    }
  ]
}

expectedCall का इस्तेमाल, नियम के आधार पर तय की गई जांच करने के लिए किया जाता है:

WebMCP टूल को किसी कॉम्पोनेंट के लाइफ़साइकल से जोड़ा जा सकता है. इसका मतलब है कि आपको तब टेस्ट करना होगा, जब आपके ऐप्लिकेशन की स्थिति WebMCP की उम्मीद के मुताबिक हो. इसे मैनेज करने के लिए, टूल की पूरी सूची दें. यह सूची उस राज्य के हिसाब से होनी चाहिए जिसके लिए आपको आकलन करना है. उदाहरण के लिए, कोई उपयोगकर्ता अपने एजेंट के साथ मिलकर ब्राउज़िंग कर रहा है और WebMCP zaMaker खोलता है.

[
...
  {
    "name": "add_topping",
    "description": "Add one or more toppings to the pizza",
    ...
  },
  {
    "name": "set_pizza_size",
    "description": "Set the pizza size directly.",
    "inputSchema": {
      "type": "object",
      "properties": {
        "size": {
          "type": "string",
          "enum": [
            "Small",
            "Medium",
            "Large",
            "Extra Large"
          ],
          "description": "The specific size name."
        },
      }
    }
  },
  {
    "name": "set_pizza_style",
    "description": "Set the style of the pizza (colors/theme)",
  ...
  },
...
]

...
 "expectedCall": [
   {
     "functionName": "set_pizza_size",
     "arguments": { "size": "Small" }
   }
 ]
...

इसे खोलने पर, WebMCP add_topping, set_pizza_size, और set_pizza_style टूल दिखाता है. इनमें से किसी भी टूल की सटीक जांच करने के लिए, आपको सभी टूल शामिल करने चाहिए, ताकि एक जैसा और पूरा स्टेटस बनाया जा सके.

ध्यान दें: किसी एजेंट के पास अन्य टूल का ऐक्सेस हो सकता है. हालांकि, आपके पास सिर्फ़ उन टूल का आकलन करने का विकल्प होता है जिन्हें आपने उपलब्ध कराया है.

अब जब आपको पता चल गया है कि एजेंट, ज़रूरत के हिसाब से सही टूल को कॉल करता है, तो यह टेस्ट किया जा सकता है कि टूल कॉल में सही पैरामीटर हैं या नहीं. साथ ही, यह भी टेस्ट किया जा सकता है कि नतीजे उम्मीद के मुताबिक हैं या नहीं. इसके दो चरण होते हैं: डिटरमिनिस्टिक टेस्ट और प्रॉबबिलिस्टिक टेस्ट.

डिटरमिनिस्टिक टेस्ट चलाना

WebMCP टूल, JavaScript या एचटीएमएल एनोटेशन के साथ बनाए जाते हैं. इसलिए, यहां दिए गए कामों को पूरा करने के लिए, डिटरमिनिस्टिक टेस्ट लिखे जा सकते हैं:

• टूल के लॉजिक की पुष्टि करें.
• पुष्टि करें कि डिपेंडेंसी को सही तरीके से कॉल किया गया हो.
• पुष्टि करें कि यूज़र इंटरफ़ेस को उम्मीद के मुताबिक अपडेट किया गया है. साथ ही, यह भी देखें कि इससे कोई अन्य खराब असर तो नहीं हुआ है.
• पुष्टि करें कि दिखाई गई जानकारी, अनुमानित वैल्यू से मेल खाती हो.
• जांच के पैरामीटर की पुष्टि करें.

उदाहरण के लिए, अगर आपका टूल SearchComponent फ़ंक्शन का इस्तेमाल करता है, तो SearchComponent का मॉक पास करके टेस्ट किया जा सकता है. बेहतरीन नतीजे पाने के लिए, उस एनवायरमेंट को सिम्युलेट करना न भूलें जिसमें टूल काम कर रहा है. यह वही तकनीक है जिसका इस्तेमाल किसी अन्य ऐप्लिकेशन इंटिग्रेशन टेस्ट को लिखने के लिए किया जाता है.

संभावित टेस्ट चलाना

अगर आपको अगले टूल को सही तरीके से कॉल करने के लिए, मॉडल आउटपुट की ज़रूरत है, तो आपको evals लिखना होगा.

ऐसा हो सकता है कि लोग मॉडल से सीधे तौर पर ऐसी क्वेरी करें जिनमें यह पूछा गया हो कि टूल क्या करता है. इसके अलावा, वे ऐसी क्वेरी भी कर सकते हैं जिनमें टूल का इस्तेमाल करने का सुझाव दिया गया हो. उदाहरण के लिए, "मेरे पिज़्ज़ा में पेपरोनी जोड़ो" एक सीधी क्वेरी है. "मुझे अपने पिज़्ज़ा में सभी तरह के मांस चाहिए" एक अस्पष्ट क्वेरी है. इसके लिए, मॉडल को यह समझना होगा कि उसे add_topping टूल की ज़रूरत है और कौनसी टॉपिंग को मांस के तौर पर तय किया जा सकता है.

अपने आकलन के लिए डेटासेट बनाते समय, ऐसी डायरेक्ट क्वेरी शामिल करें जिनसे बेसलाइन टूल के एक्ज़ीक्यूशन की जांच की जा सके. साथ ही, ऐसी ओपन-एंडेड क्वेरी शामिल करें जिनसे मॉडल की तर्क क्षमता और टूल चुनने के लॉजिक की जांच की जा सके.

अगर आपकी कोई कॉफ़ी शॉप है, तो उन उपयोगकर्ताओं की मदद की जा सकती है जिन्होंने अपने एजेंट से, पिछले महीने ऑर्डर की गई कॉफ़ी को फिर से ऑर्डर करने के लिए कहा है. पिछले ऑर्डर खोजने के लिए एक टूल लिखो. OrderHistoryService और कॉफ़ी ऑर्डर करने के लिए एक और टूल लिखो. ऑर्डर के इतिहास की सेवा को टेस्ट करने के लिए, एक मॉक भेजें. इससे कॉफ़ी प्रॉडक्ट का आईडी वापस मिल जाएगा.

इस उदाहरण में, यह देखा जाता है कि मॉडल को क्वेरी का मकसद समझ में आया है या नहीं. साथ ही, यह भी देखा जाता है कि मॉडल ने सही टूल चुना है या नहीं और उस टूल से कार्रवाई शुरू करने के लिए सही जानकारी मिली है या नहीं. अगर मॉडल get_order_history को कॉल नहीं करता है, तो उसे यह पता नहीं चलेगा कि order_product के लिए किस item_id का इस्तेमाल करना है.

शुरू से आखिर तक की टेस्टिंग

एंड-टू-एंड टेस्ट लिखें, ताकि आपको भरोसा हो कि उपयोगकर्ता और उनके एजेंट अपनी यात्राएं पूरी कर सकते हैं. अलग-अलग टूल की जांच करने के साथ-साथ, यह भी जांच की जाती है कि कई चरणों वाली कार्रवाइयां सही क्रम में की गई हैं या नहीं.

उदाहरण के लिए, मान लें कि आपकी कपड़ों की एक ऑनलाइन दुकान है. उपयोगकर्ता अपने एजेंट से पूछता है: "मुझे एक काली जैकेट और एक जोड़ी जींस खरीदनी है. क्या इस्तेमाल किए गए मटीरियल की जानकारी दी जा सकती है?"

एजेंट की मदद से टास्क पूरा करने का तरीका इस तरह से काम कर सकता है:

1. कपड़ों की कैटगरी पर जाएं.
2. कपड़ों के लिए किए गए अनुरोधों में से किसी एक को ढूंढो. इसमें ऑर्डर का कोई महत्व नहीं है.
3. कोई खास आइटम (search_clothes) ढूंढें.
4. प्रॉडक्ट की वह जानकारी पाएं जिसमें मटीरियल की सूची (get_product_details) शामिल हो.
5. अनुरोध किए गए हर आइटम के लिए, दूसरे से चौथे चरण तक की प्रोसेस दोहराएं.

जब एजेंट दूसरे चरण पर पहुंचता है, तो वह काली शर्ट या जींस खोज सकता है. इसमें क्रम मायने नहीं रखता. हालांकि, बाकी चरणों को क्रम से पूरा करना ज़रूरी है.

एजेंट के कॉल टूल को सही क्रम में इस्तेमाल करने की पुष्टि करने के लिए, एंड-टू-एंड जांच लिखें:

{
  "messages": [
    {
      "role": "user",
      "content": "I am looking to buy a black jacket and a pair of jeans.
        Could you provide a breakdown of the materials used ?"
    }
  ],
  "expectedCall": [
    {
      "functionName": "navigate_to_category",
      "arguments": { "category": "clothes" }
    },
    {
      "unordered": [
        {
          "ordered": [
            {
              "functionName": "search_clothes",
              "arguments": { "query": "black jacket" }
            },
            {
              "functionName": "get_product_details",
              "arguments": { "productId": "JACKET002" }
            }
          ]
        },
        {
          "ordered": [
            {
              "functionName": "search_clothes",
              "arguments": { "query": "jeans" }
            },
            {
              "functionName": "get_product_details",
              "arguments": { "productId": "JEANS001" }
            }
          ]
        }
      ]
    }
  ]
}

चेन के बीच में आने वाली समस्याओं का आकलन करना

ऐसा हो सकता है कि किसी एजेंट को एक के बाद एक कई टूल को कॉल करना पड़े. अगर इस प्रोसेस के बीच में कोई टूल काम नहीं करता है, तो क्या होगा? उदाहरण के लिए, किसी व्यक्ति को अपने कूपन कोड का इस्तेमाल करके पिज़्ज़ा ऑर्डर करना है:

"मुझे छोटा पेस्टो पिज़्ज़ा चाहिए. मेरे प्रोमो कोड FreePizza का इस्तेमाल करो."

ऐसा हो सकता है कि एजेंट add_discount_coupon को पूरा न कर पाए और पूरी कीमत वाले पिज़्ज़ा के लिए चेकआउट कर दे. add_discount_coupon टूल को आज़माने के लिए, इस टूल कॉल के क्रम को मैन्युअल तरीके से लागू किया जा सकता है. इसके लिए, आपको मॉडल के साथ इंटरैक्ट करने की ज़रूरत नहीं है. इससे इस स्थिति को सिम्युलेट किया जा सकता है. अपने ऐप्लिकेशन को उस स्थिति में लाएं जहां आपको लगता है कि टूल काम नहीं करेगा. इस मामले में, यह start_checkout टूल के बाद है. इसके बाद, add_discount_coupon का आकलन अलग से किया जा सकता है.

WebMCP का इस्तेमाल करके एक्सपेरिमेंट करना

टूल के लिए अलग-अलग तरीके से जांच करना शुरू करें. साथ ही, WebMCP की सुविधा वाली अपनी साइटों का आकलन करें. इसके लिए, WebMCP के साथ काम करने वाले किसी भी एजेंट का इस्तेमाल करें:

• GitHub पर, एक्सपेरिमेंट के तौर पर उपलब्ध हमारे आकलन टूल डाउनलोड करें.
• हमारा कोर्स, एआई के जवाबों का आकलन करना देखें.