Python के साथ अपना Facebook Messenger बॉट परिनियोजित करें

जब सही तरीके से किया जाए, तो मानवीय भाषा के जरिए कंप्यूटर से बातचीत करना बेहद प्रभावशाली—और काफ़ी मज़ेदार—हो सकता है। मैसेजिंग और वॉयस-कंट्रोल्ड डिवाइस अगला बड़ा प्लेटफ़ॉर्म हैं, और वार्तालाप-आधारित कंप्यूटिंग आकर्षक ऑगमेंटेड और वर्चुअल रियलिटी अनुभव बनाने में अहम भूमिका निभाती है। ऐसे प्रोग्राम बनाने में कई अलग-अलग चुनौतियाँ आती हैं, जैसे: मैं अपना चैटबॉट बाहरी दुनिया के लिए कैसे उपलब्ध कराऊँ?

इस ट्यूटोरियल में, आप Facebook Messenger पर एक चैटबॉट परिनियोजित करने के लिए आवश्यक चरणों से गुजरेंगे, जिसके 1 बिलियन से अधिक सक्रिय उपयोगकर्ता हैं। कुछ ही पंक्तियों के कोड से आप एक बहुत बड़े दर्शक-वर्ग तक पहुँच सकते हैं।

इसे करने के 3 मुख्य चरण हैं। आपको यह करना होगा:

• Facebook से आने वाले संदेशों को सुनने वाला सर्वर बनाना ( flask का उपयोग करके)
• उपयोगकर्ताओं को संदेश वापस भेजने के लिए एक फ़ंक्शन परिभाषित करना ( requests का उपयोग करके)
• अपनी लोकल मशीन तक एक https कनेक्शन फॉरवर्ड करना ( ngrok का उपयोग करके)

यदि आप यह जानना चाहते हैं कि मानवीय भाषा को मशीन निर्देशों में कैसे बदला जाए, तो Building Chatbots in Python DataCamp कोर्स देखें।

ध्यान दें कि इस पोस्ट में आप यह कवर नहीं करेंगे कि आपका बॉट लोगों की बातें कैसे समझे और उपयुक्त प्रतिक्रिया दे। इसके बारे में अधिक जानने के लिए Rasa NLU, Rasa Core और अभी-अभी उल्लिखित DataCamp कोर्स पर नज़र डालें।

अपने चैटबॉट को एक http सर्वर में लपेटें

पहला कदम एक http सर्वर बनाना है जो Facebook द्वारा भेजे गए संदेशों को सुने, उस संदेश के लिए एक प्रतिक्रिया प्राप्त करे, और अंततः वह प्रतिक्रिया Facebook पर उपयोगकर्ता को वापस भेज दे। हम यह सर्वर बनाने के लिए flask का उपयोग करेंगे। मूल विचार यह है:

• एक flask ऐप बनाएँ जो localhost:5000/webhook पर भेजे गए संदेशों को सुने। जब Facebook पर संदेश भेजे जाते हैं तो वे http रिक्वेस्ट के रूप में इस URL पर पहुँचेंगे।
• listen() फ़ंक्शन इन http रिक्वेस्ट्स को हैंडल करता है और जाँचता है कि उनमें मान्य Facebook संदेश है या नहीं
• यदि संदेश मान्य है, तो get_bot_response() फ़ंक्शन को बुलाया जाता है और प्रतिक्रिया Facebook Messenger पर वापस भेज दी जाती है

इसके अलावा, आप verify_webhook() नाम का एक फ़ंक्शन बनाएँगे जो Facebook और आपके ऐप के बीच आरंभिक प्रमाणीकरण को संभालता है।

अंतिम स्क्रिप्ट कुछ इस तरह दिखती है (इसे server.py नाम से सेव करें):

from flask import Flask, request

app = Flask(__name__)

FB_API_URL = 'https://graph.facebook.com/v2.6/me/messages'
VERIFY_TOKEN = ''# <paste your verify token here>
PAGE_ACCESS_TOKEN = ''# paste your page access token here>"


def get_bot_response(message):
    """This is just a dummy function, returning a variation of what
    the user said. Replace this function with one connected to chatbot."""
    return "This is a dummy response to '{}'".format(message)


def verify_webhook(req):
    if req.args.get("hub.verify_token") == VERIFY_TOKEN:
        return req.args.get("hub.challenge")
    else:
        return "incorrect"

def respond(sender, message):
    """Formulate a response to the user and
    pass it on to a function that sends it."""
    response = get_bot_response(message)
    send_message(sender, response)


def is_user_message(message):
    """Check if the message is a message from the user"""
    return (message.get('message') and
            message['message'].get('text') and
            not message['message'].get("is_echo"))


@app.route("/webhook")
def listen():
    """This is the main function flask uses to 
    listen at the `/webhook` endpoint"""
    if request.method == 'GET':
        return verify_webhook(request)

    if request.method == 'POST':
        payload = request.json
        event = payload['entry'][0]['messaging']
        for x in event:
            if is_user_message(x):
                text = x['message']['text']
                sender_id = x['sender']['id']
                respond(sender_id, text)

        return "ok"संचालित द्वारा

ऊपर दी गई स्क्रिप्ट में VERIFY_TOKEN और PAGE_ACCESS_TOKEN वेरिएबल अभी परिभाषित नहीं हैं — इसलिए आपको इन्हें सेट करना होगा। VERIFY_TOKEN कोई भी स्ट्रिंग हो सकती है, इसे एक तरह के पासवर्ड की तरह इस्तेमाल किया जाता है ताकि Facebook को पता चले कि यह सर्वर संदेश प्राप्त करना चाहता है। लंबी रैंडम स्ट्रिंग का उपयोग करना अच्छा विचार है। आप अपने टर्मिनल में openssl rand -base64 32 चलाकर इसे जल्दी से कर सकते हैं।

