वेबहुक

कार्रवाइयां बनाने के लिए, आपको ज़्यादा विकल्प मिलते हैं. इसके लिए, लॉजिक को एचटीटीपीएस वेब सेवाओं (फ़ुलफ़िलमेंट) को सौंपा जा सकता है. आपकी कार्रवाइयां, वेबहुक को ट्रिगर कर सकती हैं. ये वेबहुक, एचटीटीपीएस एंडपॉइंट के लिए अनुरोध करते हैं. फ़ुलफ़िलमेंट में ये कार्रवाइयां की जा सकती हैं:

  • उपयोगकर्ता की दी गई जानकारी के आधार पर, डाइनैमिक प्रॉम्प्ट जनरेट करना.
  • किसी बाहरी सिस्टम में ऑर्डर देना और उसकी पुष्टि करना.
  • बैकएंड डेटा की मदद से स्लॉट की पुष्टि करना.
पहली इमेज. इन्वोकेशन इंटेंट और सीन वेबहुक को ट्रिगर कर सकते हैं.

वेबहुक ट्रिगर और हैंडलर

आपकी कार्रवाइयां, इन्वोकेशन इंटेंट या सीन में वेबहुक को ट्रिगर कर सकती हैं. इससे, आपके फ़ुलफ़िलमेंट एंडपॉइंट पर अनुरोध भेजा जाता है. आपके फ़ुलफ़िलमेंट में वेबहुक हैंडलर होते हैं. ये हैंडलर, अनुरोध में मौजूद JSON पेलोड को प्रोसेस करते हैं. इन स्थितियों में वेबहुक ट्रिगर किए जा सकते हैं:

  • इन्वोकेशन इंटेंट मैच होने के बाद
  • किसी सीन के ऑन एंटर स्टेज के दौरान
  • किसी सीन के कंडीशन स्टेज में, किसी शर्त के सही होने के बाद
  • किसी सीन के स्लॉट-फ़िलिंग स्टेज के दौरान
  • किसी सीन के इनपुट स्टेज में, इंटेंट मैच होने के बाद

जब अपनी कार्रवाइयों में वेबहुक ट्रिगर किया जाता है, तो Google Assistant, आपके फ़ुलफ़िलमेंट को JSON पेलोड के साथ अनुरोध भेजता है. इसमें, इवेंट को प्रोसेस करने के लिए इस्तेमाल किए जाने वाले हैंडलर का नाम शामिल होता है. आपका फ़ुलफ़िलमेंट एंडपॉइंट, लॉजिक को पूरा करने और JSON पेलोड के साथ उससे जुड़ा जवाब देने के लिए, इवेंट को सही हैंडलर पर भेज सकता है.

पेलोड

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

अनुरोध का उदाहरण

{
  "handler": {
    "name": "handler_name"
  },
  "intent": {
    "name": "actions.intent.MAIN",
    "params": {},
    "query": ""
  },
  "scene": {
    "name": "SceneName",
    "slotFillingStatus": "UNSPECIFIED",
    "slots": {}
  },
  "session": {
    "id": "example_session_id",
    "params": {},
    "typeOverrides": []
  },
  "user": {
    "locale": "en-US",
    "params": {
      "verificationStatus": "VERIFIED"
    }
  },
  "home": {
    "params": {}
  },
  "device": {
    "capabilities": [
      "SPEECH",
      "RICH_RESPONSE",
      "LONG_FORM_AUDIO"
    ]
  }
}

जवाब का उदाहरण

{
  "session": {
    "id": "example_session_id",
    "params": {}
  },
  "prompt": {
    "override": false,
    "firstSimple": {
      "speech": "Hello World.",
      "text": ""
    }
  },
  "scene": {
    "name": "SceneName",
    "slots": {},
    "next": {
      "name": "actions.scene.END_CONVERSATION"
    }
  }
}

रंटाइम इंटरैक्शन

इन सेक्शन में, सामान्य टास्क के बारे में बताया गया है. ये टास्क, वेबहुक हैंडलर में किए जा सकते हैं.

