Dit is een voorbeeld van hoe je een weerchatbot op Facebook-platform kunt bouwen met Ruby on Rails en Wit.ai

De gebruikte technologiestack is

• Backend van de server: Ruby on Rails
• Natuurlijke taalverwerking platfrom: Wit.ai
• Implementatie op Facebook Messenger
• Het Singapore National Environment Agency biedt een leuke API (gratis) die zowel het actuele weer als voorspellingen geeft

Voorbeeld functie:

(1) In staat om de “2 uur Nowcast” terug te geven wanneer de gebruiker om het huidige weer vraagt

Gebruiker: “Hoe is het weer in Changi?”

Bot: “Het weer in Changi is {weather}”

Gebruiker: “Hoe is het weer in Changi?”

Gebruiker: “Regent het in Changi?”

Bot: “Het weer in Changi is {weather}”

Je kunt de weersbot hier uitproberen : WBot By Robusttechhouse

Wit.AI instellen

Ga naar https://wit.ai/home en maak een wit-app voor jou. Lees https://wit.ai/docs/quickstart en volg de stappen daar. Ga vervolgens naar de instellingen in je witte app en ontvang de token-ID.

Integreer rails met Wit

We hebben maar twee, relatief eenvoudige modellen; Bericht en gesprek

In /app/models/message.rb

# Frozen_string_literal: true 
klasse Message 
  omvatten Mongoid :: Document 
  omvatten Mongoid :: Timestamps   veld: lichaam, type: String 
  veld: conversation_id, type: Integer 
  veld: soort, type: String   has_many: quick_replies 
  belongs_to: gesprek   validates_inclusion_of: kind, in:% w (uitgaande inkomende), allow_nil: false 
  valideert: gesprek, aanwezigheid: waar 
einde

In /app/models/conversation.rb

# frozen_string_literal: true 
class Conversatie 
  include Mongoid :: Document 
  include Mongoid :: Timestamps   field: uid, type: String 
  field: context, type: Hash   has_many: messages 
end

WitExtension Singleton

‘wit’ is een heel mooi juweeltje dat onze rails-app ondersteunt om te integreren met wit.ai

edelsteen 'wit'

Maak een nieuw wit_extension.rb-bestand in / extensions . Wat we nu moeten doen, is een WitExtension Singleton-klasse maken en in de initialisatie ervan stellen we een Wit-client in, het access_token en acties.

Dankzij de bovenstaande code kunnen we WitExtension.instance.client overal in onze Rails-toepassing aanroepen en zou hetzelfde exemplaar van WitExtension en dus hetzelfde Wit-clientobject worden geretourneerd.

Houd er rekening mee dat je je access_token of een ander token zoals het gewoon niet in code moet hebben liggen te wachten om in versiebeheer te plaatsen. U moet secrets.yml gebruiken voor ontwikkelings- en omgevingsvariabelen in productie.

Onze acties Hash krijgen het gesprek om de context op het juiste moment met de juiste toetsen bij te werken.

De code in de actie getForecast haalt de entiteiten uit de verzoekparameter van Wit en werkt de sleutels en waarden van context bij op basis van wat nodig is om te werken.

Het is uit de geretourneerde context Hash dat Wit besluit wat te doen op basis van de aanwezigheid en / of afwezigheid van een van de sleutels.

# frozen_string_literal: true 
vereist 'wit' 
vereist 'singleton' klasse WitExtension 
  omvatten Singleton   def initialiseren 
    access_token = ENV ['server_access_token'] 
    acties = { 
      stuur: lambda do | _request, response | 
        put ("[debuz] kreeg antwoord ... # {antwoord ['tekst']}")         message = Message.create (body: response ['text'], soort: 'uitgaand', gesprek: @conversation) 
        bericht. digest 
      einde,       getForecast: 
        lambda do | request | 
          context = verzoek ['context'] 
          entiteiten = verzoek ['entiteiten']           location = first_entity_value (entiteiten, 'locatie') || context [locatie]
          
          if location 
            forecast = search_forecast (locatie) 
            context ['forecast'] = voorspelling 
            new_context = {} 
          anders 
            new_context = context 
          end           @ conversation.update (context: new_context) 
          return context 
        end 
    }     @client = Wit.new (access_token: access_token, actions : acties) 
  einde   attr_reader: client   def set_conversation (conversatie) 
    @conversation = gesprek 
  einde   private   def first_entity_value (entiteiten, entiteit) 
    retourneren nul tenzij entiteiten.key? entiteit
    val = entiteiten [entiteit] [0] ['waarde'] 
    retourneer nul als val.nil? 
    val.is_a? (Hash)? val ['waarde']: val 
  end   def search_forecast (locatie) 
    zet "[debuz] Zoeken naar weer in # {locatie} ..." 
    WeatherExtension.search_forecast (locatie) 
  einde 