PAGE_ACCESS_TOKEN की चिंता अभी न करें — आप इसे नीचे प्राप्त करने का तरीका देखेंगे!

उपयोगकर्ताओं को संदेश वापस भेजें

अगला कदम, आप एक फ़ंक्शन लिखेंगे जो requests नामक Python लाइब्रेरी का उपयोग करके Facebook Messenger को प्रतिक्रिया भेजता है। विशेष रूप से, आप post() मेथड का उपयोग करेंगे, जो एक HTTP POST रिक्वेस्ट बनाता है। किसी सर्वर को सूचना भेजने का सामान्य तरीका POST रिक्वेस्ट ही है।

आपका फ़ंक्शन कुछ इस तरह होना चाहिए:

import requests

def send_message(recipient_id, text):
    """Send a response to Facebook"""
    payload = {
        'message': {
            'text': text
        },
        'recipient': {
            'id': recipient_id
        },
        'notification_type': 'regular'
    }

    auth = {
        'access_token': PAGE_ACCESS_TOKEN
    }

    response = requests.post(
        FB_API_URL,
        params=auth,
        json=payload
    )

    return response.json()
संचालित द्वारा

एक https एंडपॉइंट एक्सपोज़ करें और Facebook पेज कनेक्ट करें

localhost:5000 URL केवल उसी कंप्यूटर से बनाए गए रिक्वेस्ट्स के लिए काम करता है जिस पर सर्वर चल रहा है। इसलिए आपको Facebook को यह बताना होगा कि आपका flask सर्वर कैसे पहुँचा जा सकता है। इसके लिए पहले ngrok इंस्टॉल करें।

इस पेज पर जाएँ और अपने ऑपरेटिंग सिस्टम के लिए संस्करण इंस्टॉल करें। यदि आप Mac पर हैं और आपके पास homebrew है, तो ngrok इंस्टॉल करने का सबसे तेज़ तरीका है brew cask install ngrok।

टर्मिनल में ngrok http 5000 से ngrok सर्वर शुरू करें। यह एक https एंडपॉइंट सेट करेगा जो आपकी मशीन पर पोर्ट 5000 पर फॉरवर्ड होगा, उदाहरण के लिए https://51b6b3fa.ngrok.io।

ध्यान दें कि यदि आप ngrok बंद करके दोबारा शुरू करते हैं, तो यह URL बदल जाएगा।

एक Facebook ऐप और पेज बनाएँ

अगला कदम Facebook पर एक ऐप और एक पेज बनाना है। Facebook की डॉक्यूमेंटेशन अच्छी है, लेकिन यहाँ आप मुख्य चरणों से गुजरेंगे।

ऐप बनाने के लिए यहाँ जाएँ और

• My Apps -> Add a New App पर क्लिक करें और एक नाम दर्ज करें
• आप ऐप के डैशबोर्ड पर रीडायरेक्ट कर दिए जाएँगे
• Products के अंतर्गत, Add a Product खोजें और Messenger -> Set Up पर क्लिक करें

पेज बनाने के लिए, आपको यह करना होगा:

• Messenger की सेटिंग्स में जाएँ, नीचे स्क्रॉल करके Token Generation तक जाएँ और अपने ऐप के लिए create a new page लिंक पर क्लिक करें

एक बार जब आपने पेज बना लिया, तो वापस Token Generation सेटिंग्स पर जाएँ और ड्रॉप-डाउन मेनू से इस पेज को चुनें। Page Access Token को ऊपर server.py में PAGE_ACCESS_TOKEN के प्लेसहोल्डर में कॉपी करें।

अपना बॉट सर्वर शुरू करें

अब जबकि सब सेट हो चुका है, आपका चैटबॉट सर्वर शुरू करने का समय है! एक अलग टर्मिनल टैब में, यह चलाएँ

FLASK_APP=server.py flask run
संचालित द्वारा

वेबहुक सेट करें

अंत में, आपको Facebook डेवलपर्स पेज पर अपना वेबहुक रजिस्टर करना होगा।

• दोबारा Products में Messenger टैब पर जाएँ और Webhooks तक स्क्रॉल करें, Setup Webhooks पर क्लिक करें
• Callback URL के अंतर्गत अपना ngrok URL दर्ज करें, उदाहरण के लिए, https://51b6b3fa.ngrok.io/webhook। यह ज़रूरी है कि आपका flask ऐप इस समय चल रहा हो, क्योंकि अगले चरण में verify_token() को कॉल किया जाएगा
• Verify Token फ़ील्ड में वह मान डालें जो आपने अपने server.py फ़ाइल में निर्दिष्ट किया था
• Subscription Fields में सुनिश्चित करें कि messages और messaging_postbacks चुने हुए हैं। प्रमाणीकरण करने के लिए Click Verify and Save पर क्लिक करें

महत्वपूर्ण: Products -> Messenger पर वापस जाएँ, और Select a page to subscribe your webhook to the page events के अंतर्गत अपना पेज चुनें और Subscribe पर क्लिक करें।

आपने काम पूरा कर लिया!

अब आपका बॉट Facebook Messenger के जरिए संदेश भेजने और प्राप्त करने के लिए तैयार है। अभी, आपका get_bot_response() फ़ंक्शन काफ़ी सरल है और अभी वास्तविक चैटबॉट जैसा महसूस नहीं होता! चैटबॉट बनाना पूरी तरह सीखने के लिए Building Chatbots in Python DataCamp कोर्स और Building a Chatbot using Chatterbot in Python ट्यूटोरियल, साथ ही Rasa NLU और Rasa Core Python लाइब्रेरीज़ देखें।