प्रॉम्प्ट भेजना

सादे टेक्स्ट, रिच टेक्स्ट, कार्ड, और यहां तक कि पूरी तरह से एचटीएमएल प्रॉम्प्ट भी बनाए जा सकते हैं. ये प्रॉम्प्ट, इंटरैक्टिव कैनवस वाले वेब ऐप्लिकेशन पर काम करते हैं. प्रॉम्प्ट के दस्तावेज़ में, वेबहुक इवेंट को हैंडल करते समय प्रॉम्प्ट बनाने के तरीके के बारे में पूरी जानकारी दी गई है. यहां दिए गए स्निपेट में, कार्ड प्रॉम्प्ट दिखाया गया है:

Node.js

app.handle('rich_response', conv => {
  conv.add('This is a card rich response.');
  conv.add(new Card({
    title: 'Card Title',
    subtitle: 'Card Subtitle',
    text: 'Card Content',
    image: new Image({
      url: 'https://developers.google.com/assistant/assistant_96.png',
      alt: 'Google Assistant logo'
    })
  }));
});

जवाब का JSON

{
  "session": {
    "id": "example_session_id",
    "params": {}
  },
  "prompt": {
    "override": false,
    "content": {
      "card": {
        "title": "Card Title",
        "subtitle": "Card Subtitle",
        "text": "Card Content",
        "image": {
          "alt": "Google Assistant logo",
          "height": 0,
          "url": "https://developers.google.com/assistant/assistant_96.png",
          "width": 0
        }
      }
    },
    "firstSimple": {
      "speech": "This is a card rich response.",
      "text": ""
    }
  }
}

इंटेंट पैरामीटर पढ़ना

जब Assistant का रनटाइम, किसी इंटेंट से मैच होता है, तो वह तय किए गए सभी पैरामीटर को एक्सट्रैक्ट कर लेता है. ओरिजनल प्रॉपर्टी वह होती है जो उपयोगकर्ता ने इनपुट के तौर पर दी है. वहीं, रिज़ॉल्व्ड प्रॉपर्टी वह होती है जो एनएलयू ने टाइप की जानकारी के आधार पर इनपुट को रिज़ॉल्व किया है.

Node.js

conv.intent.params['param_name'].original
conv.intent.params['param_name'].resolved

अनुरोध का JSON

{
  "handler": {
    "name": "handler_name"
  },
  "intent": {
    "name": "intent_name",
    "params": {
      "slot_name": {
        "original": "1",
        "resolved": 1
      }
    },
    "query": ""
  },
  "scene": {
    "name": "SceneName",
    "slotFillingStatus": "UNSPECIFIED",
    "slots": {},
    "next": {
      "name": "actions.scene.END_CONVERSATION"
    }
  },
  "session": {
    "id": "session_id",
    "params": {},
    "typeOverrides": []
  },
  "user": {
    "locale": "en-US",
    "params": {
      "verificationStatus": "VERIFIED"
    }
  },
  "home": {
    "params": {}
  },
  "device": {
    "capabilities": [
      "SPEECH",
      "RICH_RESPONSE",
      "LONG_FORM_AUDIO"
    ]
  }
}

उपयोगकर्ता का स्थानीय सेटिंग पढ़ना

यह वैल्यू, Google Assistant के लिए उपयोगकर्ता की स्थानीय सेटिंग के मुताबिक होती है.

Node.js

conv.user.locale

JSON

{
  "handler": {
    "name": "handler_name"
  },
  "intent": {
    "name": "actions.intent.MAIN",
    "params": {},
    "query": ""
  },
  "scene": {
    "name": "SceneName",
    "slotFillingStatus": "UNSPECIFIED",
    "slots": {}
  },
  "session": {
    "id": "session_id",
    "params": {},
    "typeOverrides": []
  },
  "user": {
    "locale": "en-US",
    "params": {
      "verificationStatus": "VERIFIED"
    }
  },
  "home": {
    "params": {}
  },
  "device": {
    "capabilities": [
      "SPEECH",
      "RICH_RESPONSE",
      "LONG_FORM_AUDIO"
    ]
  }
}