einde

Chat-extensie

Deze klasse fungeert als een controller tussen berichten van Facebook en het brein van onze Bot (Wit). Het heeft ook de verantwoordelijkheid om berichten en gesprekken te back-uppen.

# frozen_string_literal: echte 
klasse ChatExtension- 
  klasse << zelf 
    def antwoord (bericht, uid) 
      zet "[debuz] vraagt ​​WIT om ... # {bericht}" 
      find_or_initialize_conversation (uid) 
      create_incoming_message (bericht) 
      WitExtension.instance.client.run_actions (@ conversation.uid, message, @ conversation.context.to_h) 
    end     private     def find_or_initialize_conversation (uid) 
      @conversation = Conversation.find_or_create_by (uid: uid) 
      WitExtension.instance.set_conversation (@conversation) 
    end     def create_incoming_message (bericht) 
      create_message (inkomend) ', bericht) 
    einde    def create_message (kind, bericht) 
      @message = @ conversation.messages.create ( 
        body: bericht, 
        kind: kind 
      ) 
    end 
  end 
end

Integreer Rails-app met Facebook Messenger

Facebook-app instellen

Ga naar de ontwikkelaarsconsole en druk op “Een nieuwe app toevoegen”. Nadat u er een hebt gemaakt, kunt u de snelle start overslaan. Je komt hier terecht.

Vanaf hier wilt u op ‘+ Product toevoegen’ drukken en Messenger toevoegen. Nadat we een webhook hebben geconfigureerd, wil Facebook dat we de URL naar onze applicatie valideren.

App Rails instellen

We zullen het Facebook-messenger- juweel gebruiken. Het is misschien wel de beste Ruby-client voor Facebook Messenger.

Voeg initialisatiecode toe

# frozen_string_literal: true 
# config / initializers / facebook_messenger.rb tenzij Rails.env.production? 
  bot_files = Dir [Rails.root.join ('app', 'bot', '**', '* .rb')] 
  bots_reloader = ActiveSupport :: FileUpdateChecker.new (bot_files) doen 
    bot_files.each {| file | 
  vereist_afhankelijkheidsbestand 

}   einde ActionDispatch :: Callbacks.to_prepare doen     bots_reloader.execute_if_updated   einde   bot_files.each {| file | vereist_afhankelijkheidsbestand} 
einde

Voeg de eerste code toe voor onze bot

# frozen_string_literal: true 
# app / bot / listen.rb vereist 'facebook / messenger' inclusief Facebook :: Messenger Facebook :: Messenger :: Subscriptions.subscribe (access_token: ENV ['ACCESS_TOKEN']) Bot.on: message do | message | 
  # message.id # => 'mid.1457764197618: 41d102a3e1ae206a38' 
  # message.sender # => {'id' => '1008372609250235'} 
  # message.sent_at # => 2016-04-22 21:30:36 +0200 
  # message.text # => 'Hallo bot!'   begin 
    if message.text.nil? 
      message_text = KnownLocation.guess_known_location_by_coordinates (message.attachments.first ['payload'] ['coordinates'].


    zet "[debuz] kreeg van Facebook ... # {message.text}" 
    ChatExtension.response (message_text, message.sender ['id'])   rescue => e 
    zet '[debuz] kreeg een onhandelbaar bericht:' + e. message + ': @:' + message.to_json 
  end 
end

Voeg toe aan config / application.rb zodat rails onze botbestanden kent

# Auto-load / bot en zijn submappen config.paths.add File.join ("app", "bot"), glob: File.join ("**", "*. Rb") 
config.autoload_paths + = Dir [Rails.root.join ("app", "bot", "*")]

Update routes voor / bot

# config / routes.rb Rails.application.routes.draw 
  mount Facebook :: Messenger :: Server, op: "bot" 
einde

Stel de env- variabelen in voor het volgende

ACCESS_TOKEN = 
VERIFY_TOKEN = 
APP_SECRET =

Afronden

Nu we een functionele bot hebben, kunnen we spelen met de UI-elementen die Facebook biedt. Je kunt ze hier bekijken .

Ik hoop dat je met dit bericht een chat-bot voor jezelf kunt bouwen. Dit is een interessante ruimte omdat het vrij nieuw is, veel geluk!