स्टोरेज में डेटा पढ़ना और लिखना

अलग-अलग स्टोरेज सुविधाओं का इस्तेमाल करने के तरीके के बारे में पूरी जानकारी पाने के लिए, स्टोरेज का दस्तावेज़ देखें.

Node.js

//read
conv.session.params.key
conv.user.params.key
conv.home.params.key

// write
conv.session.params.key = value
conv.user.params.key = value
conv.home.params.key = value

अनुरोध का JSON

{
  "handler": {
    "name": "handler_name"
  },
  "intent": {
    "name": "actions.intent.MAIN",
    "params": {},
    "query": ""
  },
  "scene": {
    "name": "SceneName",
    "slotFillingStatus": "UNSPECIFIED",
    "slots": {}
  },
  "session": {
    "id": "session_id",
    "params": {
      "key": "value"
    },
    "typeOverrides": [],
    "languageCode": ""
  },
  "user": {
    "locale": "en-US",
    "params": {
      "verificationStatus": "VERIFIED",
      "key": "value"
    }
  },
  "home": {
    "params": {
      "key": "value"
    }
  },
  "device": {
    "capabilities": [
      "SPEECH",
      "RICH_RESPONSE",
      "LONG_FORM_AUDIO"
    ]
  }
}

जवाब का JSON

{
  "session": {
    "id": "session_id",
    "params": {
      "key": "value"
    }
  },
  "prompt": {
    "override": false,
    "firstSimple": {
      "speech": "Hello world.",
      "text": ""
    }
  },
  "user": {
    "locale": "en-US",
    "params": {
      "verificationStatus": "VERIFIED",
      "key": "value"
    }
  },
  "home": {
    "params": {
      "key": "value"
    }
  }
}

डिवाइस की क्षमताओं की जांच करना

अलग-अलग अनुभव या बातचीत के फ़्लो देने के लिए, किसी डिवाइस की क्षमताओं की जांच की जा सकती है.

Node.js

const supportsRichResponse = conv.device.capabilities.includes("RICH_RESPONSE");
const supportsLongFormAudio = conv.device.capabilities.includes("LONG_FORM_AUDIO");
const supportsSpeech = conv.device.capabilities.includes("SPEECH");
const supportsInteractiveCanvas = conv.device.capabilities.includes("INTERACTIVE_CANVAS");

अनुरोध का JSON

{
  "handler": {
    "name": "handler_name"
  },
  "intent": {
    "name": "actions.intent.MAIN",
    "params": {},
    "query": ""
  },
  "scene": {
    "name": "SceneName",
    "slotFillingStatus": "UNSPECIFIED",
    "slots": {}
  },
  "session": {
    "id": "session_id",
    "params": {},
    "typeOverrides": [],
    "languageCode": ""
  },
  "user": {
    "locale": "en-US",
    "params": {
      "verificationStatus": "VERIFIED"
    }
  },
  "home": {
    "params": {}
  },
  "device": {
    "capabilities": [
      "SPEECH",
      "RICH_RESPONSE",
      "LONG_FORM_AUDIO",
      "INTERACTIVE_CANVAS"
    ]
  }
}

सरफ़ेस की क्षमताओं की पूरी सूची देखने के लिए, Capability रेफ़रंस देखें.

रंटाइम टाइप के बदलाव

रंटाइम टाइप की मदद से, रंटाइम के दौरान टाइप की जानकारी में बदलाव किया जा सकता है. इस सुविधा का इस्तेमाल करके, अन्य सोर्स से डेटा लोड किया जा सकता है, ताकि किसी टाइप की मान्य वैल्यू अपने-आप भर जाएं. उदाहरण के लिए, सर्वे के किसी सवाल में डाइनैमिक विकल्प जोड़ने या मेन्यू में रोज़ाना का आइटम जोड़ने के लिए, रंटाइम टाइप के बदलावों का इस्तेमाल किया जा सकता है.

रंटाइम टाइप का इस्तेमाल करने के लिए, अपनी कार्रवाई से वेबहुक ट्रिगर करें. यह वेबहुक, आपके फ़ुलफ़िलमेंट में मौजूद हैंडलर को कॉल करता है. इसके बाद, अपनी कार्रवाई को वापस भेजे जाने वाले जवाब में, session.typeOverrides पैरामीटर को अपने-आप भरा जा सकता है. उपलब्ध मोड में, मौजूदा टाइप की एंट्री को बनाए रखने के लिए TYPE_MERGE या मौजूदा एंट्री को बदलावों से बदलने के लिए TYPE_REPLACE शामिल हैं.

Node.js

conv.session.typeOverrides = [{
    name: type_name,
    mode: 'TYPE_REPLACE',
    synonym: {
      entries: [
        {
          name: 'ITEM_1',
          synonyms: ['Item 1', 'First item']
        },
        {
          name: 'ITEM_2',
          synonyms: ['Item 2', 'Second item']
       },
       {
          name: 'ITEM_3',
          synonyms: ['Item 3', 'Third item']
        },
        {
          name: 'ITEM_4',
          synonyms: ['Item 4', 'Fourth item']
        },
    ]
  }
}];

जवाब का JSON

{
  "session": {
    "id": "session_id",
    "params": {},
    "typeOverrides": [
      {
        "name": "type_name",
        "synonym": {
          "entries": [
            {
              "name": "ITEM_1",
              "synonyms": [
                "Item 1",
                "First item"
              ]
            },
            {
              "name": "ITEM_2",
              "synonyms": [
                "Item 2",
                "Second item"
              ]
            },
            {
              "name": "ITEM_3",
              "synonyms": [
                "Item 3",
                "Third item"
              ]
            },
            {
              "name": "ITEM_4",
              "synonyms": [
                "Item 4",
                "Fourth item"
              ]
            }
          ]
        },
        "typeOverrideMode": "TYPE_REPLACE"
      }
    ]
  },
  "prompt": {
    "override": false,
    "firstSimple": {
      "speech": "This is an example prompt.",
      "text": "This is an example prompt."
    }
  }
}

स्पीच बायसिंग की सुविधा देना

स्पीच बायसिंग की मदद से, एनएलयू को हिंट तय किए जा सकते हैं, ताकि इंटेंट मैचिंग को बेहतर बनाया जा सके. ज़्यादा से ज़्यादा 1,000 एंट्री तय की जा सकती हैं.

Node.js

conv.expected.speech = ['value_1', 'value_2']
conv.expected.language = 'locale_string'

जवाब का JSON

{
  "session": {
    "id": "session_id",
    "params": {}
  },
  "prompt": {
    "override": false,
    "firstSimple": {
      "speech": "This is an example prompt.",
      "text": "This is an example prompt."
    }
  },
  "expected": {
    "speech": "['value_1', 'value_2']",
    "language": "locale_string"
  }
}

सीन में ट्रांज़िशन

अपनी कार्रवाइयों के प्रोजेक्ट में स्टैटिक ट्रांज़िशन तय करने के अलावा, रंटाइम के दौरान सीन ट्रांज़िशन भी किए जा सकते हैं.

Node.js

app.handle('transition_to_hidden_scene', conv => {
  // Dynamic transition
  conv.scene.next.name = "HiddenScene";
});

जवाब का JSON

{
  "session": {
    "id": "session_id",
    "params": {}
  },
  "prompt": {
    "override": false,
    "firstSimple": {
      "speech": "This is an example prompt.",
      "text": ""
    }
  },
  "scene": {
    "name": "SceneName",
    "slots": {},
    "next": {
      "name": "HiddenScene"
    }
  }
}

सीन के स्लॉट पढ़ना

स्लॉट फ़िलिंग के दौरान, स्लॉट की पुष्टि करने या स्लॉट फ़िलिंग (SlotFillingStatus) का स्टेटस देखने के लिए, फ़ुलफ़िलमेंट का इस्तेमाल किया जा सकता है.

Node.js

conv.scene.slotFillingStatus  // FINAL means all slots are filled
conv.scene.slots  // Object that contains all the slots
conv.scene.slots['slot_name'].<property_name> // Accessing a specific slot's properties

उदाहरण के लिए, मान लें कि आपको किसी जवाब से टाइम ज़ोन एक्सट्रैक्ट करना है. इस उदाहरण में, स्लॉट का नाम datetime1 है. टाइम ज़ोन पाने के लिए, इसका इस्तेमाल किया जाएगा:

conv.scene.slots['datetime1'].value.time_zone.id

अनुरोध का JSON

{
  "handler": {
    "name": "handler_name"
  },
  "intent": {
    "name": "",
    "params": {
      "slot_name": {
        "original": "1",
        "resolved": 1
      }
    },
    "query": ""
  },
  "scene": {
    "name": "SceneName",
    "slotFillingStatus": "FINAL",
    "slots": {
      "slot_name": {
        "mode": "REQUIRED",
        "status": "SLOT_UNSPECIFIED",
        "updated": true,
        "value": 1
      }
    },
    "next": {
      "name": "actions.scene.END_CONVERSATION"
    }
  },
  "session": {
    "id": "session_id",
    "params": {
      "slot_name": 1
    },
    "typeOverrides": []
  },
  "user": {
    "locale": "en-US",
    "params": {
      "verificationStatus": "VERIFIED"
    }
  },
  "home": {
    "params": {}
  },
  "device": {
    "capabilities": [
      "SPEECH",
      "RICH_RESPONSE",
      "LONG_FORM_AUDIO"
    ]
  }
}

सीन के स्लॉट को अमान्य करना

स्लॉट को अमान्य किया जा सकता है और उपयोगकर्ता से नई वैल्यू देने के लिए कहा जा सकता है.

Node.js

conv.scene.slots['slot_name'].status = 'INVALID'

जवाब का JSON

{
  "session": {
    "id": "session_id",
    "params": {
      "slot_name": 1
    }
  },
  "prompt": {
    "override": false,
    "firstSimple": {
      "speech": "This is an example prompt.",
      "text": ""
    }
  },
  "scene": {
    "name": "SceneName",
    "slots": {
      "slot_name": {
        "mode": "REQUIRED",
        "status": "INVALID",
        "updated": true,
        "value": 1
      }
    },
    "next": {
      "name": "actions.scene.END_CONVERSATION"
    }
  }
}

डेवलपमेंट के विकल्प

Actions Builder में, Cloud Functions एडिटर नाम का इनलाइन एडिटर होता है. इसकी मदद से, कंसोल में सीधे Firebase के लिए Cloud Function बनाया और डिप्लॉय किया जा सकता है. अपनी पसंद की होस्टिंग पर फ़ुलफ़िलमेंट बनाया और डिप्लॉय भी किया जा सकता है. साथ ही, एचटीटीपीएस फ़ुलफ़िलमेंट एंडपॉइंट को वेबहुक हैंडलर के तौर पर रजिस्टर किया जा सकता है.

इनलाइन एडिटर

Cloud Functions एडिटर की मदद से डेवलपमेंट करने के लिए:

  1. अपना Actions प्रोजेक्ट खोलें और डेवलप टैब > वेबहुक > फ़ुलफ़िलमेंट का तरीका बदलें पर जाएं. इसके बाद, फ़ुलफ़िलमेंट के तरीके विंडो दिखती है.
  2. इनलाइन Cloud Functions को चुनें और पुष्टि करें पर क्लिक करें.

बाहरी एचटीटीपीएस एंडपॉइंट

इस सेक्शन में, बातचीत वाली कार्रवाई के लिए, Firebase के लिए Cloud Functions को फ़ुलफ़िलमेंट सेवा के तौर पर सेट अप करने का तरीका बताया गया है. हालांकि, अपनी पसंद की होस्टिंग सेवा पर फ़ुलफ़िलमेंट डिप्लॉय किया जा सकता है.

एनवायरमेंट सेट अप करना

अपना एनवायरमेंट सेट अप करने के लिए, यह तरीका अपनाएं:

  1. Node.js डाउनलोड और इंस्टॉल करें.

  2. Firebase CLI सेट अप करें और उसे शुरू करें. अगर गड़बड़ी की वजह से यह कमांड काम नहीं करती है, तो आपको एनपीएम की अनुमतियां बदलनी पड़ सकती हैं.EACCES

    npm install -g firebase-tools

  3. firebase टूल की पुष्टि अपने Google खाते से करें:

    firebase login

  4. उस प्रोजेक्ट डायरेक्ट्री को शुरू करें जहां आपने अपना Actions प्रोजेक्ट सेव किया है. आपसे यह चुनने के लिए कहा जाएगा कि आपको अपने Actions प्रोजेक्ट के लिए, Firebase CLI की किन सुविधाओं को सेट अप करना है. Functions और अन्य सुविधाएं चुनें. जैसे, Firestore. इसके बाद, पुष्टि करने और जारी रखने के लिए, Enter दबाएं:

    $ cd <ACTIONS_PROJECT_DIRECTORY>
$ firebase init

  5. प्रोजेक्ट की सूची में, तीर कुंजियों की मदद से अपना Actions प्रोजेक्ट चुनें. ऐसा करके, Firebase टूल को अपने Actions प्रोजेक्ट से जोड़ें:

  6. प्रोजेक्ट चुनने के बाद, Firebase टूल, Functions का सेटअप शुरू करता है और आपसे पूछता है कि आपको किस भाषा का इस्तेमाल करना है. तीर कुंजियों का इस्तेमाल करके भाषा चुनें और जारी रखने के लिए Enter दबाएं.

    === Functions Setup
A functions directory will be created in your project with a Node.js
package pre-configured. Functions can be deployed with firebase deploy.

? What language would you like to use to write Cloud Functions? (Use arrow keys)
> JavaScript
TypeScript

  7. यह चुनने के लिए कि आपको संभावित गड़बड़ियों को पकड़ने और स्टाइल लागू करने के लिए, ESLint का इस्तेमाल करना है या नहीं, Y या N टाइप करें:

    ? Do you want to use ESLint to catch probable bugs and enforce style? (Y/n)

  8. प्रॉम्प्ट में Y टाइप करके, प्रोजेक्ट की ज़रूरी चीज़ें पाएं:

    ? Do you want to install dependencies with npm now? (Y/n)

    सेटअप पूरा होने के बाद, आपको ऐसा आउटपुट दिखेगा:

    ✔  Firebase initialization complete!

  9. @assistant/conversation डिपेंडेंसी इंस्टॉल करें:

    $ cd <ACTIONS_PROJECT_DIRECTORY>/functions
$ npm install @assistant/conversation --save

  10. फ़ुलफ़िलमेंट की ज़रूरी चीज़ें पाएं और फ़ुलफ़िलमेंट फ़ंक्शन डिप्लॉय करें:

    $ npm install
$ firebase deploy --only functions

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

    ✔  Deploy complete!
    
Project Console: https://console.firebase.google.com/project/<PROJECT_ID>/overview
Function URL (<FUNCTION_NAME>): https://us-central1-<PROJECT_ID>.cloudfunctions.net/<FUNCTION_NAME>

  11. अगले सेक्शन में इस्तेमाल करने के लिए, फ़ुलफ़िलमेंट यूआरएल को कॉपी करें.

वेबहुक हैंडलर रजिस्टर करना

अपने Cloud Function एंडपॉइंट को वेबहुक हैंडलर के तौर पर रजिस्टर करने के लिए:

  1. Actions कंसोल में, डेवलप > वेबहुक पर क्लिक करें.
  2. फ़ुलफ़िलमेंट का तरीका बदलें पर क्लिक करें. इसके बाद, फ़ुलफ़िलमेंट के तरीके विंडो दिखती है.
  3. वेबहुक को चुनें और पुष्टि करें पर क्लिक करें.
  4. अपने वेब सेवा के यूआरएल को वेबहुक फ़ील्ड में चिपकाएं.
  5. सेव करें पर क्लिक करें.